"Design a Parking Lot." That's the whole prompt, in almost every SDE-I/II interview loop — no starting classes, no hints. This is the round called Low-Level Design (LLD), sometimes machine coding or object-oriented design (OOD), and it's where a huge number of candidates who can code perfectly well still lose the round — not because they can't write a class, but because they never learned how to think in classes and responsibilities.
This is a free, complete LLD course built for that exact gap. We derive every idea from a real problem first — never "here's a pattern, memorise it" — so that by the end, you can design a fresh system you've never seen before, not just recite one you've memorised.
What is LLD?
LLD is the interview round (also called machine coding or object-oriented design) where you design the classes, interfaces and interactions for one part of a system — usually ending in working code. It's the "zoomed in" sibling of High-Level Design (HLD): HLD asks which services exist and how they scale over a network; LLD asks which classes exist inside one of those services, and how they call each other.
Why this course is different
Most LLD material teaches patterns as a catalogue: here's Singleton, here's Factory, memorise the UML. That produces candidates who can name a pattern but can't explain why it's the right call — and the very next interview question ("now add X") exposes that gap immediately.
This course derives every idea instead: we hit a real pain first (a growing if/else, a God class, a class that must exist exactly once), then name the principle or pattern that solves it. By the time you meet Strategy or Observer by name, you'll have already built the shape yourself, one lesson before.
How this course works
- Derive, don't announce. Every pattern starts from a stated pain, not a definition.
- SOLID as questions, not dictionary entries. Each principle becomes one sentence you ask your own design.
- Six full systems, start to finish. URL Shortener, Parking Lot, Library Management, Elevator, Vending Machine and Splitwise — each one taken from clarifying questions all the way to working code and "what if the interviewer changes this?"
- Practice at the end of every lesson. MCQs and reasoning questions, each tagged with the companies where that exact idea has been reported asked.
The full course roadmap
Fourteen lessons, in the order you should read them — foundations first, then patterns, then UML, then six complete system designs that put everything to work together.
| # | Lesson | What you'll be able to do |
|---|---|---|
| 1 | What is LLD? | Think in objects and responsibilities, and follow a repeatable design process. |
| 2 | SOLID Principles | Turn five principles into five questions you ask your own design. |
| 3 | Singleton Pattern | Guarantee exactly one instance, safely, and know when not to. |
| 4 | Factory Pattern | Decouple object creation from the code that uses it. |
| 5 | Strategy Pattern | Swap interchangeable algorithms without a growing if/else. |
| 6 | Observer Pattern | Notify a growing set of dependents without hard-coding each one. |
| 7 | Adapter Pattern | Make two interfaces that were never designed to fit, work together. |
| 8 | UML Diagrams for LLD | Draw class, sequence and state diagrams that pass the whiteboard test. |
| 9 | Design a URL Shortener | Design code generation, storage and collisions from scratch. |
| 10 | Design a Parking Lot | Combine Factory, Strategy and Observer, plus handle a concurrency race. |
| 11 | Design a Library Management System | Model shared metadata vs per-copy state, and reuse the concurrency fix. |
| 12 | Design an Elevator System | Model internal state cleanly, and reason about scheduling and dispatch. |
| 13 | Design a Vending Machine | See the clearest possible State pattern example, plus a real edge case (exact change). |
| 14 | Design Splitwise | Model a balance sheet and simplify group debts algorithmically. |
And once the lessons are done, the sidebar's Company-wise LLD PYQs section is your mock-round layer — real reported questions from Amazon, Google, Microsoft, Meta and more.
How to study this course
Before reading how a lesson solves a problem, try to solve it yourself first — even badly. The "aha" moment when the abstraction clicks is worth far more than reading someone else's finished design. Beyond that: read the patterns and SOLID lessons in order (they build on each other), then work through the six system-design lessons one at a time, actually sketching the class diagram yourself before reading the course's version.
FAQ
Do I need to know all 23 Gang-of-Four design patterns?
No. This course deliberately covers five — Singleton, Factory, Strategy, Observer, Adapter — because they're the ones that actually recur as real solutions in SDE-I/II LLD interviews. Knowing five deeply beats a shallow list of twenty.
Is this the same as a system design (HLD) course?
No — HLD is about services, databases, load balancers and scaling across machines. LLD is about the classes inside one part of a system. Both matter for senior interviews; this course focuses on LLD specifically.
Which programming language does this course use?
Python, for readability — the design ideas themselves are language-agnostic and translate directly to Java, C++, or any other object-oriented language you're asked to use in an interview.
How long will this course take?
Roughly two weeks at one lesson a day. In a hurry before an interview? Lessons 1–5 (LLD basics, SOLID, Singleton, Factory, Strategy) plus the Parking Lot lesson cover what most SDE-I/II rounds actually test.
Ready? Lesson 1: What is LLD? →