The LLD Interview Method
Knowing OOP, SOLID and the design patterns is necessary for a low-level design interview, but it isn't enough. The round is a timed performance. You get a one-line prompt and 45 minutes, and the interviewer scores you on the evidence you produce in that time. Strong engineers fail these rounds every day. They don't lack knowledge. They spend twenty minutes on requirements, jump into code with no model, never mention the race condition sitting in their booking method, or run out of time in the middle of the one method that mattered.
This module is about method: a repeatable way to use the 45 (or 90) minutes so your knowledge shows up as evidence. It sits after the modelling, principles and patterns modules for a reason. It assumes you know what a strategy or a value object is, and teaches you when and how to deploy them under a clock.
What's in this module
The module has five lessons. Read them in order the first time. Afterwards, the framework and the mistakes page are the two you'll come back to before each interview.
1. The LLD Interview Framework
This is a minute-by-minute plan for a 45-minute round, in ten steps: clarify, use cases, entities, class diagram, interfaces, core code, patterns, concurrency, extensions and wrap-up. For each step it covers what to say aloud, the questions to ask and what should exist when you finish it. A library lending system runs through every step, ending in runnable Java, Python and TypeScript, with a concurrent-borrow check to show the locking works. It also covers what to cut when you fall behind, and how to adapt the plan to 60-minute or interviewer-led rounds.
2. How LLD Interviews Are Scored
This lesson looks at what's on the interviewer's form: modelling, abstraction, design principles, extensibility, code quality, testability, concurrency awareness and communication, each with weak and strong evidence side by side. It covers the red flags that outweigh good work, a rubric showing how the bar moves from junior to mid to senior, and the differences between whiteboard LLD, machine-coding and OOD discussion rounds. It ends with how expectations tend to vary across kinds of company.
3. Machine Coding Rounds
The 60–120 minute format, where code has to run. It covers a time plan with hard stops, a project skeleton you can type from memory, the four building blocks (models, in-memory repositories, a service layer and a command-line driver), where validation goes, and how to write a handful of useful tests in ten minutes. The worked solution is a complete expense-sharing ledger with equal, exact and percentage splits, netted balances and settlements. It's written in all three languages, with tests and identical sample output. The lesson ends with a checklist to run before you say "done".
4. Common LLD Mistakes
Ten habits that cost candidates offers: god classes, anaemic models, over-patterning, inheritance abuse, primitive obsession, ignoring concurrency, premature persistence and framework talk, leaky enums, untestable statics and singletons, and missing edge cases. Each one comes with before and after code and a sentence you can say in the interview to show you avoided it on purpose.
5. Mock Interview: Design a Parking Lot
A full 45-minute transcript of a mid-level candidate designing a parking lot, with commentary boxes on every moment that earns or costs credit. The candidate makes three common mistakes and recovers from each one, which is more instructive than a perfect run. The page ends with an illustrative scorecard, the final class and sequence diagrams, and runnable code in all three languages.
How the lessons fit together
flowchart LR
F["Framework<br/>what to do, minute by minute"] --> S["Scoring<br/>why each step matters"]
S --> M["Machine coding<br/>the runnable-code variant"]
M --> X["Mistakes<br/>what to avoid"]
X --> K["Mock interview<br/>all of it, live"]
K -->|"practise on case studies"| F
The framework tells you what to do, and the scoring lesson tells you why each step is there: every step produces evidence for one or more boxes on the form. Machine coding is the same idea in a format where working code dominates. The mistakes page is the framework seen from the other side, as the traps each step is designed to avoid. The mock interview shows all of it happening together, including the recoveries.
Before you start
The module assumes you're comfortable with:
- classes, interfaces, composition and polymorphism (Object-Oriented Programming);
- class and sequence diagrams (OOP Concepts in Depth and UML, and UML for Interviews in Module 1);
- turning requirements into entities (From Nouns to Classes);
- the SOLID principles and the common design patterns, especially Strategy, Factory, Observer and State.
Concurrency gets a short treatment in every lesson here, and a full module of its own later in the course. If locks and races are new to you, skim race conditions first.
How to practise with this module
Reading about interviews doesn't make you better at them, but practice does. A plan that works:
- Read the framework and the mock interview to see the method once, end to end.
- Pick a case study from LLD Interviews. The vending machine and tic-tac-toe are gentle starting points. Don't read it yet.
- Set a 45-minute timer and design it yourself using the framework. Speak aloud, even alone, or better, with a friend acting as interviewer.
- Score yourself against the rubric in the scoring lesson, and scan your code against the mistakes page.
- Then read the case study and compare. Where did your design differ, and was the difference a mistake or just a different valid choice?
- Every third practice, do a 90-minute machine-coding version instead: same problem, but the code has to run.
After five or six rounds, the timeline stops being something you consult and becomes something you feel. That's the point where your knowledge reliably turns into a good score.
Interview questions
These are about the method itself, the kind of questions a mentor might ask after a practice round.
- "What's the first thing you do when you hear an LLD prompt?" Say that you'll take a few minutes to clarify scope, then ask grouped questions (actors, operations, rules, boundaries) and write down the agreed in-scope, out-of-scope and likely-to-change lists.
- "How do you decide where to put interfaces?" At the points the requirements say will vary, which are usually on the "likely to change" list from clarification, and nowhere else.
- "What's different about a machine-coding round?" The code must run. So you compile early, build one feature end to end at a time, keep everything in memory with a command-line driver, and treat validation and a few tests as part of done.
- "When should you bring up concurrency?" Ask whether multiple actors exist during clarification. Then name the shared state and the invariant in the design, and explain the lock and its granularity before the interviewer asks.
- "What do you do with the last minute?" Summarise the design, the reason for each key choice, and the known gaps. It's the cheapest and most consistently skipped high-signal step.