TL;DR: three Design Gurus courses carry the word "patterns," and they share a teaching method, not a subject. Grokking the Coding Interview: Patterns for Coding Questions teaches algorithm patterns for LeetCode-style rounds. System Design Patterns teaches the 62 architecture patterns behind scalable systems. Grokking Microservices Design Patterns teaches service-boundary patterns like sagas and CQRS. And if you searched "design patterns" meaning singleton and factory, none of these is that; the closest fit in the catalog is the OOD interview course.
Search for "grokking patterns" and you'll land on three different courses with confusingly similar names. That's my fault, in the most literal way: pattern-based teaching is the method the whole catalog is built on, so the word ended up in three titles that have almost nothing else in common.
This page untangles them once and for all: what each course actually teaches, who it's for, and which one you need for the thing you're actually preparing for.
Why everything is called "patterns"
When I wrote the original Grokking courses, the bet was simple: don't teach a thousand problems, teach the couple dozen underlying structures the problems are made of. Learn the sliding-window idea once and twenty LeetCode problems become one problem. Learn consistent hashing once and every sharded system you ever meet makes sense. That bet became the house method, most modern prep resources adopted some version of it, and the word "patterns" stuck to everything we make.
The method transfers. The subjects don't. Patterns of algorithms, patterns of system architecture, and patterns of microservice boundaries are three different bodies of knowledge for three different situations, and picking the wrong course wastes weeks.
Course 1: Grokking the Coding Interview (patterns of algorithms)
The full name is Grokking the Coding Interview: Patterns for Coding Questions, and it's the course most people mean when they say "grokking patterns." It's for coding rounds: the LeetCode-style algorithm interviews.
Instead of grinding hundreds of unrelated problems, it organizes 245 problems around the underlying algorithm patterns: sliding window, two pointers, fast and slow pointers, merge intervals, BFS and DFS variants, two heaps, dynamic programming families, and the rest. You learn each pattern's shape once, then recognize it inside new problems, which is the entire game in a 45-minute coding round. It's the largest course in the catalog by study time, and the one with the longest track record.
Take it if: you're preparing for coding/algorithm interviews. Skip it if: your loop's challenge is the system design or design rounds; it won't help there at all.
Course 2: System Design Patterns (patterns of systems)
The newest course, and the subject of its own full tour. It teaches the 62 patterns scalable systems are built from, across 10 chapters: caching strategies, sharding and consistent hashing, queues and pub-sub, circuit breakers and idempotency, quorums and sagas, up through a dedicated AI infrastructure chapter (RAG pipelines, LLM gateways, semantic caching). Every chapter ends with a capstone design, and the course closes by assembling four full systems.
This is the concept layer of system design: it's for architecture fluency, in interviews and at work both, and it's the first course in the catalog aimed at every engineer rather than only interview candidates. The free pattern reference on this site lists all 62 with one-line definitions.
Take it if: you want to actually understand the building blocks behind system design, for interviews, design reviews, or day-job depth. Skip it if: your interview is inside a few weeks; take the interview course first and use this for targeted depth.
Course 3: Grokking Microservices Design Patterns (patterns of service boundaries)
The specialist of the three. Where System Design Patterns covers whole-system architecture, this course zooms into the specific problems that appear when a system is split into many services: how to decompose a monolith, who owns which data, how services communicate without coupling, and how a distributed transaction works when there's no single database to hide behind. Sagas, CQRS, event sourcing, service discovery, API gateways, and the resilience patterns applied at the service boundary.
It's the right course for a narrower audience: engineers building or operating microservices at work, architects making decomposition decisions, and senior candidates whose interviews probe microservice trade-offs specifically.
Take it if: microservices are your daily reality or your interview's stated focus. Skip it if: you're earlier in the journey; the general courses cover the shared foundations first, and this one assumes them.
The one-table version
| Grokking the Coding Interview | System Design Patterns | Grokking Microservices Design Patterns | |
|---|---|---|---|
| Patterns of what | Algorithms | System architecture | Service boundaries |
| Example patterns | Sliding window, two pointers, BFS/DFS | Caching, sharding, circuit breaker, RAG | Saga, CQRS, event sourcing, API gateway |
| Built for | LeetCode-style coding rounds | System design fluency, interviews and work | Microservice architecture, work and senior rounds |
| Size | 245 problems, the catalog's largest | 62 patterns, ~20 hours | Focused specialist course |
| Typical buyer | Any interview candidate | Backend, data, and AI engineers | Engineers on microservice systems |
Which one do you need?
Preparing for a full interview loop? Most loops have a coding round and a system design round, which means the realistic pairing is Grokking the Coding Interview for the first and the system design track for the second. The two pattern subjects don't substitute for each other any more than algorithms substitute for architecture.
Building engineering depth without a deadline? System Design Patterns is the one designed for exactly that, with Microservices Patterns as the follow-up if your systems are service-oriented.
Searching for singleton, factory, and observer? That's Gang of Four design patterns: code-level object-oriented patterns, a different subject from all three courses above. In this catalog, that territory lives closest to Grokking the Object Oriented Design Interview, which applies OOD principles to interview case studies.
Frequently asked questions
Is Grokking the Coding Interview about design patterns? No. It teaches algorithm patterns (sliding window, two pointers, BFS/DFS and so on) for coding rounds. Design patterns in the GoF sense are object-oriented code patterns, and system design patterns are architecture patterns; each lives in a different course.
Do System Design Patterns and Microservices Design Patterns overlap? Some, at the shared foundations: both touch event-driven communication and resilience ideas. The altitude differs: System Design Patterns covers whole-system architecture for every engineer; Microservices Patterns goes deep on the problems specific to service decomposition, data ownership, and inter-service transactions. Take the general course first unless microservices are your immediate reality.
Which pattern course helps system design interviews most? System Design Patterns for the depth, paired with Grokking the System Design Interview for the framework and worked problems; the ordering guide covers which first. The dozen patterns that carry most interviews are listed here.
Are all three included in the subscription? Yes. The annual Design Gurus subscription unlocks the entire catalog, including all three pattern courses; lifetime access is purchased per course.
Related reading
- Every Grokking Course, Explained: The 2026 Catalog Guide. The full catalog map, one page.
- System Design Patterns: What the New Course Covers and Who It's For. The deep tour of course 2.
- The 60+ System Design Patterns, Organized. The free reference behind it.
- System Design vs Object-Oriented Design Interviews. For the GoF and LLD searchers.
Match the course to the round
All three courses have free preview content on DesignGurus.io. Pick the one that matches what you're actually being tested on, spend thirty minutes in its free lessons, and you'll know you're in the right room.
Grokking the Coding Interview · System Design Patterns · Microservices Design Patterns