Low-level design and machine coding

For SDE I, SDE 2 and India product company candidates. Inside: which LLD format your loop uses, how it is graded, the patterns that matter, 28 practice problems and a machine coding routine.

Four formats, one skill

Format	Length	What you hand in	Real code?	Who runs it
OOD or LLD round (whiteboard or doc)	35 to 60 min	Classes, interfaces, key methods, 2 to 3 methods implemented	Partly. US big tech expects some real code; India and Asia often accept structured pseudocode (Hello Interview)	Amazon SDE I, Salesforce, Goldman Sachs, D. E. Shaw, Oracle
Multi-part class problem inside a coding round	45 to 90 min	A class that grows over 2 to 4 parts, with tests	Yes, runnable	Atlassian Code Design, Jane Street, Two Sigma, Bloomberg, Lyft's 90-min Laptop round
Machine coding	60 to 120 min plus a review	A working, modular program with a demo from a main method, no UI	Yes, runnable and extensible	Flipkart, PhonePe, Uber (60 min at L4), Rippling, Swiggy-style companies
Progressive build in the online assessment	Varies	A small system built level by level (bank, file storage, key-value store)	Yes, graded by tests	Airbnb, Coinbase, Anthropic, eBay, Meta (see OA formats)

Some companies call it OOD, some LLD: "They're the same interview, just a different name" (Hello Interview).

Which companies ask it (as of Oct 2026)

Rows marked "reports" come from 2025 to 2026 candidate reports collected for the company pages. Formats vary by team; confirm with your recruiter using the script on the overview page.

