Domain-Driven Design consulting and EventStorming: domain boundaries that hold in your code and your teams

Domain-Driven Design (DDD) designs software around the business domain: the words, rules and boundaries the company actually works with. We facilitate EventStorming with the people who know the business and the people who write the code. Then we stay with your team and turn what came out into bounded contexts, context maps and models in the code, until the team can maintain those boundaries without us.

This is the work to do before two expensive decisions: how to refactor the architecture, and how to organise teams around the product.

Book a call

When do you need Domain-Driven Design?

When the boundaries of your software no longer match those of the business, and every product change cuts across modules and teams it shouldn't touch.

  • A feature you can explain in two lines needs changes in many modules and coordination between several teams
  • The same word (customer, order, contract) means different things in different parts of the code and in meetings
  • You want to make the monolith modular or move to microservices, and nobody can say where to cut
  • Business rules are scattered across shared services, queries and interfaces, and only two or three people know where to look
  • Teams are split by technical layer or by project, and every release means synchronising them

All of these signals have the same root. Architecture, organisation and business each grew on their own. That is why domain mapping comes before architectural refactoring and before redrawing the teams. Anyone who cuts up a monolith or moves people without knowing where the business boundaries run only moves the coupling somewhere else in the system.

What do we do?

We facilitate EventStorming at all three levels, then work with your team to bring the resulting model into the code and the organisation.

EventStorming Big Picture

We put the whole business flow, told through events, on a wall (physical or digital), with product, business and development people in front of the same wall. Out come the points where work gets stuck, the terms people disagree on and the first candidate boundaries between one context and another.

EventStorming Process Level

We take one process at a time, the one that costs most to change today, and break it down into commands, rules, actors and external systems. Rules that live in the heads of a few people become explicit, and everyone can discuss them.

EventStorming Design Level

From the process we move to the software: aggregates, invariants to protect, domain events the code must publish. This is where the model becomes precise enough to guide the design of modules and tests.

Bounded contexts and context map

We draw bounded contexts where the language changes meaning, then map the relationships between them: who depends on whom, who conforms to the other's model, and where an anti-corruption layer is needed to protect a model from an external or legacy system. The map also shows which boundaries the code doesn't respect today.

Domain modelling in code

We write the model together with your developers, using pair and mob programming. The language of the business goes into the names of modules, classes and tests, and tactical patterns (aggregates, value objects, domain events) arrive where they solve a real problem. Often the first step is a modular monolith with explicit boundaries, which can hold up well for years before microservices are worth discussing.

Training on your own domain

When the team needs a shared foundation, we build training sessions around your domain and your code, either at the start of the engagement or within the ongoing work. The examples come from your own system, so what people learn applies the next day.

How do we work with your team?

The workshop opens the work, and most of it happens afterwards, in the code, with the people who will maintain it.

A wall of sticky notes changes little on its own. If nobody carries the model into modules, names and tests in the following weeks, the system goes back to what it was and the workshop stays a nice shared memory. So after the facilitation, our very senior extreme programmers pair with your developers on the changes the roadmap needs anyway, and use each one to move a boundary or clarify a concept.

Model decisions stay with your team. We facilitate and propose, and we write the code together with the people who will be responsible for it. A model written by the people who use it every day is also the one that stays up to date when the product changes.

The service can be the start of a programme, with a Big Picture and the first contexts brought into the code, or ongoing work alongside architectural refactoring or a team reorganisation. Workshops run on site or remotely with a digital whiteboard, preferably on site, because the discussion in front of the wall is part of the result. We adopt your stack and your tools.

What do we measure to find our bearings?

Wherever possible, we steer by measurement. When we can't, we describe the systemic effects we have observed or the factors that need a closer look. The measures look at how closely the boundaries of the code and the teams follow those of the domain, and whether work flows better as we move them.

  • How many modules or contexts a typical product change has to touch
  • Which parts of the code always change together despite sitting in different contexts, taken from the change history
  • How many dependencies between teams it takes to get a feature into production

Alongside these, DORA metrics, cycle time, lead time and value stream mapping are some of the metrics and techniques we use to guide continuous improvement.

What changes for the team and the product?

Business and development speak the same language, and a typical product change stays inside a single context.

  • Product people and developers use the same terms in meetings and in the code
  • Business rules live in one specific place and are described by tests
  • Architectural refactoring follows a map. You know what to separate and in what order, and every cut is explained by a domain boundary everyone recognises
  • Team boundaries can follow domain boundaries, and dependencies between teams fall
  • New joiners understand the system by reading the model, without having to ask whoever was there
  • The team can rerun an EventStorming and update the context map on its own when the product changes

Where do you start?

You can start directly with an EventStorming Big Picture on your product, or with the Software Delivery Assessment, which we recommend when it is unclear whether the bottleneck sits in the domain boundaries or elsewhere.

The assessment looks at code, practices, process and organisation together, and says whether domain mapping is the step that unblocks the rest. It remains a recommendation. If you already know the problem is where the boundaries run, we start with the workshop.

Related services

Domain mapping is the starting point for two services, which take the order of work from the context map. The assessment, if needed, comes first and tells you whether to start here.

  • Legacy Code Refactoring – the context map says which parts to separate first and where to put the boundaries when the monolith has to be made modular or a part has to be replaced
  • Engineering Team Design – with the bounded contexts in hand, you can design teams aligned to domain boundaries, each with clear ownership of a part of the system
  • Software Delivery Assessment – to find out, before starting, which level the bottleneck sits at

Frequently asked questions

What is EventStorming?
EventStorming is a workshop technique, devised by Alberto Brandolini, in which business and development rebuild a domain by lining up the events that happen in it. It is used at three levels of detail: Big Picture for the whole flow, Process Level for a single process and Design Level for the design of the software. In one session it brings out disagreements and implicit rules that would otherwise surface in the code, much later.
How is this service different from an EventStorming workshop?
A workshop leaves a shared map, and its value depends on what happens next. As well as facilitating it, we work with your team in the code to turn that map into bounded contexts, modules and tests, and we support the architecture and organisation choices that follow.
Is Domain-Driven Design useful if we don't want to move to microservices?
Yes. Bounded contexts are logical boundaries and work inside a monolith too, which with explicit boundaries becomes a modular monolith. In many systems that is the best choice, and microservices remain an option to assess when a context needs independent releases or independent scaling.
Do you offer Domain-Driven Design training?
Yes, targeted training. We build it around your domain and your code, at the start of the engagement or within the ongoing work. We don't run off-the-shelf courses, because DDD is learned by applying it to a problem the team knows.
Who should take part in the EventStorming?
People who know the business and people who write the code, together: product managers, domain experts, developers and whoever decides on architecture. If one side is missing, the map tells only half the story of the system.
Which technologies do you work with?
We're stack-agnostic and adopt the languages, frameworks and tools your team already uses. Domain-Driven Design is about how the parts of a system are divided and named, and it applies in any technology.

Want to know where the boundaries of your domain run?

We start with a call. You tell us about the product and where changes cost the most, and together we work out which level of EventStorming to begin with

We use your data to respond to your request. Read our Privacy Policy.