Tag: AI

Sustainable Velocity: Why Clarity Is Making a Comeback

cvjepsenLeave a comment

Ever notice how ideas in software development tend to come full circle? There was a time when we put a lot of effort into documenting everything up front. It wasn’t perfect, but many of us believed that gaining clarity early would lead to better decisions later on.

Then the world sped up. Markets moved faster, customers expected continuous improvement, and the industry responded. Agile methodologies emerged as a way to shorten feedback loops and stay closely aligned with real user needs. “Working software over comprehensive documentation” became a guiding mantra, and it made sense. It kept teams focused on delivering value rather than writing paperwork for its own sake.

But in practice, some teams took that mantra a bit too literally, almost as if “documentation doesn’t matter as long as we ship.” The Agile Manifesto never said documentation has no value. It simply warned against letting documents slow us down. Skipping documentation entirely might reduce overhead in the moment, yet it often creates a different kind of waste: confusion, rework, and lost context. A lack of shared understanding doesn’t remove cost; it only postpones it.

Today there’s a quiet return to writing things down for clarity. Techniques like Architecture Decision Records, specification by example, and lightweight design docs are gaining traction again. Not as bureaucracy or thick binders on a shelf, but as living tools that help teams move quickly without losing meaning. Documentation is returning not to slow us down, but to make sure our speed is sustainable.

This shift even aligns with the tools we’re beginning to rely on. Code generation, model-driven systems, and AI-assisted development all depend on precision. You cannot feed a vague idea into a generation engine and expect reliable software to emerge. A clear specification, however, can be turned into code. The more we ask machines to help us build, the more disciplined our thinking needs to become. That kind of discipline starts to look a lot like the documentation we thought we could neglect.

Maybe that’s the lesson behind these cycles. Writing down what we mean isn’t a step backward. It’s part of moving forward. Speed still matters, but clarity is what makes speed repeatable and trustworthy. If both humans and machines can clearly understand what we intend to build, then we can move fast with purpose.

In that sense, the renewed interest in documentation isn’t about going back to the past. It’s an investment in sustainable velocity, the kind of speed we can maintain with confidence over time.

The Philosophy of Self-Driving Enterprise Software – Rethinking How We Build Software

cvjepsenLeave a comment

At its core, the philosophy is simple and something I have always believed in and promoted: enterprise systems should support people, not vice versa. Technology should extend human capability, not consume it. For too long, enterprise software has demanded that people conform to its predefined structure, based on legacy workflows, accommodating the ever-increasing amount of functionality. Over time, this has turned enterprise software from a valuable productivity tool to a burden that can best be described as digital bureaucracy.

I believe in building context-sensitive, adaptive systems aligned with operational intent. Systems that reduce cognitive load by providing relevant insight when needed to improve decision-making. This is not just about productivity. It’s about respecting people’s time by giving people back their time, focus, and ability to do work that matters.

The philosophy of AI-supported enterprise systems is rooted in utility, ethics, and design that handles complexity while minimizing user burden by removing digital bureaucracy. Software should no longer be the center of attention. People should.

The De-Flowchartification of Enterprise Software

For decades, enterprise software has been defined by structure and control. We created systems to record, to enforce, to comply. They reflected the world as we thought it should be: organized, linear, deterministic.

We took paper-based processes, turned them into flowcharts, and then imprisoned users within the rigidity of those flowcharts. But the problem didn’t stop there.

Screens were built to reflect not just the workflows, but the underlying database tables themselves. In many enterprise systems today, you can look at a screen and nearly reverse-engineer the data model behind it. A tightly coupled triangle emerged: flowcharts dictating processes, databases shaping screens, and UIs enforcing structure and workflow.

This triad has constrained enterprise software into a narrow path, where the user’s experience is predefined by systems designed for data accuracy and compliance, not for real-world flexibility. The result is an inflexible, stepwise interaction model that reflects system architecture more than human need. The system we constructed stripped users of their agency, reducing them to transactional processing entities.

Over time, we slowly lost track of how users actually experience these systems. Enterprise software began to serve its own abstractions, tables, forms, and flows rather than the people using it.

In the AI-supported era, deterministic structures may still exist in the background to safeguard data fidelity and transactional integrity, but the visible rigidity dissolves. What emerges instead is a more adaptive, event-driven interaction where action is based on context, not sequence. Users are guided, not constrained.

