CourseFlix

Pragmatic Clean Architecture

6h 21m 27s
English
Paid

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.

Clean Architecture Deep-Dive

  1. Learn the architectural principles to make better decisions
  2. How to design applications that stand the test of time
  3. Where should you use Clean Architecture


Build a Rich Domain Layer with DDD

  1. A practical guide to using Domain-Driven Design
  2. Learn the most important DDD tactical patterns
  3. Best practices for designing a rich domain model


Clean Application Layer use cases

  1. Learn how to implement clean use cases with CQRS
  2. Solve cros-cutting concerns with ease
  3. How to achieve blazing query speed


Powerful Infrastructure Layer

  1. How to implement a blazing fast persistence layer
  2. Get the most from advanced EF Core features
  3. Learn how to solve concurrency issues


Elegant Presentation Layer

  1. How to set up dependency injection the right way
  2. Configuration management and documentation
  3. Adding API and endpoints efficiently


Bulletproof Authentication

  1. Implement robust JWT authentication to secure your API
  2. Learn how to integrate an external identity provider
  3. How to apply modern security best practices


Robust Authorization NEW

  1. Learn how to implement custom authorization policies
  2. Role-based and permission-based authorization
  3. Why you need resource-based authorization


Production-Ready Advanced Features NEW

  1. Structured logging, health checks, API versioning
  2. Improve scalability with background jobs
  3. Distributed caching with Redis


High-Quality Testing NEW

  1. Learn how to test complex systems the right way
  2. Unit testing, Integration testing, Functional (E2E) testing
  3. Enforce your software architecture with architecture tests


After Completing This Course You Will

  1. Confidently use Clean Architecture to build amazing projects at your work
  2. Build a rich domain model with Domain-Driven Design fundamentals
  3. Set up production-ready applications with industry best practices
  4. Understand the most important architectural principles

About the Author: Milan Jovanović

Milan Jovanović thumbnail

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

This is a demo lesson (10:00 remaining)

You can watch up to 10 minutes for free. Subscribe to unlock all 91 lessons in this course and access 10,000+ hours of premium content across all courses.

View Pricing
0:00
/
#1: Welcome
All Course Lessons (91)
#Lesson TitleDurationAccess
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 subscription

Books

Read Book Pragmatic Clean Architecture

#TitleTypeOpen
1Pragmatic Clean Architecture —

Course content

