Leestijd
Almost every organisation today claims to be product-led. Investment flows into Agile, cross-functional teams and shorter development cycles. Product Owners take on more responsibility, architecture shifts towards teams, and organisations work hard to respond more quickly to market changes. On paper, it looks as though all the conditions for successful product development are in place.
Yet many organisations experience the opposite. As the number of teams grows, so does the complexity. Decisions take longer, dependencies build up, and products develop less predictably than hoped. New features turn out to have unexpected consequences for other systems, teams keep having the same conversations over and over, and aligning business and technology demands ever more coordination.
The instinct is often to look for the root cause in technology. Organisations invest in new platforms, modernise their architecture or introduce a new framework. While those initiatives can be valuable, they rarely solve the underlying problem. In many cases, complexity doesn’t originate in the technology itself — it comes from the way the organisation understands its own reality.
That may sound abstract, but it shows up in practice every day. One department talks about customers, while another actually means contract holders. Product Management prioritises based on customer value, Finance manages to cost centres, and IT works from the structure of existing applications. Everyone uses the same words, but means something different. It’s only when multiple teams work together on the same value stream that the extent of those interpretation gaps becomes apparent.
That’s precisely where Domain-Driven Design — DDD — comes in. Although it’s often presented as a method for software development, at its core it’s a way of helping organisations work from a shared understanding of reality. The premise is surprisingly simple: before you design systems, you first need to collectively understand how the organisation actually works. Only once that shared understanding exists can products and software support that reality in a consistent way.
When Eric Evans published his book Domain-Driven Design in 2003, the focus was primarily on complex enterprise software. The context has changed significantly since then. Almost every organisation now develops digital products, and almost every organisation has multiple teams working simultaneously on different parts of the same landscape. What was once mainly a challenge for software companies has become a pressing issue for banks, government agencies, healthcare institutions, retailers and industrial organisations.
That shift has also changed the role of software. Applications no longer simply support business processes — they increasingly are the product itself. That means decisions about technology, product development and operations are constantly intertwined. A change to a digital product has a direct impact on customers, internal processes and sometimes even an organisation’s revenue model.
That makes the quality of collaboration more important than ever — not just among developers, but especially between product management, business, architecture and the people who work with customers day to day. When those disciplines each hold a different picture of the domain they’re operating in, it creates a form of complexity that can’t be resolved through technical measures alone.
This is visible in almost every large organisation. Product teams build solutions that work well technically but fall short of meeting users’ day-to-day needs. Business articulates requirements that make sense from its own process, but are barely achievable within the existing products. Architects try to bring coherence to a landscape that keeps changing. Meanwhile, the volume of meetings, documentation and governance keeps growing, while decision-making becomes slower.
Remarkably, that slowdown is often accepted as a natural consequence of scale. Large organisations are complex — that’s the reasoning. But that’s only part of the picture. Of course, technical complexity increases when dozens of teams are working on hundreds of applications. What matters just as much, however, is whether all those teams share the same understanding of the domain. Without that shared view, interpretation gaps are inevitable — and those gaps are often the biggest source of delay.
Within Domain-Driven Design, the Ubiquitous Language plays a central role. Literally, it means a pervasive language — a set of terms that everyone within a given domain uses in the same way. At first glance, that sounds like a question of terminology. In practice, the impact is far greater.
In many organisations, departments gradually develop their own language over the years. This usually happens unconsciously. Finance thinks in terms of financial entities, marketing talks about target audiences, operations focuses on processes and software teams work with objects and databases. Each discipline builds its own view of reality that is internally consistent, but doesn’t necessarily connect with the reality of others.
As long as these worlds largely operate in isolation, the problems stay manageable. That changes the moment cross-functional teams become jointly responsible for a product or value stream. Suddenly, seemingly simple terms turn out to mean different things. An order means something different to the logistics team than it does to Finance. A subscription means something different to the commercial organisation than to the billing system. Even the term ‘customer’ has multiple definitions within many organisations.
Those kinds of differences may seem harmless, but they have serious consequences for product development. Developers build software based on concepts that later turn out to be interpreted differently. Product Managers prioritise features based on assumptions that aren’t shared across the organisation. Architects try to structure systems logically, while the organisation itself hasn’t yet agreed on what its own domain actually looks like.
The result is recognisable. Teams spend a significant part of their time clarifying decisions that were made earlier. Requirements need to be revised, processes redesigned and software extended with exceptions that should never have been necessary. The technical debt that accumulates as a result often doesn’t begin in the code — it begins much earlier, in the language organisations use to describe their own reality.
That’s why Domain-Driven Design isn’t primarily about software patterns or architecture models. It starts with conversations — conversations in which business, product management, architecture and development jointly explore how an organisation actually works. Not how processes were originally designed or how applications are currently structured, but how value genuinely flows to customers and what concepts belong to that flow.
That’s what makes DDD surprisingly relevant today. Modern product organisations invest heavily in autonomy. Teams are given space to make decisions independently and take ownership of their own products. But autonomy only works when everyone shares the same starting points. A team can only make good independent decisions when it’s clear which domain it operates in, what language belongs to that domain and what it is genuinely responsible for.
Those coming to Domain-Driven Design for the first time often get the impression it’s primarily a discipline for software developers. Concepts such as Aggregates, Entities, Value Objects and Repositories dominate many books, presentations and training courses. This easily gives the impression that DDD only becomes relevant once technical architecture is being designed.
In practice, the opposite proves true. The organisations that benefit most from Domain-Driven Design are often those that invest first in understanding their business and only then think about software. They use DDD not as a method for designing code, but as a tool for bringing product development, business processes and technology closer together.
This calls for a different way of thinking about product development. Not the application but the problem the organisation is trying to solve sits at the centre. Not the organisational structure but the logic of the domain itself determines how software is built. That shifts the focus from systems to products and from functions to value creation.
That shift aligns closely with the journey many organisations have made in recent years. Product thinking, value streams and cross-functional teams are now familiar concepts in many organisations. In practice, however, teams are still frequently organised around existing applications or departments. This creates dependencies that have little to do with customer value and stem mainly from historical decisions.
Domain-Driven Design offers a different perspective. Rather than starting from existing systems, DDD first looks at the logical coherence within the domain. Which problems genuinely belong together? Where do decisions arise? Which responsibilities can logically be combined, and where do different realities diverge? These may seem like simple questions, but the answers often form the basis for a far more effective design of products and teams.
That brings us to one of the best-known concepts within Domain-Driven Design: the Bounded Context. Although this term is often explained technically, in practice it is above all an organisational principle. A Bounded Context describes a well-defined part of the organisation in which concepts have an unambiguous meaning and in which it is clear what rules, processes and responsibilities apply. Outside that context, the same term may mean something different — and that needn’t be a problem.
That insight helps many organisations move forward. There’s no reason why a concept like ‘customer’ has to mean exactly the same thing everywhere. For a marketing team, a prospect is something quite different from what it means to the finance department, while a service team operates within an entirely different reality. Problems arise when organisations expect all these perspectives to fit into one universal model. In practice, that typically leads to convoluted data structures, endless debates and software that becomes harder and harder to maintain.
By deliberately drawing boundaries around domains, space opens up for simplicity. Teams gain a clear area of responsibility, decision-making can happen closer to the team, and dependencies become visible before they hold up progress. In that sense, Domain-Driven Design directly connects to topics such as Team Topologies, platform thinking and modern product organisations — not because these approaches are the same, but because they all start from the same idea: organise teams around a logically bounded problem space rather than around technology or organisational structures.
That doesn’t mean every product team can operate entirely independently. Modern organisations still depend on collaboration between domains. That’s precisely why Domain-Driven Design devotes considerable attention to the relationships between different contexts. Not all teams need to speak the same language, as long as it’s clear where the boundaries lie and how information is exchanged between domains. That clarity prevents every change from immediately affecting dozens of other teams.
In practice, that represents an important difference from many traditional organisational designs, where collaboration is often managed through additional governance structures, committees or centralised decision-making. Domain-Driven Design takes a different route. The clearer the boundaries of a domain, the less coordination is required — not because teams collaborate less, but because the nature of that collaboration changes. Conversations shift away from interpreting concepts and towards the value that different domains create together.
Domain-Driven Design is still regularly seen as a discipline for software developers. In modern product organisations, that view is outdated. Product Managers, architects and business representatives all play a crucial role in developing a shared understanding of the domain.
For Product Managers, this means their role extends well beyond managing a backlog or prioritising features. They need to understand how an organisation creates value, which business rules are decisive and where different interests converge. That requires intensive collaboration with domain experts, users and development teams. The better that shared understanding becomes, the easier it is to make decisions that are both technically and commercially sound.
Architecture also takes on a different role within Domain-Driven Design. Where architects once designed entire system landscapes, their role increasingly shifts towards maintaining coherence between domains. They help teams recognise logical boundaries, support integration challenges and ensure that local optimisations don’t come at the expense of the bigger picture.
The same applies to software development. Good developers don’t only build technically strong solutions — they also invest in understanding the domain for which they’re developing software. That requires far more direct contact with product management and business than was typical in traditional project organisations. Ultimately, the quality of the software is determined not just by the code, but above all by the quality of the conversations that come before it.
One technique widely used in Domain-Driven Design is Event Storming. In an Event Storming session, people from different disciplines jointly map out which events take place within a domain. Interestingly, the greatest value usually lies not in the end result, but in the conversations that emerge along the way. Teams discover they’re working from different assumptions, interpreting processes differently or viewing responsibilities very differently from colleagues in other disciplines.
That’s why Event Storming is much more than a workshop technique. It’s a way of making collective knowledge visible before technical decisions are made. Many organisations skip that step. They start with user stories, process models or architecture diagrams while it’s still unclear how the domain actually works.
That pitfall is more common than many organisations realise. Under deadline pressure, there’s a constant temptation to jump straight to solutions. New features are built, processes are automated and systems are extended, while fundamental questions about concepts, responsibilities and domain boundaries remain unanswered. In the short term, that feels efficient. Over time, it produces a landscape where every change has unexpected consequences.
That’s also why many organisations only start working with Domain-Driven Design once complexity has already become high. Teams are constantly waiting on each other, ownership is unclear and the pace at which products develop starts to slow. The response is often to look for a new framework or to reorganise, while the root cause lies much deeper. As long as different parts of the organisation operate from different realities, any new structure will eventually run into the same limits.
Perhaps that is the most important lesson of Domain-Driven Design. It doesn’t offer a blueprint for what an organisation should look like, nor does it prescribe exactly how software should be developed. Its strength lies in collectively understanding the domain before processes, products or systems are designed. Organisations that invest in this often discover that many technical problems are, in reality, organisational challenges.
That makes Domain-Driven Design more relevant than ever. Modern product organisations work with autonomous teams, value streams, platforms and increasingly with artificial intelligence. Technology is advancing rapidly, but that is precisely why a shared understanding of the domain becomes ever more important. Without that shared foundation, complexity grows faster than the organisation can keep up with.
More than twenty years after its introduction, the central idea behind Domain-Driven Design remains surprisingly relevant. Ultimately, it isn’t technology that determines the success of a product organisation — it’s the degree to which people share the same understanding of reality. Those who invest in that don’t just build better software; they build an organisation in which product management, business and technology genuinely strengthen each other.
View the Domain Driven Design For Product Management training
Artikel delen
For Product Owners, gaining a certification has become standard practice in many organisations. Scrum, SAFe and other Agile frameworks are
By Nico Schellingerhout and Jeroen Jan Elzinga Agile. A word that once promised transformation, but is now often met with
A summary of the webinar: Strategic portfolio management: what organisations can learn from Silicon Valley’s VCs, 17 June 2026. Why
Change does not have to be difficult or complex. With the right focus, energy and guidance, you create clarity, direction and results.
We would be happy to explore how we can help.
