Milan JovanovićMilan Jovanović

The Black Friday sale starts November 23

Sale prices on every course, and two new bundles

The sale is not open yet. Look through the curricula now, then come back on November 23.

Explore the courses

The Black Friday sale has ended

Thank you for all the support

The sale checkout links are closed. Every course still comes with lifetime access and future updates, and every course page has the full curriculum.

Explore all courses
Black Friday sale · November 23 through 30

Black Friday sale
Up to 60% off my .NET courses

Hi, I'm Milan. This week every .NET course I teach is 50% off, and the Community editions are 60% off. Pragmatic Self-Hosting: Foundations is $149. If you want all of it, there are two new bundles, and the bigger one saves you $1,091.

If you're paying for this yourself, one Course edition is plenty to start with. And if now isn't the right time, that's fine. The newsletter keeps coming every Saturday either way.

One-time payment in USD, plus applicable tax.97 coupons left

The four courses in the sale: Pragmatic Clean Architecture, Modular Monolith Architecture, Pragmatic REST APIs, and Pragmatic Self-Hosting: Foundations
9,700+ studentsPay once, keep every lesson and future updateA receipt you can expense at work

Why these courses, with AI writing code

Coding agents change how fast code appears, not what makes it correct. You still decide where the business rules live and how the parts of your system talk to each other, and you still review what the agent wrote.

That's what these courses teach, in a real .NET application you build along with me. Each one is below with its full chapter list, so you can see exactly what's inside before you buy.

New for this sale

Two bundles

Both have the Community editions of all three .NET courses, so you get every bonus, priority support and community access. Build & Deploy adds Foundations, the course on running your app on your own server.

.NET Architecture & APIs

The Community editions of all three .NET courses, with every bonus.

Normally $1,291 if you buy the three separately.

$349You save $942

$1,291 is the sum of the list prices above, bought one by one. Bought one by one during the sale, the same three Community editions come to $516.40.

Get .NET Architecture & APIs for $349

One-time payment in USD, plus applicable tax.

ALL FOUR COURSES

Build & Deploy

The same three Community editions, plus the course on running your app on a server you control.

Normally $1,540 if you buy the four separately.

$449You save $1,091

$1,540 is the sum of the list prices above, bought one by one. .NET Architecture & APIs plus Foundations on its own would come to $498 during the sale.

Get Build & Deploy for $449

One-time payment in USD, plus applicable tax.

Which bundle?

The only difference is the self-hosting course.

What each bundle includes, and its price
Included.NET Architecture & APIsBuild & Deploy
Pragmatic Clean ArchitectureCommunity edition, 6+ hoursIncludedIncluded
Modular Monolith ArchitectureCommunity edition, 14+ hoursIncludedIncluded
Pragmatic REST APIsCommunity edition, 16+ hoursIncludedIncluded
Pragmatic Self-Hosting: FoundationsDeploy and run your app on your own VPSNot includedIncluded
Every Community bonusAdvanced CA Template, Modularize Your Monolith, Minimal APIs, Auth0IncludedIncluded
Priority support and community accessIncludedIncluded
Normally$1,291$1,540
This week$349save $942$449save $1,091

The step from .NET Architecture & APIs to Build & Deploy is $100. Foundations on its own is $149 during the sale.

Pick .NET Architecture & APIs if someone else runs the servers where you work and you don't plan to deploy an app to a VPS of your own.

Single courses

Each .NET course comes in two editions. Both are a one-time payment with lifetime access and future updates. Here is what each course covers, so you can pick the one that fits the work in front of you.

Pragmatic Clean Architecture course cover

Pragmatic Clean Architecture

Production-ready .NET with Clean Architecture, CQRS, and DDD.

  • 10 chapters
  • 6+ hours of video
  • Full source code
  • .NET 8, PostgreSQL, Redis, Docker
  • 5,000+ students

A complete system for building maintainable .NET applications, from core principles to production deployment. Writes go through the domain model, where the business rules live. Reads take the short path. You build both, end to end.