Company	Level	Format	Reported prompts	Source
Amazon	SDE I	One OOD round. Discuss classes, relationships and key methods without full code, then handle "curveball" extensions	Linux find command API, parking lot, pizza billing, package system with dependencies, file search; also rate limiter, AWS billing for one user, train fare calculator with a weekend cap	HI L4, reports
Flipkart	SDE 1 lateral, SDE 2	Machine coding, then a code-review viva where you extend your code live and sketch a UML class diagram. Design rounds in a Google Doc: entities, full schema, APIs, service classes	BNPL, quick commerce, food ordering, distributed task scheduler, conference room booking, restaurant ordering, gym management	Flipkart SDE prep doc, reports
PhonePe	0 to 3 years	Machine coding assignment with a later review that focuses on concurrency	Customer issue resolution system, fitness class booking (tiers, waitlist, thread safety), leaderboard with concurrent score submissions, email and SMS provider layer, app version rollout, logger library with sinks	Reports
Uber	Entry level to L4	US backend: specialized coding such as "implement a parking lot data structure". L4: a 60-min machine-coding LLD with running code and tests. India SDE-1: LLD of a food delivery system with classes and tables	Splitwise, parking lot, circuit breaker with OPEN, CLOSED and HALF_OPEN states, pub-sub queue with ordering, in-memory file system with mkdir, cd and pwd	Aced, reports
Swiggy, Ola, Cred, Razorpay, Udaan	SDE 1, SDE 2	Machine coding as the first onsite round	See the workat.tech practice list below	workat.tech (written a few years ago)
Microsoft	60 (1 to 2 years), 61 to 62	LLD round common in India loops, sometimes with runnable code. New grads (59) get OOP or data-modeling questions instead	Cache with strategy-pattern eviction, notification module, cart backend with REST APIs, message queue with concurrency	Reports
Google	L3, L4	No LLD round, but coding rounds often ask you to implement a class with several methods	AdService, BookShelfManager	Reports
DoorDash	Onsite loops (E4, some E3)	Code Craft: practical service or API work that acts as the LLD round; an AI-enabled version exists since late 2025	Dasher payout endpoint calling a mocked upstream service	Reports
Roblox	Some loops	Low-level systems design	Bump allocator, multithreaded ResourceLoader	Reports
Intuit	SE1 (India, Uptime track)	LLD round	Producer-consumer, Java streams	Reports
PayPal	Early career and up	Machine-coding class design inside the OA (45 min) and role-specialization rounds	Library management in Java, booking system, concurrency control, notification system	Reports
Cisco	Intern, new grad	Light LLD tied to your projects	Design a router in Python, multithreading design	Reports
Nvidia	Experienced, team-dependent	LLD; systems teams probe concurrency design	Parking lot, data sync to Slack and email, thread-safe shared pointers	Reports
Atlassian	P30 and up	Code Design in your own IDE with tests, plus an AI-enabled Code Design round on an existing repo	Snake game, middleware router, tennis court booking, rating systems	Atlassian, reports
Salesforce	AMTS, MTS	LLD graded as "production-ready" OOP	LRU then LFU as classes, library management; MTS: Splitwise, LUDO, inventory reservation (reserve, confirm, release)	Reports
Walmart Global Tech	SWE III	LLD in compiling Java	Strategy, Observer, Factory, Singleton, SOLID, ThreadPoolExecutor, LRU, BookMyShow with database locking and isolation levels	Reports
Adobe	MTS-2	Dedicated LLD round	In-memory file system, configuration management service, warehouse allocation, autocomplete top-K, rate limiter, LRU with pluggable eviction	Reports
Goldman Sachs	Analyst	LLD inside "Software Design and Architecture"	Parking lot with nearest spot from several entrances, distributed cache class	Reports
Morgan Stanley	India Associate	LLD on paper	Snake and Ladder, Controller-Service-DAO-Entity layering, SOLID	Reports
D. E. Shaw	Intern and new grad	Class design plus a class diagram, sometimes concurrency	Furniture shop, Google Classroom, Stack Overflow, chat app	Reports
Two Sigma	New grad	OOD exercise	Connect-7 game	Reports
Jane Street	Intern and new grad	Practical builds where classes evolve over several parts	Key-value store class, order book with APIs, memoization with FIFO then LRU eviction	Reports
Databricks	New grad (L3)	Low-level system design	Cached file over a remote storage client, thread-safe event writer with fsync, a map with load-measurement methods	Reports
Rippling	SDE-1	LLD or machine coding	Employee access management, resource manager, rules engine	Reports
Lyft	T3 and up	90-min Laptop round: practical OOP with your own tests, extended for new requirements	Varies	Reports
Expedia	SDE II	LLD with runnable code and patterns	OTP notification service, token-based password reset, delivery-date API by pincode	Reports
eBay	About 4 years	LLD; the CodeSignal assessment itself is an OOP exercise	In-memory file system with addDirectory, addFile, goToDirectory, ls	Reports
Oracle	Campus IC1, IC2	Simple LLD at IC1; design-and-code at IC2 (US)	Parking lot, library management (IC1); file system (IC2)	Reports
Qualcomm	New grad	Systems-flavored LLD	LRU variants, custom malloc, smart pointers, circular buffer	Reports
Bloomberg	New grad	Design-a-class problems	Wordle checker, O(1) lottery, hit counter	Reports

Tip: For Amazon SDE I, Jugal's 6-week Amazon roadmap gives design two days: "You're not designing Netflix. You're designing a parking lot system or a library management system." Do problems 1 and 7 below with the 35-minute framework.

How LLD is graded

Source	What they score
Hello Interview LLD	Problem analysis, class design, code quality, extensibility and maintainability, communication
Amazon OOD round	Design problem analysis, object-oriented design skills, clarity of communication, adaptability and depth. Do not get lost drawing perfect UML
Machine coding	Working, demonstrable code; functionally correct; modular and readable with separation of concerns; takes new requirements with minimal changes; a main method to run it; no UI. Then a code review, where workat.tech says most people get eliminated

Hello Interview also notes that mid-size companies in India and Asia ask about design patterns more directly and give vaguer requirements.

The 35-minute LLD framework

Based on Hello Interview's LLD delivery framework.

