Monolith to Microservices - The Modernization Playbook

Descripción

Legacy monoliths are everywhere. Rewriting them from scratch is risky, expensive, and often unnecessary. In Monolith to Microservices - The Modernization Playbook, you will learn how to modernize a real-world legacy application step by step using practical software architecture patterns used in enterprise systems. This is not a theory-only microservices course. You will work through a complete modernization journey: starting with a monolith, discovering domain boundaries, moving toward a modular monolith, introducing domain events, adding a Strangler Fig API Gateway, extracting a real microservice, adding a service-owned database, implementing the Outbox Pattern, integrating RabbitMQ, and finally adding observability and resilience with OpenTelemetry, Aspire Dashboard, and Elastic/ELK. You will learn how to break a monolith safely without breaking the business. The course uses a healthcare claims processing system as the case study, making the architecture realistic enough to demonstrate real modernization decisions: claims, members, policies, providers, documents, payments, notifications, audit trails, and reporting. By the end, you will understand not only how microservices are built, but how they are extracted from existing systems in a controlled, domain-driven, production-minded way. What You’ll Learn • Modernize a legacy monolith without a risky big-bang rewrite • Apply Domain-Driven Design to discover real service boundaries • Refactor a monolith into a modular monolith with clear module ownership • Use domain events to decouple business capabilities • Implement the Strangler Fig Pattern with an API Gateway • Extract a Documents microservice from an existing system • Add a service-owned database to remove shared database dependency • Implement the Outbox Pattern for reliable cross-service events • Replace local integration events with RabbitMQ • Add OpenTelemetry tracing, metrics, and logs • Use Aspire Dashboard for local observability • Understand how Elastic/ELK fits as a production-style observability option • Add basic gateway resilience, correlation IDs, and operational visibility • Build a modernization roadmap that is practical, incremental, and demo-ready Who This Course Is For • .NET developers working with legacy systems • Backend engineers moving from monoliths to microservices • Software architects designing modernization roadmaps • Senior developers preparing for architecture responsibilities • Teams that want practical DDD, modular monolith, and microservices guidance • Developers tired of toy microservices examples and looking for a realistic migration path Requirements • Basic C# and ASP.NET Core knowledge • Familiarity with REST APIs • Basic Docker knowledge is helpful • Some experience with enterprise applications or layered architecture is useful • No prior microservices migration experience required

Lo que aprenderás

• Modernize legacy monoliths into scalable microservices.
• Apply the Strangler Fig Pattern in real projects.
• Design domains using Domain-Driven Design (DDD).
• Transform a monolith into a modular monolith.
• Build production-ready .NET microservices from scratch.
• Implement Clean Architecture and Vertical Slice Architecture.
• Use RabbitMQ and the Outbox Pattern for messaging.
• Create API Gateways for gradual service migration.
• Enable observability using OpenTelemetry and distributed tracing.
• Execute an end-to-end enterprise modernization strategy.

Requisitos

• Basics of Programming, C#, .Net Core, Docker.