At the heart of this shift lies a subtle but profound transformation: the databasification of enterprise systems. What used to be an application-centric model is now turning inside out, where the structured data, not the software UI, becomes the primary foundation. We’re moving toward systems where data is becoming truly decoupled from interfaces and behavior, allowing algorithms to interpret, through data and meta-information, state, process, and intent more adaptively.

This transformation requires more than just capturing data; it requires contextualizing it. The traditional record-based view is being replaced by semantic context, made possible through ontologies, state models, and defined relationships, the meta-information layer. It’s how we turn enterprise data from a passive ledger into a dynamic structure for inference, enabling automation systems to respond based on context, not just rules.

We’re entering a new era where algorithmic systems, powered by real-time data, probabilistic models, and embedded inference, are reshaping the very foundations of how we think about enterprise software.

This isn’t just a technological shift. It’s a foundational one.

From Control to Context

Traditional enterprise systems were built around control, predictable flows, predefined fields, and rigid, rules-based outcomes. Users had to conform to the system’s logic, navigating experiences shaped more by internal structures than real-world needs. In the process, they lost agency and were reduced to functionaries within systems designed more for control than contribution. What was meant to support work ended up dictating it.. Rather than being helpful or enabling, these systems were constraining by design.

AI-supported systems can invert the old paradigm. Where traditional systems dictated steps, these systems adapt. Instead of requiring users to follow rigid flows, they respond to context, surfacing what’s needed and when it’s needed. Rather than demanding conformity, they provide assistance. This puts the user in the center rather than the system, making the system the operator of the user, and not the other way around.

This marks a fundamental shift. Enterprise software moves from enforcing structure to enabling flow, from predefined workflows to dynamic events, from system-driven usage to purpose-driven relevance.

From UI to Inference

One of the core ideas I believe in, and always have, is that the best software becomes pervasive, not by disappearing but by reducing the need for users to engage with it actively. In traditional systems, every action required a corresponding screen. Each step was tightly coupled to a screen, a transaction, or a workflow. As a result, the user experience was designed around the software’s internal structure, rather than focusing on delivering a relevant outcome.

The ability to run machine learning algorithms at scale gives us a unique opportunity to change this. This, finally, allows us to move from interface-driven interactions to inference-driven assistance. Through predictive algorithms, the system “learns” to anticipate, recommend, and act, surfacing relevant information or completing routine steps without requiring the user to navigate menus or remember where to go next. The burden of knowing how to use the system shifts from the user to the system itself.

This is the shift from invasive to ambient. Traditional enterprise software forced users into transactional UIs. Context-aware enterprise software operates in the background, surfacing what matters when it matters.

It’s not just about reducing steps. It’s about changing the mental model entirely, from software as something we operate to software that either acts on our behalf or provides relevant information and context when needed. It automates what can be automated and augments when human judgment is needed.

Data as Living Context

To make this possible, we need to think differently about data, not just as structured records but as a living context. Traditional enterprise data has been fragmented across various software areas, often stripped of meaning beyond its immediate functional use to satisfy the system’s fundamentals. In an AI-first model, data must be elevated: organized not just by schema but, more importantly, by purpose, relationships, and state.

This is where the meta-information layer becomes critical. By introducing ontologies, state models, and defined relationships, we can construct algorithms that interpret data in context, not just what something is, but why it matters and how it connects to the broader flow of work. This is what enables predictive logic, relevance-based assistance, and automation that goes beyond coded scripting.

In AI-supported systems, the data model evolves from a passive record-keeping structure to a dynamic, semantic framework that reflects real-world complexity. The goal is to create a foundation that allows the system to draw connections, track transitions, and operate with context-driven logic.

Data is no longer just for reporting. It becomes the foundation for context-driven computation and algorithmic execution.

Enterprise Systems as Operational Infrastructure

The databasification of enterprise systems marks a fundamental shift. What used to be centered around coded business logic leading to predefined screens and database tables will increasingly be modeled through a combination of ontologies, state models, and process descriptions.

This shift allows algorithms to operate across data, state, and events without the user guiding every step. Instead of burying business logic in screens and interfaces, we make it accessible and available as computational tools that algorithms can use to adapt and optimize. Execution logic is derived in context, based on detected patterns and statistical correlations, not hardcoded instructions.

Enterprise software has always shaped how organizations operate, but now, it’s beginning to influence how they adapt to real-time conditions. From constraints and exceptions to shifting priorities, systems are starting to guide action instead of just enforcing structure.

AI-supported systems affect how decisions are framed, priorities are surfaced, and operational knowledge is applied. In this sense, they become operational infrastructure, scaffolding for operations and improvement.

