System design (HLD, LLD and architecture)
Low-Level Design (Object-Oriented Design)
Low-level design (LLD) for interviews and real projects: object models, UML, SOLID, state, money, testing, concurrency and case studies, with code that runs.
58 lessons: 11 free, 18 free with Pro answers, 8 with a free core and 21 with a free intro.
Examples run with Python 3.14.8, Pyodide 314.0.7 and Node.js 24.21.0.
Who it is for
Candidates preparing for low-level design and machine-coding interview rounds, and developers moving from scripts to object-oriented code that is easy to change and test.
What you will be able to do
- Answer a low-level design question with a repeatable method, from requirements to tested code
- Turn requirements into classes with clear responsibilities, relationships and lifecycles
- Draw the UML class, sequence and state diagrams that explain a design
- Apply SOLID and other design principles, and explain the trade-offs between them
- Model state, time, money and rules so that a new requirement changes one place
- Test a design with unit, table and property tests, test doubles and seams
- Make a design safe under concurrency, without deadlocks or double bookings
- Build and extend case studies such as a parking lot, an LRU cache and expense sharing in a timed round
Before this track
Revise and practise
- Practice: every exercise and quiz (51 exercises, 58 quizzes)
Modules and lessons
What the labels mean
- Free
- the whole lesson and every answer in it
- Free lesson, Pro answers
- the whole lesson is free; the model answers to its interview questions open with a pass
- Free core, Pro depth
- the core of the lesson is free; its in-depth parts open with a pass
- Free intro, Pro
- the first part is free; the rest opens with a pass
- Pro
- opens with a Pro, Premium or Ultimate pass
Minutes are reading time: “11 of 30 min free” means 11 minutes of the lesson are free.
What a pass opens in this track
43 in-depth parts (22 of them case-study deep dives) and 128 interview answers. The same pass opens every other track and every Pro tool.
- Module 1
LLD rounds and a repeatable answer method
What low-level design rounds test, a repeatable answer method, clarifying requirements, finding entities and responsibilities, and a playbook for machine-coding rounds.
- What low-level design (LLD) is and what it tests Free: 20 minutes
- A repeatable framework for LLD answers Free: 25 minutes
- Clarifying requirements and scope Free: 25 minutes
- Finding entities and assigning responsibilities Free: 25 minutes
- The machine-coding round playbook Free: 35 minutes
- Module 2
Designing objects for change
Refactoring a script into an object model step by step, designing domain errors and result types, and choosing the data structures behind each operation.
- From a script to an object model Free: 25 minutes
- Designing domain errors and result types Free lesson, Pro answers: 30 minutes
- Choosing data structures inside a design Free lesson, Pro answers: 30 minutes
- Module 3
Class relationships and UML
Association, aggregation, composition and dependency in UML and in code, and the class, sequence, state, use case and activity diagrams that explain a design.
- Class relationships in UML and code Free lesson, Pro answers: 30 minutes
- UML class diagrams that interviewers can read Free lesson, Pro answers: 25 minutes
- Sequence diagrams for key flows Free lesson, Pro answers: 25 minutes
- UML state machine diagrams Free lesson, Pro answers: 25 minutes
- Use case and activity diagrams Free lesson, Pro answers: 20 minutes
- Module 4
Design principles: SOLID and beyond
Coupling, cohesion and information hiding, the five SOLID principles, DRY, KISS and YAGNI, the Law of Demeter, GRASP, and what to do when principles conflict.
- Coupling, cohesion and information hiding Free: 25 minutes
- Single Responsibility Principle (SRP) Free: 20 minutes
- Open/Closed Principle (OCP) Free: 25 minutes
- Liskov Substitution Principle (LSP) Free: 25 minutes
- Interface Segregation Principle (ISP) Free lesson, Pro answers: 20 minutes
- Dependency Inversion Principle (DIP) Free lesson, Pro answers: 25 minutes
- DRY, KISS and YAGNI without dogma Free lesson, Pro answers: 20 minutes
- Law of Demeter, tell-don't-ask and CQS Free lesson, Pro answers: 20 minutes
- GRASP: assigning responsibilities Free lesson, Pro answers: 25 minutes
- When design principles conflict Free lesson, Pro answers: 25 minutes
- Module 5
Modelling lifecycles, time, money and rules
Lifecycles as state machines, clocks and timers that tests can control, money in minor units with rounding and splits, idempotency keys, and business rules kept as data.
- Implementing lifecycles: State, tables or enums Free lesson, Pro answers: 30 minutes
- Designing lifecycles as state machines Free core, Pro depth: 11 of 30 minutes free
- Time in designs: clocks, time zones and timers Free intro, Pro: 7 of 30 minutes free
- Money arithmetic: paise, rounding and splits Free intro, Pro: 7 of 30 minutes free
- IDs, idempotency keys and deduplication Free intro, Pro: 5 of 30 minutes free
- Rules as configuration: tables and effective dates Free intro, Pro: 6 of 30 minutes free
- Module 7
Testing your design
Unit tests that check a design, test doubles and seams, test-driven development under a time limit, and table, property and contract tests.
- Unit tests that check a design Free lesson, Pro answers: 20 minutes
- Test doubles and seams Free core, Pro depth: 11 of 30 minutes free
- Test-driven development under a timer Free intro, Pro: 7 of 30 minutes free
- Module 8
Code quality under time pressure
The code smells reviewers flag in low-level design answers, and weak answers rewritten into strong ones.
- Code smells interviewers flag in LLD answers Free lesson, Pro answers: 25 minutes
- Weak LLD answers: how to spot and fix them Free core, Pro depth: 8 of 30 minutes free
- Module 9
One design, six languages
One design written in Java 25, Python 3.14, TypeScript, Go, modern C++ and Rust, with the idioms each language uses for objects, interfaces and errors.
- LLD in Java 25: records, sealed types, patterns Free lesson, Pro answers: 30 minutes
- LLD in Python 3.14: dataclasses and protocols Free core, Pro depth: 10 of 30 minutes free
- LLD in TypeScript with erasable syntax only Free intro, Pro: 8 of 30 minutes free
- LLD in Go: interfaces, embedding, generics Free intro, Pro: 8 of 30 minutes free
- LLD in modern C++: ownership and variants Free intro, Pro: 7 of 30 minutes free
- LLD in Rust: traits, enums and ownership Free intro, Pro: 9 of 30 minutes free
- Module 11
Case studies: everyday machines
Parking lot, elevator, vending machine, ATM, coffee machine, traffic signal, parcel locker and toll lane designs, each with a model, code, tests and a follow-up change.
- Low-level design: parking lot (the model) Free: 45 minutes
- Low-level design: traffic signal controller Free core, Pro depth: 15 of 40 minutes free
- Module 13
Case studies: booking and scheduling
Movie tickets, hotels, car rental, airline seats, meeting rooms, railway berths with waitlists, and course registration, designed so that nothing is booked twice.
- Low-level design: meeting scheduler and calendar Free intro, Pro: 9 of 40 minutes free
- Module 14
Case studies: money and commerce
Expense sharing, a wallet with a ledger, a payment gateway, payment mandates, carts and discounts, inventory, auctions, an order book, and food and restaurant ordering.
- Low-level design: payment gateway Free intro, Pro: 9 of 40 minutes free
- Low-level design: UPI-style payments and mandates Free intro, Pro: 10 of 40 minutes free India-specific
- Low-level design: shopping cart and discount engine Free intro, Pro: 8 of 40 minutes free
- Low-level design: food ordering and delivery Free core, Pro depth: 15 of 40 minutes free
- Module 15
Case studies: platforms and apps
Library management, a Q&A site, a professional network, a cricket scorecard, playlists, chat, a task board, cab booking, notifications, version control, search and exams.
- Low-level design: live cricket scorecard Free core, Pro depth: 8 of 20 minutes free
- Low-level design: chat application Free intro, Pro: 10 of 40 minutes free
- Low-level design: task manager and kanban board Free core, Pro depth: 12 of 35 minutes free
- Low-level design: notification service Free intro, Pro: 11 of 40 minutes free
- Low-level design: mini version control Free intro, Pro: 10 of 40 minutes free
- Low-level design: online exam with negative marking Free intro, Pro: 8 of 35 minutes free
- Module 16
Case studies: infrastructure components
In-process building blocks: LRU and LFU caches, a logging framework, a rate limiter, a pub-sub broker, a key-value store with TTL, a file system, a job scheduler and a connection pool.
- Low-level design: key-value store with TTL Free intro, Pro: 10 of 35 minutes free
- Low-level design: in-memory file system Free intro, Pro: 8 of 35 minutes free
- Module 17
Machine-coding and interview practice
Handling follow-up questions, a timed machine-coding mock worked step by step, and a self-run object-oriented design discussion.
- Handling follow-up questions and extensions Free lesson, Pro answers: 25 minutes
- A timed machine-coding mock, step by step Free intro, Pro: 6 of 40 minutes free
- Self-mock: object-oriented design discussion Free intro, Pro: 7 of 30 minutes free
Related tools
Official documentation
- Unified Modeling Language (UML) specification (Object Management Group)
- The Python Tutorial: Classes (Python Software Foundation)
- The Single Responsibility Principle (Robert C. Martin (The Clean Code Blog))
- Classes (TypeScript Handbook) (TypeScript project)