Low-Level Design
SOLID, design patterns, and object-oriented design — interview-grade walkthroughs of Parking Lot, Chess, Splitwise, and more, built around how real engineers actually design.
guides
LLD Case Study: Thread-Safe LRU Cache
Design an O(1) LRU cache using HashMap + doubly linked list. Covers the exact data structure invariants, thread-safe implementation with per-key segmented locking, TTL eviction, singleflight to prevent thundering herd, and the step-by-step path from a single-server cache to a distributed Memcached-style tier. The canonical LLD problem that separates engineers who understand data structure composition from those who just memorize it.
LLD Case Study: Extensible Rate Limiter
Design a thread-safe, extensible rate limiter supporting token bucket and sliding window log algorithms, with clean interfaces, deterministic testability, and a clear migration path from a single-process limiter to a distributed Redis-backed cluster. Covers the exact concurrency pitfalls — race conditions in read-modify-write, thundering-herd on cold buckets — and how production systems like Stripe, Cloudflare, and Kong solve them.
LLD Interview Framework & Walkthrough
A repeatable 5-step framework for LLD interviews. Includes a complete walkthrough of the Parking Lot problem — the most commonly asked LLD problem — with class diagrams and code.
How to Approach a Low Level Design Interview
The mindset and communication playbook for low level design interviews. Covers what interviewers grade on (SOLID adherence, design patterns, extensibility), time budgeting, recovery patterns, and the failure modes that catch senior candidates in object-oriented design and lld rounds.
How to Design at LLD: Blank Whiteboard to Class Diagram
The mechanical playbook for low level design interview execution. Covers entity extraction, SOLID principles, picking the right design patterns (Strategy, State, Observer, Builder), concurrency primitives, dependency injection, and canonical lld problems like parking lot and library as object-oriented case studies.
Behavioral Patterns: Observer, Command, Strategy, Template Method & Chain of Responsibility
Behavioral design patterns define how objects communicate and delegate work. Master Observer (event notification), Command (encapsulate requests), Strategy (interchangeable algorithms), Template Method (algorithm skeleton with extension points), and Chain of Responsibility (pipeline processing) — with Java examples and real interview applications.
Design Patterns for LLD Interviews
The 7 most frequently tested design patterns in LLD interviews with concrete code examples and the exact problems they solve. Know which pattern to reach for and why.
Refactoring Patterns: Strangler Fig, Extract Class, Anti-Corruption Layer & Legacy Modernization
The production refactoring toolkit for senior engineers: how to safely modernize legacy codebases without a big-bang rewrite. Covers Strangler Fig migration, Extract Class/Interface, Introduce Parameter Object, Anti-Corruption Layer, and the Branch-by-Abstraction technique with concrete Java/Python examples.
Structural Patterns: Proxy, Adapter, Facade, Composite & Decorator
Structural design patterns define how classes and objects are composed into larger structures. Master Proxy (lazy loading, access control, caching), Adapter (interface translation), Facade (simplified subsystem interface), Composite (tree structures), and Decorator (dynamic behavior extension) — each with Java examples and real interview applications.
API Design Principles: REST, Idempotency, Versioning, and Error Contracts
Well-designed APIs are force multipliers — enabling teams to work independently and systems to evolve safely. Master REST's UNIFORM INTERFACE constraint, idempotency keys, API versioning strategies, and error contracts — the LLD interview topics that separate senior from junior engineers at FAANG.
SOLID Principles in Practice
SOLID principles aren't just theory — they're the vocabulary interviewers use to evaluate your OOP design. Learn each principle with concrete before/after code examples and how to spot violations.
Airline Reservation & Seating — LLD (PNR, Segments, Overbooking Policy)
LLD for airline reservations: PNR, segments per FlightInstance, seat holds, FareRule/Strategy, overbooking policy, and TOCTOU-safe seat commit. Ties to hotel/movie-ticket holds; names DCS check-in and standby as extensions.
LLD Case Study: ATM Machine System Design
Design an ATM system covering hardware abstraction, session state machines, security constraints, and cash dispensing algorithms. Covers the exact questions FAANG interviewers probe: preventing double-dispensing, handling mid-transaction cash exhaustion, and why concurrency must be handled at the bank service layer.
LLD Case Study: Chess Game System Design
Design a fully-featured chess engine covering piece hierarchy, move validation, check/checkmate detection, and special moves. Covers the exact tradeoffs interviewers probe at senior level: where move validation lives, how undo works, and how to extend the system for AI opponents without rewriting the core.
LLD Case Study: Elevator System (Scheduling, State Machines, Concurrency)
Production-grade object-oriented elevator system design covering SCAN scheduling, state machine modeling, multi-elevator coordination, and failure modes. Covers what most prep resources get wrong: the difference between SCAN and LOOK, and why nearest-car is correct for modern buildings.
LLD Case Study: Food Delivery System
Design the domain model and class hierarchy for a food delivery platform like DoorDash, Uber Eats, or Swiggy. Covers order state machine, Observer-driven notifications, Strategy-based pricing, SOLID principles, thread-safe concurrent order placement, and extensibility for scheduled orders and group orders.
Hotel Booking System — LLD Deep Dive
Design a hotel booking system using object-oriented design patterns — State machine for booking lifecycle, Strategy for dynamic pricing, and optimistic locking to prevent double-booking. Covers availability modeling, cancellation policies, and chain-scale extension.
Library Management System — LLD Deep Dive
Design a Library Management System using object-oriented design patterns — Strategy for search, Observer for reservations, and per-copy locking for concurrency. The Book vs BookItem distinction is the #1 mistake candidates make and what senior engineers probe for.
LLD Case Study: Parking Lot System (Production-Grade)
Deep-dive production design of a multi-floor parking lot with EV charging, dynamic pricing, reservations, and concurrent access. Goes beyond basic OOP to cover lock granularity, optimistic concurrency, and real extension patterns interviewers probe at senior level.
LLD Case Study: Ride-Sharing Booking Engine
Object-oriented design of the Uber/Lyft booking and matching engine — entities, state machines, fare calculation, and concurrency. Focused on LLD class design, not distributed architecture.
Online Shopping Cart & Checkout — LLD (Lines, Idempotency, Order Boundaries)
Object-oriented design for a production-style cart: immutable product snapshots, merge-on-login, promotion strategies, and checkout with idempotency keys aligned to payment APIs. Explains when cart inventory is advisory vs when it must call reservation services, and how Order differs from Cart as an aggregate.
Social Follow & Home Feed — LLD (Graph, Push vs Pull, Feed Strategies)
Object-oriented design for follow relationships, optional follow requests, blocking, and feed generation. Teaches how to model the social graph separate from posts, when to use Strategy for push-fanout vs pull-merge feeds, and what to leave to infrastructure without faking a single Map that scales to billions of edges.
Task & Job Scheduler — LLD (Cron, Queues, At-Least-Once, Idempotent Workers)
LLD for schedulable jobs: cron/one-shot triggers, Run state machine, worker claim+lease, exponential backoff, DLQ, and at-least-once delivery. Aligns with Conductor/Sidekiq-style idempotent handlers vs fake exactly-once.
Movie & Event Ticket Booking — LLD (Seat Map, Holds, Concurrency)
Object-oriented design for BookMyShow-style ticketing: venue seat graph, per-show instance inventory, time-boxed seat holds, and TOCTOU-safe booking. Covers pricing strategies, idempotent checkout, and extension to best-available search without an HLD detour.
LLD Case Study: Vending Machine
Design a production-grade vending machine with multi-payment support, change dispensing, and inventory management. Covers State, Strategy, and Observer patterns applied to a canonical LLD interview problem.
Concurrency Patterns: Thread Safety, Producer-Consumer, Read-Write Lock & Thread Pool
Thread safety and concurrent design are tested at every senior+ interview. Master the fundamentals of mutual exclusion (ReentrantLock, synchronized), the producer-consumer pattern with blocking queues, read-write locks for read-heavy systems, thread-safe singletons, and thread pool design — all with Java examples and Python equivalents.
Thread Pool Pattern: Fixed, Cached, Scheduled, and Work-Stealing Executors
Thread pools are the primary concurrency primitive in production Java and Python systems — they prevent thread explosion, manage CPU resources, and control backpressure. This guide covers thread pool mechanics, the four Java ExecutorService variants, rejection policies, work-stealing queues (ForkJoinPool), and the deadlock patterns that trap candidates at Meta, Google, and Amazon LLD rounds.