Microservices Mastery Path¶
Most microservices advice is either a diagram of boxes and arrows or a warning that "it's harder than it looks" — without ever showing you the actual mechanism that makes it hard. This course tries to fix that: you'll build two real small services that talk over real HTTP, break the "just call the other service" approach on purpose by killing one mid-request, fix it with a real saga and a real compensating transaction, then wrap the call in a real circuit breaker and watch it trip. Microservices aren't a technology — they're an organizational and data-ownership bet, and the only way to understand what you're betting is to feel where a single shared database or a single synchronous call chain actually breaks under failure.
This course was written and run against real local services — small FastAPI and gRPC services on an ordinary laptop, started and killed by hand, called over real HTTP and real gRPC, with real timeouts, real retries, and real partial failures triggered on purpose. No Kubernetes cluster and no cloud account were needed for almost everything here. Where a full production service mesh control plane (e.g., Istio's control plane) genuinely couldn't be run as part of this course, that's said plainly, and the sidecar/mTLS mechanics are shown with a real lightweight proxy instead.
It assumes basic programming and command-line comfort, and some exposure to REST APIs. This course is deliberately scoped to not re-teach what three sibling courses already cover in depth: see System Design for distributed-systems theory (CAP, consensus, load balancing), Docker for container mechanics, and Kubernetes for orchestration. This course is about the application-level patterns that sit on top of all three: how you actually split a system, keep its data consistent, and keep it resilient once it's split.
How the program is organized¶
| Level | Focus | Modules | What you can do after |
|---|---|---|---|
| 1 · Decomposition & Service Boundaries | Why and when to split, bounded contexts, sizing services, sync vs async communication, REST/gRPC contracts, API gateway, BFF, service discovery | 10 | Decompose a real system into well-bounded services |
| 2 · Data & Consistency Across Services | Database-per-service, data ownership, sagas, the outbox pattern, idempotency, CQRS, eventual consistency, testing data consistency | 10 | Design and implement a real cross-service transaction |
| 3 · Resilience & Service Mesh | Circuit breakers, retries/timeouts/backoff, bulkheads, rate limiting, the sidecar pattern, mTLS, distributed tracing, contract testing | 10 | Build services that fail safely and recover on their own |
| 4 · Organizing, Migrating & Operating Microservices | Strangler fig migration, team topologies, versioning, deployment strategies, observability, anti-patterns, when not to use microservices | 10 | Plan a real monolith-to-microservices migration |
Each level has 9 teaching modules plus a hands-on project (module 10), for 40 lessons total.
How to use this site¶
- Run it yourself. Every service in this course is a small Python (FastAPI) or gRPC program you can start with one command — no account, no cloud bill, no container orchestrator required for the core lessons.
- Read the "what was run" note at the top of each lesson. Where real services were started, called, and killed to produce the output shown, that's stated; where a concept (like a full mesh control plane) couldn't be run locally, that's stated too.
- Do the "predict, then run" exercises. Distributed failure modes — a timeout cascading into a retry storm, a saga left half-finished — are easy to get wrong in your head and genuinely clarifying to watch happen.
- Do the projects. Each one is a real, runnable multi-service system, not a diagram.
More from the Mastery Path series¶
Free, structured, module-wise training across 97 other languages, platforms and disciplines — expand a category to browse: