TL;DR: "design interview" means two different rounds, and confusing them is one of the most expensive prep mistakes there is. System design (high-level design, HLD) is the architecture round: design Twitter, boxes and arrows, scale and trade-offs, no code. Object-oriented design (low-level design, LLD, OOD) is the code-structure round: design a parking lot's classes, SOLID principles, sometimes working code. The prep is different too: Grokking the System Design Interview for HLD, Grokking the Object Oriented Design Interview for LLD, and neither substitutes for the other.
An engineer wrote to me after a rough loop: they'd spent six weeks mastering distributed systems, walked into their "design round," and were asked to design a parking lot. Classes, interfaces, extensibility. Not a load balancer in sight. They'd prepared brilliantly for the wrong round.
The word "design" is doing too much work in interview loops, and recruiters don't always disambiguate. This post is the map: what each round actually tests, how to tell which one is on your calendar, and how to prepare for each.
The two rounds, side by side
System design, also called high-level design (HLD), is the architecture round. The question is "design Twitter," "design Uber," "design a URL shortener." You work at the altitude of services, databases, caches, queues, and load balancers; the conversation is about scale, availability, and trade-offs; the artifact is boxes and arrows on a whiteboard; and no one expects a line of code. It's a 45-minute structured conversation, which is why the 6-step framework matters as much as the knowledge.
Object-oriented design, also called low-level design (LLD) or OOD, is the code-structure round. The question is "design a parking lot," "design a library management system," "design a movie booking system." You work at the altitude of classes, interfaces, and relationships; the conversation is about responsibilities, SOLID principles, and extensibility ("now add electric-vehicle spots without rewriting everything"); the artifact is a class design, often with real code. In its most demanding form, the machine coding round, you build a small working system in 90 minutes.
| System design (HLD) | Object-oriented design (LLD/OOD) | |
|---|---|---|
| Typical question | Design Twitter, Uber, a URL shortener | Design a parking lot, a library, a booking system |
| Altitude | Services, databases, caches, queues | Classes, interfaces, methods, relationships |
| What's evaluated | Scale, availability, trade-off reasoning | Responsibility assignment, SOLID, extensibility |
| Artifact | Architecture diagram + conversation | Class design, often working code |
| Code expected | No | Often, sometimes fully working |
| GoF design patterns | Rarely relevant | Frequently relevant (strategy, factory, observer) |
| Prep course | Grokking the System Design Interview | Grokking the OOD Interview |
The vocabulary, detangled
Five terms cause most of the confusion, so here they are, pinned down:
- HLD (high-level design) = system design = the architecture round. Same thing, three names.
- LLD (low-level design) = the code-structure round. The term dominates in India-market loops, where LLD rounds are near-universal.
- OOD (object-oriented design) = the same round by its older, US-market name. "Grokking OOD" and "grokking low level design" searches land on the same course because they're the same skill.
- Machine coding = LLD with the code requirement turned all the way up: a working mini-system, compiled and running, under time pressure.
- Design patterns (GoF) = singleton, factory, strategy, observer: code-level patterns that are tools used within LLD rounds, not a round themselves. And they're a different thing again from system design patterns, which are architecture patterns. The pattern-courses guide untangles that side of the confusion.
Who gets asked which
By seniority: LLD rounds concentrate at the junior-to-mid band, where interviewers want to see whether you can structure code you'd actually write on the job. HLD rounds start appearing at mid-level and dominate senior loops, where architecture judgment is the differentiator. Senior loops at many companies still include one LLD-flavored round to check that the architecture talk is backed by code sense.
By market and company: India-market product companies run LLD and machine coding rounds almost universally, often as a dedicated gate before HLD. US big tech leans HLD-heavy, with OOD appearing mostly at the junior band or folded into coding rounds. Startups vary wildly, which is why the only reliable method is the next paragraph.
The reliable method: ask. When the recruiter email says "design round," reply and ask whether it's high-level system design or low-level object-oriented design. Recruiters answer this question happily, interviewers expect you to have asked, and the answer changes your entire prep plan. Six weeks is too expensive to spend on a coin flip.
How to prep for each
For the HLD round: Grokking the System Design Interview is the purpose-built course: the framework, 18 worked problems, and the practice loop. The honest review and study plans cover it in depth, and System Design Patterns adds the concept-layer depth for senior loops.
For the LLD/OOD round: Grokking the Object Oriented Design Interview works through the classic case studies (a parking lot, a library system, a movie booking system, and more) the way the round actually runs: requirements to use cases to class design, applying OOD principles as you go. Roughly 20 hours, and the case-study format matters because LLD is a practiced skill; reading SOLID definitions doesn't survive contact with "now add a waitlist feature."
If your loop has both: prep them separately, because the overlap is close to zero. Sequence by distance: the HLD prep is the longer build, so start it first, and bring the LLD case-study practice into the final two weeks when the round date is close. Machine-coding candidates should also rehearse under a timer at least twice; the time pressure, not the design, is what fails most people.
Frequently asked questions
What is the difference between system design and object-oriented design interviews? System design (HLD) tests distributed-system architecture: services, databases, scale, and trade-offs, with no code. Object-oriented design (LLD) tests code structure: classes, interfaces, SOLID principles, and extensibility, often with working code. They're separate rounds with separate preparation.
Is LLD the same as OOD? Effectively yes: low-level design is the newer name (dominant in India-market loops), object-oriented design the older one. Both refer to the round Grokking the Object Oriented Design Interview prepares for.
Does Grokking the System Design Interview cover LLD? No, by design. It's the HLD course. LLD is a different skill with its own course; taking the wrong one for your round is the exact mistake this post exists to prevent.
Do I need GoF design patterns for LLD interviews? They help: strategy, factory, and observer appear naturally in good LLD answers. But interviewers score responsibility assignment and extensibility, not pattern name-dropping. The OOD course teaches patterns in context of the case studies rather than as a list.
Are LLD rounds only an India-market thing? They're most systematic there, but OOD questions appear in US junior loops, fintech, and anywhere that runs machine-coding rounds. The recruiter email, or a direct question to the recruiter, is the only reliable signal.
Which should I learn first as a junior engineer? If your target companies run LLD gates, LLD first; it's also the round closest to your daily work. HLD skills compound later as you approach mid-level loops. If you're unsure, ask your recruiter which rounds your specific loop includes.
Related reading
- Every Grokking Course, Explained. Where both courses sit in the full catalog.
- Grokking's Pattern Courses, Untangled. GoF vs system design vs coding patterns, disambiguated.
- About Grokking the System Design Interview. The HLD course in full.
- The Complete Interview Guide. The 6-step HLD framework, free.
Prep for the round you'll actually face
Confirm which round is on your loop, then open the matching course's free preview on DesignGurus.io. Thirty minutes in the right course beats six weeks in the wrong one.
Grokking the System Design Interview · Grokking the Object Oriented Design Interview