TL;DR: System Design Fundamentals (recently renamed from Grokking System Design Fundamentals, same course and content) is the beginner on-ramp: 100+ short text lessons teaching the vocabulary of scalable systems, with no prerequisites beyond basic programming. Grokking the System Design Interview is the interview course: the framework, 18 worked problems, and the practice loop. If you can already explain what a load balancer, a cache, and a CDN do, skip Fundamentals and start with the interview course. If those words are fuzzy, Fundamentals first will make everything after it faster.
Every review and guide on this site tells complete beginners the same thing: "start with Fundamentals." This post is the page that advice deserved all along: what the Fundamentals course actually is, how it differs from the main course, how much they overlap, and a 30-second way to know which one you should open first.
One housekeeping note before anything else, because it's the reason some readers are here.
First, the rename
The course long known as Grokking System Design Fundamentals is now officially named System Design Fundamentals. Same course, same content, same URL; if you had progress in it, nothing changed but the title. So if you searched the old name and results looked inconsistent, that's all that happened. Throughout this post I'll use the new name.
The two courses, side by side
| System Design Fundamentals | Grokking the System Design Interview | |
|---|---|---|
| Job | Teach the vocabulary of scalable systems | Teach you to run a system design interview |
| Format | 100+ short text lessons with diagrams and section quizzes | Video + text + interactive diagrams, ~400 quizzes, AI design playground |
| Content | ~20 hours, self-paced | ~20 hours, self-paced |
| Covers | Load balancing, caching, CDN, DNS, sharding, CAP, databases, messaging, security basics | The 6-step framework, building blocks at interview depth, a 22-lesson trade-offs module, 18 worked problems |
| Assumes | Basic programming only | You know the basic vocabulary already |
| Built for | Complete beginners to distributed systems | Engineers preparing for actual interview loops |
| Learner base | Rated 4.5 across 29,000+ ratings | Studied by 440,000+ engineers |
What System Design Fundamentals actually is
Fundamentals is a vocabulary course, and I mean that as a compliment: vocabulary is precisely what beginners are missing.
It walks through the building blocks of scalable systems one short lesson at a time: what a load balancer is and the algorithms behind it, why caching matters and how invalidation works, CDNs, DNS, data partitioning and sharding, proxies, replication and redundancy, the CAP theorem, SQL vs NoSQL, indexes, Bloom filters, quorum and heartbeat, authentication vs authorization, messaging systems and Kafka, and the classic comparisons (batch vs stream, stateful vs stateless, event-driven vs polling). Each section ends with a quiz.
Two honest notes about the format. First, it's entirely text-based: clear written lessons with diagrams, no video lectures. That's a feature for readers who like self-paced reading and a real limitation if you learn primarily from video (the main course has video; Fundamentals doesn't). Second, it deliberately stays at explanation depth, not interview depth: it teaches you what consistent hashing is, not how to defend it under follow-up questions. That's the point of an on-ramp.
There are no prerequisites beyond basic programming knowledge, which makes it the only course in the catalog a true beginner can open on day one.
What the main course is
Grokking the System Design Interview is the interview course: the 6-step framework drilled until it's reflex, the building blocks at interview depth, the 22-lesson trade-offs module, and 18 real interview problems worked end to end, with video walkthroughs, interactive diagrams, ~400 quizzes, and the AI design playground. The full review covers it honestly, including who shouldn't take it.
The relevant fact for this post: its chapter 2 covers the same building blocks Fundamentals teaches, at the depth an interview answer needs, but at a pace that assumes the words aren't brand new to you.
The honest overlap
This is the question underneath "which first": if the main course already has a fundamentals chapter, why does the Fundamentals course exist?
Pace and altitude. The main course's building-blocks chapter is a fast, interview-focused pass: here's the concept, here's the framing you'll use in an answer, moving on. Fundamentals takes the same territory at a third of the speed with three times the patience: more lessons per topic, gentler explanations, quizzes to confirm each step before the next. Plus material the main course doesn't slow down for at all: DNS resolution, proxies, Bloom filters, heartbeat, checksums, security basics.
So the overlap is real, and it's by design. Fundamentals is the slow lane through the same city; the main course is the highway that assumes you've driven before. Take both back to back as an experienced engineer and the repetition will annoy you. Take the highway as a true beginner and you'll be lost by chapter 3. The order question is really a question about you.
The 30-second self-test
Ask yourself two questions, honestly, without Google:
- Can you explain what a load balancer, a cache, and a CDN each do, and why a system would want them?
- Could you argue when you'd pick SQL over NoSQL, and name the trade-off you're accepting?
If yes to both: skip Fundamentals. Start with the interview course; its building-blocks chapter will refresh anything rusty at the right depth, and your prep time is better spent on the framework, trade-offs, and worked problems. Adding Fundamentals first would mostly buy you repetition.
If no, or not confidently: Fundamentals first. You'll move through it faster than a true beginner (skim what you know, quiz yourself forward), and the main course will land dramatically better afterward. This is the single most common regret pattern I hear from beginners who skipped ahead: they spent the interview course's problem chapters silently googling vocabulary.
One override: if your interview is inside about 4 weeks, go straight to the interview course regardless, and use Fundamentals as a lookup reference when a concept doesn't stick. On a short clock, framework practice beats vocabulary completeness.
Which order, by situation
| Your situation | Order |
|---|---|
| New to backend concepts, no interview scheduled | Fundamentals at a steady pace, then the interview course later |
| Career-switcher or bootcamp grad, interview in 8+ weeks | Fundamentals in 2-3 fast weeks, then the interview course |
| Working backend engineer, interview coming | Straight to the interview course |
| Interview inside 4 weeks | Interview course only; Fundamentals as reference |
| Not interviewing, want engineering depth | Fundamentals if new, then System Design Patterns rather than the interview course |
| Failed the self-test on some topics only | Interview course, with targeted Fundamentals lessons for the gaps |
Two notes on that table. The annual subscription includes both courses (and the rest of the catalog), so this is an ordering decision, not a purchasing one. And for readers building durable skill rather than prepping for a loop, the natural next step after Fundamentals is the patterns course, not the interview course; that path is covered in its own guide.
Frequently asked questions
Is System Design Fundamentals the same as Grokking System Design Fundamentals? Yes. The course was renamed to System Design Fundamentals; the content, URL, and any progress you had are unchanged.
Is System Design Fundamentals text-based or video? Entirely text-based: written lessons with diagrams and section quizzes, no video lectures. The main interview course is the one with video walkthroughs and interactive diagrams.
Is System Design Fundamentals enough to pass a system design interview? On its own, usually not. It builds the vocabulary an interview assumes, but not the framework, the worked problems, or the time-boxed practice that interviews actually test. It's the on-ramp; the interview course is the vehicle.
Do I need Fundamentals before the main course? Only if the basic vocabulary is new to you. If you can pass the two-question self-test above, start with the main course directly; its building-blocks chapter covers the refresher at the right depth.
How long does System Design Fundamentals take? About 20 hours of content. True beginners studying a bit each day typically finish in a few weeks; engineers using it as a fast-pass on-ramp can compress it to 2-3 weeks comfortably.
Do I need Fundamentals before the System Design Patterns course? Same test applies. The patterns course assumes basic backend literacy; if servers, databases, and APIs are comfortable concepts, you can start there. If not, Fundamentals first.
Related reading
- Grokking the System Design Interview Review: Is It Worth It?. The honest founder review of the main course.
- About Grokking the System Design Interview. What the interview course is and where the official version lives.
- System Design Patterns: What the New Course Covers. The concept-layer course that follows Fundamentals for non-interview paths.
- How Long Does It Take to Finish Grokking the System Design Interview?. Study plans for once you get there.
Start where the self-test points
Both courses have free content on DesignGurus.io, so the self-test costs nothing to act on: open the one it pointed you to, spend 30 minutes, and you'll know whether you're in the right lane.
System Design Fundamentals · Grokking the System Design Interview