This is what I mean by databasification. Databases transitioned from terminal-based interaction to a supporting infrastructure. Similarly, enterprise software is evolving, no longer just the “system where you go to work,” but now the pervasive engine that records changes, interprets data, provides insights, and triggers actions, based on analysis, across the workplace.

This is where the real shift lies. We’re no longer just building tools. We’re enabling systemic responsiveness.

A Belief System, Not a Roadmap

What I’m trying to describe isn’t just a strategy. It’s a belief system, a philosophy for constructing systems that, through thoughtful application of technology, reduces complexity and increases clarity to help people do more of the work that matters.

I fundamentally believe:

  • That software should empower, not encumber.
  • That system should adapt to circumstances, not require people to adjust to rigid flows.
  • That automation should decrease complexity and increase clarity.
  • That enterprise software can evolve from a back-office burden to forward-looking engines of innovation.

We have the tools. We have the data. What we need now is the discipline to rethink the foundations.

Because the future isn’t just about building better features. It’s about building better systems of interaction.

The Enterprise Software Promise

An ethical commitment for building AI-supported systems that serve human purpose.

As creators of enterprise systems in the age of adaptive automation, let’s hold ourselves to the following principles:

1. Build systems that support people, not systems that people serve.
The highest obligation is to assist human agency and purpose, giving people time back to work on what matters.

2. Amplify human judgment, don’t override it.
Enterprise systems should support decision-making, not dictate it. Software should be assistive, not authoritative, tools that extend human capability without displacing responsibility or control.

3. Design for relevance, not just execution.
Surface relevant information in context when needed.

4. Automate only what should be automated.
Recognize the difference between repetitive operations and human judgment.

5. Respect the dignity of work.
Enhance creativity, collaboration, and insight, not replace them.

6. Treat data not as exhaust, but as actionable input.
Give data meaning through meta-information to create systems that can respond.

7. Respect time and cognitive load.
Prioritize relevance, reduce friction, and eliminate wasteful complexity. Build systems that work for people, not the other way around.

ERP and the A.I. Factor

cvjepsenLeave a comment

Artificial Intelligence (AI) is here. Once a topic of conversation, news, and science fiction, AI has finally entered our technology landscape. We are only beginning to see the impact it will have on our businesses, our jobs, and our enterprise software, but we already know that impact is profound and growing.

Until very recently advanced AI functionality was extremely expensive due to the limited and immature tooling available. Constructing the algorithms required highly skilled and very specialized employees, not available to most software vendors. In addition, these new and complex algorithms required immense amounts of additional data storage for pattern recognition and required CPU-intensive computing power for pattern recognition.

All this has changed. We will see it often. Current ERP software will incorporate AI capabilities more and more, and here is why.

Today, all major cloud vendors offer both PaaS and IaaS that specifically address computing and storage issues. Fierce competition between major cloud players has resulted in decreasing prices for both cloud storage and computing power, literally democratized machine learning functionality and AI capabilities. It is allowing software vendors to incorporate more-complex algorithms that crunch bigger and bigger datasets.

The result is ERP with AI for all.  It is leading to ever-more-advanced solutions. It has given birth to a whole new range of systems capable of making decisions based on historic data. Data collection is becoming pervasive, automatic and non-intrusive, instead of spotty, manual, and requiring high levels of interaction. Natural language input will soon decrease the need for manually intensive UI.  Increasingly, computers will proactively support decision making.

We recently announced our new digital assistant, Wanda. Wanda and its functional agents epitomize the evolution to semi-intelligent and self-driving solutions. They liberate people from their tedious manual interactions with enterprise software and allow them to focus on running their business and serving their customers.

Should we fear AI?

Human beings all share an important trait – the ability to devise tooling that simplifies tasks and drives our species forward. Our tools liberate us from mundane day-to-day chores, so we can focus on more abstract challenges, solving more problems – problems we solve, ironically, by devising even more tools. This has made us the most successful and adaptable animal on the planet.

Every new technology invented gave rise to a backlash. Change is difficult. Many people will prefer the status quo.

Despite resistance to change, advances in technology always prevail. In time we learn to trust and use our new tools with enthusiasm. The introduction of AI into enterprise applications will follow the same path. It’s only human. Initially there will be lots of resistance because AI will fundamentally change how users interact with software.  Large amounts of structured and unstructured new data will enter the ERP system invisibly, through mobile, UI improvements and IoT. Knowledge systems will employ agents – computer programs that decide and act independently on behalf of an employee.  Many users will feel threatened. Despite this, technology will prevail. It always does because companies will always strive to operate more efficiently and focus on their primary objective, serving their customers.

