Trigpoint
Collections › Software & Systems Architecture › Domain-driven design (DDD)
Draw the architecture first, or first get domain experts and developers using one set of terms?

Domain-driven design (DDD)

Domain-Driven Design (DDD) · Evans (2003)
Bibliography checked ✓ Software architecture · language and boundaries Read first: Modularity and thin crossing points Tell the editor privately ▸
In three sentences The main battleground of complexity is the domain itself, not the technical layer. The first move against it is not drawing an architecture diagram. It is unifying the vocabulary: domain experts and developers share one set of terms, and those terms become the names inside the system. Once scale arrives, cut into contexts, keep meaning consistent inside each, and translate explicitly across them.

↳ Seen a counter-example?

Holds when
When experts and developers speak different vocabularies, and the conditions and exceptions in domain rules get lost in translation.
Evidence
Conceptual framework; Bibliography checked
Breaks down when
Adopting its terms without changing how people talk and divide the work, or using it where things were already simple: modelling effort spent, nothing clearer.
Domain-driven design (DDD) Evans (2003) One vocabulary runs into the code; at scale, cut contexts Domain knowledge with its exceptions One shared vocabulary no translation layer Model and code names nothing off the glossary Once scale arrives: cut contexts, do not unify Context A meaning is consistent inside one word, one sense here Context map + anti-corruption everything crossing is translated Context B the same word, another sense this is allowed, not a defect When one word means two things on two lines, do not unify: draw a boundary spend design effort on what is genuinely differentiating; use off-the-shelf for the rest Figure: trigpoint.pub
Figure 1 · The top row is how knowledge gets into the system: domain experts and developers share one set of terms, and those terms become the names in the model and in the code with no translation layer in between. The bottom row is what happens once scale arrives: cut into several contexts, keep meaning consistent inside each, and manage what crosses between them through one map and a layer of anti-corruption translation. The flow is conceptual, with no measured numbers. View full size ▸

1. What happened

Whether to settle the architecture first, or first a vocabulary shared by domain experts and developers, is a trade-off to make as soon as work on a system begins. The position of Evans's 2003 book Domain-Driven Design is that the real difficulty in software lies in the business domain rather than in frameworks and databases[1]Evans, E. (2003). Domain-Driven Design: Tackling Complexity in the Heart of Software. Addison-Wesley. ISBN-13 978-0-321-12521-7. Bibliographic details checked against the publisher's record. 560 pages, published August 2003. The book systematises shared language, bounded contexts, the building blocks of model-driven design, and strategic design (context maps, distillation, the core domain). Passages in the book were not checked word for word here.. And the first bottleneck to getting knowledge into a system without loss is not technical. It is translation.

The typical failure looks like this. The domain expert speaks one set of terms, the developer translates them mentally into a second set, and then writes them down as a third (the variable and class names in the code). Every translation drops a little, and what it usually drops are conditions and exceptions. The expert says this kind of customer normally does not prepay, unless there was a dispute on the last order, and what reaches the code is one boolean field.

The book's first requirement is therefore a shared language: one vocabulary used by domain experts and developers alike, with no translation layer between them, and those terms become the names in the model and in the code. That sounds like advice about communication. It is actually a design constraint: if a concept has no name in the vocabulary, it should not have an implementation quietly growing for it in the code.

The second requirement comes from scale. A large system cannot sustain one unified model: the same word already means different things in sales and in logistics, and forcing them together only turns the model into a compromise nobody is happy with. The book's handling is to cut into several bounded contexts: meaning stays consistent inside each, what crosses between them is managed explicitly through a map, and where necessary a layer of anti-corruption translation sits at the join so the shape of an external model does not seep in[1]Evans, E. (2003). Domain-Driven Design: Tackling Complexity in the Heart of Software. Addison-Wesley. ISBN-13 978-0-321-12521-7. Bibliographic details checked against the publisher's record. 560 pages, published August 2003. The book systematises shared language, bounded contexts, the building blocks of model-driven design, and strategic design (context maps, distillation, the core domain). Passages in the book were not checked word for word here..

