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 20m

2h 20m

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.

This course is 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 Overview
  2. Introduction
  3. Domain-centric Architecture
  4. Application Layer
  5. Commands and Queries
  6. Functional Organization
  7. Microservices
  8. Testable Architecture
  9. Evolving the Architecture

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

by Dino Esposito

Dec 3, 2019 / 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
  • Event Sourcing

Table of contents
  1. DDD at a Glance
  2. Discovering the Domain Architecture through DDD
  3. The DDD Layered Architecture
  4. The "Domain Model" Supporting Architecture
  5. The CQRS Supporting Architecture
  6. Event Sourcing
  7. Designing Software Driven by the Domain

Domain-Driven Design Fundamentals

by Julie Lerman

May 14, 2021 / 4h 47m

4h 47m

Start Course

In this course, Domain-Driven Design Fundamentals, you’ll learn the key concepts and means to implement DDD. First, you’ll explore how to model a software problem. Next, you’ll discover the elements of DDD. Finally, you’ll learn how to leverage DDD in a sample software application. When you’re finished with this course, you’ll have the skills and knowledge of Domain-Driven Design needed to unravel the complexity of your domain, build smarter software and gain an even deeper understanding of DDD.

Table of contents
  1. Course Overview
  2. Introducing Domain-Driven Design
  3. Modeling Problems in Software
  4. Elements of a Domain Model
  5. Understanding Value Objects & Services in the Model
  6. Tackling Complexity with Aggregates
  7. Working with Repositories
  8. Adding in Domain Events and Anti-corruption Layers
  9. Evolving the Application Easily Thanks to DDD


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.

Domain-Driven Design in Practice

by Vladimir Khorikov

Sep 16, 2019 / 4h 18m

4h 18m

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. Introduction
  2. Starting with the First Bounded Context
  3. Introducing UI and Persistence Layers
  4. Extending the Bounded Context with Aggregates
  5. Introducing Repositories
  6. Introducing the Second Bounded Context
  7. Working with Domain Events
  8. Looking Forward to Further Enhancements

Refactoring from Anemic Domain Model Towards a Rich One

by Vladimir Khorikov

Nov 13, 2017 / 3h 35m

3h 35m

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 Overview
  2. Introduction
  3. Introducing an Anemic Domain Model
  4. Decoupling the Domain Model from Data Contracts
  5. Using Value Objects as Domain Model Building Blocks
  6. Pushing Logic Down from Services to Domain Classes
  7. Organizing the Application Services Layer
  8. Domain Modeling Best Practices

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 Overview
  2. Introduction
  3. Introducing a Legacy Project
  4. Creating a Bubble Context with a New Domain Model
  5. Creating an Anticorruption Layer
  6. Making the Bubble Autonomous by Introducing a Separate Data Storage
  7. Promoting the Anticorruption Layer to Synchronizing Anticorruption Layer
  8. Exploring Further Ways of Dealing with the Legacy Project

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 Overview
  2. Introduction
  3. Implementing the Specification Pattern the Naive Way
  4. Refactoring Towards Better Encapsulation

DDD and EF Core: Preserving Encapsulation

by Vladimir Khorikov

Mar 4, 2020 / 3h 38m

3h 38m

Start Course

Entity Framework has made great progress over the past several years and introduced a lot of features that help you build rich, highly encapsulated domain models. In this course, DDD and EF Core: Preserving Encapsulation, you will learn foundational knowledge of pitfalls and shortcomings to be aware of when applying Domain-driven Design to applications with EF Core. First, you will learn how to preserve encapsulation of your domain models in such applications. Next, you will discover various mapping techniques that will help you to build complex domain models. Finally, you will explore the tips and tricks that will help you navigate around the common ORMs’ issues. When you are finished with this course, you will have the skills and knowledge of Domain-driven Design needed to adhere to DDD principles without compromising on domain model encapsulation.

Table of contents
  1. Course Overview
  2. Introduction
  3. Working with Many-to-one Relationships
  4. Working with Lazy Loading
  5. Mapping Backing Fields
  6. Working with Disconnected Graphs of Objects
  7. Mapping Value Objects
  8. Implementing a Domain Event Dispatcher


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.

CQRS in Practice

by Vladimir Khorikov

Oct 11, 2018 / 4h 21m

4h 21m

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 Overview
  2. Introduction
  3. Introducing a Sample Project
  4. Refactoring Towards a Task-based Interface
  5. Segregating Commands and Queries
  6. Implementing Decorators upon Command and Query Handlers
  7. Simplifying the Read Model
  8. Introducing a Separate Database for Queries
  9. Synchronizing the Commands and Queries Databases
  10. CQRS Best Practices and Misconceptions
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