Name: .NET 9 Microservices, Modular Monolith: DDD & Vertical Slice
Rating: 4.7 (69 reviews)

Udemy Business

Teach on Udemy

Turn what you know into an opportunity and reach millions around the world.

Learn More

Your cart is empty.

Keep shopping

Created byLaurentiu Dumitrescu

Last updated 4/2026

English

What you'll learn

Build 5 real microservices end-to-end — and see how modular monoliths fit in the same solution
Implement CQRS & Interceptors using both MediatR and FastEndpoints
Use gRPC for synchronous and MassTransit for asynchronous microservices communication
Design your system first with C4 diagrams, sequence diagrams and tactical DDD
Apply Vertical Slice and Clean Architecture to organize your microservices
Apply DDD to model aggregates, value objects and domain events around real business rules
Use Docker to containerize your microservices & external dependencies
Build flexible Minimal APIs using ASP.NET Core, with or without Carter
Build global exception handling middleware for clean, consistent error responses
Apply interception with endpoint filters, MediatR behaviors, pre-processors and gRPC interceptors
Use GraphQL to query and filter efficiently from a PostgreSQL database
Secure your APIs using role-based authentication with .NET Identity and JWT tokens
Use Redis as a database to boost your microservice performance
Implement a CacheRepository pattern with DbContext and InMemoryCache for faster queries
Store your files in Azure Blob Storage or Mongo GridFS for scalable file management
Handle domain events to trigger side effects across your services using SaveChangesInterceptor
Map DTOs and integration events efficiently using Mapster or AutoMapper

Course content

10 sections • 175 lectures • 25h 44m total length

What We Will Do1:16
What You Will Learn3:29
Setup and Requirements1:53
GitHub Repositories0:22
How to Follow the Course4:00

Microservices – Introduction2:33
Microservices – The Core Pillars7:21
Microservices – Benefits & Challenges6:34
Modular Monolith – Introduction4:21
Modular Monolith – vs Microservices3:11
Modular Monolith – Real Example: FileStorage7:12
Modular Monolith – Summary0:49
Let’s Publish an Article – The Business Workflow We’ll Implement2:45
Article Domains – Core / Supporting / Generic4:14
DDD – Introduction4:08
DDD – The Core Pillars4:03
DDD – Event-Driven Design2:04
Modular Clean Architecture — The Practical Way5:34

Overview – Article Workflow & Tech Highlights1:51
Clean Architecture – Layers & Project Setup Plan3:33
Hands-on Kickoff – What We’ll Build & How1:59
Create Solution & Projects – API, Application, Domain, Persistence6:40
CreateArticle – Implement Endpoint with Minimal API & MediatR19:20
CreateArticle – Implement the Domain with DDD Principles12:43
Toolbox – Choosing the Right NuGet Version4:20
CreateArticle – Configure Domain Entities with EF Core16:14
CreateArticle – Implement Generic & Domain Repositories8:06
CreateArticle – Implement Command Handler with MediatR & FluentValidation3:41
Defining User Stories – From Business Scenarios to Requirements3:59
Designing Endpoints – Mapping User Stories to REST Operations4:02
Functional Requirements – Core Features & Rules6:37
Non-Functional Requirements – Scalability, Security & Reliability3:27
High-Level Architecture – Tech Stack, Layers & Dependencies5:49
Tactical DDD – Aggregates, Entities, Value Objects & Domain Events6:18
Application Startup – Configure Services & Modules with Dependency Injection14:11
CreateArticle – Implement NotFound with Repositories & HTTP Status Code6:16
CreateArticle – Implement Domain to Assign Current User as Author12:15
CreateArticle – Configure Persistence to Assign Current User as Author14:11
CreateArticle – Implement Handler to Assign Current User as Author10:06
AssignAuthor – Implement Full Feature with Domain, Handler & Endpoint20:24
CreateAndAssignAuthor – Implement Full Feature with Domain, Handler & Endpoint9:08
UploadManuscript – Implement Endpoint with Minimal API & FromForm Binding11:51
UploadManuscript – Implement Domain with Asset Aggregate and File Value Object20:46
UploadManuscript – Configure Asset and File with EF Core & ComplexProperty11:22
UploadManuscript – Implement Command Handler with MediatR and Repositories9:33
UploadManuscript – Implement In-Memory Cache Repository for AssetType13:37
UploadManuscript – Implement FileStorage Module (Monolith) with Mongo GridFS29:22
UploadManuscript – Integrate FileStorage Module in Command Handle11:17
Module Wrap-Up - All Endpoints & Testing0:44