You'll learn how to:

  • Model the domain with entities, value objects, domain events and the Result pattern, instead of primitive types and exceptions
  • Split commands and queries with CQRS and MediatR, with commands on the rich domain model and queries in Dapper
  • Wire up EF Core, the Unit of Work and optimistic concurrency to stop race conditions
  • Add authentication with Keycloak and JWTs, then role, permission and resource-based authorization
  • Publish domain events reliably with the Transactional Outbox
  • Add structured logging with Serilog and Seq, caching with Redis, health checks and API versioning
  • Write domain, application, integration, functional and architecture tests
All 10 chapters
  1. 1Clean Architecture Fundamentals12mThe principles, the layers, and what we build
  2. 2Domain Layer and Domain-Driven Design43mEntities, value objects, domain events, repositories, a domain service, double dispatch, the Result class
  3. 3Application Layer and CQRS45mMediatR, commands, domain event handlers, queries with Dapper, logging and validation pipelines
  4. 4Infrastructure Layer27mEF Core, entity configurations, a generic repository, optimistic concurrency
  5. 5Presentation Layer26mControllers and endpoints, Docker Compose, migrations, seeding, a global exception handler
  6. 6Authentication and API Security26mKeycloak as the identity provider, JWTs, registration and login
  7. 7Authorization, Roles and Permissions41mRole-based, permission-based and resource-based authorization
  8. 8Outbox, Structured Logging, Redis1h 26mSerilog and Seq, Redis caching, health checks, API versioning, the Outbox, Minimal APIs
  9. 9Testing Clean Architecture1h 15mUnit, integration, functional and architecture tests
  10. 10Bonus: Get Started FasterClean Architecture Template, Code Quality Shortcut, CI/CD Blueprint
"Every chapter offers real practical solutions with no fluff, including design patterns and principles."
Roman Fairushyn, Senior Software Engineer
Full course page and reviews

Course edition · 6+ hours50% off

$123.50 this week, regular $247

You save $123.50

  • All 10 chapters and the full source code
  • Clean Architecture Template
  • Code Quality Shortcut and CI/CD Blueprint
  • Email support
Get the Course edition for $123.50

Community edition · 6+ hours60% off

$158.80 this week, regular $397

You save $238.20

  • Everything in the Course edition
  • The Advanced CA Template instead: messaging over a message broker, telemetry, Minimal APIs setup, and more
  • Priority support
  • Community access, with direct access to me
Get the Community edition for $158.80

Or get all three Community editions in .NET Architecture & APIs for $349.

Modular Monolith Architecture course cover

Modular Monolith Architecture

Clear module boundaries and a safe path to microservices.

  • 10 chapters
  • 12+ hours of video
  • Project source code
  • .NET 10, PostgreSQL, RabbitMQ, Docker
  • 2,800+ students

We build Evently, a production-ready system, from scratch: dozens of API endpoints, 50+ use cases, and 6,000+ lines of code. You start with one module and finish by extracting a module into a microservice.

You'll learn how to:

  • Find module boundaries with DDD, Event Storming and bounded contexts
  • Isolate each module: its own DI, configuration, validation, Redis caching and health checks
  • Pick synchronous or asynchronous communication between modules, and handle eventual consistency
  • Set up Keycloak for token-based authentication and role-based authorization
  • Keep the team inside the architecture, including with architecture tests
  • Make messaging reliable with the Outbox and Inbox patterns and idempotent consumers
  • Use event-carried state transfer, materialized views and saga orchestration
  • Extract a module into a microservice with RabbitMQ, YARP and OpenTelemetry tracing
All 10 chapters
  1. 1Modular Monoliths: Introduction46mMonoliths, microservices, modular monoliths, module constraints
  2. 2Defining Module Boundaries1h 47mDDD, Event Storming, bounded contexts, the first Evently module
  3. 3Module Cross-Cutting Concerns1h 13mDI, configuration, Serilog and Seq, exceptions, FluentValidation, Redis, health checks
  4. 4Module Communication1h 22mDomain events, sync and async communication, duplicated data, eventual consistency
  5. 5Authentication & Authorization1h 23mKeycloak, token-based authentication, registration, RBAC
  6. 6Architecture Enforcement35mThree techniques, including architecture tests
  7. 7Reliable Messaging: Outbox and Inbox1h 10mOutbox, idempotent consumers, Inbox
  8. 8Event-Driven Architecture1hEvent notifications, event-carried state transfer, materialized views, sagas
  9. 9Testing Modular Monoliths1h 14mUnit, integration and system integration tests, tests in CI/CD
  10. 10Microservices: Extracting Modules1h 24mOpenTelemetry, RabbitMQ, YARP as the API gateway, extracting a module
