Udemy
    •  
    •  
    •  
    •  
    •  
    •  
    •  
    •  
Subscribe
Turn what you know into an opportunity and reach millions around the world.
Learn More
Your cart is empty.
Keep shopping
Monolith to Microservices - The Modernization Playbook
30 students

Monolith to Microservices - The Modernization Playbook

Transform legacy applications into domain-driven, cloud-ready microservices using DDD and Strangler Fig pattern.
Created byRahul Sahay
Last updated 7/2026
English
English [Auto],

What you'll learn

  • 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.

Course content

16 sections • 185 lectures • 20h 24m total length

  • Introduction10:01
  • Understanding Domain Discovery9:10
  • Github Strategy10:25
  • About the Solution Structure7:57
  • Runtime Flow Demonstration2:33
  • About the Program6:42

Requirements

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

Description

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

Who this course is for:

  • .NET developers who want to modernize legacy ASP.NET Core monoliths into modular, cloud-ready applications.
  • Software architects designing modular monoliths, strangler gateways, microservices, and event-driven systems.
  • Solution architects planning safe enterprise application modernization without risky big-bang rewrites.
  • Technical leads guiding teams through monolith decomposition, service extraction, and distributed architecture.
  • Senior software engineers building clean architecture, CQRS, outbox pattern, RabbitMQ, and observability solutions.
  • Backend developers who want hands-on experience with ASP.NET Core APIs, EF Core, SQLite, RabbitMQ, and OpenTelemetry.
  • Full stack developers who want to keep a React frontend stable while modernizing backend architecture.
  • Enterprise application developers working on healthcare, insurance, claims, or workflow-heavy business systems.
  • Developers preparing for real-world system design discussions around monolith to microservices migration.

Report abuse