CF

Pragmatic Clean Architecture

6h 21m 27s
English
Paid

Pragmatic Clean Architecture is a 91-lesson 6 hours 21 minutes self-paced course by Milan Jovanović. This comprehensive course will teach you the system I use to ship production-ready applications using Clean Architecture.

Course facts

Lessons
91
Duration
6 hours 21 minutes
Level
All levels
Language
English
Updated
Instructor
Milan Jovanović
Price
Premium

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

Who teaches Pragmatic Clean Architecture? 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.

What lessons are included in Pragmatic Clean Architecture?

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 PDF

What courses are similar to Pragmatic Clean Architecture?

More courses by Milan Jovanović

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.