TL;DR: Grokking the Advanced System Design Interview has not disappeared. It has been expanded and relaunched as Advanced System Design Interview, Volume II, the direct successor to the original Grokking the System Design Interview. It is built for Senior, Staff, and L5/L6 interviews: 142 lessons, roughly 36 hours of content, deep dives into seven real distributed systems (Dynamo, Cassandra, Kafka, Chubby, GFS, HDFS, BigTable), fifteen medium-to-hard design problems, and 400 practice quizzes. If you are targeting mid-level roles, start with Volume I instead.
If you have searched for "Grokking the Advanced System Design Interview" recently and ended up somewhere unexpected, here is the short explanation: the course was renamed. The old link now redirects to its successor, and reviews written about the earlier edition describe only part of what the current course contains. This post covers what happened, what Volume II actually includes, and how to decide whether it is the right course for your level.
Where did Grokking the Advanced System Design Interview go?
Grokking the Advanced System Design Interview began as the deep-dive companion to the original Grokking the System Design Interview. Its signature material was the study of real distributed systems: how Dynamo, Cassandra, Kafka, and Google's infrastructure papers actually work under the hood.
As we rebuilt the course family, we expanded that material and merged it with a set of harder, senior-level design problems, then relaunched the result as Advanced System Design Interview, Volume II. The name change makes the relationship explicit: Volume I teaches the framework and the classic problems, Volume II is the next step for engineers who are past the basics and preparing for a senior bar.
So if you bought or bookmarked the old course, nothing was taken away. The deep dives are still there. They now sit alongside a substantially larger set of design problems, quizzes, and a patterns reference.
What Volume II covers
The course has three kinds of material, and the mix is what defines it.
1. Deep dives into seven real distributed systems
This is the part longtime readers will recognize from the Advanced course, expanded with quizzes and walkthrough mock interviews for each system:
- Dynamo: consistent hashing, vector clocks, Merkle trees, gossip, and how a key-value store stays available during failures
- Cassandra: wide-column data modeling, tunable consistency levels, the write and read paths, compaction, and tombstones
- Kafka: consumer groups, delivery semantics, the controller broker, and what ZooKeeper actually does
- Chubby: distributed locking, sessions, master election, and why coarse-grained locks won
- GFS and HDFS: the anatomy of reads, writes, and appends in distributed file systems, fault tolerance, and high availability
- BigTable: SSTables, tablets, and how a wide-column store is assembled from GFS and Chubby
These are the systems interviewers themselves grew up on, and their ideas (quorums, leases, log-structured storage, partitioning schemes) are the raw material of senior-level answers. When an interviewer pushes past your high-level diagram with "and what happens when that node dies mid-write?", this is the chapter of your preparation that answers.
2. Fifteen design problems at the senior bar
Volume II's problem set deliberately avoids re-teaching the classics. Instead of another URL shortener, you get problems rated medium to hard that reward judgment under ambiguity:
- Medium: YouTube likes counter, notification service, Reddit, Google Calendar, a recommendation system, Gmail, Google News, unique ID generator, and a code judging system like LeetCode
- Hard: a payment system, a flash sale system, and a reminder alert system
The hard tier is where the course earns its title. A flash sale design sounds simple until fairness, inventory consistency, and thundering-herd traffic collide, and that collision is precisely what L5/L6 interviews are made of.
3. A System Design Patterns reference
The closing section abstracts the recurring ideas from the deep dives into a reusable pattern catalog, followed by a final assessment. Nearly every module ends with a quiz (400 in total), and the major systems each include a walkthrough mock interview.
Altogether: 142 lessons, roughly 36 hours of content, self-paced, written with input from senior engineers at Google, Meta, Amazon, Microsoft, and Uber.
Volume I vs. Volume II
| Grokking the System Design Interview (Vol. I) | Advanced System Design Interview, Volume II | |
|---|---|---|
| Level | Mid-level and senior engineers starting structured prep | Senior, Staff, and L5/L6 candidates |
| Focus | The 7-step framework, core building blocks, trade-offs, classic problems | Real distributed systems internals, harder problems, failure reasoning |
| Signature content | 22-lesson trade-offs chapter, classics like URL shortener, Instagram, Uber | Dynamo/Cassandra/Kafka/BigTable deep dives, payment and flash sale designs |
| What interviews it maps to | The standard system design round | Rounds where the interviewer keeps pushing until something breaks |
The short version: Volume I teaches you to structure an answer. Volume II teaches you to defend it.
Who Volume II is for
Take it if:
- You are interviewing for Senior, Staff, or L5/L6 roles where "it scales" is not accepted as an answer
- You have already internalized the fundamentals, whether from Volume I, from production experience, or both
- You want to understand the systems behind the buzzwords, so that "we could use something Kafka-like here" comes with an explanation of partitions, consumer groups, and delivery guarantees
- You are an engineering manager or architect who needs depth on distributed systems trade-offs beyond interview prep
Skip it (for now) if:
- You are preparing for your first system design interview. Start with Volume I or, if you are completely new, Grokking System Design Fundamentals.
- Your target round is a standard mid-level loop. Volume I covers that bar thoroughly, and jumping straight to internals can cost you time you should spend on framework practice.
If you are unsure which bar your interview sets, our guide to how long the courses take to finish breaks preparation down by level.
Do you need Volume I first?
Not strictly, but the sequencing matters. Volume II assumes you can already run the standard interview loop: clarify requirements, estimate scale, sketch a high-level design. If you have solid production experience with distributed systems, you can start with Volume II and reference Volume I's trade-offs chapter as needed. If your framework is shaky, do Volume I first; senior interviews still begin with the same structured conversation, they just refuse to stop there.
Frequently asked questions
Is Grokking the Advanced System Design Interview still available? Yes. It was expanded and relaunched as Advanced System Design Interview, Volume II on DesignGurus.io. The old course link redirects there, and the distributed systems deep dives it was known for are all included.
How many lessons does Volume II have? 142 lessons, roughly 36 hours of content, with 400 practice quizzes and walkthrough mock interviews for the major systems.
Is Volume II worth it for senior engineers? If you are facing L5/L6 interviews, yes. Those rounds test failure reasoning and trade-off defense, not component naming, and Volume II is built specifically for that bar. For the broader question of whether the Grokking approach fits you at all, see is Grokking the System Design Interview worth it?
Do I need to finish Volume I before starting Volume II? No, but you need its material. Engineers with strong distributed systems experience can start with Volume II directly; everyone else should build the framework with Volume I first.
Is this the same as Educative's advanced system design content? No. Like the flagship course, Volume II is authored and maintained by the original Design Gurus team on DesignGurus.io. The naming confusion between platforms is explained in our Educative vs. original comparison.
Ready to go deeper? Explore the full curriculum, free preview lessons, and reviews on the official course page: Advanced System Design Interview, Volume II on DesignGurus.io. New to the method? Start with the story of what Grokking System Design is or the free GitHub companion.