System design is a moving target. The fundamentals are stable, but the specific systems engineers ask about in interviews shift every couple of years. Pinterest gives way to Reddit. WhatsApp gives way to Discord. The classic ad-click-tracking problem gives way to the flash-sale problem.
A static resource can't keep up with this. A continuously updated course can. That's the practical case for keeping Grokking System Design current rather than freezing it like a book.
Here's what actually changed in 2026, organized by what kind of update it is.
| Update | What it is |
|---|---|
| Rebuilt course | Video lessons and interactive diagrams on top of the illustrated text, now 83 lessons |
| Volume II | A new senior-focused course with 12 new case studies |
| AI design playground | Sketch your own design and get AI feedback before seeing the solution |
| Inline AI explainer | Highlight any text for a deeper, tailored explanation |
| Trade-offs module | More than doubled, with five new edge-level comparisons |
| Quizzes | Around 400, now live across the course |
| Flashcards | In development, rolling out through 2026 |
First, the course itself was rebuilt
If your mental picture of Grokking System Design is a long page of text with a few static diagrams, it is out of date.
A lot of engineers remember the original course that way, because that is how it looked when an early version was hosted on a third-party platform years ago. The original Grokking the System Design Interview on DesignGurus.io has since been rebuilt from the ground up, and it now looks and feels nothing like the text-only version people remember.
It is video now, not just text. The current version pairs the written lessons with video walkthroughs and illustrated explanations. You can watch a concept get explained, see it drawn out, and then read the detail at your own pace. This matters more for system design than for most subjects. System design is spatial: requests flow through gateways, data lands in shards, caches sit between layers, and queues absorb spikes. Watching that movement explained on video, instead of reconstructing it from a paragraph in your head, makes the ideas land faster and stick longer. The writing did not go away; the videos sit on top of the illustrated text, so you get both. That is the part the older copies floating around the internet simply do not have.
The diagrams are interactive. Static architecture diagrams have a ceiling. The updated course uses interactive architecture diagrams instead: you step through a design and watch it build, component by component, rather than staring at a finished picture and trying to reverse engineer the reasoning. By the time you reach the end of a case study, you have seen the system assembled in the same order you would have to assemble it at a whiteboard.
It expanded to 83 lessons. The curriculum grew to 83 lessons across five chapters, roughly 20 hours of content, spanning the interview introduction, the glossary of system design basics, the trade-offs module, the worked design problems, and the appendix. The curriculum page has the full lesson-by-lesson breakdown.
Everything below builds on that rebuilt foundation.
The biggest update: Volume II as a separate course
The most significant addition isn't a feature inside the original course. It's a new course alongside it.
Grokking the System Design Interview, Volume II launched as a deeper, senior-focused companion to the original Grokking the System Design Interview. The original course (now thought of as Volume I) is designed for engineers up to about 5 years of experience, covering the fundamentals, trade-offs, and 18 classic system design problems.
Volume II is built for the gap above that. Senior engineers, staff engineers, and anyone with 5+ years of experience who needs deeper coverage of more complex systems will find it directly relevant. Mid-level engineers who want to push past their comfort zone can also benefit, especially in the final weeks of preparation.
This addresses the most consistent feedback I've received over the years: the original course is excellent for the audience it was built for, but it caps at mid-level interview difficulty by design. We made that scope choice deliberately to keep the original course focused. Volume II is the answer for everyone who needed more.
If you've read the honest review of the original course, you saw me explicitly call out the mid-level cap as a limitation. Volume II is the structural answer to that limitation.
The 12 new case studies in Volume II
Volume II contains 12 system design case studies, all new and not duplicated from Volume I. These are problems that have been showing up in 2025 and 2026 senior-level interview loops, and most are deeper or more architecturally complex than the Volume I set:
- YouTube Likes Counter: distributed counter design at massive scale, one of the most commonly asked problems for engineers interviewing at companies with high-throughput counting systems.
- Design Reddit: feed ranking, subreddit sharding, vote counting, and comment trees at scale.
- Designing a Notification System: multi-channel delivery (push, email, SMS), prioritization, deduplication, and at-scale fanout.
- Design Google Calendar: recurring events, time zones, conflict resolution, and reminders at billions of users.
- Design a Recommendation System for Netflix: collaborative filtering, content-based ranking, and serving recommendations with sub-100ms latency.
- Design Gmail: email storage at scale, spam filtering, search indexing, and consistent delivery.
- Design Google News (Global News Aggregator): crawling, deduplication, clustering, ranking, and serving personalized news feeds globally.
- Design Unique ID Generator: Snowflake-style ID generation, the trade-offs between centralized and distributed approaches, and clock synchronization.
- Design Code Judging System like LeetCode: sandboxing, queue management, language-specific runners, and result delivery.
- Design Payment System: idempotency, double-spend prevention, fraud detection, and integration with payment providers.
- Design a Flash Sale for an E-commerce Site: inventory locking, traffic spike absorption, queueing, and preventing overselling.
- Design a Reminder Alert System: distributed scheduling, persistence, retry logic, and at-scale time-based execution.
Each case study uses the same 6-step framework as Volume I (clarify requirements, estimate capacity, define APIs, sketch high-level design, drill into components, identify bottlenecks), so engineers who've taken Volume I can apply familiar structure to harder problems.
The "harder" comes from a few directions: more complex consistency requirements (Payment System, Flash Sale), bigger scale considerations (YouTube Likes Counter, Google News), and trickier distributed coordination (Reminder Alert System, Unique ID Generator).
AI features in the original course
Two AI features were added to Volume I in 2026, both included at no extra cost for everyone with course access (free tier and paid). These aren't additions to the curriculum so much as additions to how you study the curriculum.
AI design playground
Available on every case study in the course. Before watching the lesson's solution, you can sketch your own design and ask AI to evaluate it. The AI compares your design to the patterns the course teaches and gives feedback on what's solid, what's missing, and where you'd benefit from going deeper.
The pedagogical point: the course has always recommended attempting your own design before watching the solution. That's the highest-leverage habit in system design prep. Most learners skip it because there's friction (no easy way to get feedback on your attempt). The playground removes that friction.
This is the feature I'm most pleased with. It converts the course from a thing you watch into a thing you practice with.
Inline AI text explainer
On any course page, you can highlight a piece of text and a popup gives you a deeper explanation tailored to what you selected. If a paragraph mentions consistent hashing and you want more detail without leaving the page or context-switching to Google, you select the text and ask.
This is targeted at the moments where readers hit something they don't fully understand, would otherwise stop, and either skip ahead (losing learning) or go down a rabbit hole on Wikipedia (losing momentum). The explainer keeps you in the course while filling the gap.
Both features are available across the entire Volume I course. They're available on Volume II as well.
Expanded trade-offs module
The trade-offs module in Volume I was originally about 10 lessons covering the most common comparisons engineers face in interviews. We've expanded it significantly.
The module has more than doubled in size, with several recent additions specifically targeting "edge-level" trade-offs. These are the ones that, when discussed well in an interview, mark you as a stronger candidate. They tend to come up in senior-level interview loops where the conversation shifts from "you know this concept" to "you know when to apply it and when not to."
Recent additions to the trade-offs module:
- Serverless Architecture vs Traditional Server-based: when serverless wins on cost and operational overhead, when traditional servers win on cost predictability and control.
- Stateful vs Stateless Architecture: session handling, scalability implications, and when each approach is the right choice for APIs and web services.
- Hybrid Cloud Storage vs All-Cloud Storage: balancing scalability against compliance and control requirements for enterprise systems.
- Token Bucket vs Leaky Bucket: the two main rate-limiting algorithms compared on traffic shaping behavior and burst handling.
- Read-Heavy vs Write-Heavy System: how design decisions diverge when the workload is biased one way or the other, with techniques like batching, replication, and partitioning.
These are the kinds of trade-offs senior interviewers probe with follow-up questions like "why didn't you use serverless here?" or "how would you handle a traffic spike that's 10x your normal write rate?" The expanded module gives you the vocabulary to handle those questions confidently.
For the complete trade-offs list, the curriculum page shows every lesson with a one-line description.
Quizzes are live, flashcards are next
Reading and watching are passive. Recall is active.
Quizzes shipped across the course in 2026. There are now around 400 of them woven through the lessons: nearly every module ends with a quiz, and every case study closes with one, so the design you just walked through gets locked in rather than fading the moment you move on. The point is comprehension verification. After you've worked through a case study, do you actually understand why the design choices were made? The quizzes catch the moments where you nodded along without internalizing.
This is one of those changes that sounds small and turns out to matter a lot. Active recall is one of the most reliable ways to retain technical material, and the quizzes bake it into the course instead of leaving it up to you.
Flashcards are the next feature in development, based on the same feedback loop. Expect 50 to 80 flashcards per case study, designed for revision rather than initial learning. The use case: you finished the course three weeks ago, your interview is in three days, you don't have time to rewatch. You drill the flashcards. They're also useful for engineers who want to keep their system design knowledge fresh between interviews, not just for the immediate prep cycle. Flashcards will roll out lesson by lesson through 2026.
Who should care about which update
Different updates matter for different readers.
If you're a current Volume I user
The AI playground is the biggest practical change. Use it on the next case study you study. Try designing your own solution before watching the lesson. The feedback you'll get is more useful than passively watching.
The trade-offs module expansion matters too if you're interviewing for senior roles. Make sure you've covered the recent additions, especially Serverless vs Traditional, Stateful vs Stateless, and Read-Heavy vs Write-Heavy.
If you're a senior or staff engineer
Volume II is built for you. The 12 case studies are deeper than Volume I and target the kinds of problems that come up at L5+ interviews. If you've already done Volume I, Volume II is the natural next step.
If you haven't done Volume I yet, you can start there or jump to Volume II depending on how confident you are with the fundamentals. Most senior engineers benefit from doing Volume I first as a refresher, then Volume II for the depth.
If you're a Volume I user from before 2026
The course you took earlier still works, but several lessons in the trade-offs module are new, the quizzes didn't exist, and neither did the AI features. If you have ongoing course access through a subscription or lifetime, log back in and check the trade-offs module specifically. New material is unlocked there.
And if you used Grokking System Design years ago and bounced off the text-only format, the honest answer is that it's worth another look. Video lessons, interactive diagrams, and quizzes make it a different experience now.
If you're considering enrolling for the first time
Start with Volume I. The free tier on DesignGurus.io includes introductory lessons, and the AI features are available even in the free tier so you can try them before paying. If you're a senior engineer specifically targeting L5+ interviews, plan for Volume I plus Volume II.
For more context on whether the course fits your situation, the honest review includes a five-question decision framework that walks you through it.
Still the original, just rebuilt
None of this changes the lineage. Grokking System Design is, and always has been, a Design Gurus course, created by Arslan Ahmad and his team. The version that lives on DesignGurus.io is the official one, maintained by the people who invented the methodology.
If you want the full story of how the name ended up on more than one platform, and how to tell the original from the copies, that is covered in detail on the homepage and in the comparison with Educative's similarly named course. The short version: the actively maintained original is the one on DesignGurus.io.
Why we keep updating instead of leaving it alone
The honest answer: because system design is a field where what's "current" actually changes.
Eight years ago when I wrote the first version of this course, event-driven architectures were exotic. Today they're standard. Five years ago, "design a payment system" wasn't a common interview question. Today it is. Three years ago, "design a recommendation system" wasn't asked outside of ML-specific roles. Today it shows up in general system design rounds.
A course that doesn't keep up loses relevance. Not all at once, but slowly, lesson by lesson, as the field moves and the course doesn't.
The alternative most resources take is to ship a fixed product (like a book) and let it age out, then write a Volume 2 a few years later. That's a fine model and it produces excellent books. But it doesn't serve readers preparing for an interview happening in 2026 with content frozen in 2020.
So we update. Sometimes by adding new case studies. Sometimes by expanding chapters that turned out to be more important than we initially recognized (like trade-offs). Sometimes by building entirely new courses for audiences the original wasn't designed for (like Volume II for senior engineers). Sometimes by adding tools that change how the course is studied (like AI features and quizzes).
The course you take in 2026 is meaningfully different from the course you'd have taken in 2024, and that's intentional.
Frequently Asked Questions
Is the AI playground available in the free tier?
Yes. The AI design playground and the inline AI text explainer are both available across all course access levels, including the free tier. There's no extra charge for either feature.
Do I need to pay separately for Volume II?
Volume II is a separate course with its own pricing. If you have an annual subscription that unlocks all Design Gurus courses, Volume II is included. If you have lifetime access to Volume I only, Volume II would be a separate purchase.
Should I take Volume I before Volume II?
For most readers, yes. Volume II builds on the framework, fundamentals, and trade-offs vocabulary from Volume I. Senior engineers with strong existing system design experience can sometimes start directly with Volume II, but the smoother path is Volume I first.
Are the new trade-offs in Volume I or Volume II?
The trade-offs module is part of Volume I. The expansion more than doubled it from about 10 lessons. Volume II has its own deep trade-off discussions woven into each case study but doesn't have a separate trade-offs module.
Are quizzes and flashcards available now?
Quizzes are live: around 400 of them spread across the course, with nearly every module and case study ending in one. Flashcards are in development and will roll out lesson by lesson through 2026.
How many lessons does the course have now?
83 lessons across 5 chapters, roughly 20 hours of self-paced content. The curriculum page lists every lesson.
How do I access the AI features if I'm an existing user?
Log into your DesignGurus.io account and open any course lesson. The AI playground and text explainer are integrated directly into the course interface. No separate setup needed.
If I bought Volume I in 2024, do I have access to the new trade-offs lessons?
Yes, if you have an active subscription. Lifetime course buyers also receive ongoing updates to the course they purchased. Log in and check the trade-offs module: the new lessons should be available.
Will Volume II have AI features too?
Yes. The AI playground and inline explainer are available across both Volume I and Volume II.
Is there a Volume III planned?
Not at this time. Our current focus is on completing the flashcards rollout, expanding case studies in both volumes as new patterns emerge in interview practice, and building out the Advanced System Design Interview course for principal-level architecture deep-dives.
What's the most important update for someone preparing for an interview right now?
If you're interviewing in the next few weeks, the AI playground is the most practical addition because it speeds up active practice (the highest-leverage prep activity). The expanded trade-offs module matters most for senior-level interviews. Volume II case studies are most relevant if your interview will likely include problems beyond the Volume I set (Reddit, Payment System, Notification System, etc).
Related reading
- About Grokking the System Design Interview. The complete guide to what the original course covers.
- The Full Curriculum. Every lesson with a one-line description, including the expanded trade-offs module.
- Grokking the System Design Interview Review: An Honest Look from the Person Who Built It. Detailed review covering strengths, limitations, and a five-question worth-it decision framework.
- Grokking Modern System Design Interview vs the Original. How to tell Educative's similarly named course apart from the original.
- Grokking the System Design Interview vs Alex Xu Books: An Honest Comparison. Side-by-side with the most popular alternative.
Try the AI features in the free tier
The AI playground and text explainer are available without payment. Spend 30 minutes with the introductory content and the first case study, try the playground on a problem you haven't seen before, and see whether the format works for you. The free tier is the most reliable way to evaluate the 2026 version of the course before committing.