Overview – Auth Flow, User Stories & Endpoint Design6:48
Requirements – Features, Performance & Security2:54
High Level Architecture – Tech Stack, Layers & Design Choices6:08
Integration – Auth Flow with JWT Tokens for SSO Across Services2:25
Tactical DDD – Aggregates, Entities, Value Objects & Domain Events3:44
Architecture Summary - Key Patterns, Tools & Design Decisions1:49
CreateUser – Overview & Architecture C4 Component Diagram2:25
CreateUser – Implement Command & Validator Logic with FluentValidation14:12
CreateUser – Implement User Domain Aggregate with DDD Principles19:58
CreateUser – Implement Domain Persistence with EF Core & SQL Server14:54
Toolbox – Upgrade to .NET 95:52
CreateUser – Implement Command Handler with ASP.NET Identity & FastEndpoints22:37
EmailService Module – Implement SMTP Integration in Modular Monolith20:48
CreateUser – Implement Domain Event for Confirmation Email with FastEndpoints11:40
Application Startup – Configure Services & Modules via Dependency Injection19:06
Login – Architecture Overview & Auth Flow Diagram1:58
Login – Implement Command & Validator Logic with FluentValidation4:17
Login – Implement Command Handler with ASP.NET Identity & FastEndpoints5:00
Login – Generate JWT Token in Command Handler14:16
Login – Generate & Persist Refresh Token7:05
Login – Refactor with SRP & DDD: Move Token Generation to Factory12:13

Overview – Auth Flow, User Stories & Endpoint Design7:19
Requirements – Features, Performance & Security2:23
High Level Architecture – Tech Stack, Layers & Design Choices6:15
Integration - Sync Journal Data Across Services with Events1:17
Integration - Validate Editor in Submission via Journal gRPC Service1:38
Tactical DDD – Aggregates, Entities, Value Objects & Domain Events2:26
Architecture Summary - Key Patterns, Tools & Decisions1:58
Map journal service features to http endpoints to show editor and admin interactions, and discuss clean architecture, vertical slice patterns, and integration with submission service via gRPC and domain events.
CreateJournal - Clean Architecture & Setup1:26
CreateJournal - Architecture Overview with C4 Component Diagram3:22
CreateJournal – Implement Command & Validator Logic with FluentValidation9:53
CreateJournal - Implement Domain & Persistence with Redis.OM & StackExchange16:33
CreateJournal – Implement Command Handler with FastEndpoints & Redis.OM9:20
GetPerson - Implement gRPC Contracts with protobuf-net14:29
GetPerson – Implement Aggregate Decomposition: Split User into Person & User10:17
GetPerson – Implement Person Persistence with EF.Core & SQL Server10:03
GetPerson – Implement Login Refactor for Person Aggregate11:14
GetPerson – Implement CreateUser Refactor for Person Aggregate7:02
GetPerson - Implement Person gRPC service with Grpc.AspNetCore & protobuf-net10:00
CreateJournal – Implement Editor Creation via Person gRPC Service3:58
Application Startup – Configure Services & Modules with Dependency Injection14:50
SearchJournals – Implement Redis Index & Full-Text Search19:46
ApproveArticle – Implement Minimal API Endpoint, Command & Fluent Validator10:55
ApproveArticle– Implement Command Handler with MediatR & Repository9:52
ApproveArticle– Implement CreateEditor scenario via Person gRPC6:20
Journal - Implement IsEditorAssignedToJournal gRPC Contracts (protobuf-net)5:34
Journal - Implement IsEditorAssignedToJournal gRPC Service & Repository6:30
ApproveArticle -Implement IsEditorAssignedToJournal via Journal gRPC Service5:56

