Skip to content

HLD vs LLD: System Design Interview Guide#

HLD (High-Level Design) and LLD (Low-Level Design) are the two pillars of a modern system-design interview. HLD evaluates how you reason about distributed-systems architecture (sharding, replication, caching, consistency). LLD evaluates how you reason about object-oriented class design within a single service. Most senior interview loops in India and at FAANG test both, in separate rounds.

This page is a curated reading list from the 300+ topic site so you can prep both tracks without getting lost.

flowchart LR
  H[HLD<br/>Architecture<br/>Distributed systems]
  L[LLD<br/>Classes<br/>Concurrency<br/>Patterns]
  HQ[HLD interview round]
  LQ[LLD interview round]
  H --> HQ
  L --> LQ

  classDef hld fill:#dbeafe,stroke:#1e40af,stroke-width:1px,color:#0f172a;
  classDef lld fill:#fef3c7,stroke:#92400e,stroke-width:1px,color:#0f172a;
  classDef round fill:#d1fae5,stroke:#065f46,stroke-width:1px,color:#0f172a;
  class H hld;
  class L lld;
  class HQ,LQ round;

What is HLD?#

HLD is the architecture view. You sketch boxes and arrows for components, services, data stores, network paths, and explain how a user request flows end-to-end. Topics you must know:

  • Load balancer, CDN, API gateway, service mesh
  • Database sharding, consistent hashing, replication (leader / follower)
  • Caching strategies, CDN, materialised views
  • CAP / PACELC, consistency models, MVCC, distributed transactions, sagas
  • Pub/Sub, change data capture, message queues, event sourcing
  • Resilience patterns (circuit breaker, bulkhead, backpressure, retries)
  • Capacity planning, SLO / SLI / SLA, observability

A full HLD round at FAANG / Indian-unicorn-tier asks you to design something like Twitter, Uber, or YouTube in 60 minutes. The interviewer probes scale numbers, failure modes, and where you'd push back on requirements.

What is LLD?#

LLD is the class-level view. You design the internal structure of a single service or component: classes, interfaces, methods, design patterns, concurrency primitives, error handling. Topics you must know:

  • OOP pillars, SOLID, composition-over-inheritance, immutability
  • Design patterns: creational (Builder, Factory, Singleton), structural (Decorator, Adapter, Facade), behavioural (Strategy, Observer, State, Command, Chain of Responsibility)
  • Concurrency: mutex, semaphore, RW-lock, atomic / CAS, thread pool, deadlocks
  • Architecture: clean / hexagonal, ports and adapters, repository pattern, DDD tactical
  • State machines, MVC / MVP / MVVM, dependency injection, error handling

A full LLD round in Indian SDE-2 / SDE-3 loops asks you to design something like Splitwise, a parking lot, an ATM, an elevator, or a rate limiter in 45-60 minutes. The interviewer probes class boundaries, interfaces, concurrency safety, and extensibility.

Suggested 8-week prep plan#

flowchart TB
  W1[Week 1-2<br/>HLD fundamentals]
  W3[Week 3<br/>HLD classics]
  W4[Week 4-5<br/>LLD foundations]
  W6[Week 6<br/>LLD problems]
  W7[Week 7<br/>Domain HLDs]
  W8[Week 8<br/>Mocks + company-specific]
  W1 --> W3 --> W4 --> W6 --> W7 --> W8

  classDef wk fill:#cffafe,stroke:#0e7490,stroke-width:1px,color:#0f172a;
  class W1,W3,W4,W6,W7,W8 wk;

Week 1-2 (HLD foundations): Network basics, HTTP protocols, load balancer, API gateway, CDN, caching strategies, CAP / PACELC, database sharding, consistent hashing, replication.

Week 3 (HLD classics): Walk 5 problems end-to-end: URL shortener, rate limiter, news feed, search autocomplete, web crawler.

Week 4-5 (LLD foundations): OOP pillars, SOLID, design patterns (creational, structural, behavioural), concurrency primitives, threading and deadlocks, clean architecture, repository pattern, state machines.

Week 6 (LLD problems): Parking lot, elevator, ATM, Splitwise, rate limiter, thread pool, chess engine, in-memory filesystem.

Week 7 (Domain HLDs): Twitter, Uber, Netflix, Stripe, WhatsApp, plus one industry-specific design (payments / fintech / ads / collaboration).

Week 8: Mock interviews + the specific company's known interview themes.

Where to start on this site#

Track Start here Then
HLD foundations Network basics → HTTP protocols Load balancer → CDN → Caching strategies
HLD scale / data Database sharding → Consistent hashing Replication leader-follower → CAP / PACELC → Distributed transactions
HLD classics URL shortener → Rate limiter News feed → Key-value store → Web crawler
LLD foundations OOP pillars → SOLID principles Creational patterns → Behavioral patterns → Clean architecture
LLD concurrency Concurrency primitives → Threading and deadlocks Async models → Lock-free concurrency
LLD problems Parking lot → Elevator system ATM → Splitwise → Rate limiter LLD
Domain HLDs Twitter → Uber YouTube → Payment gateway → WhatsApp
Modern AI Agent loop & ReAct → Tool use & function calling RAG patterns → Coding agent

Common HLD LLD interview pitfalls#

  • Jumping to architecture before clarifying scale. Ask for QPS, data volume, latency targets, consistency requirements before drawing a single box.
  • Treating HLD and LLD as the same skill. They use different vocabulary (services, caches, queues vs classes, interfaces, threads). Practice each track separately.
  • Memorising solutions instead of trade-offs. Interviewers know you've seen the URL shortener question; what they're testing is whether you can defend each choice when they probe.
  • Skipping the LLD round. Indian SDE-2 / SDE-3 loops weight LLD equally with HLD. If you only prep HLD, you'll fail the LLD round.
  • Ignoring failure modes. Every HLD answer needs at least one failure scenario worked through end-to-end.

FAQ#

What is HLD in system design?#

HLD (High-Level Design) is the architecture view of a system. It covers components, services, data stores, network paths, and how requests flow end-to-end. Think load balancer, sharded database, cache, message queue, replication strategy, failure modes.

What is LLD in system design?#

LLD (Low-Level Design) is the class-level view of a single service or component. It covers classes, methods, interfaces, design patterns, concurrency primitives, error handling, and code organisation. Think parking lot, elevator, thread pool, rate limiter.

What is the difference between HLD and LLD?#

HLD answers how a distributed system works at the architecture level (latency, consistency, scale). LLD answers how a single component is structured in code (classes, patterns, threads). A senior IC interview usually tests both: HLD first, then LLD on one component.

Should I prepare HLD or LLD first?#

Prepare HLD first if you're early-career or interviewing at infra-heavy companies. Prepare LLD first if you're interviewing at product-heavy or Indian companies (Flipkart, Razorpay, Atlassian, Microsoft) where LLD rounds are explicit and weighted equally with HLD.

How is the HLD LLD interview structured in India?#

Indian SDE-2 / SDE-3 / Staff loops typically have one dedicated LLD round (45-60 min on a class-design problem like Splitwise or a rate limiter) plus one HLD round (60 min on something like designing Twitter or Uber). FAANG-India follows the same pattern.

How long should HLD LLD interview preparation take?#

4 to 8 weeks for a focused candidate. Start with 5-10 HLD fundamentals, walk 5 classic problems end-to-end, then do 5 LLD problems with class diagrams. Spend the last week on company-specific deep dives and mock interviews.