Course · Training · Workshop

CQRS, Event Sourcing and DDD in .NET

Hands-on course for experienced .NET developers covering Domain-Driven Design, CQRS, and Event Sourcing – from aggregates and bounded contexts to event stores and projections.

Modern software architecture demands more than technical know-how – it demands a deep understanding of the business domain. In this three-day course, experienced .NET developers learn how to build software with Domain-Driven Design, CQRS, and Event Sourcing that precisely reflects the business, is easily testable, and can keep pace with growing requirements. The course walks step by step through the core DDD building blocks – entities, value objects, aggregates, and bounded contexts – and shows how command-query separation and event-driven architecture work together in practice. With Event Sourcing, participants learn to model state changes as an immutable sequence of events and build read models through projections. More than half of the course time is reserved for hands-on exercises. The course is up-to-date with .NET 10 and delivers practical knowledge that transfers directly to real projects.

In-house course

Tailored for your team.

Request

No suitable date?

Request a new public date.

Request a date

Trainers

Tore Nestenius

Instructor

What participants say

These customers booked courses in the same topic cluster.More customers →

Content

The course covers the following topics with a strong focus on practical application and hands-on exercises. Focus areas and depth can be adapted to the audience:

– Modern Application Architecture:

Modularity and composition
Immutability and eventual consistency
Layered architecture vs. ports-and-adapters – Domain-Driven Design:
Ubiquitous language and domain modeling
Entities and value objects
Domain services
Aggregates and consistency boundaries
Invariants and domain rules
Bounded contexts and context mapping
Workflow modeling – CQS and CQRS:
Command-query separation (CQS)
Command-query responsibility segregation (CQRS)
Read/write separation in practice
Mediator pattern – Events and Event-Driven Architecture:
Commands vs. domain events
Event storming and event modeling
Policies and reactions to events
Decider pattern – Event Sourcing:
Core principles of event sourcing
Event store: structure and implementation
Streams and versioning
Snapshots and state rebuilding
Schema evolution strategies – Read Models and Projections:
Building and managing projections
Query design for read models
High-performance patterns – Testing:
TDD in the domain context
BDD and example-driven testing
Testing event-sourced aggregates

The course is up-to-date with .NET 10 and includes plenty of hands-on exercises for immediate application of learned concepts.

The actual course content may differ from the above depending on the trainer, delivery, duration and the composition of participants.

Goal

Upon completing this course, participants will be able to model software according to DDD principles and cleanly separate domain logic from infrastructure code. They will understand how CQRS improves the readability and scalability of applications, and be able to use Event Sourcing as a persistence strategy for event-driven systems. Through the many hands-on exercises, the learned patterns and techniques can be directly applied to their own projects.

Duration

3 days

Format

A proven mix of theoretical concepts, live coding demonstrations, and plenty of hands-on exercises. Participants model real domains and implement event sourcing scenarios hands-on. The trainer guides the process with expert knowledge and individual support.

Target group

Experienced .NET developers with at least one year of professional experience who want to deepen their architecture knowledge and learn to structure complex business logic with DDD, CQRS, and Event Sourcing. Good knowledge of C# including generics, lambdas, and LINQ is expected.

Prerequisites

Professional experience as a .NET developer is helpful. A solid understanding of C# including generics, lambdas, and LINQ is beneficial. Prior knowledge of DDD, CQRS, or Event Sourcing is not required.

Preparation

Each participant receives a questionnaire to assess their experience level and installation instructions for the required development environment after registration. Based on the answers, we send individual feedback for optimal course preparation.

Request this course in-house

Request a public date

No suitable public date? Register without obligation — once there is enough interest we schedule a new public date and let you know first.

More about CQRS, Event Sourcing and DDD in .NET

Domain-Driven Design, CQRS, and Event Sourcing have established themselves as key concepts for developing complex, long-lived software systems. Together they form a powerful toolkit for building software that truly meets the needs of the business.

Further resources:

History and Development

Domain-Driven Design was introduced in 2003 by Eric Evans in his landmark book "Domain-Driven Design: Tackling Complexity in the Heart of Software". Building on this, Greg Young formulated CQRS and Event Sourcing from 2010 onward as concrete architectural patterns for distributed systems.

Event Storming was developed by Alberto Brandolini as a lightweight workshop method to extract domain knowledge from the entire team. Event Modeling by Adam Dymitruk complements this with a more structured, blueprint-style approach to system modeling.

In the .NET world, libraries such as MediatR, Marten, and EventStoreDB have helped make these patterns accessible. Today, DDD, CQRS, and Event Sourcing are part of the standard repertoire of modern backend architecture.