Overview – Article Flow, User Stories & Endpoint Design7:31
Requirements – Features, Performance & Security3:12
High Level Architecture – Tech Stack, Layers & Design Choices3:57
Tactical DDD – Aggregates, Entities, Value Objects & Domain Events5:05
Architecture Summary - Key Patterns, Tools & Decisions1:25
Clean Architecture & Setup1:31
ArticleApproved- Architecture Overview with C4 Dynamic Sequence Diagram3:33
ArticleApproved - Projects Setup3:48
Implement Aggregate Root for Domain Events, Identity & Boundaries6:25
Dispatch Domain Events – EF Core Interceptor, MediatR & FastEndpoints13:10
ArticleApproved - Publish ArticleApproved Integration Event with MassTransit12:09
ArticleApproved - Create Mapster configuration5:49
ArticleApproved - Configure MassTransit with RabbitMQ10:01
ArticleApproved – Include Article Aggregate Entities with EF Core & LINQ3:47
ArticleApproved - Comsume ArticleApproved Event with MassTransit & RabbitMq3:57
ArticleApproved – Implement Domain Aggregates with DDD Principles23:23
ArticleApproved – Persist Domain with EF Core & SQL Server29:37
ArticleApproved - Implement ArticleApproved Consumer with RabbitMQ & MassTransit23:56
ArticleApproved - Implement Transfer Files with FileStorage (Mongo GridFS)12:52
Refactor FileStorage Integration – Clean Architecture Principles8:06
ArticleApproved - Finalize File Transfer with FileStorage (Mongo GridFS)5:54
Application Startup – Configure Services & Modules with Dependency Injection19:55
InviteReviewer – Implement Endpoint with Carter & FluentValidation15:39
Implement the invite reviewer endpoint with Carter and fluent validation, coordinating the article invitation flow via mediator, generating a token and URL, and sending the invitation email.
InviteReviewer - Implement Domain with DDD Principles13:15
InviteReviewer - Implement Command Handler with MediatR, Repos & Behaviors27:39
AcceptInvitation - Architecture Overview with C4 Dynamic Sequence Diagram2:33
AcceptInvitation - Implement Endpoint with Carter & FluentValidation7:22
AcceptInvitation - Implement Command Handler with gRPC, Repos & Behaviors29:32
AcceptInvitation – Implement Domain Event for Confirmation Email with MediatR3:54

Overview – Search Article Flow, User Stories & Endpoint Design6:48
Requirements – Features, Performance & Security6:08
High-Level Architecture – Tech Stack, Layers & Design Choices5:44
Tactical DDD – Aggregates, Entities, Value Objects & Domain Events2:33
Architecture Summary - Key Patterns, Tools & Decisions2:13
ArticleFeed - C4 Dynamic Sequence Diagram3:56
ArticleFeed - Setting Up the Event Consumers5:42
ArticleFeed – Implement Article Domain Aggregate with DDD Principles8:08
ArticleFeed – Implement Domain Persistence with EF Core & PostgreSQL14:23
ArticleFeed - Implement ApprovedForReview Event Consumer with MassTransit17:18
ArticleFeed - Implement Integration Event Building Block8:49
ArticleFeed - Implement AcceptForProduction Consumer with MassTransit5:07
Search Articles - Implement GraphQL Query with Hasura & PostgreSQL18:23
Search Articles - Implement Search Pagination7:17
Application Startup – Configure Services & Modules with Dependency Injection12:35

Tech Foundations – Why This Section1:35
Middleware – Global Exception Handling22:02
Interception – All Interception Points (Pipeline Overview)3:57
Interception – Endpoint Filters (Minimal APIs)22:19
Interception – Behaviors (MediatR)4:42
Interception – Pre-Processors (FastEndpoints)6:09
Interception – gRPC Interceptors5:29
Interception – Summary & Best Practices3:59
Docker & Docker-Compose – Configure & Run32:19
EF Core Migrations – Manage Migrations per Microservice24:22
EF Core Migrations – Design-Time Factory8:13

Auth Token Factory – Generating JWT & Refresh Tokens3:04
Base Repository – Implementation6:48
Cache Repository – Adding Caching to Repositories12:57
Claims Provider – Extracting User Claims15:10
Configure & Validate Options – Strongly Typed Settings5:58
Email Service (SMTP) – Sending Notifications20:17
Entity Configuration – Implement the Base Class with EF.Core4:03
Enum Entity – Typed Enumerations2:43
Fixing NuGet Version Conflicts – Consolidate & Update Package Versions0:59
Global Usings – Centralizing Common Namespaces1:03
Handling Missing Entities - Not Found Exception & HTTP Code5:07
Value Object – Base Class Implementation4:59
String Value Object – Base Class Implementation2:13
Validation Behavior – Wiring FluentValidation into the MediatR Pipeline3:07

