Strategic thinking, tactical craft, real modeling
Day 1
Strategic DDD
- What is DDD? When the investment pays off and when it doesn't — an honest assessment
- Ubiquitous Language: Building a shared vocabulary with the business — concrete methods that survive past the workshop
- Bounded Contexts: Defining explicit model boundaries; why the same word means different things in different contexts
- Context Mapping: How bounded contexts integrate — Partnership, ACL, Open Host Service, Published Language
- Event Storming: Collaborative domain discovery workshop — facilitation, materials, and how to run it with your own team
- Hands-on: event storming a real business process from the room
Day 2
Tactical DDD & Implementation
- Entities vs Value Objects: Identity vs structural equality — deciding correctly, applying consistently
- Aggregates: Defining consistency boundaries, aggregate roots, protecting invariants — the core of tactical DDD
- Repositories: The persistence abstraction — what belongs inside and what doesn't
- Domain Services vs Application Services: Where business logic actually lives
- Domain Events: State changes as first-class citizens, event-driven integration between contexts
- DDD with Spring Boot: Package structure, aggregate mapping, testing strategies for domain objects
- Anti-patterns: anemic domain model, over-engineering — recognizing both in real code
Workshop
Applying DDD to a real problem
- Translating event storming output into service boundaries and bounded context definitions
- Modeling aggregates in groups: live design, code review, and structured feedback
- Common implementation failures — analyzed live against real code examples
- How developers and domain experts keep the language in sync over time (living documentation)
What your team walks away with
DDD isn't a switch you flip — it's a practice that builds over time. This training lays the foundation solidly enough that the team can move forward independently. Concretely:
- Define and communicate bounded contexts explicitly — no more implicit "that kind of belongs here"
- Model aggregates cleanly and protect invariants without relying on database transactions as a workaround
- Facilitate event storming workshops and use them as a regular tool, not a one-off exercise
- Justify microservice boundaries by bounded context — business-driven, not technically arbitrary
- Keep the Ubiquitous Language consistent in code, tests, and documentation
The training works especially well when participants bring a real domain problem from their own company. If that's desired, it's agreed upfront — and we model with real material instead of a demo shop.
Book the DDD training
DDD workshops work best when developers and domain experts attend together. Short conversation about participants and domain — then a concrete concept.
Get in touch