Implementing Domain-Driven Design
The Broadest. The Deepest. The One That Sticks.
Master the art of software design with Vaughn Vernon: Internationally respected pioneer, developer, author, and speaker in Domain-Driven Design.
Thousands of architects and developers have used this workshop to transform how they design software. Vaughn’s influence runs broad and deep in the DDD world. This is your chance to learn it all.
I have attended a number of Vaughn's workshops and came away with new insights every time.
The IDDD Workshop I attended was one of my best trainings ever.
Reserve Your Spot in Vaughn Vernon’s Flagship Workshop.
Join a live, small-group cohort and learn directly from the author of Implementing Domain-Driven Design. Seats are limited for deeper engagement.
Fall workshops are coming! Get first access when the schedule drops — join our mailing list now.
The IDDD Tour Throwback is open for registration NOW.
All tickets $2000 $400.
Don’t miss this opportunity to learn from Vaughn at throwback pricing!
Save $1600
💡 What Makes This Training Different
This workshop gets straight to what matters.
You’ll gain practical techniques, strategic clarity, and deep insight that comes from learning with the original voice of fully implementing with Domain-Driven Design.
🧰 Everything You Need to Apply DDD with Confidence
How to design complex systems that work at scale—and keep working.
Strategic DDD: Make sense of your domain of core innovations with Bounded Contexts and Context Maps.
Tactical DDD: Model aggregates, use values, enforce invariants, protect business rules, and publish events.
Architecture patterns that are extensible and enduring—modular monoliths, microservices, and event-driven systems that play well together.
How to communicate clearly across teams using a shared language that means something to business and development.
🧠 What You’ll Walk Away With
By the end of this workshop, you won’t just know about DDD. You’ll know how to use it to:
- Break through messy legacy code and business confusion of the Big Ball of Mud
- Navigate legacy systems and tech debt with clarity and a go-forward understanding
- Build strategically significant software with the business, not just for it
- Navigate architectural trade-offs with clarity and make decisions that promote flexibility
👨🏫 Meet Your Instructor: Vaughn Vernon
Vaughn has taught thousands of business leaders, architects, and developers worldwide.
He’s known for a clear, hands-on teaching style that helps you understand how to apply DDD—and keep your designs simple, even in complex systems.
Vaughn Vernon's teaching style was engaging and dynamic, making it easy for everyone to follow along and understand the concepts. His expertise and enthusiasm for DDD were evident throughout the workshop, and he was able to answer all of our questions in a clear and concise manner.
Thank you for this course. You communicate in a very clear and easy to understand manner and I think this and your professional experience were key factors in transmitting your extensive knowledge.
📝 Everything You Need to Apply DDD with Confidence
Vaughn covers a full range of Domain-Driven Design—from business strategic thinking and design to architectural patterns to tactical modeling. While the material is comprehensive, each session is guided by the needs and pace of the group. You’ll learn with peers who care about building better systems, just like you. You get the clarity you need, when it matters most.
🧭 Strategic Design Foundations
Discover breakthroughs with EventStorming, Impact Mapping, and related tools
Understand your domain using Subdomains, Bounded Contexts, and Context Maps
Identify where to apply DDD for the greatest impact, appropriate investment, and value
Align teams and architecture using collaborating components with shared mental models
Break free from both intentional and accidental complexity by focusing on strategic purpose
🧱 Tactical DDD in Practice
Model Aggregates, Entities, Value Objects, Domain Services, and Domain Events
Manage business rules and invariants using policies and designed persistence boundaries
Tackle complexity with simplicity and reject ceremony with purpose and agility
🧠 Architecture that Purposely Supports Your Domain
Discover how to apply DDD while building modular monoliths, microservices, and serverless
Work with event-driven architectures, messaging patterns, and asynchronous flows
Understand when and how to design and model choreographed and orchestrated processes
Grasp how strategic modeling guides the shape of your architecture
🤝 Modeling Together
Participate in collaborative strategic planning and a full range of modeling exercises
Practice using EventStorming, Impact Mapping, domain scenarios, and other visual tools
Apply what you’re learning to realistic problems: from legacy cruft to greenfield elegance
Experience how Vaughn guides modeling sessions in a way that makes the complex doable
Day 1
Strategic Domain-Driven Design
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.
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.
Learn how to turn system complexity into simple solutions by reduction of concepts and organization that decreases cognitive load and increases flow of software value outcomes. Uses strategic goals, reductionism, and conceptual composition, and applies the Cynefin Framework and Impact Mapping.
Human communication and learning through sense-giving and sense-reading are indispensable for successful strategic software outcomes. Increase the effectiveness of your team and organizational communication using patterns and practices that deliver real results.
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 require more rigorous design. You will gain a new tool from this experience, known as Context Topo Maps.
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. You will use Context Topo Maps to make it all make sense.
Day 2
Architecture and Event-Driven Modeling
Day 2 crosses over to architecture, preparing you for modularity, to employ Ports and Adapters, Event-Driven, and other powerful architectural tools as you develop new Bounded Contexts in hands-on exercises and homework. Students learn ways to develop a Ubiquitous Language within a Bounded Context, using Event Storming, Extreme Modeling, and Context Topo Maps. Students use these tools to reach a shared understanding of a Core Domain and Subdomains.
If you don’t understand modularity and apply it to the full, you will have trouble using DDD. Don’t go to all the trouble to carefully craft a Ubiquitous Language with domain objects but overlook proper modularization. Learn why modularity at every level is so vital to good architecture and design. Capture the techniques for organizing concepts within a Bounded Context and inside its domain model.
See how various architecture styles and patterns can be used to support your DDD projects. We will survey use of 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.
Learn to use Domain Events and Event Storming for both “big picture” systems designs and “detail level” tactical designs. Yet, with remote team interactions, you’ll need a technique beyond Event Storming. That’s why you’ll learn to leverage Extreme Modeling. Includes online exercises.
Gain an understanding of the mindset to accomplish data product development through a decentralized platform and architectural patterns to bring harmony to data analytics, machine learning, along with practical and narrow artificial intelligence (AI).
Day 3
Tactical Domain-Driven Design
On Day 3 we switch our focus to tactical design, giving you the aptitude to make proper finer-grained modeling decisions within a Core Domain. Whether it’s 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. Learn the advantages and trade offs of using each of the tools, and when another tool could provide a better set of trade offs.
Understand how to properly employ this necessary modeling tool. 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. Rather than overusing Entities, you will learn how to best use them only when a domain concept must change over time.
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.
Use this powerful modeling tool to shape, structure, and compose, transactional boundaries around a meaningful whole concept. Transform your understanding of Entity thinking into one that scales broadly and performs under high load, all while protecting valuable and time-sensitive business state.
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.
Learn when and how to use domain-specific factories to support the creation of domain objects.
Day 4
Strategic Design Meets Implementation
During Day 4 we bring all the parts together to form a microservice (or 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. 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 support REST frontends and Applications Services when necessary. With all this background you will be prepared to move forward with a DDD project of your own, or to make greater strides on your current DDD strategic initiative.
You will learn how to persist and retrieve your Aggregates using object-based persistence and with Event Sourcing.
Learn what CQRS is and how to apply CQRS using full Entity state, Domain Events, and Event Sourced models. Discover how to partition your Bounded Context for two-sided operation for the command model and the query model. We consider the basics of query/read-side projections, how to deal with complex projections, and how to implement queries.
Employ both REST and messaging to realize your Context Maps in 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. Integration techniques include long-running transactions by means of Process Managers, aka Sagas.
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. Guidance includes how the CQRS query model factors in as well as using API composition.
What People Say After Attending
I have learned so much, and a lot of misconceptions of mine were cleared up when it comes to DDD. The workshop is very engaging and collaborative. There is such a big difference... being taught by Vaughn.
Regardless of whether you’re a seasoned DDD practitioner or just getting your feet wet, get ready to experience what practicing Domain-Driven Design on your team could be like.
DDD? Begin at the source. @VaughnVernon 's Implementing Domain Driven Design workshop was worth every penny.
This Workshop Is For You If You’re…
A technical leader, architect, or mid- to senior-level developer
Working on complex business systems
Tired of vague advice and want practical modeling clarity
Leading or collaborating on event-driven or modular systems
Open-minded and willing to learn vastly different approaches
What You Get:
4 live, half-day sessions with Vaughn Vernon
Practical exercises + real-world modeling
Lifetime access to workshop materials
Small-group format for deeper engagement
Full polyglot example and solution source code
You don’t have to figure it out alone.
Learn directly from the person who’s helped thousands to apply DDD with clarity and purpose
Register now and start building better systems
Still have questions?
Contact us. We’ll help you figure out if this training is right for you and your team.