Requirements

Basic knowledge of C# and .NET (classes, interfaces, async/await)
Familiarity with REST APIs (HTTP methods, JSON, controllers)
Understanding of databases and SQL (basic queries, relations)
Familiarity with Visual Studio or VS Code
Some experience with Git and GitHub is helpful
Familiarity with Docker is a plus

Description

In this course we build real C# microservices and a modular monolith in a .NET 9 solution from scratch: a full MVP for managing scientific articles. You’ll learn how to apply Domain-Driven Design (DDD) and Vertical Slice Architecture to real business workflows — not toy examples.

You'll see how to turn business requirements into bounded contexts, aggregates, value objects and domain events, then implement them end-to-end with C#, ASP.NET Core, EF Core, gRPC, messaging and Docker. Each feature is built as a vertical slice: from the API contract and validation, through command handlers and domain logic, down to persistence and tests.

We implement both synchronous and asynchronous communication between services. You'll learn to differentiate between Core/Critical services (using direct gRPC for reliability) and Domain services (using event-driven architecture with messaging). This gives you practical experience with CQRS and event-driven patterns in a real distributed system.

Along the way we focus on practical architecture decisions: when to use microservices vs a modular monolith, how to design rich domains instead of "anemic" models, how to apply CQRS with MediatR, and how to keep code clean, simple and testable while services communicate over gRPC and messaging.

By the end of this course you will be able to:

Design and implement .NET 9 microservices and a modular monolith with DDD and Clean Architecture
Apply Vertical Slice, CQRS and event-driven architecture in a real project
Model solid aggregates, value objects and domain events
Implement sync (gRPC) and async (messaging) communication between services
Structure solutions for long-term maintainability and clear boundaries
Make pragmatic architecture trade-offs, instead of just following theory

Who is this course for?

Intermediate to senior C# / .NET developers who have already built at least one Web API and want to learn how to design real systems with DDD and microservices/modular monolith.
Ambitious junior developers who are comfortable with C#, ASP.NET Core Web APIs and SQL, and want to move to the next level into architecture and system design.

Software architects who want a concrete end-to-end .NET 9 example of modern architecture patterns.

You should be comfortable with C# fundamentals, have some experience with ASP.NET Core Web APIs, and know basic SQL (tables, relationships, CRUD). It is recommended that this is not your very first C# project, nevertheless I will guide you step by step from an empty solution to a working, production-style architecture.

Who this course is for:

Intermediate to senior C# / .NET developers who have already built at least one Web API and want to learn DDD, CQRS and modern microservices / modular monolith architecture in .NET 9.
Ambitious junior developers who are comfortable with C#, ASP NET Core Web APIs and SQL, and want to move from “just coding” to designing real systems
Developers who want to understand the trade-offs between microservices and a modular monolith
Software architects or tech leads looking for a concrete, end-to-end .NET 9 microservices + modular monolith reference implementation

What you'll learn

Explore related topics

Course content

Course Overview & Getting Started5 lectures • 11min

Technical Concepts & Architecture Fundamentals13 lectures • 55min

Submission Microservice with MediatR, FluentValidation & EF.Core31 lectures • 5hr 4min

Auth Microservice with FastEndpoints, JWT Auth, and Role-Based Access Control21 lectures • 3hr 20min

Journal Microservice with FastEndpoints, Redis & gRPC27 lectures • 3hr 31min

Review Microservice with MediatR, FluentValidation & EF.Core29 lectures • 5hr 9min

ArticleHub Microservice with GraphQL, Hasura & MassTransit Events15 lectures • 2hr 5min

Tech Foundations: Middleware, Interception, Docker, EF Core & More11 lectures • 2hr 15min

Technical Deep Dives – Individual Topics14 lectures • 1hr 28min

Testing & Debugging with Postman9 lectures • 1hr 47min

Requirements

Description

Who this course is for: