This comprehensive course will teach you the system I use to ship production-ready applications using Clean Architecture. Learn how to apply the best practices of modern software architecture. Join 2,600+ other students to accelerate your growth as a software architect.
Pragmatic Clean Architecture
6h 21m 27s
English
Paid
Clean Architecture Deep-Dive
- Learn the architectural principles to make better decisions
- How to design applications that stand the test of time
- Where should you use Clean Architecture
Build a Rich Domain Layer with DDD
- A practical guide to using Domain-Driven Design
- Learn the most important DDD tactical patterns
- Best practices for designing a rich domain model
Clean Application Layer use cases
- Learn how to implement clean use cases with CQRS
- Solve cros-cutting concerns with ease
- How to achieve blazing query speed
Powerful Infrastructure Layer
- How to implement a blazing fast persistence layer
- Get the most from advanced EF Core features
- Learn how to solve concurrency issues
Elegant Presentation Layer
- How to set up dependency injection the right way
- Configuration management and documentation
- Adding API and endpoints efficiently
Bulletproof Authentication
- Implement robust JWT authentication to secure your API
- Learn how to integrate an external identity provider
- How to apply modern security best practices
Robust Authorization NEW
- Learn how to implement custom authorization policies
- Role-based and permission-based authorization
- Why you need resource-based authorization
Production-Ready Advanced Features NEW
- Structured logging, health checks, API versioning
- Improve scalability with background jobs
- Distributed caching with Redis
High-Quality Testing NEW
- Learn how to test complex systems the right way
- Unit testing, Integration testing, Functional (E2E) testing
- Enforce your software architecture with architecture tests
After Completing This Course You Will
- Confidently use Clean Architecture to build amazing projects at your work
- Build a rich domain model with Domain-Driven Design fundamentals
- Set up production-ready applications with industry best practices
- Understand the most important architectural principles
About the Author: Milan Jovanović
Milan Jovanović is a Serbian software engineer and Microsoft MVP focused on the architectural side of .NET development — particularly Clean Architecture, Modular Monoliths, and the patterns for building maintainable production .NET applications. He runs the Milan Jovanović Tech newsletter — one of the more widely-read newsletters in the .NET community — and publishes paid course material on the same topics.
His CourseFlix listing carries three Milan Jovanović courses: Pragmatic Clean Architecture, Modular Monolith Architecture, and Pragmatic REST APIs. The teaching style is unusually rigorous for the .NET tutorial market about architectural decisions — each course is essentially a senior engineer's playbook on a specific architectural pattern.
Material is paid and aimed at intermediate-and-up .NET developers responsible for architectural decisions on real production systems. For broader content, see CourseFlix's C# and System Design & Architecture category pages.
Watch Online 91 lessons
0:00
/ #1: Welcome
All Course Lessons (91)
| # | Lesson Title | Duration | Access |
|---|---|---|---|
| 1 | Welcome Demo | 00:44 | |
| 2 | What you will learn in this course | 01:03 | |
| 3 | Who this course is for | 00:55 | |
| 4 | What are the prerequisites for taking this course | 01:07 | |
| 5 | Architectural principles & Design principles | 06:12 | |
| 6 | Clean Architecture layers | 03:07 | |
| 7 | What we are building & why | 01:49 | |
| 8 | Chapter recap | 00:36 | |
| 9 | Introduction | 02:01 | |
| 10 | Creating the Domain project | 01:05 | |
| 11 | Defining our first domain entity | 04:03 | |
| 12 | What is an Entity in Domain-Driven Design? | 02:39 | |
| 13 | Introducing Value Objects for solving primitive obsession | 08:24 | |
| 14 | The importance of private setters in the domain model and encapsulation | 00:25 | |
| 15 | Using the Static Factory pattern in the domain | 03:12 | |
| 16 | Introducing the Domain Events pattern to the solution | 03:09 | |
| 17 | Adding Repositories and the Unit of Work to the domain | 01:54 | |
| 18 | Creating the Booking entity | 03:32 | |
| 19 | Implementing a Domain service | 03:58 | |
| 20 | Using Double Dispatch for a better domain model | 01:21 | |
| 21 | Introducing the Result class to the project | 03:17 | |
| 22 | Defining a dictionary of domain errors | 01:19 | |
| 23 | Chapter recap | 00:27 | |
| 24 | Introduction | 05:09 | |
| 25 | Creating the Application project | 00:24 | |
| 26 | Configuring dependency injection and installing MediatR | 02:32 | |
| 27 | Adding the required abstractions for CQRS | 03:40 | |
| 28 | Implementing Commands with the rich domain model & repositories | 08:47 | |
| 29 | Defining a domain event handler | 04:26 | |
| 30 | Implementing Queries with Dapper for blazing performance | 09:50 | |
| 31 | Solving logging as a cross-cutting concern | 03:49 | |
| 32 | Creating a Validation pipeline for commands | 05:47 | |
| 33 | Chapter recap | 00:38 | |
| 34 | Introduction | 01:02 | |
| 35 | Creating the Infrastructure project | 00:22 | |
| 36 | Configuring infrastructure services with dependency injection | 03:07 | |
| 37 | Adding Entity Framework Core to the solution | 01:25 | |
| 38 | Configuring Entity Framework Core with dependency injection | 01:38 | |
| 39 | Creating the Domain entity configurations | 03:35 | |
| 40 | Automatically applying entity configurations | 00:46 | |
| 41 | Implementing repository interfaces using a generic repository | 03:00 | |
| 42 | Implementing the SQL connection factory | 01:52 | |
| 43 | Publishing domain events inside the Unit of Work | 04:18 | |
| 44 | Solving race conditions with optimistic concurrency | 04:42 | |
| 45 | Chapter recap | 00:28 | |
| 46 | Introduction | 01:06 | |
| 47 | Creating the Presentation project | 02:40 | |
| 48 | Configuring services with dependency injection | 00:53 | |
| 49 | Adding Controllers and endpoints | 05:34 | |
| 50 | Setting up Docker Compose and running the API | 03:49 | |
| 51 | Creating EF migrations and applying them | 04:20 | |
| 52 | Seeding initial data | 01:45 | |
| 53 | Adding Middleware - Global exception handler | 02:30 | |
| 54 | Demo: Presentation layer & API | 01:59 | |
| 55 | Chapter recap | 00:38 | |
| 56 | Introduction | 01:20 | |
| 57 | Keycloak identity provider setup | 02:07 | |
| 58 | Keycloak admin panel overview | 01:23 | |
| 59 | Demo: Obtaining JWTs using Keycloak | 01:40 | |
| 60 | Configuring authentication middleware & services | 01:58 | |
| 61 | Configuring JWT authentication options | 02:09 | |
| 62 | Demo: Authentication in action | 00:43 | |
| 63 | Implementing the user registration feature | 02:57 | |
| 64 | Adding an API endpoint for registering a user | 01:22 | |
| 65 | Implementing the authentication service | 03:02 | |
| 66 | Configuring the authentication service as a typed HTTP client | 01:50 | |
| 67 | Demo: User registration with Keycloak | 00:48 | |
| 68 | Implementing the user login feature | 03:06 | |
| 69 | Demo: User login with Keycloak | 00:44 | |
| 70 | Chapter recap | 00:24 | |
| 71 | Introduction | 00:38 | |
| 72 | Implementing Role-based Authorization | 17:47 | |
| 73 | Implementing Permission-based Authorization | 15:15 | |
| 74 | Implementing Resource-based Authorization | 06:18 | |
| 75 | Chapter recap | 00:32 | |
| 76 | Introduction | 00:38 | |
| 77 | Structured Logging with Serilog and Seq | 17:24 | |
| 78 | Distributed Caching with Redis | 16:34 | |
| 79 | Health Checks in Clean Architecture | 08:37 | |
| 80 | Implementing API Versioning | 12:03 | |
| 81 | Transactional Outbox Pattern | 20:23 | |
| 82 | Minimal APIs | 09:49 | |
| 83 | Chapter recap | 00:37 | |
| 84 | Introduction | 01:03 | |
| 85 | Domain Layer Unit Testing | 15:37 | |
| 86 | Application Layer Unit Testing | 16:45 | |
| 87 | Integration Testing | 18:46 | |
| 88 | Functional Testing | 13:22 | |
| 89 | Architecture Testing | 08:40 | |
| 90 | Chapter recap | 00:46 | |
| 91 | One Small Ask From Me | 01:30 |
Unlock unlimited learning
Get instant access to all 90 lessons in this course, plus thousands of other premium courses. One subscription, unlimited knowledge.
Learn more about subscriptionBooks
Related courses
-
Updated 2y agoBlazor Bootcamp - .NET 6 (WASM and Server)
By: UdemyThis course will provide you a complete real world scenario with Blazor which will make you face many challenges and solve those issues as we proceed with the c15h 36m -
Updated 2y agoUnity RPG Dialogue & Quests: Intermediate C# Game Coding
By: GameDev.tvUsing Unity 2020.1, we’ll show you how to include two essential game mechanics, dialogue and quests, in your games. This highly acclaimed series was over 200% f12h 34m
Frequently asked questions
What prerequisites should I have before starting the course?
Before enrolling in the course, you should have a solid understanding of basic programming concepts and familiarity with object-oriented programming. Experience with C# and .NET is highly recommended, as the course involves using Entity Framework Core and setting up projects in a .NET environment. Understanding Domain-Driven Design principles and basic architectural concepts will also be beneficial.
What kind of project will I build during the course?
Throughout the course, you will build a production-ready application using Clean Architecture principles. The project will involve creating multiple layers such as Domain, Application, Infrastructure, and Presentation. You will implement various components like domain entities, repositories, services, and a validation pipeline, ultimately running the application as an API with Docker Compose.
Who is the intended audience for this course?
The course is designed for software developers and architects who want to deepen their understanding of Clean Architecture and apply it to build robust and maintainable applications. It's also suitable for those interested in improving their skills in software architecture and design principles, as well as developers looking to use modern frameworks like Entity Framework Core and MediatR.
How does the depth of this course compare to others on Clean Architecture?
This course provides a detailed exploration of Clean Architecture, covering 91 lessons that include practical implementations, design principles, and real-world applications. It offers comprehensive coverage of key topics such as domain-driven design, dependency injection, CQRS, and handling cross-cutting concerns, which may not be as extensively covered in shorter or more introductory courses.
What specific tools and frameworks will I learn to use in the course?
You will learn to use several tools and frameworks, including Entity Framework Core for data access, MediatR for implementing CQRS, and Docker Compose for deploying the API. The course also covers setting up Keycloak for identity management and using Dapper for performance optimization in queries.
What topics are not covered in the course?
The course does not cover front-end development or user interface design, as it focuses on backend architecture and API development. It also does not delve into advanced cloud deployment strategies beyond using Docker Compose locally. Security practices beyond basic authentication setup with Keycloak are not deeply explored.
How much time should I expect to commit to complete the course?
The course comprises 91 lessons, but the total runtime is unspecified. Given the extensive content, including practical exercises and demos, you should expect to dedicate a significant amount of time to fully absorb the material. An estimated commitment of several weeks, dedicating a few hours each day, would be reasonable to complete the course thoroughly.