Domain Driven Design Course

Lesson 1 • Domain Experts and Collaboration

Covers techniques for engaging domain experts as active design partners. Students practice knowledge-crunching conversations and structured workshops.

Lesson 2 • DDD Strategic vs. Tactical Patterns

Distinguishes the two pattern families and explains how they complement each other. Sets the learning roadmap for the rest of the course.

Lesson 3 • The Ubiquitous Language Concept

Introduces shared language between developers and domain experts as DDD's foundational practice. Students learn to identify and build a living glossary.

Lesson 4 • Understanding the Domain and Subdomains

Teaches decomposition of a business domain into core, supporting, and generic subdomains. Students apply this to real scenarios to prioritize design investment.

Lesson 1 • Choosing Between Entities and Value Objects

Provides decision criteria for classifying domain concepts correctly. Students analyze ambiguous cases and justify their modeling choices.

Lesson 2 • Modeling Rich Domain Behavior

Moves beyond data containers to place business logic inside domain objects. Students implement domain methods that enforce invariants.

Lesson 3 • Practical Implementation Patterns

Translates conceptual models into working code structures. Students apply factory methods, copy constructors, and equality overrides.

Lesson 4 • Entities: Identity and Lifecycle

Defines entities as objects with a continuous identity across state changes. Students learn identity assignment strategies and lifecycle management.

Lesson 1 • Aggregate Fundamentals

Defines aggregates as consistency units composed of entities and value objects. Students learn why aggregates exist and what problems they solve.

Lesson 2 • The Aggregate Root Role

Explains the root entity as the sole external access point for an aggregate. Students implement root-controlled access and identity referencing.

Lesson 3 • Aggregate Invariants and Validation

Covers enforcing business rules that span multiple objects within an aggregate. Students write invariant checks triggered by state-changing commands.

Lesson 4 • Cross-Aggregate Communication

Addresses how aggregates interact without violating isolation. Students use domain events and eventual consistency to coordinate across boundaries.

Lesson 1 • Domain Services for Stateless Logic

Identifies operations that belong to no single entity or value object. Students implement domain services that express pure business logic.

Lesson 2 • Factory Pattern in DDD

Explains factories as encapsulators of complex creation logic. Students build factories that enforce invariants during object construction.

Lesson 3 • Repository Implementation Strategies

Covers concrete repository implementations and their trade-offs. Students map aggregate roots to persistence stores without leaking infrastructure into the domain.

Lesson 4 • Integrating the Supporting Patterns

Shows how repositories, factories, and services collaborate in a complete use case. Students trace a command from application layer through domain and back.

Lesson 1 • Context Mapping Patterns

Introduces the full catalog of context relationship patterns. Students select appropriate patterns based on team dynamics and integration needs.

Lesson 2 • Bounded Context Fundamentals

Defines a bounded context as an explicit boundary within which a model is consistent. Students identify context boundaries in existing systems.

Lesson 3 • Drawing and Documenting Context Maps

Teaches notation and tooling for producing readable context maps. Students create maps that communicate integration contracts to all stakeholders.

Lesson 4 • Anti-Corruption Layer Design

Deep-dives into the ACL as a translation boundary protecting the domain model. Students implement adapters and translators that isolate external model concepts.

Lesson 1 • Domain Events as Business Facts

Defines domain events as immutable records of something meaningful that occurred. Students distinguish domain events from technical messages and system notifications.

Lesson 2 • Event Sourcing Introduction

Introduces event sourcing as an alternative persistence strategy driven by domain events. Students evaluate when event sourcing fits and when it adds unnecessary complexity.

Lesson 3 • Eventual Consistency and Saga Patterns

Addresses multi-step business processes that span aggregates and contexts. Students implement choreography-based and orchestration-based sagas.

Lesson 4 • Integrating Events Across Bounded Contexts

Extends domain events to cross-context integration via messaging infrastructure. Students design integration events that respect context autonomy.

Lesson 1 • Layered Architecture in DDD

Introduces the classic four-layer DDD architecture and its dependency rules. Students map domain concepts to the correct layer.

Lesson 2 • Infrastructure Concerns and Dependency Inversion

Shows how dependency inversion keeps the domain layer free of infrastructure dependencies. Students wire infrastructure adapters using dependency injection containers.

Lesson 3 • Application Services and Use Cases

Defines application services as orchestrators of domain logic for specific use cases. Students keep application services free of business rules.

Lesson 4 • CQRS Pattern Fundamentals

Introduces Command Query Responsibility Segregation as a complement to DDD. Students separate write models from read models to optimize each independently.

Lesson 1 • Strategic Distillation of the Core Domain

Focuses design investment on the core domain through distillation techniques. Students produce a highlighted core document and a generic subdomain extraction plan.

Lesson 2 • Handling Domain Complexity with Modules

Uses modules to organize large domain models into cohesive, loosely coupled packages. Students apply cohesion and coupling metrics to module design.

Lesson 3 • Supple Design Principles

Covers Evans's supple design patterns for making models intention-revealing and flexible. Students apply intention-revealing interfaces and side-effect-free functions.

Lesson 4 • Modeling Policies and Business Rules

Addresses complex, changeable business rules as explicit domain objects. Students implement the specification and policy patterns to encapsulate rule logic.