Low-Level Design for MAANG Interviews

If this were a book, this page is the table of contents. For MAANG interviews, Low-Level Design should be learned in a progression from OOP fundamentals → SOLID → design principles → design patterns → UML → concurrency → case studies → interview problems. Unlike System Design, LLD is about writing maintainable, extensible, testable code while demonstrating strong object-oriented thinking — not about horizontal scale. Each Part below links out to the deeper OOP, pattern, and concurrency notes that already exist elsewhere in this wiki instead of duplicating them. Unwritten chapters are listed as stubs, not empty files.

Parts

00 — Foundations of Object-Oriented Design

The base vocabulary this whole book assumes: what LLD actually evaluates in an interview, and a fast OOP/object-relationship/lifecycle recap. See Object-Oriented Programming for the full-depth treatment of the four pillars and object relationships this Part only recaps.

1 — What is Low-Level Design? — (stub)
2 — Object-Oriented Programming Refresher — (stub)
3 — Relationships Between Objects — (stub)
4 — Object Lifecycle — (stub)

01 — Object-Oriented Design Principles

SOLID and GRASP as the two principle sets that turn working code into well-designed code, plus the heuristics and clean-code habits interviewers expect alongside them. See SOLID Principles and GRASP Principles for the OOP-book treatment of the same two principle sets.

1 — SOLID Principles — (stub)
2 — GRASP Principles — (stub)
3 — OO Design Heuristics — (stub)
4 — Clean Code — (stub)

02 — UML and Modeling

The notation used to communicate a design during a whiteboard interview — class, sequence, state, activity, object, and package diagrams. See the UML appendix chapters in Object-Oriented Programming for the class/sequence/state/activity diagram reference notation.

1 — UML Fundamentals — (stub)
2 — Class Diagrams — (stub)
3 — Sequence Diagrams — (stub)
4 — State Diagrams — (stub)
5 — Activity Diagrams — (stub)
6 — Object Diagrams — (stub)
7 — Package Diagrams — (stub)

03 — Design Patterns

The 23 canonical Gang-of-Four patterns grouped by intent, plus a selection guide for recognizing which pattern a problem is asking for. Full implementations already live in Patterns and Object-Oriented Programming — these chapters are the LLD-interview framing and recognition lens.

1 — Introduction to Design Patterns — (stub)
2 — Creational Patterns — (stub)
3 — Structural Patterns — (stub)
4 — Behavioral Patterns — (stub)
5 — Pattern Selection Guide — (stub)

04 — Dependency Management

How objects get their collaborators — constructor/setter/interface injection, IoC, and the service-locator anti-pattern debate. See Dependency Management in Patterns for the full injection-style and IoC-container catalog.

05 — Error Handling & Reliability

Designing for the failure paths, not just the happy path — exception hierarchies, validation, defensive programming, and immutable value objects as a reliability tool.

06 — Concurrency Design

Where the interesting design decision is thread safety, not class hierarchy — locks, concurrent collections, producer-consumer, thread pools, deadlocks, race conditions, and lock-free design. See Multithreading and Deadlocks in Operating System for the underlying primitives, and Threading Patterns in Patterns for the pattern-level treatment.

1 — Thread Safety — (stub)
2 — Synchronization — (stub)
3 — Locks — (stub)
4 — Concurrent Collections — (stub)
5 — Producer Consumer — (stub)
6 — Thread Pools — (stub)
7 — Deadlocks — (stub)
8 — Race Conditions — (stub)
9 — Lock-Free Design — (stub)

07 — Domain Modeling

Identifying the entities, value objects, aggregates, and domain services a system is actually made of before writing any code. See Domain-Driven Design Basics in Object-Oriented Programming and Domain Modeling Patterns in Patterns for the full DDD tactical toolkit.

1 — Identifying Entities — (stub)
2 — Value Objects — (stub)
3 — Aggregates — (stub)
4 — Domain Services — (stub)
5 — Repositories — (stub)
6 — Domain Events — (stub)

08 — API-Oriented Design

Designing the interface layer of a system — request/response shape, mapping, pagination, and error responses — as its own design discipline, independent of the domain model underneath it.

1 — Interface Design — (stub)
2 — DTOs — (stub)
3 — Validation Layers — (stub)
4 — Mapping Objects — (stub)
5 — Pagination — (stub)
6 — Error Responses — (stub)

09 — Testing Design

Designing for testability, not testing as an afterthought — unit testing, mocking, DI for tests, and contract testing between collaborators.

1 — Unit Testing — (stub)
2 — Testable Design — (stub)
3 — Mocking — (stub)
4 — Dependency Injection for Testing — (stub)
5 — Contract Testing — (stub)

10 — Refactoring

The concrete techniques for improving a design without changing its behavior — spotting code smells and applying named refactorings like Replace Conditional with Polymorphism.

