plus de 20 d'expérience à votre service
plus de 20 d'expérience à votre service

Implementing Domain-Driven Design

Go beyond the theory of DDD

Course overview

Intensive, 3-Day, hands-on IDDD Workshop by Vaughn Vernon

Go beyond the theory of DDD and see how your team can actually use DDD to accelerate your strategic initiatives in a way that helps you design for the business’ competitive advantage. Emphasis is placed on software development as a craft by embracing software design in the source code that works within the framework of agile processes and de-emphasizes attempts to solve real strategic business software initiatives by throwing technology at the problem.

The event is best for senior and mid-level software developers and architects interested in software craftsmanship and learning domain modeling using the Domain-Driven Design (DDD) approach. If your organization is looking for the way forward with Microservices, consider this workshop an essential foundation.

This is a hands-on workshop. Students are strongly encouraged to engage in workshop exercises and write source code that includes implementing multiple interacting Microservices, as DDD Bounded Contexts, that are event-driven. You will use DDD strategic and tactical design in your implementations.

The Workshop will be given by Vaughn Vernon the author of the books Implementing Domain-Driven Design and Domain-Driven Design Distilled .

Day One

Getting started, strategic design, and architecture

The goal of Day 1 is for you to get grounded with a DDD mentality that will free your mind from data-driven approaches. This is necessary to grasp the thrust of developing a Ubiquitous Language within a Bounded Context, the hallmark of DDD. From there you will be ready to embrace strategic design using Sub-domains, Bounded Contexts, and Context Maps. Day 1 then crosses over to architecture, preparing you to employ Ports and Adapters, Event-Driven, and other powerful architectural tools as you develop new Bounded Contexts in classroom exercises. Students learn ways to develop a Ubiquitous Language within a Bounded Context, using both Specification by Example and Event Storming. Find your way toward correct software delivery goals using Impact Mapping. Teams of students will use these tools to reach a shared understanding of a Core Domain and Sub-domains. Each team will present their “big picture” and “design level” direction and receive helpful feedback before the Implementation begins on Day 2.

Getting started with DDD

Understand the essence of DDD. Form the right mentality for powerful software modeling. Develop a Ubiquitous Language for your project using the Specification by Example approach and Acceptance Tests. This lays a foundation for moving forward with DDD.

Domains, subdomains, and bounded contexts

Grasp the core concepts of DDD strategic modeling, and put them to use. Learn to vigorously gather core concepts and separate irrelevant ones. Learn why strategic design is so essential. Develop the ability to determine when your domain models are composed correctly and when they required more rigorous design.

Context mapping

Learn how to integrate with other subsystems using DDD and straightforward design techniques. Context Maps are not just drawings. Use them for cross-team communications, project thinking, learning, planning, and as an integration tool.

Architectures that support DDD

See how various architecture styles and patterns can be used to support your DDD projects. We will look at the following: Layers; Dependency Inversion Principle; Hexagonal; Microservices; REST; Event-Driven; Process Management; Event Sourcing and CQRS; Actor Model. Coupled with DDD, these architecture styles and patterns will support your microservices efforts.

Domain events and event storming

Learn to use Domain Events and Event Storming for both “big picture” systems designs and “detail level” tactical designs. Exercises will lead to using and Event-Driven Architecture in Day-2 implementations.

Day Two

Tactical Design

In Day 2 we switch our focus to tactical design, giving you the aptitude to make proper finer-grained modeling decisions within a Core Domain. Whether its the use of Entities, Value Objects, Aggregates, Domain Events, or Domain Services that best fit your specific modeling situation, you can put each of the tactical tools to use in your own Core Domain project. As the day progresses, you will learn the advantages of using each of the tools, and when another tool could provide a better set of trade-offs.


There will likely be at least some Entities in object-oriented domain models because of the need to manage change over the life cycle of mutable objects. Understand how to properly employ this necessary modeling tool, but also why you should use these less often than you may think. Rather than overusing Entities, learn how to best use them only when a domain concept must change over time.

Value objects

Embrace this invaluable, functional modeling tool, which you should use as often as possible. You will learn the Value Object characteristics and why using Values where possible is a safer way to design. You will learn by modeling concepts as Values, and you may even decide to use Value-prolific designs rather than Entities.


Learn how to integrate with other subsystems using DDD and straightforward design techniques. Context Maps are not just drawings. Use them for cross-team communications, project thinking, learning, planning, and as an integration tool.

Domain events

Learn how to model, publish, and consume the facts of what happened in a domain model. You will see how Domain Events have a far-reaching impact on your designs across the enterprise. Here you will gain an understanding of how to publish and consume Events using messaging.

Domain services

Add powerful stateless operations to your model when its use is appropriate. The modeling techniques cover both domain-specific services and those of a more technical nature, often used for integration.


Understand the importance of and techniques for organizing concepts within a single domain model. Why go to all the trouble to carefully craft domain objects but without proper modularization using your Ubiquitous Language?


See when and how to use factories to support the creation of domain objects.

Day Three

Aggregate persistence, integrating bounded contexts, application

During Day 3 we bring all the parts together to form an application. We look at different ways to persist Aggregates using object-relational mapping, document databases, key-value stores, as well as by employing Event Sourcing. We then take a deep dive into applying Context Mapping techniques as we return to strategic design, but this time by developing integration solutions between Core Domains and other Bounded Contexts in your whole-system solution. Finally, we give attention to other parts of the application, such as the user interface and querying with CQRS. We also take a look at how to use Applications Services when necessary. With all this background you will be better prepared to move forward with a DDD project of your own or to make greater strides in your current DDD strategic initiative.

Repositories and event sourcing

Consider two primary approaches to persisting and reconstituting your domain objects. You will learn how to persist and retrieve your Aggregates using both SQL and NoSQL databases. You will also learn how to use Event Sourcing as both a persistence approach and to publish Domain Events for broader consumption.

Integrated bounded contexts

Employ both REST and messaging to realize your Context Maps in the code as you integrate multiple Bounded Contexts of enterprise applications. Understand the complexities and challenges of distributed computing environments, and how to deal with them. An important lesson that is reemphasized is to model each Bounded Context cleanly and separately from those with which you integrate.


Learn how the components that surround your domain model comprise a whole subsystem application. Consideration is given to User Interface strategies and the Application Programming Interface (API) using Application Services. Here you will learn how to apply CQRS from Domain Events and Event Sourcing.

Vaughn Vernon
Atelier, Atelier
Software Developers, Architect, Business Analyst
There're no item that match your search criteria. Please try again with different keywords.

Interested in our services now?