Course cover

Confidently Ship Production-Ready Apps Using Clean Architecture

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 980+ other students to accelerate your growth as a software architect.

🔓 Get Instant Access for $150 →

Here's What Students Are Saying

🔓 Unlock Lifetime Access for $150 →

What You'll Learn Inside This Course

Everything You Need To Build Production-Ready Applications

  • Clean Architecture
  • Domain-Driven Design
  • CQRS with MediatR
  • Authentication with Keycloak
  • Testing with xUnit
🔓 Get Instant Access for $150 →
Course snippet

Build a Rich Domain Model With Domain-Driven Design

  • Learn the most important DDD tactical patterns
  • Use the best practices for designing a rich domain model
  • How to design persistence ignorant entities
🔓 Get Instant Access for $150 →
Course snippet

Clean Use Cases With CQRS

  • Master the techniques that pros use
  • Solve cros-cutting concerns with ease
  • Learn why separation of concerns is so valuable
  • Get incredible query performance with Dapper
🔓 Get Instant Access for $150 →
Course snippet

Blazing Fast Persistence

  • Apply best practices with EF Core
  • Learn the advanced EF Core features
  • Learn the right way to implement the repository pattern
  • Solve concurrency issues with industy-standard approach
🔓 Get Instant Access for $150 →
Course snippet

Master Cutting-Edge Technologies

  • Learn the latest .NET trends and best practices
  • Use Minimal APIs to build robust endpoints
  • Build a reliable system with the Outbox pattern
  • How to improve scalability with background jobs
🔓 Get Instant Access for $150 →
Course snippet

Make Your API Impenetrable

  • Learn the fundamentals of API security
  • Get the most out of the built-in authentication
  • Learn how to use an external identity provider
  • How to implement JWT authentication with Keycloak
🔓 Get Instant Access for $150 →
Course snippet

Bulletproof Your System With Tests

  • Learn why testing is important for a complex system
  • How to unit test your use cases with xUnit and Moq
  • Enforce your software architecture with architecture tests
🔓 Get Instant Access for $150 →
Course snippet

Access Pragmatic Clean Architecture Instantly

$150

3.5 value-packed hours

80+ actionable lessons

Certificate of completion

Source code used in the course

BONUS: Additional app features

🔓 Get Instant Access for $150 →

The Full Curriculum

Chapter 1: Course Introduction

Chapter 2: Clean Architecture Fundamentals

  • Architectural principles & Design principles
  • Clean Architecture layers
  • What we are building & why
  • Chapter recap

Chapter 3: Domain Layer

  • Introduction
  • Creating the Domain project
  • Defining our first domain entity
  • What is an Entity in Domain-Driven Design?
  • Introducing Value Objects for solving primitive obsession
  • The importance of private setters in the domain model and encapsulation
  • Using the Static Factory pattern in the domain
  • Introducing the Domain Events pattern to the solution (free preview)
  • Adding Repositories and the Unit of Work to the domain
  • Creating the Booking entity
  • Implementing a Domain service
  • Using Double Dispatch for a better domain model
  • Introducing the Result class to the project
  • Defining a dictionary of domain errors
  • Chapter recap

Chapter 4: Application Layer

  • Introduction
  • Creating the Application project
  • Configuring dependency injection and installing MediatR
  • Adding the required abstractions for CQRS
  • Implementing Commands with the rich domain model & repositories
  • Defining a domain event handler
  • Implementing Queries with Dapper for blazing performance
  • Solving logging as a cross-cutting concern
  • Creating a Validation pipeline for commands
  • Chapter recap

Chapter 5: Infrastructure Layer

  • Introduction
  • Creating the Infrastructure project
  • Configuring infrastructure services with dependency injection
  • Adding Entity Framework Core to the solution
  • Configuring Entity Framework Core with dependency injection
  • Creating the Domain entity configurations
  • Automatically applying entity configurations
  • Implementing repository interfaces using a generic repository
  • Implementing the SQL connection factory
  • Publishing domain events inside the Unit of Work
  • Solving race conditions with optimistic concurrency
  • Chapter recap

Chapter 6: Presentation Layer

  • Introduction
  • Creating the Presentation project
  • Configuring services with dependency injection
  • Adding Controllers and endpoints
  • Setting up Docker Compose and running the API
  • Creating EF migrations and applying them
  • Seeding initial data
  • Adding Middleware - Global exception handler
  • Demo: Presentation layer & API
  • Chapter recap

Chapter 7: Authentication

  • Introduction
  • Keycloak identity provider setup
  • Keycloak admin panel overview
  • Demo: Obtaining JWTs using Keycloak
  • Configuring authentication middleware & services
  • Configuring JWT authentication options
  • Demo: Authentication in action
  • Implementing the user registration feature
  • Adding an API endpoint for registering a user
  • Implementing the authentication service
  • Configuring the authentication service as a typed HTTP client
  • Demo: User registration with Keycloak
  • Implementing the user login feature
  • Demo: User login with Keycloak
  • Chapter recap

Chapter 8: Advanced Topics

  • Introduction
  • Strongly Typed IDs
  • Minimal APIs
  • Transactional Outbox Pattern
  • Chapter recap

Chapter 9: Testing

  • Introduction
  • Unit testing in Clean Architecture
  • Architecture tests
  • Chapter recap

BONUS

  • Additional application features with source code
  • C# Tips & Tricks e-book (coming soon)
  • Postman collection to test the API
🔓 Unlock Lifetime Access for $150 →

Hi, I'm Milan 👋

Milan Jovanović
Microsoft MVP

I'm a Software Architect and Microsoft MVP for Developer Technologies with years of experience building large-scale systems.


I've helped thousands of people become better software engineers through my content on social media, newsletter, and YouTube channel.


My goal is to teach you everything I learned while building and maintaining production-ready applications using Clean Architecture.

Frequently Asked Questions

  • Who is this course for?

    This course is for anyone who wants to learn how to apply Clean Architecture in the real world. And how you can use it to create testable, maintainable, large-scale systems.


    This course is also for anyone who wants to learn the principles of Domain-Driven Design. The course focuses on tactical DDD patterns and how to apply them in practice.

  • What will I learn in this course?

    You'll learn the best practices for building production-ready applications using Clean Architecture.
    These are the same core principles I've used to build many large-scale systems in the past 6 years.

    • Clean Architecture Fundamentals
    • Domain-Driven Design
    • CQRS
    • Dependency inversion
    • Modularity
    • Authentication
    • Testing

  • How long is the course?

    The course is roughly 3 hours and 36 minutes long and is a video course. It has a lot of value packed into a few hours, and I designed it to be easy to follow.

  • Got it. This must be expensive, right?

    No. It's $150.

  • Do I get lifetime access?

    Absolutely. You can access the course forever with no extra payment.

  • What are the prerequisites for taking this course?

    You should have at least 1 year of experience with ASP.NET Core and (preferably) Entity Framework Core. If you are a beginner, this course will help you improve regardless, but it will be slightly harder to follow.

  • Ok. What should I do next if I want to enroll?

    Click the "Unlock Lifetime Access for $150" button below and get started today.