High-level design vs low-level design interviews (HLD vs LLD)

What a high-level design round asks (architecture, scale, trade-offs) against a low-level design or machine coding round (classes, interfaces, patterns, working code), example questions for each, how they are graded, and how to prepare for both.

Reading is half of it. See it used in a real interview.A strong candidate answers Design a Rate Limiter turn by turn, drawing the design as they talk. Free, no sign-up to start.

Watch the walkthrough

"System design" covers two different interviews. High-level design (HLD) is the architecture round: boxes, arrows, numbers and trade-offs for a system that serves millions of users. Low-level design (LLD), also called object-oriented design, is about the code inside one of those boxes: the classes, their responsibilities, the interfaces between them, and often a working program. Some companies run one, some both, and a few run LLD as a longer machine coding round where you build something that compiles and runs. Knowing which one you are in decides what you put on the board in the first five minutes, so if the invitation does not say, ask.

Side by side

	High-level design	Low-level design
The question	Design a URL shortener, a news feed, a chat system	Design a parking lot, an elevator system, an LRU cache, a rate limiter class
What you produce	Components, data flow, storage, an API, estimates	Classes, interfaces, relationships, method signatures, sometimes running code
What is graded	Scoping, numbers, the right building blocks, trade-offs, failure handling, depth where it is hard	Clean responsibilities, extensibility, sensible patterns, correct behaviour, edge cases, readable code
Scale	Millions of users, many machines	One process; concurrency sometimes
Typical length	45 to 60 minutes of discussion	45 to 60 minutes of design, or 90 minutes or more for machine coding
Common at	Most large tech companies, for mid-level and above	Many companies for early-career roles, and as a machine coding round at a number of Indian product companies

High-level design, briefly

An HLD round follows a familiar arc: agree the functional and non-functional requirements, put numbers on them, sketch the API and data model, draw the high-level design, then go deep on the two or three parts most likely to break. The vocabulary is distributed systems: load balancers, caches, queues, partitioning, replication, consistency. You never write real code. The interview framework walks through the structure, and the patterns cheat sheet lists the building blocks.

Low-level design, briefly

An LLD round starts from a problem small enough to code but rich enough to model:

Clarify the requirements as behaviours: a parking lot has floors and spot sizes, vehicles of several types, tickets, payment, and a display of free spots.
Find the entities and their responsibilities: ParkingLot, Floor, Spot, Vehicle, Ticket, PaymentProcessor. Give each one job.
Define the interfaces: what each class exposes, and where behaviour varies (spot allocation strategy, pricing), put it behind an interface so a new variant is a new class, not an edit.
Walk through the main flows in terms of method calls: a car enters, gets a spot, leaves, pays.
Handle the edges: a full lot, two cars racing for the last spot (a lock or an atomic claim), a lost ticket.
Write the code if the round asks for it, starting with the core path.

Interviewers look for the SOLID principles in practice rather than by name, a few well-chosen patterns (strategy, factory, observer, state) rather than all of them, and code that a teammate could extend. A machine coding round adds a working program within the time limit, usually with in-memory storage and a simple command-line or test harness, graded on whether it runs, how it is structured, and how easily a new requirement fits in.

Where the two meet

Several questions exist at both levels, and practising both versions is a good way to see the boundary:

Rate limiter. HLD: where it sits, a shared counter store, what happens when that store is slow. LLD: a RateLimiter interface with token bucket and sliding window implementations, thread-safe. See the rate limiter question and the rate limiting algorithms guide.
LRU cache. HLD: a distributed cache with sharding and eviction. LLD: a hash map plus a doubly linked list with O(1) get and put. See the distributed cache question and the LRU, LFU and FIFO playground.
Leaderboard. HLD: sorted sets, sharding by score range, time windows. LLD: a class that keeps the top K under updates. See the leaderboard.
URL shortener. HLD: key generation, caching, redirects at scale. LLD: an encoder interface with base62 and hash-based implementations, and a repository behind it. See the URL shortener.

How to prepare

For HLD: learn the building blocks, then practise whole answers out loud against a 45-minute clock until the structure is automatic. Reading alone is not enough; most candidates who fail know the material and cannot produce it under time. The questions and walkthroughs on this site are built for this round.

For LLD: practise a dozen classic problems (parking lot, elevator, vending machine, library, splitting expenses, a movie ticket booking system, an LRU cache, a rate limiter, a logger, a chess game) by writing the classes and the main methods, not just a diagram. Time yourself. For machine coding, practise building one end to end in 90 minutes, with tests, in the language you will use on the day.

For both: say your assumptions, name the trade-off behind each choice, and keep the interviewer with you. The habits that sink candidates in one round sink them in the other: designing before clarifying, choosing without reasons, and running out of time before the interesting part. See common mistakes.

Questions people ask

What is the difference between HLD and LLD?

High-level design is the architecture round: components, data flow, storage, an API and estimates for a system serving millions of users, graded on scoping, trade-offs and failure handling. Low-level design is about the code inside one component: classes, interfaces, relationships and method signatures, often with running code, graded on clean responsibilities, extensibility and correct behaviour.

What questions are asked in a low-level design interview?

Problems small enough to code but rich enough to model: a parking lot, an elevator system, a vending machine, a library, splitting expenses, a movie ticket booking system, an LRU cache, a rate limiter class, a logger or a chess game. You clarify behaviours, find the entities and their responsibilities, define interfaces, walk through the main flows as method calls, handle edge cases and often write the code.

What is a machine coding round?

A longer form of low-level design, 90 minutes or more, where you build a working program within the time limit, usually with in-memory storage and a simple command-line or test harness. It is graded on whether it runs, how it is structured, and how easily a new requirement fits in. A number of Indian product companies use it.

Do I need to write code in a system design interview?

Not in a high-level design round: you discuss components, data flow, storage and trade-offs, and never write real code. Low-level design rounds are different: you define classes, interfaces and method signatures, and many ask for working code. Ask which kind of round it is if the invitation does not say.

How should I prepare for HLD and LLD interviews?

For high-level design, learn the building blocks, then practise whole answers out loud against a 45-minute clock until the structure is automatic. For low-level design, practise a dozen classic problems by writing the classes and main methods, not just a diagram, and time yourself; for machine coding, build one end to end in 90 minutes with tests.