Time	Step	What you say or do
About 5 min	Requirements	"Let me confirm what the system must do." List must-haves, out of scope (persistence, UI, concurrency), and edge cases
About 3 min	Entities and relationships	Nouns become classes; note "has many" and "uses" links
10 to 15 min	Class design	Fields and method signatures for each class; enums for states; interfaces for anything that varies
About 10 min	Implementation	Happy path of the core method first, then edge cases, then trace one example for 1 to 2 minutes
About 5 min	Extensibility	"To add [new type], I add one class that implements [interface]. Nothing else changes."

Template to fill on the board:

1) REQUIREMENTS (about 5 min)
   Must: [ ] [ ] [ ]
   Out of scope: [persistence? UI? concurrency?]
   Ask: how many [types]? what happens when [edge case]? one instance or many?

2) ENTITIES AND RELATIONSHIPS (about 3 min)
   [Entity] has many [Entity]; [Entity] uses [Strategy]

3) CLASS DESIGN (10 to 15 min)
   class [Name]:
     state:    [field: type], [field: type]
     behavior: [method(args) -> return]
   enum [State] { ... }
   interface [Strategy] { [method] }

4) IMPLEMENTATION (about 10 min)
   Happy path for [core method]
   Edge cases: invalid input, illegal state, capacity full, concurrent calls
   Trace one example step by step (1 to 2 min)

5) EXTENSIBILITY (about 5 min)
   "To add [new type], I add one class implementing [interface]; nothing else changes."

Example outline for a parking lot (pseudocode, the level of detail most rounds want before you code):

enum SpotSize { SMALL, MEDIUM, LARGE }
enum VehicleType { BIKE, CAR, TRUCK }

class Vehicle      { plate: str; type: VehicleType }
class Spot         { id: str; size: SpotSize; floor: int; vehicle: Vehicle | None
                     fits(v: Vehicle) -> bool }
class Ticket       { id: str; spot: Spot; vehicle: Vehicle; entry_time: datetime }

interface SpotAllocationStrategy { find_spot(floors, vehicle) -> Spot | None }
class NearestFirstStrategy implements SpotAllocationStrategy

interface PricingStrategy { price(ticket, exit_time) -> Money }
class HourlyPricing implements PricingStrategy

class ParkingLot {
  floors: list[Floor]; allocator: SpotAllocationStrategy; pricing: PricingStrategy
  active: dict[ticket_id, Ticket]
  park(vehicle) -> Ticket        # find spot, mark occupied, issue ticket; raise LotFullError
  unpark(ticket_id) -> Money     # free spot, compute price, remove ticket
}
Extension: weekend pricing = new PricingStrategy class. EV spots = new SpotSize + fits() rule.

OOP and SOLID

Read Hello Interview's OOP concepts and design principles pages, then use this table to check yourself.

Principle	One line	Smell when you break it	Where it shows up
Encapsulation	Keep state private; change it only through methods	Other classes edit your fields directly	Account.balance changed outside deposit()
Abstraction	Expose what an object does, hide how	Callers depend on internal details	PaymentGateway.charge() hides the provider
Inheritance	Share behavior through an "is-a" relationship	Deep class trees for small differences	Car and Truck extend Vehicle
Polymorphism	One interface, many implementations	Long if/else chains on a type field	PricingStrategy.price() with several classes
Single responsibility (S)	A class has one reason to change	A ParkingLot class that also prints receipts and sends emails	Split into ParkingLot, ReceiptPrinter, Notifier
Open/closed (O)	Add behavior by adding code, not editing old code	Every new type edits the same switch statement	New split type in Splitwise = new class
Liskov substitution (L)	A subclass must work anywhere its parent works	A subclass throws "not supported" for a parent method	A Penguin that cannot fly()
Interface segregation (I)	Small, focused interfaces	Classes implement methods they do not need	Separate Printable and Scannable
Dependency inversion (D)	Depend on interfaces, inject the implementation	Services create their own concrete repositories	OrderService(repo: OrderRepository)
DRY, KISS, YAGNI	Do not repeat logic; keep it simple; do not build what nobody asked for	Speculative abstractions, copy-pasted code	Hello Interview lists all three
Composition over inheritance	Build behavior from parts you hold, not parents you extend	Subclass explosion (CheesePizzaWithOlives)	Decorator for pizza toppings