"The way it's structured, the depth of each topic and the code is simply excellent."
Mykola Kriukov, Senior Software Engineer
Full course page and reviews

Course edition · 12+ hours50% off

$148.50 this week, regular $297

You save $148.50

  • All 10 chapters and the project source code
  • Bonus: CQRS With MongoDB (40m)
  • Email support
Get the Course edition for $148.50

Community edition · 14+ hours60% off

$198.80 this week, regular $497

You save $298.20

  • Everything in the Course edition
  • Modularize Your Monolith, A Quick Guide (1h 31m), step by step on an existing monolith
  • Priority support
  • Community access, with direct access to me
Get the Community edition for $198.80

Or get all three Community editions in .NET Architecture & APIs for $349.

Pragmatic REST APIs course cover

Pragmatic REST APIs

Auth, caching, rate limiting, webhooks, and a full test suite.

  • 9 chapters
  • 14+ hours of video
  • First chapter is a free preview
  • .NET 10, PostgreSQL, React, Azure
  • 1,900+ students

We build a complete REST API from scratch, from basic CRUD to HATEOAS, authentication, and automated testing, then connect a React client and deploy it. You can follow along even if REST APIs are new to you.

You'll learn how to:

  • Design resources with the right HTTP methods, status codes and Problem Details
  • Add searching, filtering, sorting, pagination and data shaping
  • Version the API and manage changes, with HATEOAS and content negotiation
  • Secure it with ASP.NET Core Identity, JWTs and refresh tokens, RBAC and ABAC
  • Add HTTP caching, rate limiting, idempotency, webhooks and resilience with Polly
  • Test it with unit, integration and end-to-end tests, using WireMock for external services
  • Document it with OpenAPI and Scalar, then deploy to Azure with GitHub Actions and Application Insights
All 9 chapters
  1. 1REST Introduction1h 5mRichardson Maturity Model, API-First, environment setup (free preview)
  2. 2Building REST APIs4h 25mHTTP methods and status codes, CRUD with EF Core, validation, Problem Details, filtering, pagination, data shaping
  3. 3HATEOAS and Change Management1h 32mHATEOAS, content negotiation, API versioning
  4. 4Authentication and Authorization2h 7mASP.NET Core Identity, JWT and refresh tokens, RBAC and ABAC, the GitHub API, encryption
  5. 5Client Integration50mA React client, batch operations, HATEOAS-driven UI, OpenAPI client generation
  6. 6Advanced REST API Concerns1h 36mHTTP caching, optimistic locking, cursor pagination, rate limiting, Refit, Polly, idempotence, webhooks
  7. 7Testing REST APIs1h 7mUnit, integration and end-to-end tests, WireMock, tests in CI/CD
  8. 8Documenting REST APIs34mOpenAPI, versions and auth flows, Scalar
  9. 9Deployment and Monitoring56mAzure, database migrations, Application Insights, GitHub Actions
"This is by far the best and the most comprehensive REST APIs course I have seen."
Anton Martyniuk, Microsoft MVP
Full course page and reviews

Course edition · 14+ hours50% off

$123.50 this week, regular $247

You save $123.50

  • All 9 chapters
  • Bonus: REST API Case Study, one lesson on the Patreon API
  • Email support
Get the Course edition for $123.50

Community edition · 16+ hours60% off

$158.80 this week, regular $397

You save $238.20

  • Everything in the Course edition
  • Building REST APIs With Minimal APIs (50m)
  • Integrating Auth0 (52m)
  • Priority support and community access, with direct access to me
Get the Community edition for $158.80

