Most enterprise .NET applications have anemic domain models. Property bags with no behavior. The standard advice is to "apply DDD patterns". But blindly applying patterns rarely produces clean code.
This course takes a pragmatic path: start with a real procedural codebase, listen to what the code is telling us, and refactor toward a domain model that earns its complexity.
Be the first to know when the course launches and get exclusive early-bird pricing.
Join the waitlist and I'll send a heads-up the moment the course goes live, plus an early-bird discount.
WHAT'S INSIDE
Each chapter follows the same rhythm: notice the friction, reshape the code, and watch a DDD building block emerge naturally.
ASP.NET Core Web API
Modern data access
Reliable, production-grade database
Real unit and integration tests
We don't prescribe DDD patterns up front. We start with a real procedural codebase, listen to where it resists change, and refactor toward a domain model that earns its complexity.
Two procedural handlers thread through the course. The friction is systemic, and the refactoring works on both.
Most DDD content stops at a Customer with an Address. This course goes much further: a Learnify domain with course capacity, tiered revenue share, refund cascades across aggregates, and bounded contexts that span Catalog, Learning, Billing, and Identity. Patterns you can actually apply to the codebase you ship.
Each chapter has a clear starting and ending git ref, so you can drop in at any point. Skip ahead, jump back, or follow the whole arc. It's up to you.
By the end of the course, you'll be able to:
THE FULL CURRICULUM
Five phases (Foundations, Story, Domain Model, Hardening, and Strategic View) move you from a procedural codebase to a rich domain model with bounded contexts.
WHO'S BEHIND THIS
I'm a Software Architect and Microsoft MVP for Developer Technologies with years of experience building large-scale systems with rich domain models.
I've helped thousands of engineers level up through my practical tips on social media, The .NET Weekly newsletter, and my YouTube channel.
My goal with this course is simple: teach you to read code for friction signals and refactor toward a domain model that earns its complexity, without ceremony or dogma.
GOT QUESTIONS?
Intermediate .NET developers who are comfortable with C# and Entity Framework, but new to Domain-Driven Design. Or who've tried DDD and ended up with anemic models anyway.
If you write production .NET applications and want to push real behavior into your domain model, this course is for you. No prior DDD knowledge is required.
You'll learn how to refactor a procedural codebase into a rich domain model by reading the code, listening to friction signals, and relocating behavior toward where it belongs.
All examples target .NET 10.
Most DDD content prescribes patterns up front. This course does the opposite: it starts with a real, ugly procedural codebase and lets the DDD building blocks (Entity, Value Object, Domain Service, Aggregate, Bounded Context) emerge as we refactor. By the end, every pattern you use is one you earned, not one you copied.
I'm putting the finishing touches on it now. Join the waitlist and you'll get an email the moment it goes live, plus an early-bird discount.
Yes. Everyone on the waitlist gets first access to the launch discount before the course is announced publicly.
Reach out via the contact page and I'll get back to you.
BE THE FIRST TO KNOW
Join the waitlist and I'll send a heads-up the moment the course goes live, plus an exclusive early-bird discount for people on the list.