Free reading: DigitalOcean: SOLID, AlgoMaster: SOLID with code, and Robert C. Martin's Solid Relevance, where the author of SOLID restates each principle.

Design patterns that come up

Hello Interview argues most of the 23 classic patterns no longer matter and teaches 8: Factory Method, Builder, Singleton, Decorator, Facade, Strategy, Observer and State (patterns page). Learn those first. Add the rest if you target India product companies, which ask about patterns by name.

Pattern	Use it when the prompt says	Example problem	Free link
Strategy	"Support several pricing, allocation or split algorithms"	Parking lot pricing, Splitwise splits, rate limiter algorithms	refactoring.guru
Observer	"Notify users or displays when something changes"	Pub-sub, stock price alerts, waitlists	refactoring.guru
State	"It behaves differently in each state"	Vending machine, elevator, order lifecycle	refactoring.guru
Factory Method	"Different notification, payment or vehicle types"	Notification service, vehicle creation	refactoring.guru
Builder	"Objects with many optional fields"	Building a complex order or query	refactoring.guru
Singleton	"Exactly one shared instance" (use sparingly; it is hard to test)	Logger, configuration	refactoring.guru
Decorator	"Add features without a subclass for every combination"	Pizza billing with toppings, adding retries or logging	refactoring.guru
Facade	"A simple API over a complex subsystem"	Booking facade over seats, payment and email	refactoring.guru
Command	"Undo, queue or log operations"	Text editor undo, job queue	refactoring.guru
Chain of Responsibility	"Pass a request through a series of handlers"	ATM cash dispensing, log levels, approvals	refactoring.guru
Adapter	"Integrate a third-party API with a different interface"	Payment providers, SMS providers	refactoring.guru
Composite	"Treat a group the same as a single item"	In-memory file system (files and folders)	refactoring.guru
Template Method	"Same steps, one step varies"	Game turn loop, report generation	refactoring.guru
Iterator	"Walk a collection without exposing its structure"	Playlist, paginated results	refactoring.guru

Watch out: Forcing a pattern where the problem does not need one reads as over-engineering. Say the requirement first, then the pattern that serves it.

Concurrency for LLD

Concurrency comes up in booking and counter problems: Flipkart seat booking, the PhonePe machine coding review, Databricks thread-safe writers, Walmart's BookMyShow and Salesforce trending counts (company pages). Learn this list:

• Race condition and critical section: two threads read-modify-write the same data.
• Locks: synchronized or ReentrantLock in Java, threading.Lock in Python. Lock per resource (per show, per account), not one global lock.
• Thread-safe collections and atomics: ConcurrentHashMap, AtomicInteger.
• Read-write locks when reads far outnumber writes.
• Producer-consumer with a blocking queue.
• Deadlock: always take locks in the same order.
• Database side: optimistic locking with a version column vs pessimistic row locks, and what each isolation level allows.
• Idempotent operations so retries are safe.

Free reading: Hello Interview's LLD concurrency intro, the Java concurrency tutorial, and Python's threading docs.

Line to have ready: "book() checks and reserves the seat while holding the lock for that show, so two users can never get the same seat. Other shows are not blocked."

Practice problems

AL = awesome-low-level-design (solutions in several languages), WT = workat.tech machine coding, HI = Hello Interview LLD, SDP = System Design Primer notebooks. Levels for WT prompts are workat.tech's own labels; the rest are our estimate.