91 lessons · 6h 21m 27s
Show all 91 lessons
  1. 1 Welcome 00:44
  2. 2 What you will learn in this course 01:03
  3. 3 Who this course is for 00:55
  4. 4 What are the prerequisites for taking this course 01:07
  5. 5 Architectural principles & Design principles 06:12
  6. 6 Clean Architecture layers 03:07
  7. 7 What we are building & why 01:49
  8. 8 Chapter recap 00:36
  9. 9 Introduction 02:01
  10. 10 Creating the Domain project 01:05
  11. 11 Defining our first domain entity 04:03
  12. 12 What is an Entity in Domain-Driven Design? 02:39
  13. 13 Introducing Value Objects for solving primitive obsession 08:24
  14. 14 The importance of private setters in the domain model and encapsulation 00:25
  15. 15 Using the Static Factory pattern in the domain 03:12
  16. 16 Introducing the Domain Events pattern to the solution 03:09
  17. 17 Adding Repositories and the Unit of Work to the domain 01:54
  18. 18 Creating the Booking entity 03:32
  19. 19 Implementing a Domain service 03:58
  20. 20 Using Double Dispatch for a better domain model 01:21
  21. 21 Introducing the Result class to the project 03:17
  22. 22 Defining a dictionary of domain errors 01:19
  23. 23 Chapter recap 00:27
  24. 24 Introduction 05:09
  25. 25 Creating the Application project 00:24
  26. 26 Configuring dependency injection and installing MediatR 02:32
  27. 27 Adding the required abstractions for CQRS 03:40
  28. 28 Implementing Commands with the rich domain model & repositories 08:47
  29. 29 Defining a domain event handler 04:26
  30. 30 Implementing Queries with Dapper for blazing performance 09:50
  31. 31 Solving logging as a cross-cutting concern 03:49
  32. 32 Creating a Validation pipeline for commands 05:47
  33. 33 Chapter recap 00:38
  34. 34 Introduction 01:02
  35. 35 Creating the Infrastructure project 00:22
  36. 36 Configuring infrastructure services with dependency injection 03:07
  37. 37 Adding Entity Framework Core to the solution 01:25
  38. 38 Configuring Entity Framework Core with dependency injection 01:38
  39. 39 Creating the Domain entity configurations 03:35
  40. 40 Automatically applying entity configurations 00:46
  41. 41 Implementing repository interfaces using a generic repository 03:00
  42. 42 Implementing the SQL connection factory 01:52
  43. 43 Publishing domain events inside the Unit of Work 04:18
  44. 44 Solving race conditions with optimistic concurrency 04:42
  45. 45 Chapter recap 00:28
  46. 46 Introduction 01:06
  47. 47 Creating the Presentation project 02:40
  48. 48 Configuring services with dependency injection 00:53
  49. 49 Adding Controllers and endpoints 05:34
  50. 50 Setting up Docker Compose and running the API 03:49
  51. 51 Creating EF migrations and applying them 04:20
  52. 52 Seeding initial data 01:45
  53. 53 Adding Middleware - Global exception handler 02:30
  54. 54 Demo: Presentation layer & API 01:59
  55. 55 Chapter recap 00:38
  56. 56 Introduction 01:20
  57. 57 Keycloak identity provider setup 02:07
  58. 58 Keycloak admin panel overview 01:23
  59. 59 Demo: Obtaining JWTs using Keycloak 01:40
  60. 60 Configuring authentication middleware & services 01:58
  61. 61 Configuring JWT authentication options 02:09
  62. 62 Demo: Authentication in action 00:43
  63. 63 Implementing the user registration feature 02:57
  64. 64 Adding an API endpoint for registering a user 01:22
  65. 65 Implementing the authentication service 03:02
  66. 66 Configuring the authentication service as a typed HTTP client 01:50
  67. 67 Demo: User registration with Keycloak 00:48
  68. 68 Implementing the user login feature 03:06
  69. 69 Demo: User login with Keycloak 00:44
  70. 70 Chapter recap 00:24
  71. 71 Introduction 00:38
  72. 72 Implementing Role-based Authorization 17:47
  73. 73 Implementing Permission-based Authorization 15:15
  74. 74 Implementing Resource-based Authorization 06:18
  75. 75 Chapter recap 00:32
  76. 76 Introduction 00:38
  77. 77 Structured Logging with Serilog and Seq 17:24
  78. 78 Distributed Caching with Redis 16:34
  79. 79 Health Checks in Clean Architecture 08:37
  80. 80 Implementing API Versioning 12:03
  81. 81 Transactional Outbox Pattern 20:23
  82. 82 Minimal APIs 09:49
  83. 83 Chapter recap 00:37
  84. 84 Introduction 01:03
  85. 85 Domain Layer Unit Testing 15:37
  86. 86 Application Layer Unit Testing 16:45
  87. 87 Integration Testing 18:46
  88. 88 Functional Testing 13:22
  89. 89 Architecture Testing 08:40
  90. 90 Chapter recap 00:46
  91. 91 One Small Ask From Me 01:30

Related courses

  • Learn Blazor Server (Blazor Server: In Depth) thumbnail

    Learn Blazor Server (Blazor Server: In Depth)

    By: Tim Corey
    Blazor Server is a game changer for developers. But figuring out how to access the full power of Blazor Server can leave you frustrated.
    16 hours 28 minutes 25 seconds
  • TimCo Retail Manager Phase 1 thumbnail

    TimCo Retail Manager Phase 1

    By: Tim Corey
    Businesses today are using .NET Framework in their applications. Moving forward, they are going to need to upgrade to .NET Core. Will you be ready?
    25 hours 56 minutes 13 seconds
  • C# Developers: Double Your Coding Speed thumbnail

    C# Developers: Double Your Coding Speed

    By: Mosh Hamedani (Code with Mosh)
    If you want to be a real pro C# coder, you need to master your keyboard and Visual Studio. You need to be able to navigate in your code base, find and modify co
    1 hour 30 minutes 36 seconds

Frequently asked questions

What is Pragmatic Clean Architecture about?
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…
Who teaches Pragmatic Clean Architecture?
Pragmatic Clean Architecture is taught by Milan Jovanović. You can find more courses by this instructor on the corresponding source page.
How long is Pragmatic Clean Architecture?
Pragmatic Clean Architecture contains 91 lessons with a total runtime of 6 hours 21 minutes. All lessons are available to watch online at your own pace.
Is Pragmatic Clean Architecture free to watch?
Pragmatic Clean Architecture is part of CourseFlix's premium catalog. A CourseFlix subscription unlocks the full video player; the course description, table of contents, and preview information are available to everyone.
Where can I watch Pragmatic Clean Architecture online?
Pragmatic Clean Architecture is available to watch online on CourseFlix at https://courseflix.net/course/pragmatic-clean-architecture. The page hosts every lesson with the integrated video player; no download is required.