1 — Refactoring Techniques — (stub)
2 — Identifying Code Smells — (stub)
3 — Replace Conditional with Polymorphism — (stub)
4 — Extract Object — (stub)
5 — Introduce Parameter Object — (stub)
6 — Builder Refactoring — (stub)

11 — Classic LLD Interview Problems

The worked case studies every LLD prep list is built around — small enough to finish in a 45-minute round, rich enough to exercise real class relationships, state machines, and concurrency. See Coding Problems and Object-Oriented Design Interviews for the OOP-book framing of the same interview process, and Distributed Rate Limiter in System Design for the cross-service scale variant of the rate-limiter problem covered here at single-process scope.

1 — Parking Lot — (stub)
2 — Elevator System — (stub)
3 — Library Management System — (stub)
4 — Hotel Booking System — (stub)
5 — Movie Ticket Booking — (stub)
6 — Splitwise — (stub)
7 — Snake and Ladder — (stub)
8 — Chess — (stub)
9 — Tic Tac Toe — (stub)
10 — ATM — (stub)
11 — Vending Machine — (stub)
12 — Coffee Machine — (stub)
13 — Cricbuzz — (stub)
14 — Amazon Locker — (stub)
15 — Cab Booking — (stub)
16 — Food Delivery — (stub)
17 — Notification Service — (stub)
18 — Cache (LRU/LFU) — (stub)
19 — Rate Limiter — (stub)
20 — Logging Framework — (stub)
21 — File System — (stub)
22 — Linux find — (stub)
23 — Kafka-like Queue — (stub)
24 — Pub/Sub System — (stub)

12 — Advanced Object-Oriented Design

Architectural styles built on top of solid object modeling — Hexagonal and Clean Architecture, DDD at the essentials level, event-driven design, CQRS, event sourcing, and plug-in/extensible frameworks. See Layering Patterns for the Hexagonal/Clean/Onion catalog, and CQRS / Event Sourcing in Patterns for the full treatment of both.

1 — Hexagonal Architecture — (stub)
2 — Clean Architecture — (stub)
3 — Domain-Driven Design Essentials — (stub)
4 — Event-Driven Design — (stub)
5 — CQRS Basics — (stub)
6 — Event Sourcing Basics — (stub)
7 — Plug-in Architectures — (stub)
8 — Extensible Framework Design — (stub)

13 — Performance-Oriented Design

Object-level performance work — memory optimization, pooling, lazy initialization, caching strategies, efficient collection choices, and profiling an OO application under load.

1 — Memory Optimization — (stub)
2 — Object Pooling — (stub)
3 — Lazy Initialization — (stub)
4 — Caching Strategies — (stub)
5 — Efficient Collections — (stub)
6 — Profiling Object-Oriented Applications — (stub)

14 — MAANG Interview Masterclass

Where everything above gets applied under interview conditions — the repeatable framework, communication tactics, whiteboard technique, common mistakes, time management, and full mock-walkthrough transcripts. See Object-Oriented Design Interviews for the parallel process framing from the OOP side.

1 — LLD Interview Framework — (stub)
2 — Communicating During LLD Interviews — (stub)
3 — Whiteboard Design Techniques — (stub)
4 — Common Interview Mistakes — (stub)
5 — Time Management in 45–60 Minute Interviews — (stub)
6 — Complete Mock Interview Walkthroughs — (stub)

15 — Appendices

Quick-reference material — cheat sheets, decision matrices, an interview checklist, and per-language implementation guidelines for turning any chapter above into working code.

1 — Appendix A: UML Cheat Sheet — (stub)
2 — Appendix B: SOLID & GRASP Cheat Sheet — (stub)
3 — Appendix C: Design Pattern Decision Matrix — (stub)
4 — Appendix D: LLD Interview Checklist — (stub)
5 — Appendix E: Java Implementation Guidelines — (stub)
6 — Appendix F: C# Implementation Guidelines — (stub)
7 — Appendix G: C++ Implementation Guidelines — (stub)
8 — Appendix H: Go Implementation Guidelines — (stub)
9 — Appendix I: Python Implementation Guidelines — (stub)

Recommended Study Order

OOP Foundations
SOLID + GRASP
UML Modeling
Clean Code & Refactoring
Design Patterns
Dependency Injection & Testability
Concurrency
Domain Modeling
Advanced Architectural Styles
Solve 20–30 classic LLD interview problems
Conduct timed mock interviews

This sequence aligns with interview expectations at companies such as Google, Meta, Amazon, Microsoft, Uber, and Stripe, where interviewers assess not only correctness but also extensibility, maintainability, abstraction quality, and the ability to reason about design trade-offs.

Metadata


Author	Amit Singh
Scope	low-level-design