#	Problem	Level	What it teaches	Free write-ups	Reported at
1	Parking lot	SDE I to II	Entities, spot allocation strategy, pricing strategy, enums	AL, WT, SDP, LeetCode 1603	Amazon, Goldman Sachs, Oracle, Uber
2	Elevator	SDE I to II	State machine, scheduling strategy, request queues, concurrency	HI, AL	Pinterest, Roblox
3	LRU cache	SDE I	Hash map plus doubly linked list for O(1) get and put; thread safety as the follow-up	LeetCode 146, AL, SDP, then LFU, LeetCode 460	Salesforce, Walmart, Adobe, Qualcomm, Jane Street
4	Rate limiter (classes)	SDE I to II	Strategy for each algorithm, per-client state, thread safety	BBG rate limiter for the algorithms	Amazon, Adobe
5	Splitwise	SDE I to II	Split strategies (equal, exact, percent), balance graph, simplifying debts	WT, AL	Salesforce
6	Snake and ladder	SDE I	Board, dice, players, turn loop, input parsing	WT, AL	Morgan Stanley
7	Library management	SDE II	Book vs BookItem, members, checkout and returns, fines, search	WT, AL	Salesforce, Oracle, PhonePe
8	Tic-tac-toe or Connect Four	SDE I	Board representation, win detection, N x N extension	HI Connect Four, WT, AL	Two Sigma (Connect-7)
9	Amazon Locker	SDE I	Locker sizes, assignment, pickup codes, expiry	HI	Amazon
10	Vending machine	SDE I	State pattern (idle, has money, dispensing), inventory, change	AL, AL coffee machine
11	ATM	SDE I	State, Chain of Responsibility for cash dispensing	AL
12	Traffic signal	SDE I	State pattern, timers	AL
13	In-memory key-value store	SDE II to III	Data model, secondary search by attribute, type validation, thread safety	WT, LeetCode 981	Jane Street, Coinbase, LinkedIn
14	In-memory file system	SDE II	Composite pattern, path parsing, mkdir and ls	refactoring.guru Composite (LeetCode 588 is Premium)	Adobe, eBay, Oracle
15	Logging framework	SDE II	Chain of Responsibility for levels, sinks as Strategy, thread safety	AL	PhonePe (logger with sinks)
16	Pub-sub system	SDE II	Observer, topics, subscribers, delivery	AL	Adobe
17	Movie ticket booking (BookMyShow)	SDE II	Seat locking, concurrency, booking and payment states	AL, AL concerts	Walmart, Flipkart
18	Hotel management	SDE II	Rooms, reservations, booking states, payments	AL	Expedia
19	Food delivery	SDE II	Orders, restaurants, delivery assignment strategy	AL	Flipkart
20	Restaurant management	SDE II	Tables, orders, kitchen queue	AL	Flipkart
21	Ride sharing	SDE II	Matching strategy, trip states, pricing	AL	Lyft
22	Digital wallet	SDE II	Balances, transfers, transaction history, idempotency	AL	PhonePe
23	Online auction	SDE II	Bids, auction states, concurrent bids	AL	Meta (as HLD)
24	Stack Overflow	SDE II	Users, questions, answers, votes, reputation	AL	D. E. Shaw
25	Chess	SDE II	Piece rules through polymorphism, board validation, turns	AL
26	Task management (Trello-like)	SDE II	Boards, lists, cards, assignment, status changes	AL
27	Car rental	SDE II	Inventory, reservations, availability windows	AL
28	Online shopping	SDE II	Catalog, cart, orders, payments	AL

The full awesome-low-level-design problem list also covers airline management, course registration, music streaming, LinkedIn, Cricinfo and a stock brokerage.

LeetCode design problems as warm-ups

These train the same skill in 20 to 40 minutes: pick the right data structures behind a class API.

Free	Difficulty
146 LRU Cache	Medium
460 LFU Cache	Hard
1603 Design Parking System	Easy
706 Design HashMap	Easy
155 Min Stack	Medium
622 Design Circular Queue	Medium
208 Implement Trie	Medium
211 Design Add and Search Words Data Structure	Medium
380 Insert Delete GetRandom O(1)	Medium
355 Design Twitter	Medium
1396 Design Underground System	Medium
1472 Design Browser History	Medium
981 Time Based Key-Value Store	Medium
1146 Snapshot Array	Medium
2353 Design a Food Rating System	Medium
1797 Design Authentication Manager	Medium
432 All O'one Data Structure	Hard

