On this page

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

SignalThe interviewer's question
ModellingDid the candidate find the right entities and put data and behaviour in the right places?
AbstractionAre interfaces placed where variation is expected, and only there?
SOLID and design principlesAre responsibilities separated, and do dependencies point the right way?
ExtensibilityWhen I added a requirement, did the design bend or break?
Code qualityIs the code correct, readable and idiomatic, with sensible names and error handling?
TestabilityCould this be unit-tested without heroics? Did they think about tests?
Concurrency awarenessDid they notice shared mutable state and protect the invariants?
CommunicationCould 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 evidenceStrong evidence
Book with a quantity field, so "which copy is overdue?" can't be answeredBook (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 itRules 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 behaviourUnneeded nouns dropped explicitly: "Librarian is an actor, not a class, for now"
Relationships drawn but never explainedCardinalities 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 evidenceStrong evidence
No interfaces at all: pricing, notification and storage are all concrete and created inlineOne 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 ParkingLot that 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 evidenceStrong evidence
Naming all five principles at the start without applying themNot naming them, but every class clearly having one job, then naming the principle when asked
new StripeGateway() inside the checkout serviceCheckoutService(PaymentGateway gateway), with a fake passed in for tests
A switch (vehicleType) in three different methodsPolymorphism 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 evidenceStrong 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'tBeing honest: "this one touches borrow, because the holder rule changes who can check out"
Designing for ten hypothetical extensions up frontDesigning 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) vs doIt(v). Names are the cheapest documentation you'll ever write.
  • Error handling. Specific exceptions or results with reasons, not return null for five different failures.
  • Types that carry meaning. Money as integer cents or a Money type, never a double. 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 evidenceStrong 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() directlyA Dice interface, with a fixed-sequence dice in tests
Tests only for the happy pathTests 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:

  1. What is shared and mutable (the seat map, the spot list, the account balance)?
  2. Which invariant breaks under interleaving (no double booking, no negative balance)?
  3. What mechanism protects it, and at what granularity?
  4. What does that cost, and what's the alternative?
Weak evidenceStrong 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 classOne 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 itMentioning 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 Member because 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 evidenceStrong evidence
Long silences while typing, then a big revealA 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

  1. Coding before clarifying. Opening the editor in the first two minutes on a vague prompt.
  2. A god class. One class with most of the methods, while the others are just data holders.
  3. Floating point for money. double price in a payment, billing or splitting problem.
  4. Pattern-dropping. Naming patterns without tying them to requirements, or forcing a pattern where a plain method would do.
  5. Inheritance for code reuse. Truck extends Car "because it has the same fields".
  6. Hidden time, randomness or I/O inside business logic, which makes it untestable.
  7. Ignoring a concurrency hint, or answering "make everything synchronized".
  8. Not finishing the core method. Twenty minutes of diagrams and no working borrow, park or book logic.
  9. Defensiveness. Arguing with every suggestion, or abandoning every choice at the first question.
  10. 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.

SignalJunior (0–2 yrs)Mid (2–5 yrs)Senior (5+ yrs)
ClarifyingAsks some questions when promptedDrives clarification, separates in-scope from out-of-scopeAlso identifies likely extensions and non-functional constraints unprompted
ModellingMain entities right, with some guidanceEntities right, and behaviour mostly on the right objectsClean split of identity and description, invariants named, and aggregates sized sensibly
AbstractionUses interfaces when suggestedPuts interfaces at obvious variation pointsPlaces interfaces precisely, and justifies the ones left out
PrinciplesCode roughly follows SRPApplies SRP, OCP and DIP naturally, and can name themDiscusses trade-offs between principles, such as DRY vs coupling
PatternsMay use one pattern correctlyUses two or three where they fit, and explains whyChooses patterns by the forces involved, rejects tempting ones and explains the costs
CodeWorking core logic, maybe roughClean, idiomatic, correct edge casesProduction-quality: clear errors, types that carry meaning, minimal surface
ExtensibilityHandles one extension with helpHandles extensions with small, located changesAnticipates them, and is honest about which ones are expensive
TestabilityCan describe some testsDesigns for injection, and names the edge-case testsHas a test strategy: what to unit test, where the seams are, what not to mock
ConcurrencyNot expected unless the problem is about itIdentifies the race when hinted, and proposes a lockSpots races unprompted, chooses granularity, and discusses optimistic vs pessimistic
CommunicationFollows the interviewer's leadDrives the session with check-insRuns 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 LLDMachine codingOOD discussion
Duration45–60 min60–120 min45–60 min
PromptOne line, vagueA page of requirementsOne line, or an existing design
CodeCore methods, needn't compileMust run, with a driverLittle or none
Top signalsModelling, abstraction, communicationWorking code, structure, error handlingTrade-offs, depth, handling pushback
Common failureNever reaching codeNothing runs at the endStaying shallow and broad
DiagramsClass diagram centralOptional, mostly in the walkthroughClass, 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:

  1. Did I write down in-scope and out-of-scope items in the first five minutes?
  2. Can I point to where each invariant is enforced?
  3. Does every interface I added correspond to a requirement?
  4. Did I complete the core method, and does it validate before it mutates?
  5. Did I mention concurrency, even briefly?
  6. Did I show at least one extension as a small diff?
  7. 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.

  1. "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.
  2. "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.
  3. "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.
  4. "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.
  5. "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.
  6. "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.
  7. "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.