Domain-Driven Design


Domain-Driven Design

Authors: Matthew Renze, Dino Esposito, Julie Lerman, Steve Smith, Vladimir Khorikov

Learn the philosophy and major design patterns that underlie the Domain Driven Design approach to software architecture. Understand the importance of focusing on the core domain... Read more

• How to split the problem domain into Core, Generic, and Supporting subdomains and design bounded contexts for them with appropriate level of effort (e.g. rich domain model, transaction script, etc.) • How to identify entities and Value Objects in the domain model • How to choose aggregate boundaries in the bounded context and identify the root entity in the aggregate • How to work with domain events • The Specification pattern • How to identify an anemic domain model and refactor away from it towards a rich one • How to work productively with a legacy project via implementation of an anti-corruption layer • How to map complex domain models using modern ORMs, such as EF Core and NHibernate • How to apply the CQRS pattern in practice • Working with Event Sourcing


C# programming language


Like a building, the strength of your software construction starts with a solid foundation. Here we learn both the basics of clean software architecture design and the fundamental pillars of the Domain Driven Design approach you’ll need in any solution you create.

Clean Architecture: Patterns, Practices, and Principles

by Matthew Renze

Jan 11, 2017 / 2h 21m

2h 21m

Start Course

Hello, and welcome to Pluralsight! My name is Matthew Renze, and I want to give you a quick overview of my course, Clean Architecture: Patterns, Practices, and Principles. It’s designed to help you learn how software experts keep their architecture clean using a modern approach to software architecture called Clean Architecture, and covers things like domain-centric architecture, application layers, CQRS (Command-Query Responsibility Separation), event sourcing, functional cohesion, bounded contexts, and more. In addition, you'll use these practices to replace the outdated three-layer database-centric architecture that has been used for decades. Most important though, you'll see how these practices, when combined, create an architecture that is simple, understandable, flexible, testable, and maintainable. When you’re done, you’ll have the skills necessary to understand and implement these clean architecture practices on your own software projects. As an introductory course, there are no prerequisites for this course. However, having basic experience with at least one C like programming language, and basic knowledge of software architecture will be beneficial. I look forward to working with you on Clean Architecture: Patterns, Practices, and Principles, here at Pluralsight.

Table of contents
  1. Course Overview1m
  2. Introduction21m
  3. Domain-centric Architecture12m
  4. Application Layer21m
  5. Commands and Queries16m
  6. Functional Organization12m
  7. Microservices18m
  8. Testable Architecture25m
  9. Evolving the Architecture11m

Modern Software Architecture: Domain Models, CQRS, and Event Sourcing

by Dino Esposito

Jul 23, 2015 / 4h 25m

4h 25m

Start Course

This course covers DDD analysis patterns helpful in discovering the top-level architecture of a business domain. Architects and developers will find details of implementation patterns such as Domain Model, CQRS, and Event Sourcing.

Table of contents
  1. DDD at a Glance19m
  2. Discovering the Domain Architecture through DDD33m
  3. The DDD Layered Architecture29m
  4. The "Domain Model" Supporting Architecture58m
  5. The CQRS Supporting Architecture56m
  6. Event Sourcing44m
  7. Designing Software Driven by the Domain23m

Domain-Driven Design Fundamentals

by Julie Lerman

Jun 25, 2014 / 4h 16m

4h 16m

Start Course

Hello, and welcome to Domain-Driven Design Fundamentals, part of the ASP.NET MVC 5 Learning Path here at Pluralsight. Your authors, Steve Smith and Julie Lerman, are looking forward to helping you learn the fundamentals of Domain-Driven Design (DDD) through a demonstration of customer interactions and a complex demo application. Along the way, you’ll learn about elements of a domain model, aggregates in Domain-Driven Design, and repositories. You’ll also get hands on modeling problems, and learn about technical components of DDD, and how to manage complexity. So if you’re ready to get started, Domain-Driven Design Fundamentals is waiting for you. Thanks again for visiting us here at Pluralsight!

Table of contents
  1. Introducing DDD24m
  2. DDD: Modeling Problems in Software45m
  3. Elements of a Domain Model1h 1m
  4. Aggregates in Domain-Driven Design24m
  5. Repositories27m
  6. Domain Events and Anti-corruption Layers35m
  7. Reaping the Benefits of Domain-Driven Design37m


Once you understand the basic principles, it’s time to learn how to handle the havoc imposed by the real world. Start by learning not just to use DDD in your ground-up designs but how to refactor existing designs to leverage the power of DDD. We’ll also explore how the Specification Pattern can solve a class of problems and how to leverage the power of Modern Object Relational Mapping tools.

COMING SOON: Mapping Complex Domain Models with Modern ORMs

Domain-Driven Design in Practice

by Vladimir Khorikov

Jan 21, 2016 / 4h 19m

4h 19m

Start Course

While Domain-Driven Design offers invaluable insights regarding developing enterprise-level software projects, it is often unclear how to apply them in practice. In this course, we'll go through the whole process of building an application from the very beginning using the DDD principles.

Table of contents
  1. Introduction29m
  2. Starting with the First Bounded Context46m
  3. Introducing UI and Persistence Layers33m
  4. Extending the Bounded Context with Aggregates35m
  5. Introducing Repositories20m
  6. Introducing the Second Bounded Context33m
  7. Working with Domain Events39m
  8. Looking Forward to Further Enhancements20m