Premium only (checked Oct 2026): 362 Design Hit Counter, 359 Logger Rate Limiter, 348 Design Tic-Tac-Toe, 1166 Design File System, 588 Design In-Memory File System, 1244 Design A Leaderboard. Buy a month of Premium only if your target company tags them. More on lists in Problem lists.

Machine coding round playbook

What the round looks like

• You get a written problem and 60 to 120 minutes. Flipkart's official prep doc describes a 120-minute block (15 minutes pre-coding, 90 coding, 15 demo); Uber L4 candidates report 60 minutes.
• You must hand in working, demonstrable code: modular, readable, with separation of concerns, a main method or simple command line to run it, and no UI (workat.tech).
• A code review follows. Reviewers ask you to extend the code live, justify classes and patterns, explain concurrency, and sometimes draw the class diagram (Flipkart and PhonePe reports).

Time plan

From workat.tech's how to ace the round:

Phase	Time	What to do
Read the problem	5 to 10 min	Read carefully, list assumptions, ask clarifying questions
Design the solution	10 to 15 min	Design for extension, estimate coding time, rank mandatory over optional requirements
Code	60 to 75 min	Working code first, handle exceptions, clear names, use an IDE you know
Demo	The rest	Give a short overview, run sample inputs, offer to test more cases

Set up a starter project before the day

Build this once in your interview language and reuse it every practice session, so minute one goes to the problem, not to setup.

JAVA
src/main/java/com/[you]/[app]/
  Main.java                 driver: builds objects, runs demo commands
  model/                    plain entities: User, Order, Slot
  repository/               interfaces + InMemory[Name]Repository (HashMap inside)
  service/                  business logic: BookingService, PaymentService
  strategy/                 swappable rules: PricingStrategy, AllocationStrategy
  exception/                custom exceptions: SlotUnavailableException
src/test/java/...           one JUnit test file per service

PYTHON
[app]/
  main.py                   driver
  models.py                 dataclasses
  repositories.py           abstract base class + in-memory dict implementation
  services.py
  strategies.py
  exceptions.py
tests/test_services.py      pytest

During the round

1. Read the whole statement twice. Mark each requirement mandatory or optional.
2. Write your assumptions at the top of Main and ask the clarifying questions you have (input format, concurrency, persistence).
3. List entities and relationships, then decide which services own which operations.
4. Code models first, then repositories behind interfaces, then services, then the driver.
5. Get the first mandatory feature running end to end before you start the second. Run it.
6. Implement the remaining mandatory features in the order listed. PhonePe's instructions rank them by importance and say a partial solution on time beats a late one (reports).
7. Throw custom exceptions for invalid input so the demo never crashes.
8. Add optional features or thread safety only after every mandatory feature works.
9. Stop coding 10 minutes before the end. Prepare demo input and walk through it.

The review: questions to expect

• "Why is this its own class?" and "Why this pattern here?"
• "Add [new rule or type] now." Count how many files you touch. Fewer is better.
• "What happens if two users call book() at the same time?"
• "Draw the class diagram."
• "How would you persist this, and what changes?"

Watch out: Do not add features or methods nobody asked for. One 2026 PhonePe candidate was rejected for an extra sink-specific method on a logger API that leaked implementation details (reports).

Self-review checklist

Run this after every practice session. Based on workat.tech's expectations.

• The code runs and I can demo it from a main method or simple command line.
• Every mandatory requirement works; optional ones came after.
• Models, services and repositories are separate.
• Names are clear; no god class; no 200-line method.
• I added one new requirement just now and it touched few files.
• Invalid input raises a clear exception instead of crashing.
• Storage sits behind an interface so it can be swapped later.
• I have sample input ready to show.
• I can name each pattern I used and say why.

Company tips

