How to use this section

This section is 154 pages across seven modules, and nothing about the sidebar tells you which one to read next. That's fine if you're building the fundamentals properly over a few weeks, and actively unhelpful if your interview is Friday. This page exists to close that gap: a default order with the reasoning spelled out, four narrower routes for specific situations, an honest list of what to skip, and a map of every interactive drill on the site, since none of them announce themselves from the sidebar either.

The default path, and why it's in this order

1. Introduction - what LLD actually is, how it differs from HLD, and which of the two interview formats you're walking into. Skip this and every later page is answering a question you never asked.
2. OOPs 101 - the vocabulary everything downstream assumes. Design patterns lean hard on "encapsulate what varies," "program to an interface," and composition over inheritance; skip straight to patterns without these and a Strategy reads as an arbitrary trick with a name attached, not a direct application of a principle you already believe.
3. Design Patterns - now legible, because you have the vocabulary that makes each one look inevitable instead of clever.
4. Clean Code - a genuinely separate skill (naming, function size, error handling) that doesn't depend on knowing a single pattern. It comes after patterns here because it's about the code you write once you're already producing pattern-shaped designs, not a prerequisite for understanding them.
5. Interview Tips - meta-advice on performing under interview conditions. Worth little until you actually have material to perform with, which is why it sits after the content modules instead of before them.
6. Machine Coding - where all of the above gets applied under a clock, across 45 problems spanning state machines, management systems, data structures, and concurrency-flavored designs.
7. Revision - drills, quizzes, and cheat sheets. Reviewing material you haven't built anything with yet is close to reviewing nothing; this module is deliberately last.

Narrower paths for a specific situation

You should not read 154 pages in order two days before an interview. Pick the route that matches your actual problem.

"I have a machine-coding round on Friday." How to approach machine coding interviews first, since the round format matters more right now than any single pattern. Then work three problems that don't repeat the same shape - a state machine (Elevator System), a management system (Library Management), and a concurrency-flavored one (Rate Limiter). Finish with Pattern Duel to check the pattern recall you'll need mid-interview when nobody hands you a cheat sheet.

"I know OOP already, I'm here for the patterns." Start at Design Patterns for what a pattern actually is (and isn't), then work the 23 GoF patterns by family - Creational, Structural, Behavioral - skipping OOPs 101 entirely since you already have the vocabulary it exists to teach. Close with Guess the Pattern to check the recognition skill actually stuck.

"I keep failing the requirements-gathering part of the interview." How to approach OOD interviews for the format, then How to identify entities and model relationships for the actual skill - this is the page that's failing you, not a pattern you don't know yet. Practice with How to approach machine coding interviews's guided drill, then run the whole thing on one real problem, like Parking Lot, start to finish.

"I want the fundamentals properly, no shortcuts." The default path above, in order, all seven modules. This is the only route where reading linearly is actually the right call.

What to skip, and when

• The 8 additional patterns (Null Object, Repository, MVC, Dependency Injection, Specification, Game Loop, Thread Pool, Producer-Consumer) matter less than the 23 GoF patterns for most interviews. Read the GoF 23 first; treat the additional patterns as bonus depth for when you have time left over, not a prerequisite for anything else on the site.
• Clean Code's case studies - JUnit internals and refactoring SerialDate - are enrichment, not prerequisites. They show the earlier chapters' rules applied to a real, messy codebase, which is valuable once you have time, and skippable entirely on a deadline.
• You do not need all 45 machine-coding problems. You need 4-5 that don't repeat the same shape, because the other 40 mostly reuse the same handful of structures with new nouns on top. A reasonable spread: a state machine (Elevator System), a management system (Library Management), a data structure (LRU Cache), and a concurrency-flavored design (Rate Limiter). Add Parking Lot if you want a fifth - it's the page most other machine-coding pages cross-reference, so it's worth having fresh in memory.

Every interactive drill on the site, since none of them announce themselves

The sidebar lists pages, not features. Here's what's actually clickable, and where:

• RelationshipPicker - pick the right UML relationship for a scenario, on Class relationships.
• CodeSmellSpotter - spot which SOLID principle a code snippet breaks, with the answer behind a reveal instead of sitting in view, on SOLID principles.
• PatternMatcher - match a scenario to the pattern that fits, on Additional patterns.
• Pattern Duel - two patterns people confuse for each other, pick the one that actually fits: Pattern Duel.
• Guess the Pattern, Flashcards, Cheat Sheet, and Pattern Picker - four different ways to drill pattern recall, all in Revision.
• EntityTagger - tag the nouns in a prompt as entities, value objects, or noise, on How to identify entities and model relationships.
• DesignDrill - a guided walkthrough of an entire design process, step by step, on How to approach machine coding interviews.
• HldLldSorter - sort real decisions into "that's HLD" or "that's LLD," on LLD vs HLD.
• PatternCueMatcher - match a scenario to the decision cue that should trigger a pattern, on How to choose design patterns.
• ConcurrencyFixPicker - match a race condition to the fix that actually closes it, on How to handle concurrency scenarios.
• State machine diagrams - click a state, see its legal transitions listed as text, on every machine-coding page with a real lifecycle: Elevator System, ATM, and Traffic Control among them.
• Pattern walkthroughs - every sequence diagram on every pattern page and every machine-coding page is now steppable: step through one message at a time, or hit "Show all" for the old fully-drawn view. This isn't one page, it's the whole site.

Try it yourself: before you pick a path above, answer honestly - what's actually true right now, "I don't know the vocabulary yet" or "I know the vocabulary but freeze up applying it under a clock"? Those are different problems, and this page just told you two different routes through them.