How LLD Interviews Are Scored
At the end of an LLD round, your interviewer opens a feedback form. It usually has a handful of dimensions, a score for each, a level recommendation and a free-text box. They fill it in from the notes they took while you talked. You aren't scored on the design you had in your head. You're scored on the evidence that ended up in those notes.
That one idea explains most of this page. A candidate who quietly writes a good design and a candidate who writes the same design while saying why each choice was made can get very different scores. The second candidate handed the interviewer evidence for every box on the form. The first made the interviewer guess, and interviewers are trained not to give credit for guesses.
This page breaks the evidence down. It covers the signals that most rubrics share, what strong and weak evidence looks like for each, the red flags that can outweigh good work, how the bar moves with seniority, and how the different round formats change what's measured.
About rubrics
Every company writes its own rubric, and most don't publish them. What follows is a synthesis of dimensions that appear widely across public interview guides, hiring-manager writing and common practice. It's not any particular company's form. The names differ ("design quality", "craft", "problem solving"), but the underlying questions are remarkably consistent.
The eight signals
| Signal | The interviewer's question |
|---|---|
| Modelling | Did the candidate find the right entities and put data and behaviour in the right places? |
| Abstraction | Are interfaces placed where variation is expected, and only there? |
| SOLID and design principles | Are responsibilities separated, and do dependencies point the right way? |
| Extensibility | When I added a requirement, did the design bend or break? |
| Code quality | Is the code correct, readable and idiomatic, with sensible names and error handling? |
| Testability | Could this be unit-tested without heroics? Did they think about tests? |
| Concurrency awareness | Did they notice shared mutable state and protect the invariants? |
| Communication | Could I follow their reasoning? Did they clarify, check in and take hints? |
Let's go through them one at a time. Each section has a short description, then side-by-side examples of weak and strong evidence, which is what the interviewer actually writes down.
1. Modelling
Modelling is the foundation. If the entities are wrong, every later step builds on sand. The interviewer is checking three things: that you found the important nouns, that you separated identity from description where it matters, and that behaviour lives with the data it changes.
The classic test case is anything with "types" and "instances": books and copies, movies and screenings, products and stock items, vehicle types and vehicles. Weak candidates collapse the two. Strong candidates split them and say why.
| Weak evidence | Strong evidence |
|---|---|
Book with a quantity field, so "which copy is overdue?" can't be answered | Book (title, ISBN) and BookCopy (id, status), with "a copy is what gets borrowed" said aloud |
A Library class with 15 methods and every rule inside it | Rules sitting on the object that owns the data, such as copy.checkOut() refusing if already on loan |
Classes for every noun, including Librarian, Shelf, Building, none of which have behaviour | Unneeded nouns dropped explicitly: "Librarian is an actor, not a class, for now" |
| Relationships drawn but never explained | Cardinalities and invariants stated: "a copy has at most one open loan" |
The From Nouns to Classes lesson covers the techniques behind the strong column.
2. Abstraction
Abstraction is scored in both directions. Too little, and the design can't change without edits everywhere. Too much, and it's a maze of single-implementation interfaces that slows everyone down. Interviewers look for interfaces at the points of predicted variation, with the prediction coming from the requirements.
| Weak evidence | Strong evidence |
|---|---|
| No interfaces at all: pricing, notification and storage are all concrete and created inline | One interface per stated axis of change: "pricing will vary, so PricingStrategy is an interface" |
An interface for every class (IMember, IBook, ILoan), each with one implementation | "I didn't make Member an interface. Nothing suggests a second kind yet." |
| Abstract base classes holding shared fields "for reuse" | Composition: a class has a policy instead of inheriting one |
Interface methods that leak implementation (getHashMap()) | Interface methods named for the caller's intent (fineFor(loan)) |
A good way to show judgement aloud is to name the abstraction you didn't add: "I'm keeping storage as maps inside the service. If persistence comes into scope, those become repositories." That sentence earns more credit than three unnecessary interfaces.
3. SOLID and design principles
Interviewers rarely ask "what does the S in SOLID stand for?" in an LLD round. They look for the principles in your design and sometimes ask you to name them afterwards. The ones that show up most:
- Single responsibility. Does each class have one reason to change? A
ParkingLotthat also formats receipts and talks to the payment gateway has three. See Single Responsibility. - Open/closed. Is new behaviour added by new classes rather than by editing a growing
switch? See Open/Closed. - Dependency inversion. Does the core logic depend on abstractions that are passed in, rather than constructing its own collaborators? See Dependency Inversion.
Liskov and interface segregation come up less often but are easy wins when they apply. A Square extends Rectangle-style bug in your hierarchy will be noticed. So will an interface that forces implementers to stub out half its methods.
| Weak evidence | Strong evidence |
|---|---|
| Naming all five principles at the start without applying them | Not naming them, but every class clearly having one job, then naming the principle when asked |
new StripeGateway() inside the checkout service | CheckoutService(PaymentGateway gateway), with a fake passed in for tests |
A switch (vehicleType) in three different methods | Polymorphism or a lookup table in one place |
| "This follows SOLID" as a justification | "If we add a new fee type, only a new class changes, which is the open/closed idea" |
The full treatment is in the SOLID principles section.
4. Extensibility
Almost every LLD interviewer has one or two extensions planned: "now add reservations", "now support multiple floors", "now prices change at peak hours". The question behind them is simple. How much of the existing design survives?
| Weak evidence | Strong evidence |
|---|---|
"I'd add an if-statement in calculateFee" for every new rule | "That's a new PricingStrategy implementation. The lot doesn't change." |
| A rewrite: "let me restructure the classes" | A small, located diff: "one new state, two new transitions, all inside Spot" |
| Claiming an extension is free when it obviously isn't | Being honest: "this one touches borrow, because the holder rule changes who can check out" |
| Designing for ten hypothetical extensions up front | Designing for the ones named in clarification, and explaining how others would fit |
The third row deserves emphasis. Interviewers trust candidates who admit what a change costs. "Free" is rarely the right answer, and an interviewer who knows the problem will see through it.
5. Code quality
In a whiteboard round, code quality is judged on a small amount of code, so every line counts. In a machine-coding round it's judged on a lot of code, and consistency matters as much as cleverness.
The interviewer is checking:
- Correctness first. Does the core method do the right thing, including the obvious edge cases?
- Names.
assignSpot(vehicle)vsdoIt(v). Names are the cheapest documentation you'll ever write. - Error handling. Specific exceptions or results with reasons, not
return nullfor five different failures. - Types that carry meaning. Money as integer cents or a
Moneytype, never adouble. Durations as durations. - No dead weight. No commented-out code and no unused fields "for later".
Here's the same method twice. Both "work".
class Lot {
java.util.List<Object[]> s = new java.util.ArrayList<>();
Object[] park(String p, int t) {
for (Object[] x : s) {
if (x[1] == null && (int) x[0] >= t) { x[1] = p; return x; }
}
return null; // full? wrong size? already parked? the caller can't tell
}
}
import java.util.*;
enum Size { SMALL, MEDIUM, LARGE }
class NoSpotAvailable extends RuntimeException {
NoSpotAvailable(Size size) { super("no free spot fits a " + size + " vehicle"); }
}
final class Spot {
final String id; final Size size; private String plate;
Spot(String id, Size size) { this.id = id; this.size = size; }
boolean isFreeFor(Size vehicle) { return plate == null && size.compareTo(vehicle) >= 0; }
void occupy(String plate) { this.plate = plate; }
}
final class Lot {
private final List<Spot> spots = new ArrayList<>();
void add(Spot s) { spots.add(s); }
Spot park(String plate, Size vehicleSize) {
Spot spot = spots.stream()
.filter(s -> s.isFreeFor(vehicleSize))
.min(Comparator.comparing(s -> s.size)) // smallest spot that fits
.orElseThrow(() -> new NoSpotAvailable(vehicleSize));
spot.occupy(plate);
return spot;
}
}
The strong version isn't longer because it's padded. It's longer because it encodes decisions: the sizes are an ordered enum, "fits" is defined in one place, it chooses the smallest fitting spot, and failure has a name and a message.
6. Testability
You may never be asked to write a test in a whiteboard round. You'll still be scored on whether your design could be tested, and asked "how would you test this?" more often than not.
The usual testability killers are:
- Hidden time.
LocalDateTime.now()buried in the fee calculation means a test must wait an hour to check an hourly rate. - Hidden randomness.
new Random()inside the dice of a board game means tests can't force a snake. - Hard-wired collaborators. A service that constructs its own payment client or notification sender.
- Global state. Singletons and static registries that leak between tests.
| Weak evidence | Strong evidence |
|---|---|
| "I'd test it manually with some inputs" | "The clock is injected, so the test sets entry at 10:00 and exit at 12:30 and asserts the fee" |
A Dice that calls Math.random() directly | A Dice interface, with a fixed-sequence dice in tests |
| Tests only for the happy path | Tests named after the edge cases from clarification: on the due date, one day late, at the cap |
| "Mocks for everything" | Simple fakes for owned interfaces, with a reason why that's enough |
Common LLD Mistakes shows the refactoring from hidden dependencies to injected ones.
7. Concurrency awareness
Concurrency is a differentiator rather than a baseline at most levels. Many candidates never mention it, so a candidate who does stands out. At senior level, though, failing to notice an obvious race in a booking or allocation problem is a real gap.
What the interviewer wants is a chain of reasoning, not jargon:
- What is shared and mutable (the seat map, the spot list, the account balance)?
- Which invariant breaks under interleaving (no double booking, no negative balance)?
- What mechanism protects it, and at what granularity?
- What does that cost, and what's the alternative?
| Weak evidence | Strong evidence |
|---|---|
| "I'd make it thread-safe" with no detail | "Two entry gates can both see spot 12 as free. The check and the assign must be atomic." |
synchronized on every method of every class | One lock around the critical section, with a reason for its scope |
| "Use a ConcurrentHashMap" as a cure-all | "A concurrent map makes each put safe, but check-then-put across two maps still needs a lock or a single atomic operation" |
| Never mentioning it | Mentioning it briefly even when the interviewer doesn't, and offering to go deeper |
The third row is the most common trap among candidates who do know concurrency. Thread-safe collections make single operations atomic, not sequences of operations. Saying that sentence aloud is a strong signal at any level.
8. Communication
Communication isn't a soft add-on. It's the channel every other signal travels through. The interviewer is looking for:
- Clarifying before designing. Questions grouped sensibly, and assumptions stated.
- Thinking aloud at the level of decisions. "I'm putting the limit check on
Memberbecause it owns the count." - Checking in at milestones. "Does this diagram match what you want to see before I code?"
- Taking hints well. When the interviewer asks "what happens if two people book at once?", they're not curious. They're pointing at a gap. Strong candidates recognise the hint, acknowledge it and fix the design.
- Handling disagreement. Defending a choice with reasons, or changing it when given a better reason, without getting defensive.
| Weak evidence | Strong evidence |
|---|---|
| Long silences while typing, then a big reveal | A running commentary of decisions, with silence only for short bursts of typing |
| Answering a hint with "yes, that's handled" when it isn't | "Good point, that's a race. Let me show where the lock goes." |
| Arguing for a pattern because "it's best practice" | "I chose X over Y because of requirement Z. If Z changes, I'd switch." |
| Ignoring the clock | "I have ten minutes. I'll code the fee logic and talk through the rest." |
Red flags
Some things can outweigh several good signals. Interviewers often write these down word for word, and in debriefs they can be decisive.
Red flags that commonly sink LLD rounds
- Coding before clarifying. Opening the editor in the first two minutes on a vague prompt.
- A god class. One class with most of the methods, while the others are just data holders.
- Floating point for money.
double pricein a payment, billing or splitting problem. - Pattern-dropping. Naming patterns without tying them to requirements, or forcing a pattern where a plain method would do.
- Inheritance for code reuse.
Truck extends Car"because it has the same fields". - Hidden time, randomness or I/O inside business logic, which makes it untestable.
- Ignoring a concurrency hint, or answering "make everything synchronized".
- Not finishing the core method. Twenty minutes of diagrams and no working borrow, park or book logic.
- Defensiveness. Arguing with every suggestion, or abandoning every choice at the first question.
- Silent stalls. Several minutes with no output and no narration.
Most of these are covered with before/after code in Common LLD Mistakes. Notice that only one item on the list is about knowledge (concurrency). The rest are about process and judgement. That's good news, because process can be practised in a few weeks, while deep knowledge takes years.
A rubric by level
Interviewers calibrate against the level they're hiring for. The same answer can be a strong hire for a junior role and a no-hire for a senior one. The table below describes what "meets the bar" typically looks like at each level. It's a composite, not any specific company's ladder.
| Signal | Junior (0–2 yrs) | Mid (2–5 yrs) | Senior (5+ yrs) |
|---|---|---|---|
| Clarifying | Asks some questions when prompted | Drives clarification, separates in-scope from out-of-scope | Also identifies likely extensions and non-functional constraints unprompted |
| Modelling | Main entities right, with some guidance | Entities right, and behaviour mostly on the right objects | Clean split of identity and description, invariants named, and aggregates sized sensibly |
| Abstraction | Uses interfaces when suggested | Puts interfaces at obvious variation points | Places interfaces precisely, and justifies the ones left out |
| Principles | Code roughly follows SRP | Applies SRP, OCP and DIP naturally, and can name them | Discusses trade-offs between principles, such as DRY vs coupling |
| Patterns | May use one pattern correctly | Uses two or three where they fit, and explains why | Chooses patterns by the forces involved, rejects tempting ones and explains the costs |
| Code | Working core logic, maybe rough | Clean, idiomatic, correct edge cases | Production-quality: clear errors, types that carry meaning, minimal surface |
| Extensibility | Handles one extension with help | Handles extensions with small, located changes | Anticipates them, and is honest about which ones are expensive |
| Testability | Can describe some tests | Designs for injection, and names the edge-case tests | Has a test strategy: what to unit test, where the seams are, what not to mock |
| Concurrency | Not expected unless the problem is about it | Identifies the race when hinted, and proposes a lock | Spots races unprompted, chooses granularity, and discusses optimistic vs pessimistic |
| Communication | Follows the interviewer's lead | Drives the session with check-ins | Runs the session like a design review, and manages time without being asked |
How to read the table
- Junior rounds weight code and modelling heavily. The interviewer expects to give hints and is scoring how well you use them.
- Mid-level rounds are where most candidates sit, and "drives the session" is the line that separates a pass from a borderline. If the interviewer has to prompt every step, you'll be scored at junior level even with good code.
- Senior rounds are less about whether the design works and more about judgement under ambiguity: what you left out and why, how you'd evolve it, and where it would break. A senior candidate who produces a correct design without discussing any trade-offs often gets "solid mid-level" feedback.
Ask what level you're being assessed at
If you don't know, it's reasonable to ask the recruiter beforehand. Knowing whether the bar is "working code with good structure" or "trade-off discussion with code as evidence" changes how you should spend your 45 minutes.
Three formats, three scorecards
"LLD interview" covers at least three different formats. They share signals but weight them very differently. Recognise the format in the first minute, from the prompt and the setup, and adjust.
Whiteboard (or doc) LLD
Setup: 45–60 minutes, a vague prompt, a whiteboard or a shared document. Code is expected, but only for the core methods, and it doesn't need to compile.
What's weighted: modelling, abstraction, communication and extensibility. Code quality is judged on a small sample.
How to win: follow the 45-minute framework. Spend your code budget on the one or two methods with real rules in them, and narrate decisions throughout.
Machine-coding round
Setup: 60–120 minutes, a more detailed problem statement (often a page of requirements), your own IDE or an online one, and the expectation that code runs at the end. Sometimes the interviewer leaves you alone and comes back to review. Sometimes there's a short demo and Q&A afterwards.
What's weighted: working code, code quality, structure (packages and layers), validation and error handling, and extensibility when they add a requirement during the review. Communication matters less during the build and more during the walkthrough.
How to win: get something runnable early and grow it. Use a clear layout (models, repositories, services, a driver), keep everything in memory, and handle the inputs the problem statement mentions. A design that's 80% complete and runs scores far better than one that's 100% complete and doesn't. See Machine Coding Rounds.
OOD discussion round
Setup: 45–60 minutes, often with a more senior interviewer and little or no code. It might be "design the classes for X", or a walk through a system you built, or a critique of a given design.
What's weighted: reasoning, trade-offs, depth on one or two areas, and how you respond to pushback. Diagrams matter more than code here.
How to win: go deep rather than broad. Pick the hardest part of the problem (the state machine, the allocation rule, the concurrency) and explore it thoroughly. Compare alternatives explicitly. When the interviewer challenges a choice, treat it as a design review, not an attack.
| Whiteboard LLD | Machine coding | OOD discussion | |
|---|---|---|---|
| Duration | 45–60 min | 60–120 min | 45–60 min |
| Prompt | One line, vague | A page of requirements | One line, or an existing design |
| Code | Core methods, needn't compile | Must run, with a driver | Little or none |
| Top signals | Modelling, abstraction, communication | Working code, structure, error handling | Trade-offs, depth, handling pushback |
| Common failure | Never reaching code | Nothing runs at the end | Staying shallow and broad |
| Diagrams | Class diagram central | Optional, mostly in the walkthrough | Class, sequence and state diagrams central |
How expectations differ by company type
Without naming specific companies (whose processes change and are rarely public), some patterns hold broadly across the industry.
Large product companies with standardised loops tend to use whiteboard or doc-based LLD with a shared rubric and calibrated interviewers. The rubric is usually broad, covering the eight signals above, and communication and structured thinking carry a lot of weight. Code doesn't usually need to run.
Companies with a strong machine-coding tradition, which are common among fast-growing consumer and fintech businesses, often run a 90–120 minute runnable-code round, sometimes as the main design signal for early-career roles. Working code and clean structure dominate. A brilliant discussion with broken code rarely passes.
Startups and small teams vary the most. Some use a take-home project instead of a live round, some pair-program on a realistic task in their own codebase, and some do a design conversation with the founding engineers. Pragmatism tends to be rewarded over pattern knowledge: "what's the simplest thing that works, and what's the next step?"
Infrastructure, platform and systems teams often push harder on concurrency, resource management and API contracts. An LLD question there may turn into "now make it thread-safe and explain the memory model implications".
Consultancies and enterprise-software shops sometimes lean more on classic patterns vocabulary and UML. Naming patterns and drawing standard notation is valued more there than at product companies.
When you don't know what to expect, ask the recruiter three questions: "Will I need code that runs?", "How long is the design round?" and "Is it one interviewer or a panel?" The answers tell you which of the three formats you're facing.
Turning this into practice
The best way to use this page is as a self-review checklist after each mock interview or practice problem. Record yourself, or have a friend take notes, and then score yourself honestly on each signal:
- Did I write down in-scope and out-of-scope items in the first five minutes?
- Can I point to where each invariant is enforced?
- Does every interface I added correspond to a requirement?
- Did I complete the core method, and does it validate before it mutates?
- Did I mention concurrency, even briefly?
- Did I show at least one extension as a small diff?
- Did I summarise at the end, including the gaps?
Then watch the mock parking-lot interview, which annotates exactly these signals as they happen.
Interview questions
These are questions about the interview itself, the kind a thoughtful candidate asks themselves or a mentor asks in a practice session.
- "Your design was correct, but the feedback said 'lacked depth'. What does that usually mean?" Typically that the trade-offs weren't discussed. Choices were made but not justified against alternatives, and the extensions or concurrency questions got surface answers. Depth is evidence of judgement, not more classes.
- "Is it better to finish the whole design shallowly or one part deeply?" For whiteboard LLD, cover the whole skeleton briefly (entities, diagram, signatures) and then go deep on the core logic. For OOD discussions, go deeper sooner. For machine coding, breadth that runs beats depth that doesn't.
- "How many design patterns should I use?" As many as the requirements justify, which is usually one to three in a 45-minute round. Zero is fine if nothing varies. Five is almost always too many.
- "The interviewer kept asking 'what if' questions and I kept changing my design. Was that bad?" Not if each change was small and located, which is exactly what extensibility means. It's bad if each question caused a restructure, because that suggests the original design had no clear seams.
- "Should I write tests in a whiteboard round?" Usually not in code. Describe one or two edge-case tests and point to the seam that makes them possible, like the injected clock. In machine-coding rounds, a few quick tests or assertions in the driver are a strong signal.
- "How do I show seniority in an LLD round?" Clarify non-functional constraints unprompted, name what you're deliberately leaving out, raise concurrency before being asked, be honest about which extensions are expensive, and manage the clock yourself.
- "What's the single biggest scoring lever for most candidates?" Narrating decisions. It costs no extra time, and it turns invisible good judgement into evidence on the form.