Category: Software Architecture

Surfing the Void: A Code Meditation

cvjepsenLeave a comment


Sometimes, coding isn’t about solving a problem. Sometimes it’s just a quiet way to sit with the absurd, sip your coffee, and let the rain do its thing. This one’s for those Sunday afternoons when the void isn’t threatening, just kind of hanging out.

# Import cosmic futility
import universe
import death
import coffee

# Set awareness level (1 = blissful ignorance, 10 = full Marvin)
awareness = 8

def main():
    try:
        # Accept the void
        universe.meaning = None
        print("Everything is meaningless.")
        
        # But also, go surfing
        if weather.sunny and body.not_in_pain:
            go_surfing()
        else:
            vibe_gently()
        
        # Eat snacks anyway
        eat_ice_cream(flavor="whatever", mood="existential")

    except Death:
        print("Well... that’s it.")
    finally:
        print("Wasn’t much, but it was ours.")

def go_surfing():
    print("Paddling into the abyss... feeling the breeze of nothingness... cowabunga.")

def vibe_gently():
    print("Sitting in quiet awe of entropy... scrolling memes... being okay with it.")

main()

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.

What Kind Of Enterprise Software Will Be Right For Your Business In The Future?

cvjepsenLeave a comment

Think for a moment about how organizations are evolving. They all want to be lean, fast and specialized. They’re trying to become more adaptable, intelligent and resilient. Wherever you look, it’s a pretty consistent pattern.

Now, think about the main trends in enterprise software. It seems to be evolving in 20 directions at once: AI, ML, SaaS, PaaS—it feels like you’re drowning in alphabet soup. Even when you spot a recognizable word like “cloud,” there are half a dozen different flavors.

External blog post click to continue reading

Enabling The Enterprise Shift To Microservices

cvjepsenLeave a comment

The next time you’re about to binge a season of your favorite Netflix show, consider the complex interactions taking place behind the scenes to make this possible. From negotiating with production companies and internet providers to orchestrating network traffic and predictive analytics algorithms, what Netflix has achieved is rather astounding. In just a few seconds, your show is streaming seamlessly. And this experience isn’t unique. Every day, 100 million Netflix subscribers have the same (nearly) faultless experience as they stream an average of 140 million hours of content.

External blog post click to continue reading

ERP Has Reinvented Itself Again, And This Time It’s Going Designer

cvjepsenLeave a comment

As early as the ’90s, businesses and analysts alike have foretold the death of the ERP system. Over 20 years later, however, ERP is still alive and well. Globalization, digitalization, the internet and a whole host of other technologies have made it virtually impossible for businesses to move away from ERP. There’s simply too much critical data housed in the underlying databases for elimination to ever be a viable option.

External blog post click to continue reading

Building a Better ERP Architecture to Support Machine Learning

cvjepsenLeave a comment

Users and developers agree on one thing in relation to enterprise resource planning (ERP) software: it’s boring.

For users, ERP means a lot of data entry added to their daily workload. While ERP is becoming more sophisticated with support for mobile devices and cloud functionality now commonplace, most users would prefer to use systems that are quicker and more responsive.

Developers can see this is a pain point and are trying to innovate past it, but that’s not always possible with the kind of monolithic architecture that can be found in contemporary ERP installations. ERP is a challenge to developers because ERP systems communicate with so many other systems on the network and each ERP installation is so massively configurable. Each individual instance of an ERP can feel like a unique piece of software in itself.

External blog post click to continue reading

Creating the Foundation for Developing Bots in a SaaS World

cvjepsenLeave a comment

Legacy software vendors that traditionally provide on-premise solutions still face a couple of architectural challenges. Those allow them to provide cloud-native applications as well as a solid foundation for offering a natural bedrock on which to construct bots, ultimately allowing them to offer a conversational user experience.

Cloud Architecture

Many vendors of legacy software struggle to accomplish a smooth transition from a monolithic architecture to a cloud-enabled service oriented architecture, as such a transition involves rewriting, which comes at a significant price. However, the previous economic benefit of re-architecting to ensure a more efficient use of compute and storage resources is gone due to increasingly cheaper IaaS and PaaS services.

External blog post click to continue reading

Running apps without connectivity

cvjepsen6 Comments

The other day on my daily commute I was, as usual, reading the latest news on technology and other, to me, interesting areas, I ended up spending most of my commute reflecting on the subject of mobile apps supporting disconnected state instead of reading. Honestly, I was rather annoyed with the situation, as I really enjoy being able to read my news and emails while riding the train.

So what was difference this particularly morning, since I usually read news and emails while on the train? Well, the difference was that normally I’m on an InterCity train that offers free WIFI, however, on this day I got on an earlier train – the sprinter – which doesn’t have free WIFI. Meaning, that I had to rely on “standard” mobile connectivity, which can be sketchy, even in a country like the Netherlands that got exceptional good network coverage.

Being without reliable connectivity I started testing a number of different news reader apps like Zite, FlipBoard, Dr. Dobbs and others – and found that they all requires connectivity to function. None of the newsreaders I tried, offered any solution for reading news without having connectivity. Which is some part peculiar, and I would argue a major flaw. Most of the apps build personalized news based on users preferences, it’s not as they’re searching the net for news. They could easily, on launch, download the news the user are interested in and store it on the device, and whenever there’s connection sync with the server.

If you think about this, then most of these apps and any other app that relies on connectivity is simply a revamped web app, and they doesn’t really offer any noticeable better user experience than a mobile web app would do. So why even bother building these apps as native apps? Apart from be able to distribute them as native apps by means of the app stores. But honestly, these apps don’t provide any additional advantages over traditional web apps.

When building native apps for devices like the iPad it’s crucial that there are additional benefits for the user over building mobile web apps. And one of these additional benefits is the ability to design and create apps that are capable of running without connectivity – disconnected. Remember that the mobile devices got – nearly – all the capabilities of a modern laptop. Storage, file system and database, so there’s a lot of power of API available to facilitate a great user experience, even when the device is disconnected.

When building mobile apps, you should rethink the functionality in terms of being disconnected. Look at the use case you’re trying to solve, and then rethink the use case in the light of being disconnected. Ask yourself, what your users wants to be do if there’s no connection. In the example of reading news, then I would assume that my users would like to be capable of reading news regardless of whether or not there’s connectivity. Compare it with reading a newspaper, and provide similar functionality – since that’s what the newsreader is trying to substitute – the good old newspaper. For the current mainstream apps in the newsreader space, they clearly haven’t succeeded in providing that richer user experience.

And to everyone out there, arguing that there’s such thing as perpetual connectivity, I suggest you go on a road trip, using different means of transportation as that’ll make you understand that perpetual connectivity doesn’t exists.