Refactoring from Anemic Domain Model Towards a Rich One

by Vladimir Khorikov

Nov 13, 2017 / 3h 36m

3h 36m

Start Course

Having a rich, highly encapsulated domain model is essential if you want to succeed in building building bullet-proof business line applications. In this course, Refactoring from Anemic Domain Model Towards a Rich One, is going to show you how to properly implement it. First, you'll cover why Anemic domain is an anti-pattern and its relationship to functional programming. Next, you'll learn about encapsulation and how to achieve it in your domain model. Finally, you'll touch on some important refactoring techniques. By the end of this course, you'll understand practical techniques that will help you recognize this anti-pattern in your code base and refactor it into a bullet-proof one.

Table of contents
  1. Course Overview1m
  2. Introduction22m
  3. Introducing an Anemic Domain Model18m
  4. Decoupling the Domain Model from Data Contracts29m
  5. Using Value Objects as Domain Model Building Blocks46m
  6. Pushing Logic Down from Services to Domain Classes48m
  7. Organizing the Application Services Layer35m
  8. Domain Modeling Best Practices14m

Specification Pattern in C#

by Vladimir Khorikov

Jun 27, 2017 / 1h 27m

1h 27m

Start Course

Domain-driven design includes many established patterns and practices, and the specification pattern is one of them. In this course, Specification Pattern in C#, you'll learn how to properly implement the specification pattern in practice. First, you'll learn about the use cases for this pattern. Next, you'll explore common anti-patterns and pitfalls in this area. Finally, you'll wrap up the course by learning about how to maintain encapsulation, as well as how to combine different specifications together. By the end of this course, you'll have the necessary knowledge needed to apply this pattern in real-world projects.

Table of contents
  1. Course Overview1m
  2. Introduction23m
  3. Implementing the Specification Pattern the Naive Way24m
  4. Refactoring Towards Better Encapsulation38m

Domain-Driven Design: Working with Legacy Projects

by Vladimir Khorikov

Mar 27, 2018 / 3h 51m

3h 51m

Start Course

As a programmer, you'd love to only work on green-field projects. However, you are most likely working on a legacy project right now, or will be at some point in the future. In this course, Domain-Driven Design: Working with Legacy Projects, you'll develop skills that will help you manage these legacy projects to deliver new functionality and keep the stakeholders happy. First, you'll learn how to make your way through the legacy code base by refactoring it one step at a time. Next, you'll explore how to handle rewrites, when to do that, and when it is better to keep the existing legacy code base instead. Finally, you'll discover techniques such as building an Anticorruption Layer, the Strangler pattern, and Branch by Abstraction pattern to deal with these code bases. By the end of this course, you'll have a solid understanding of the theory and practice of improving the functionality and scalability of legacy projects.

Table of contents
  1. Course Overview1m
  2. Introduction18m
  3. Introducing a Legacy Project18m
  4. Creating a Bubble Context with a New Domain Model37m
  5. Creating an Anticorruption Layer44m
  6. Making the Bubble Autonomous by Introducing a Separate Data Storage55m
  7. Promoting the Anticorruption Layer to Synchronizing Anticorruption Layer45m
  8. Exploring Further Ways of Dealing with the Legacy Project10m


To complete your journey to becoming a DDD architect, we’ll help you take full advantage of the Command Query Responsibility Segregation pattern. You’ll finish with an exploration of using Event Sourcing not only to understand the current state of your application but a trackable history of how it got there.

COMING SOON: Event Sourcing in Practice

CQRS in Practice

by Vladimir Khorikov

Oct 11, 2018 / 4h 22m

4h 22m

Start Course

There are a lot of misconceptions around the CQRS pattern, especially when it comes to applying it in real-world software projects. In this course, CQRS in Practice, you will learn all about CQRS with event sourcing, database configuration for reads and writes, and more. First, you will learn exactly what CQRS is, the principles behind it, and the benefits it can provide for your project. Next, you will explore the common misconceptions and anti-patterns around CQRS. Finally, you will see a detailed, step-by-step implementation of this pattern in practice. The sample project you'll be working on is close to what you will find in the real world, and you will see each step on the way to CQRS in great detail. By the end of this course, you will have a foundational understanding of the CQRS pattern and how to implement it in your software projects.

Table of contents
  1. Course Overview1m
  2. Introduction15m
  3. Introducing a Sample Project27m
  4. Refactoring Towards a Task-based Interface32m
  5. Segregating Commands and Queries52m
  6. Implementing Decorators upon Command and Query Handlers38m
  7. Simplifying the Read Model26m
  8. Introducing a Separate Database for Queries23m
  9. Synchronizing the Commands and Queries Databases28m
  10. CQRS Best Practices and Misconceptions15m
Offer Code *
Email * First name * Last name *
Country *

* Required field

Opt in for the latest promotions and events. You may unsubscribe at any time. Privacy Policy

By providing my phone number to Pluralsight and toggling this feature on, I agree and acknowledge that Pluralsight may use that number to contact me for marketing purposes, including using autodialed or pre-recorded calls and text messages. I understand that consent is not required as a condition of purchase from Pluralsight.

By activating this benefit, you agree to abide by Pluralsight's terms of use and privacy policy.

I agree, activate benefit