The third requirement is about allocating resources: design effort is finite, so put it first into the core domain, the part that actually produces the difference, and buy the peripheral and generic parts off the shelf wherever you can.

2. Why this matters to you

The most direct use of this page is that it explains why your collaboration with a model so often comes apart on a single word.

You hold a vocabulary of your own: what a certain file is called, what a certain stage is called, what a certain criterion is called. When you hand work over, you use your terms and the model uses the general sense it learned from the whole internet. Eight tenths of that overlaps. The remaining two tenths is where the misunderstanding comes from, and the misunderstanding does not show up as the model failing to answer; it shows up as a very fluent answer to a different question.

The shared-language move transfers directly. Fix your vocabulary, one name per concept, and carry those definitions in the context you give the model. That costs less than correcting it repeatedly, because you are repairing the input rather than the output.

The bounded-context layer is more interesting, because it licenses inconsistency in return. You do not have to make the word project mean the same thing everywhere. You only have to be consistent inside each context, and to convert explicitly when something crosses. That is unusually useful for one person running several lines at once: delivery on the client line and delivery on your own line were never the same thing, and forcing them together costs more than keeping them apart.

In practice this page offers three moves. First, write your vocabulary down, one name per concept, with synonyms marked as synonyms. Second, when you find one word meaning different things on two lines, do not unify, draw a context. Third, put design effort first into the part that genuinely differentiates you; if you cannot say how some part differs from the usual way of doing it, handle it the usual way and do not build a vocabulary and contexts for it.

Verification layer · Members
The guided layer of this node is open to all readers.
Verification details and failure boundaries are for members.
US$8.25 a month on average · or subscribe monthly ▸

Lab cases Written only where there is evidence

No field record for this node yet.

Common misreadings

Page verification: Bibliography checked ✓ · Content last revised 2026-11-14

  • A common account says domain-driven design is that set of naming conventions (entities, value objects, aggregates, repositories). That is the tactical layer. According to a report of a 2009 talk, the author said this set of building blocks is over-emphasised, and that bounded contexts and the core domain deserve more weight. Adopting the naming without doing the language and the contexts degrades into ordinary create-read-update-delete with fancier names. Nor can the set of building blocks be credited as a whole to Evans's 2003 book Domain-Driven Design: the Repository pattern, for one, was already included in the book on enterprise application architecture patterns published the year before, where the entry is credited to two other authors, Hieatt and Mee. #
  • A common account says one bounded context is one microservice. The two are orthogonal: one service can hold several contexts, and the reverse. Binding context boundaries hard to deployment boundaries cuts in the wrong places. #
References

How to read the source notes “Bibliographic details checked” means author, year, title and venue were confirmed. It does not mean the source's claims were checked. Definitions as of 2026-09-20.

  1. [1] Evans, E. (2003). Domain-Driven Design: Tackling Complexity in the Heart of Software. Boston: Addison-Wesley Professional. ISBN-13 978-0-321-12521-7. 560 pp. ↩

↳ Is a citation wrong?

Tell me when a new shelf opens

Tell me when a new shelf opens

Shelf notices are sent only when a new shelf opens or when the reading rules change.

Trial

Tell the editor privately: a correction, a counter-example or where it applies

Submissions are read only by the editor, and nothing is published before they are handled. Once a note is handled, a summary and response written by the editor are published. No sign-up is needed, and the nickname may be left blank.

What are you submitting?
Set a public name to be credited by name ▸
Submit anonymously, without signing in

Signing in lets you follow the status on your page. What you have written is kept.

You are signed in: this note is linked to your account, visible only to you and the editor, so you can follow its status on your page. The text is never published. Full privacy policy ▸

Submit anonymously instead, not linked to your account ▸

No email is collected. Your original text and nickname are read only by the editor and are never published; the site publishes only a summary the editor writes. The human check is provided by Cloudflare Turnstile. To limit abuse, the system keeps a hash of your IP address, not the address itself. Your original text is stored with our cloud provider and can be deleted on request. Full privacy policy ▸