Grokking Microservices Design Patterns

What the course covers

The course page lists 19 chapters, 158 lessons, 32 code playgrounds and 249 assessments, with about 13 hours of study time at intermediate level. After an introduction, each pattern gets its own chapter:

• Migration and entry points: strangler fig (breaking up a monolith gradually), API gateway, backends for frontends
• Finding services: service discovery, and why hardcoded addresses stop working when the fleet changes shape
• Resilience: circuit breaker, bulkhead and retry, including the failure modes each can add, such as a naive retry turning a small outage into a large one
• Infrastructure patterns: sidecar and service mesh, moving retries, timeouts and encryption out of your code into a proxy
• Data: database per service, saga (distributed transactions with compensating actions instead of two-phase commit) and transactional outbox (changing data and publishing its event together)
• Events and reads: event-driven architecture, CQRS and event sourcing
• Operations: configuration externalisation

It ends with a final exam and a wrap-up. Each chapter includes flashcards and an adaptive assessment, and examples draw on real companies such as Netflix.

Ratings and learners

As of September 2026 the course page shows a rating of 4.1 out of 5 from 4,492 ratings and 13,475 learners. It was first published in 2023 and updated within the last month.

Why these patterns are worth learning by name

Every pattern here exists because of a specific production failure: a slow dependency taking down a healthy service, a retry storm amplifying an outage, a transaction that cannot span two databases. Knowing the names gives you a shared vocabulary with your team and with interviewers, and knowing the cost of each pattern stops you applying them everywhere.

How to get the most from it

• Run the Java examples and change them. Break the circuit breaker's threshold, remove the outbox, and see what goes wrong.
• Map each pattern onto a system you know. Where would a saga replace a transaction you use today? Where would a bulkhead have contained a past incident?
• Build a tiny two-service project with an API gateway, one database per service and an outbox publishing events. It makes the data chapters concrete.
• Plan two to three weeks at an hour a day.

What you will be able to do afterwards

Choose patterns for a service architecture and explain what each one costs, plan an incremental migration from a monolith, keep data consistent across services without distributed transactions, and design resilience into service-to-service calls.

Where it fits

Grokking Microservices for System Design Interviews is the companion course: it teaches when to use microservices at all and how to discuss them in a design round, while this course goes deep on each mechanism. Both are part of the wider system design path alongside Grokking the System Design Interview.

Buying and access

The course is paid: you can buy it once for lifetime access, or get it as part of an all-access subscription covering more than 40 courses. Prices shown depend on your region and current offers, so check the course page. A free preview lets you read the opening lessons first, and a certificate is issued on completion.

Common questions

Do I need to know Java? Basic reading knowledge helps with the examples, but the patterns apply to any language.

Is it for beginners? It is marked intermediate. You should be comfortable with REST APIs and databases.

How long does it take? About 13 hours of material, plus time with the playgrounds.

Best for: developers and aspiring architects who work with service-based systems and want the core patterns with their trade-offs.