Domain-Driven Design is a philosophy and approach to developing software, it's not an architecture. Strategic DDD helps us of getting out of the big ball of mud (logical and not physical coupling). It helps us in identifying our business capability boundaries (bounded context) using an ubiquitous language (a language that is shared and understood in one part of the business) as well identifying and naming the relationships (context mapping) that our bounded contexts (also teams) have between each other. By understanding the relationships between our contexts, it aids in making decisions about how are we going to model our software.
It’s a mindset: the application Design is Driven by the business Domain. There are no steps of how to do DDD and there isn’t a formula you can learn. What you can learn from Eric Evans or other DDD experts is how they approached a problem, but nobody can give you a sure recipe of how to do things.
updates:
14.04.2024: Addition of Bounded Context examples subsite
05.01.2024: correction of link references
24.11.2023: XTI XTI Domain-Driven Design - Een pragmatische gids ebook pdf (Dutch)
14.03.2023: Added Hands-On Domain Driven Design with .NET Core pdf (Zimarev)
28.01.2023: Rethinking Bounded Contexts (Florian Sauter)
27.12.2022: Continuous Architecture: Case study
30.11.2022: About Team Topologies and Context Mapping (Alberto Brandolini)
29.09.2022: Build Business Capabilities, not APIs (Nial Darbey)
11.09.2022: Microsoft - Microservices architecture e-book
02.09.2022: Irfan Muhammad - Microservices – Design and Implementation
18.07.2022: Added DDD Europe 2022 links at bottom
21.05.2022: Going “Events-First” for Microservices with Event Storming and DDD
14.05.2022: The highly desirable way of context communication is event-based
29.04.2022: Implementing Domain-Driven Design for Microservice Architecture (Ernese Norelus)
26.04.2022: Applying Domain-Driven Design and Patterns (Jimmy Nilsson)
11.04.2022: Patterns on Deriving APIs and their Endpoints from Domain Models
09.04.2022: The Art of Discovering Bounded Contexts by Nick Tune (YouTube)
22.03.2022: Added a subset of Dutch sites
27.02.2022: Gateway Interchange Context on YouTube - Nick Tune 2019
22.01.2022: What is Microservice Architecture - Kenneth Lange 2017
08.01.2022: The Bounded Context Canvas - DDD crew 2021
04.01.2022: Canonical Data Models - Gateway Interchange Contexts Nick Tune 2019
04.01.2022: Bounded Contexts and Canonical Data Models - Michael Plöd 2016
13.11.2021: Bounded contexts and subdomains - Robert Basic 2018
05.10.2021: Context Maps - a deep dive - Michael Plöd - KanDDDinsky 2019
28.09.2021: Strategies for getting started with DDD - Eric Evans 2013
26.09.2021: The repository cares about storing/retrieving objects from the db
- The canonical Big Blue Book of Eric Evans (2003): Domain-Driven-Design Tackling Complexity in the Heart of Software
- Domain Driven Design Quickly is a short, quick-readable summary and introduction to the fundamentals of DDD (2006): Domain Driven Design Quickly
- Strategies for getting started with DDD when you have a big commitment to legacy systems (by Eric Evans 2013): Getting started with DDD when surrounded by legacy systems
- Domain-Driven Design, Definitions and Pattern Summaries (by Eric Evans 2015): Domain-Driven Design Reference
- Vaughn Vernon presents the whole of Domain-Driven Design (by Vaughn Vernon 2013): Implementing Domain-Driven Design
- Concise basics of DDD (by Vaughn Vernon 2016): Domain-Driven Design Distilled
- Patterns, Principles and Practices of Domain-Driven Design (by Scott Millet and Nick Tune 2015): Patterns, Principles and Practices of Domain-Driven Design
- The Anatomy of Domain Driven Design (by Scott Millett 2019): Primer DDDEurope.com
- Applying Domain-Driven Design and Patterns: With Examples in C# and .NET (by Jimmy Nilsson 2006): Applying Domain-Driven Design and Patterns
- Learning Domain-Driven Design. Aligning Software Architecture and Business Strategy (by Vlad Khononv 2021): Learning Domain-Driven Design
- Hands-On Domain Driven Design with .NET Core - Tackling complexity in the heart of software by putting DDD principles into practice (by Alexey Zimarev 2019): Hands-On Domain Driven Design with .NET Core
- XTI Domain-Driven Design - Een pragmatische gids (by XTI 2021): Domain-Driven Design - Een pragmatische gids
- Literature phrases on Bounded Contexts (2023): Quotes for the concept of Bounded Context
- Literature Bounded Context examples (2024): Bounded Context examples as found in DDD-literature
- Literature phrases Ubiquitous Language (2023): Quotes for the concept of Ubiquitous Language
- Literature phrases Published Language (2023): Quotes for the concept of Published Language
- DDD easily explained (by Anders Gill 2019): Part 1: Domain Driven Design like a pro
- A Decade of DDD, CQRS and Event Sourcing (by Anes Hasičić 2019): A Decade of DDD, CQRS and Event Sourcing by Anes Hasičić
- DDD introduction (by Dan Haywood 2019): An Introduction to Domain Driven Design
- Various articles on Sapiens Works (2012 - 2018): Sapiens Works: Domain Driven Design
- Triple D Courses (2019): DDD basic concepts
- Wikipedia (2021): Domain-driven design
- This article shows a domain-driven approach to designing microservices (by Microsoft 2019): Using domain analysis to model microservicess
- What is Bounded Context? (by Dave Taubler 2020): If You’re Building Microservices, You Need to Understand What a Bounded Context is
- BoundedContext (by Martin Fowler 2014): Bounded Context is a central pattern in Domain-Driven Design
- The Bounded Context Canvas (by DDD-crew Github 2021): A structured approach to designing and documenting each of your bounded contexts
- Clues for discovering Contexts (by Nick Tune 2017): The Art of Discovering Bounded Contexts
- Rethinking Bounded Contexts (by Florian Sauter 2021): Learnings about DDD, Bounded Contexts and team Autonomy
- Clues for discovering Contexts (by Nick Tune 2017): The Art of Discovering Bounded Contexts
- Bounded Contexts are the exact opposite of Microservices! (by Vladik Khononov 2018): Bounded Contexts are NOT Microservices
- Design of microservices using the principles of Domain-Driven Design (by IBM 2018): Apply Domain-Driven Design to microservices architecture
- SOA vs Microservices (by Rahul Lanje 2017): What is Microservice Architecture? How is it different from SOA? Why containers?
- Ideally there should be a direct mapping between a business service / capability and a microservice (or what in Domain Driven Design is called a bounded context (by Kenneth Lange 2017): What is Microservice Architecture?
- Break a monolith into multiple domain-based microservices - as we break the monolith and spread the aggregates into different contexts... (by Chandra Ramalingam 2020): Building Domain Driven Microservices
- Thoughts on how to marriage Domain-Driven Design (DDD) with microservice architecture (Ernese Norelus 2019): Implementing Domain-Driven Design for Microservice Architecture
- Design Characteristics of Microservices (Irfan Muhammad 2022): Microservices – Design and Implementation
- A domain model should omit the extraneous information irrelevant to its task. (by Vladik Khononov 2020): Thread on models and bounded contexts
- But in order to make the API understandable to domain experts, it is essential that names and abstractions in the API follow the terms defined in the ubiqitous language which is formally specified by the domain model (2021): Patterns on Deriving APIs and their Endpoints from Domain Models
- Bounded Contexts can have a unified model (a way of structuring MultipleCanonicalModels). (by Martin Fowler 2014): MultipleCanonicalModels
- Implement the bounded context concept meaning one model per context. (by Teiva Harsanyi 2017): Why is a Canonical Data Model an Anti Pattern
- Lightweight Canonical Data Model per functional domain. (by Tanya du Preez 2016): Canonical Data Models & Microservices
- Multiple smaller canonical models that sit within our bounded contexts - bounded context in API path. (by Jeff Watkins 2018): Architectural Mistakes I Have Made: Microservices, APIs, Commoditisation and Bounded Contexts
- Microservices Domain Driven Design, why and how? (Published Language as pattern and Canonical Data Model). (by Michael Plöd 2016): Published Language and Canonical Data Model can be a dangreous pattern
- Michael Plöd: Microservices love Domain Driven Design, why and how? (2d). (by Michael Plöd 2017): Published Language and Canonical Data Model don't overdue this
- Gateway Interchange Contexts. (by Nick Tune 2019): Gateway Interchange Context as Enterprise Integration Pattern
- Canonical Data Model Best practices. (by Majeed 2018): For microservices, define a light weight canonical model per functional domain
- Data Management at Scale. (by O'Reilly Piethein Strengholt 2020): Enterprises took the “E” in ESB literally and implemented monoliths into their organization to take care of all the service integration
- Strategic Microservice Patterns. (by Nick Tune 2019): Gateway Interchange Contexts on YouTube
- Microservices represent a more pragmatic approach to service design by focusing more on the needs of individual business units.This is in contrast with the first overly-ambitious aim of SOA to deliver services reusable across the enterprise, and its consequential emphasis on enterprise-wide canonical models.. (by Nial Darbey 2016): Build Business Capabilities, not APIs
- The subtle relationship between bounded contexts and sub-domains (by Lev Gorodinski 2013): Sub-domains and Bounded Contexts in Domain-Driven Design (DDD)
- Stackoverflow (2018): Confused about Bounded Contexts and SubDomains
- Stackoverflow (2018): Can subdomain and bounded context be same in domain driven design?
- 'The optimal solution would be to have one bounded context in one subdomain...so it might happen that one bounded context spans multiple subdomains, or that one subdomain has multiple bounded contexts.' (by Robert Basic 2018): Bounded contexts and subdomains
- Subdomain vs Bounded Context (by Nick Tune 2020): Domain, Subdomain, Bounded Context, Problem/Solution Space in DDD: Clearly Defined
- 'It is a desirable goal to align Subdomains one-to-one with Bounded Contexts (p77)' (by Vaughn Vernon 2013): Implementing Domain-Driven Design
- 'Strategic design starts with the problem space, which represents the business architecture and which includes the problem domains and (categorized) subdomains. The solution space represents the software architecture and contains the bounded context. There must be an overlap between the two.' (by Michael Plöd 2019): Pitching DDD to the management - YouTube
- '(Sub)domains Problem Space - Bounded Contexts Solution Space' (by Alpha Code 2018): DDD Strategic Design in under 15 minutes - YouTube
- Stackoverflow (2013): Communicating between two Bounded Contexts in DDD
- Stackoverflow (2013): DDD - How to design associations between different bounded contexts
- Context Mapping (by Vladik Khononov 2019): What Is Domain-Driven Design? O'Reilly
- Context Maps - a deep dive (Published Language - Consortium) (by Michael Plöd 2019): Context Maps - a deep dive - Michael Plöd - KanDDDinsky 2019
- Stackoverflow (2016): The highly desirable way of context communication is event-based
- 'Use events as a way to communicate between bounded contexts'. (by Indu Alagarsamy 2019): Practical DDD: Bounded Contexts + Events => Microservices
- 'Consider “Events-First”'. (by Russ Miles 2022): Going “Events-First” for Microservices with Event Storming and DDD
- 'DDD is mostly used together with an event driven architecture. The communication between the Product Catalog and the Sales Bounded context would be done by using events.'. (by StackExchange 2021): How to manage data consistency between Bounded Contexts?
- Entities versus Value Objects (by Philip Brown 2014): What is the difference between Entities and Value Objects?
- Entity vs Value Object (by Vladimir Khorikov 2016): Entity vs Value Object: the ultimate list of differences
- The repository cares about storing/retrieving objects from the db (2014): Repositories in domain driven design
- 'Microservices should avoid the orchestration pattern to communicate with each other' (Irfan Muhammad 2022): Microservices – Design and Implementation
- Smart endpoints dumb pipes (by Ian Cooper 2020): Capability Mapping YouTube - Ian Cooper
- Start with a strategy (by Yoan Thirion 2018): DDD re-distilled This article is an abstract of the book DDD Distilled written by Vaughn Vernon
- API design - Azure Architecture (2019): Designing APIs for microservices
- Aggregate Roots are a good starting point for API Resources (Zimmerman ao 2021): A Grey Literature Study Based on Grounded Theory
- Apache Kafka + Domain-driven design (DDD) = Decoupled event streaming microservices (by Kai Waehner 2019): Microservices, Apache Kafka, and Domain-Driven Design
- 'Like every other technology, the Microservice Architecture has drawbacks and is not a silver bullet'. (by Dakshitha Ratnayake 2019): API-driven Microservice Architecture - A WSO2 Reference Architecture
- 'There is no microservice architecture'. (by dwmkerr.com 2018): The Death of Microservice Madness
- kgoralski (2019): Domain-driven design (DDD) learning resources
- heynickc (2021): Awesome Domain-Driven Design
- ddd-cqrs-es: ddd-cqrs-es.slack.com
- IBM (2021): ESB vs. Microservices: What's the Difference?
- 'We would design a pure domain model, untainted by theinfrastructure details, that captures the Ubiquitous Language and implements the necessary business logic'. (p145) (by Vaughn Vernon 2013): Implementing Domain-Driven Design
- 'The logic that should be in a domain object is domain logic - validations, calculations, business rules - whatever you like to call it.'. (by Martin Fowler 2014): Implementing Domain-Driven Design
- 'The main point of DDD is to identify relevant domain behaviour, which means getting to know plenty of domain rules.'. (by Sapiens Works 2017): How To Handle Business Rules in Domain Driven Design
- 'As a result, the business logic will be in the domain-model, with a lot less duplication as a result'. (by Albert Starreveld 2020): Domain-Driven Design in a nutshell
- 'This principle is similar in Domain-driven design (DDD), where each Bounded Context or autonomous subsystem or service must own its domain model (data plus logic and behavior)'. (p28) (by Microsoft 2022): Microservices architecture e-book
- Brandolini (2022): About Team Topologies and Context Mapping
- 'Team Topologies and Context Maps are two interesting approaches to visualize sociotechnical architectures.' (by Michael Plöd 2022): Systems Thinking by combining Team Topologies with Context Maps
- Continuous Architecture: We (Michelin) wrote this case study, inspired by a real use case, to present one approach to apply Domain Driven Design if you are an architect trying to design your product
- Javiera Laso: How to start with DDD when you have a Monolith
- Julien Topçu: REST next level : Crafting business-oriented web APIs by Julien Topçu
- Thomas Ploch: What is a DDD Aggregate? The One Question To Haunt Everyone!
- Michael Plöd: Introduction to Context Mapping