Welcome
What will you learn in this course?
Who is the course for and prerequisites
Getting Started: Domain-Driven Design
Learn the fundamentals of Domain-Driven Design (DDD) with practical examples in this course. Explore complex domains, strategic patterns, and tactical design to create well-aligned systems!
About This Course
Domain-Driven Design (or DDD for short) is one of the most popular approaches
to software development, and that's for a very good reason.
As described excellently by Martin Fowler, it "is an approach to software
development that centres the development on programming a domain model with a
rich understanding of the processes and rules of a domain".
Building software that way, especially when dealing with a complex domain,
leads to aligned business people and developers and better software that does
precisely what the business needs. Ever since its formal definition by
Eric Evans all the way back in 2003, developers have used it to create software
based on a well-developed model of design. In this Getting Started course,
Amichai Mantinband will break down Domain-Driven Design into a very easily
digestible concept using his real-world experience.
Course Curriculum
5h 12m 11 sections
What is Domain-Driven Design?
What is a Domain?
Why you should learn and practice DDD
The two parts of DDD
Section Recap
The domain we’ll be exploring
The domain’s Ubiquitous Language
Ubiquitous Language as a tool for detecting Domain Objects
The domain’s invariants
Enforcing invariants
Creating the domain objects
Invariants as Unit Tests
Enforcing Invariants that rely on dependencies
The Result Pattern
Section Recap
What are Tactical Patterns?
What is Tactical Design?
Entities
Implementing the Entity base class
Value Objects
Implementing the Value Object base class
Aggregates
Shifting the focus to Aggregates
Implementing the Aggregate base class
Structuring the Domain Layer around Aggregates
Domain Services
Factories
Implementing a Static Factory Method
Repositories
Disconnected Domain Models
Repositories and EF Core
Implementing a Repository
Section Recap
Accessing the Domain Layer via a web API
A system without Domain Events
Eventual Consistency
What is a Domain Event?
The Domain Event Sausage Factory
Implementing a Domain Event
Section Recap
Domain Modeling & Analysis Paralysis
Domain Model Identity Uniqueness
Domain Object Deletion
One Aggregate Per Transaction
Reference Between Domain Models
Section Recap
Application Services vs Domain Services
Transactional vs. Eventual Consistency
Rich vs. Anemic Domain Models
Always Valid vs. Not Always Valid
Persistence Ignorance
Section Recap
What is Strategic Design?
Sub-Domains
The 3 types of Sub-Domains
Context Mapping and Context Maps
Context Map example
Team Relationships
Context Map Patterns
Section Recap
Bounded Contexts
Bounded Contexts vs. Sub-Domains (Problem vs. Solution Space)
Exploring our Domain’s Bounded Contexts
Exploring relationships between our Bounded Contexts
Defining our Context Map
Section Recap
What are Integration Events?
The chain of Integration and Domain Events
Using a Message Broker for distributing Integration Events
Error handling when publishing Integration Events
The Outbox Pattern
The Integration Events Sausage Factory - Outbox Writer
The Integration Events Sausage Factory - Integration Event Publisher
The Integration Events Sausage Factory - Consuming Integration Events
Section Recap
Course conclusion
Meet Your Instructor
Amichai Mantinband
© 2026 Dometrain. All rights reserved.