Or get all three Community editions in .NET Architecture & APIs for $349.

Pragmatic Self-Hosting: Foundations course cover

Pragmatic Self-Hosting: Foundations

Deploy your app to a VPS you control.

  • 10 modules
  • About 4 hours of video
  • Dokploy, Tailscale, Docker
  • One edition

Learn to run your app with Dokploy, keep administration private with Tailscale, verify releases, and restore a database backup. I build and self-host Katabench, a .NET coding platform with a few thousand users. I also run my internal tools and observability platform on Dokploy.

It's for developers who can run a Docker container, use Git and read terminal commands. The VPS and the domain cost extra. The course VPS costs about $7 a month before tax.

You'll learn how to:

  • Provision Ubuntu on Hetzner with a passphrase-protected SSH key and a cloud firewall
  • Harden the server: a deploy user, key-only SSH, root and password login off, automatic security updates
  • Move SSH and the Dokploy admin onto a private Tailscale network, with two-factor auth
  • Deploy a .NET and React app with PostgreSQL, Redis and automatic HTTPS through Traefik
  • Ship releases from GitHub Actions to GHCR over Tailscale, with migrations and rollback to an earlier image
  • Back up to Cloudflare R2, then restore into a temporary database and compare schema and row counts
  • Watch the readiness endpoint with UptimeRobot and keep a monthly maintenance routine

It covers one server. Kubernetes, high availability and multi-server setups are out of scope.

Full course page

One edition · about 4 hours40% off

$149 this week, regular $249

You save $100

  • 10 modules plus an AI companion lesson
  • TaskFlow source code (.NET and React, MIT)
  • The Production Runbook and 7 agent skills
  • Transcripts
Get Foundations for $149

It's also the fourth course in Build & Deploy for $449.

Lifetime access

Pay once and keep every lesson forever, including all future updates.

No subscription

One payment covers your chosen course edition.

Expense it at work

You will get a receipt you can submit to your company for reimbursement.

9,700+ students so far

What students say

"While going through the course it helped me propose an architecture for a project I am working on with my current employer."
Pete Dragun
Pragmatic Clean Architecture
"This course describes in depth important aspects that can be applied to any architecture, like the Inbox/Outbox pattern, cross-service communication, etc."
Vladislav Antonyuk
Modular Monolith Architecture
"A major upside is the integration with a client application and the deployment to production."
Horia Apostol
Pragmatic REST APIs

Questions, answered

How does the discount work?

Every buy button on this page goes straight to checkout with the discount already applied. You do not need to type a code.

When does the sale end?

The sale runs through November 30. Buy before it closes to get the sale price. You can start learning whenever you are ready.

Course edition or Community edition?

Both have the full course with lifetime access and future updates. The Course edition comes with email support, and it is enough to learn everything in the curriculum. The Community edition adds the bonus material listed on each card, priority support, and community access with direct access to me.

What is in the two bundles?

.NET Architecture & APIs has the Community editions of Pragmatic Clean Architecture, Modular Monolith Architecture, and Pragmatic REST APIs. Build & Deploy has the same three, plus Pragmatic Self-Hosting: Foundations. Courses released later are not part of either bundle.

Which .NET version do the courses use?

Modular Monolith Architecture and Pragmatic REST APIs are updated to .NET 10. Pragmatic Clean Architecture is updated to .NET 8.

Do I keep access after the sale?

Yes. Pay once and keep every lesson forever, including all future updates. No subscription. The sale changes the price, not what you get.

Can I expense this at work?

Yes. You will get a receipt you can submit to your company for reimbursement. Many students expense the course through their employer.

Why do I see different prices than a friend?

Prices are lower for some countries. If yours is one of them, the page shows your price and every button applies it at checkout.

Do prices include tax?

Prices are in USD before tax. Depending on your country, applicable tax (like VAT) is added at checkout.

The sale runs through November 30

One course from $123.50, three Community editions for $349, or all four courses for $449 instead of $1,540. Prices are in USD, plus applicable tax.

97 coupons left

Or pick a single course

Thank you for all the support. It really means a lot.
Milan