Software Architecture in .NET
Decide how a .NET application is organized, where its domain boundaries sit and when a module should become its own service. It closes on the architect's role: recording decisions, choosing technologies and explaining the trade-offs to your team.
- Milestone 1
Structuring an application
Compare architecture styles, organize a .NET application by layers or by feature and record why you chose one, and handle validation, domain events and eventual consistency in Clean Architecture.
- Getting Started: Solution ArchitectureStarts with the architect's view: architecture styles, system design basics and how to document a decision, before you apply them to one .NET application.4h 47m
- Getting Started: Clean Architecture in .NETBuilds an app layer by layer, with CQRS, mediator, result and repository patterns placed where Clean Architecture puts them.3h 10m
- Deep Dive: Clean Architecture in .NETGoes further with Clean Architecture: validation, domain events, eventual consistency, testing, and authentication and authorization across the layers.3h 51m
- From Zero to Hero: Vertical Slice ArchitectureThe feature-first alternative to layers, with REPR endpoints, CQRS and domain events, so you can compare both approaches.6h 4m
- Milestone 2
Domain-Driven Design
Model a complex domain with aggregates, domain events and bounded contexts, and map how those contexts integrate.
- Getting Started: Domain-Driven DesignThe first Clean Architecture course gives DDD a 1000-foot view; this covers the tactical patterns, then strategic design and bounded contexts.5h 12m
- Deep Dive: Domain-Driven DesignAdds the discovery side: event storming, sub-domains, context mapping and aggregate design worked through in practice.5h 41m
- Milestone 3
Modular monoliths
Build a .NET application as modules with clear boundaries and choose how those modules communicate.
- Getting Started: Modular Monoliths in .NETBounded contexts from DDD become modules here, kept in one deployable app instead of separate services.3h 11m
- Deep Dive: Modular Monoliths in .NETAdds module communication patterns and event-driven upgrades across order processing, email and reporting modules.4h 21m
- Milestone 4
Microservices
Decide when a module should become a separate service and when services belong back in one deployable app, and handle communication, resilience and security across services.
- Getting Started: Microservices ArchitectureSome modules eventually need to scale or ship on their own; covers integration, resilience, testing and the team side of services.5h 21m
- Deep Dive: Microservices ArchitectureBuilds the first services, then takes a monolith apart into microservices and secures the calls between them.4h 18m
- From Zero to Hero: From Microservices to Modular MonolithsThe move in the other direction: planning and migrating from microservices to a modular monolith.2h 26m
- Milestone 5
The architect's role
Manage complexity across the whole system, choose technologies against business needs and explain the trade-offs to your team.