Company	Tip
Flipkart	Practice 5 to 6 problems end to end at 90 minutes each (BNPL, quick commerce, food ordering, task scheduler, meeting room booking). Finish every P0 feature with running code before bonus items. In design rounds, write the complete schema; one candidate lost marks for a missing payments table
PhonePe	Implement functions in the listed order and submit on time. Expect the review to focus on how assign and book behave under concurrent calls
Atlassian	Open a blank project with a test framework (JUnit or pytest) before the round; you write, run and test on screen share. Finish part 1 fast and keep classes open for parts 2 and 3
Walmart Global Tech	Reports say LLD rounds expect compiling Java code, not class diagrams alone: LRU with generics, ThreadPoolExecutor, BookMyShow with locking
Salesforce	Write LRU and then LFU as clean classes with clear responsibilities; "production-ready" OOP is graded
Uber	The L4 machine-coding round is 60 minutes with running code and tests. Get to running code early, then refactor and add tests; interfaces and extensible classes score well. Practice Splitwise, parking lot and a circuit breaker with OPEN, CLOSED and HALF_OPEN states

2-week machine coding plan

Run this alongside DSA. Each session is 90 to 120 minutes with runnable code.

• Day 1: Read workat.tech's what is a machine coding round, how to practice and how to ace it. Build your starter project.
• Day 2: Snake and Ladder.
• Day 3: Self-review Day 2 against the checklist and rewrite the worst class.
• Day 4: Tic-Tac-Toe.
• Day 5: Parking Lot.
• Day 6: Splitwise.
• Day 7: Review the patterns you used; read the three you did not (pattern table).
• Day 8: Library Management.
• Day 9: In-memory key-value store.
• Day 10: One reported prompt from your target company (table above), written from the description alone.
• Day 11: Movie ticket booking with one lock per show. Write a test where two threads book the same seat; exactly one must succeed.
• Days 12 and 13: Two timed sessions with a friend who adds a new requirement at minute 60. Extend without rewriting.
• Day 14: Redo your weakest problem from scratch and practice naming every pattern out loud.

LLD resources (free first)

Resource	What it is	How to use it
awesome-low-level-design	OOP, SOLID, all classic patterns, UML, concurrency, and a problem list with solutions in several languages	Use its problem list as your practice queue after the 28 above
Hello Interview: LLD in a Hurry (freemium)	Free: intro, delivery, principles, OOP, patterns, concurrency intro, and the Amazon Locker, Connect Four and Elevator breakdowns. Premium: parking lot, rate limiter, BookMyShow, file system, inventory, logging	Read every free page in week 3 of the 4-week plan
refactoring.guru: Design patterns (free, paid ebook)	Illustrated explanation of each pattern with code in many languages	Read one pattern a day with its code in your language
AlgoMaster LLD (freemium)	Articles per pattern and concept, including class diagrams	Learn enough UML to sketch a class diagram in the review
AlgoMaster: How to answer an LLD problem	A step-by-step answer structure	Read before your first timed LLD
System Design Primer: OOD notebooks	Python notebooks: hash map, LRU cache, call center, deck of cards, parking lot, online chat	Read the LRU and parking lot notebooks after you attempt them
iluwatar/java-design-patterns	Every pattern implemented in Java	Java users: read the implementation of each pattern you learn
faif/python-patterns	Patterns and idioms in Python	Python users: same use
workat.tech machine coding	Real prompts labeled by level; the articles say they were written a few years ago	Your machine coding practice set
kumaransg/LLD	Collection of LLD questions and implementations	Extra problems; code quality varies
Concept && Coding (Shrayansh Jain) on YouTube	LLD and HLD channel widely used by India candidates	Watch a problem video only after you attempt it
Hello Interview Premium (paid)	Premium LLD breakdowns and guided practice	Only after the free set is done

Watch out: GitHub repos that copy the paid "Grokking the Object Oriented Design Interview" text appear to be unauthorized mirrors. Skip them.

Next: System design resources