Should we then fear it? No, not at all. New technology brings us better living standards, safer working conditions, more goods, better services, and endless benefits. AI will do likewise. It will remove tedious, repetitious work.  It will empower employees to improve their performance. It will enable companies to provide more goods and better services. A new era is upon us. Embrace it. The impact of AI on ERP will be enormous and wonderful.

Self-driving enterprise software

cvjepsen1 Comment

By using advanced technologies within pattern recognition, machine learning and computer aided decision support systems, as well as new IoT devices, software can make automated decisions on behalf of the user, or provide guidance to allow users to make intelligent decisions based on smart patterns. This is achieved through self-learning software that assumes actions based on previous or similar scenarios and uses that to pre-populate and self-drive.

Interaction with the software is minimized to only involve people when human intelligence and experience is critical to resolving a business issue or to drive business processes in the right direction. If user interaction is required, a UI will be provided in its simplest form to accommodate that, on the users preferred device of choice, intelligently adapted to the situation.

Incredible value can be derived by limiting the amount of manual input required by users so they can focus on serving customers. This is the future of business software.

What is self-driving enterprise software really about?

In a nut shell self-driving enterprise software is literally about creating software with which the user does not need to interact, or at least interaction is minimized. The reality is that the majority of the interactions users have with their enterprise software is administrative. It’s not about doing their job well or running their business but simply maintaining the mechanics of sending invoices, doing bookkeeping or filing expense reports.

All these mechanic interactions can be tracked, analyzed and fed into algorithms so the software can learn typical usage patterns within a specific context whether that’s procurement, invoicing, bookkeeping or expenses. Through pattern recognition and statistical analysis the software can “learn” typical user actions in specific situations and automate the expected action in the future.

Analyzing past interactions will allow us to construct more semi-intelligent solutions. Solutions that dynamically alter behavior based on previous interactions, decisions and user actions. There are a number of different aspects to self-driving software.

Adaptive UI

 
The fundamental idea of adaptive UI is, as the name suggests, UI that intelligently adapts to the user based on previous interactions. In today’s enterprise software, forms or screens typically contain many fields that need to be filled out by the user. Some fields are linked with other fields, and there are even hard dependencies meaning that if a certain field has a specific value, others need to be populated exactly right for the system to accept the data as a whole. As a causal user simply entering a purchase order it can be a horrifying experience – regardless of how nice the UI looks. The adaptive UI records everything the user is doing, when he or she is doing it and in what order. If a user always populates a specific number of fields with the same values it can do that automatically. Even better, if some fields are always left untouched – they can be removed dynamically from the UI to make it less ‘noisy’ or confusing. By removing un-used fields, and populating everything automatically based on previous interactions – the system can complete the task on the user’s behalf. For example, if someone orders A4 binders on every second Monday from the same vendor, the system might as well just do it.

Workflow

Normally business processes require user interaction for approvals. A manager needs to approve a request for a new laptop from one of his reports for example. If the manager in question always approves requests within certain criteria, most commonly the price, the system can give that approval and notify the manager it’s been done.

Historical and Current Data

What I’ve discussed above is all based on historical data; however, using aggregation of historical and current data – like your present location software has the ability to automatically populate travel expenses, field service work reports, and even suggest additional maintenance work do be done as part of a field service visit.

Some examples of where self-driving ERP will add significant value:

Expense Reports

Expense reporting is a great example of an administrative task that lends itself to self-driving software. In the future systems will automatically create line items in an expense report based on the scanning of a receipt. By extracting the address the system can gauge what the item is and based on the time know if it’s breakfast, lunch or dinner. Essentially populating the complete line. Rather than having to store the receipt, go into the system and enter expense type, date, amount, all the user has to do is photograph the receipt.

Field Service

Within field service, systems can schedule maintenance visits for equipment based on the previous maintenance of similar equipment at other customers. Also, if a visit is already planned, it may prove more economical to – pro-actively – service other equipment while already on-site.

The future is here

Previously analyzing massive amounts of data was expensive due to the amount of data storage and computational power required. However, due to ever decreasing prices on storage and CPU, running advanced algorithms becomes more accessible enabling inclusion of semi-intelligent agents into a vast majority of the functionality within enterprise software. Customers will benefit from being able to focus on running their businesses and serving their clients rather than the tedious mechanics of maintaining the ERP.

This is why we focus on developing enterprise software that allows customers to focus on their business instead of focusing on the software, by making it completely self-driving. We’re already starting to deliver this in our software.