Course Information
Registration period
Year-round Recruitment
Course Level
Study Mode
Duration
11 Hour(s) 0 Minute(s)
Language
English
Taught by
Laurentiu Dumitrescu
Rating
2 views
Course Overview
Build an MVP in .NET 9 with C# microservices, DDD, CQRS, Clean Architecture & Vertical Slice, gRPC, messaging & Docker
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.
Course Content
- 10 section(s)
- 171 lecture(s)
- Section 1 Course Overview & Getting Started
- Section 2 Technical Concepts & Architecture Fundamentals
- Section 3 Submission Microservice with MediatR, FluentValidation & EF.Core
- Section 4 Auth Microservice with FastEndpoints, JWT Auth, and Role-Based Access Control
- Section 5 Journal Microservice with FastEndpoints, Redis & gRPC
- Section 6 Review Microservice with MediatR, FluentValidation & EF.Core
- Section 7 ArticleHub Microservice with GraphQL, Hasura & MassTransit Events
- Section 8 Tech Foundations: Middleware, Interception, Docker, EF Core & More
- Section 9 Technical Deep Dives – Individual Topics
- Section 10 Testing & Debugging with Postman
What You’ll Learn
- Use Domain-Driven Design (DDD) to organize your system around real business needs
- Model aggregates, entities, value objects and domain events in EF Core based on real business rules
- Apply Vertical Slice and Clean Architecture to organize your microservices (in projects and folders)
- Design modular monoliths and split them into microservices when needed
- Implement CQRS using MediatR and FluentValidation with Pipeline Behaviors
- Implement CQRS with FastEndpoints for high-performance and low-boilerplate APIs
- Build flexible Minimal APIs using ASP.NET Core, with or without Carter
- Secure your APIs using role-based authentication with .NET Identity and JWT tokens
- Use gRPC for synchronous and MassTransit events for asynchronous microservices communication
- Handle domain events using SaveChangesInterceptor to trigger side effects
- Use GraphQL to query and filter efficiently from a PostgreSQL database
- Use Redis as a distributed cache or database to boost your microservice performance
- Store your files in Azure Blob Storage or Mongo GridFS for scalable file management
- Map DTOs and integration events efficiently using Mapster or AutoMapper
- Use Docker to containerize your microservices & external dependencies
Reviews
-
CCiprian Stoican
I initially wanted to refresh my memory on microservices, but I ended up learning more than expected. Very informative content.
-
CCristi Dumitru
As a .net / azure architect i took this course to see a real example of how other people design and code modern apps nowadays using both microservices and a modulith. the architecture (ddd, vertical slices, cqrs, grpc etc.) is pragmatic, not just theory. code quality is high and this is something i’d be ok using as a reference for a production system on azure. it starts a bit slow for my level, but later the workflows and integrations get nicely complex and very relevant for real projects.
-
AAmith V
Not very beginner-friendly, but extremely valuable for mid-level .NET developers. This course really helps improve architectural thinking and gives a clear understanding of how to approach real-world problems. It explains modern architecture patterns in a practical way, making it a great learning experience. Thanks to the instructor for putting together such a helpful and insightful course.
-
RRia Dms
I’m a CS student first time touching C# and .NET. This course is definitely above my level, but in a good way. I didn’t always understand the code, but I loved seeing how a “serious” app is structured with microservices and DDD. It’s not a beginner C# tutorial – it’s more like a peek into how senior devs think. I’m keeping it in my library and will rewatch it after I finish a basic C# course.
