Low Level Design

Encapsulation, abstraction, inheritance, polymorphism. The vocabulary every LLD interview assumes you have internalised.

Hiding internal state behind a public API. Why fields are private, why getters/setters are not always the answer.

Modelling a concept as the minimum set of operations a caller needs. Where interfaces beat concrete classes, and where they don't.

is-a relationships, the hierarchy taxonomy, when to prefer composition over inheritance.

Compile-time (overloading) vs run-time (overriding) dispatch. Why polymorphic code beats switch-statements.

Object-Oriented Analysis and Design, the role of UML, when each diagram type pays off, the bottom-up approach to interviews.

Actors, use cases, system boundary, include/extend relationships — and the right level of detail for an interview.

Classes, attributes, methods, associations, aggregation, composition, inheritance, multiplicities — the workhorse OOD diagram.

Objects, lifelines, synchronous vs asynchronous messages, activation bars. Communicating dynamic behaviour in interviews.

Workflow modelling — initial node, actions, decisions, forks/joins, final node. When activity beats sequence.

A class should have one and only one reason to change. The smell, the refactor, the cost of misapplying it.

Open for extension, closed for modification. How polymorphism and strategy patterns let you add behaviour without editing existing code.

Subtypes must be substitutable for their base types. The square-vs-rectangle parable and what it actually teaches.

No client should be forced to depend on methods it doesn't use. The case for many small interfaces over one fat one.

Depend on abstractions, not concretions. Where DIP, IoC, and constructor injection are the same idea wearing three names.

One instance, global access point. The threading caveats, the why-everyone-says-don't, and when it's still right.

Defer instantiation to a method subclasses override. The seam between knowing what to make and knowing how to make it.

Families of related objects without specifying concrete classes. When one factory isn't enough.

Step-by-step construction of complex objects, fluent API, telescoping-constructor problem solved.

Clone an existing object instead of constructing from scratch. Shallow vs deep copy and when each is correct.

Make incompatible interfaces work together. Object adapter vs class adapter, and the legacy-integration use case.

Wrap an object to add behaviour without subclassing. The classic IO-stream example and how to avoid wrapper explosion.

A single entry point hiding a complex subsystem. The architectural cost of skipping it.

Treat individual objects and compositions uniformly. The recursive tree-of-things pattern that shows up everywhere.

Encapsulate interchangeable algorithms behind a common interface. The dual of the Open-Closed Principle in practice.

Publish-subscribe for objects. Push vs pull, the leaky-listener problem, and modern event-bus alternatives.

An object's behaviour changes with its internal state — represented as a class hierarchy. The state-machine pattern in disguise.

Encapsulate a request as an object. Undo, queue, log, and macro — all fall out of this one structure.

Define the skeleton of an algorithm in a base class and let subclasses fill in the steps. The hollywood principle illustrated.

MVC, MVVM, layered, microservices, event-driven, hexagonal. The patterns that organise whole systems, not just classes.

The canonical OOD interview problem. Multi-floor lot, spot types, tickets, payment. The first hour of every LLD prep.

Single and multi-elevator scheduling, request handling, state machine, edge cases (maintenance mode, emergency stop).

Books, members, borrowing/returning, reservations, fines. The classic CRUD-plus-rules domain model.

Locker assignment, package lifecycle, OTP-based pickup, expiry, capacity planning across sizes.

State-pattern showcase — idle, selection, payment, dispense. Coin and bill handling, refund flow.

Calendar, rooms, attendees, conflicts, recurring events. Where availability search meets booking integrity.

Theatres, shows, seats, holds, payment, concurrent booking. The seat-lock race condition every candidate misses.

Card, PIN, account, transaction, cash dispenser, hardware abstraction. State machine plus banking ops.

Board, pieces, moves, rules engine, check/checkmate, game state. Polymorphism over piece behaviour.

Rooms, room types, reservations, check-in/out, billing, housekeeping. A multi-actor domain done right.

Catalogue, cart, order, payment, inventory, shipping. The end-to-end e-commerce domain in one OOD.

Player, dealer, deck, hand, round. State machine on the round and a Strategy for dealer policy — the cleanest cards-game OOD.

Fleets, reservations, pickup/return, insurance, billing. State machine on the rental and a Strategy for tiered pricing.

Questions, answers, votes, comments, badges, tags. Reputation as derived state; moderation as a workflow.

Tables, reservations, orders, menu, bill, waiter, chef. Order state machine plus table-assignment Strategy.

Users, friendships, posts, reactions, comments, groups, pages. Friendship state machine plus Observer for notifications.

Accounts, portfolios, market/limit/stop orders, matching, transactions. Order state plus price-time matching strategy.

Puzzle, piece, solver. The lightest case study — focus is the class model and a recursive backtracking solver.

Aircraft, flights, schedules, crew, bookings, seats, itineraries. Multi-aggregate transactional design at scale.

Tournaments, matches, innings, overs, balls, scorecards. Ball-by-ball event stream plus Observer for live-score subscribers.

Profiles, connections, feed, messaging, search. Social-graph mechanics expressed as an object model.

The 45-minute structure: clarify scope, identify entities, draw the class diagram, narrate a flow, defend trade-offs. The meta-script.

Open-ended exercise — riders, drivers, matching, pricing, surge, trip lifecycle. Scope it like a real interview.

Restaurants, menus, orders, delivery agents, real-time tracking. A multi-actor design with clear failure modes to discuss.