Low-Level Design: OOP Foundations → Design Patterns → Classic Interview Problems

A hands-on curriculum in Low-Level Design (LLD/OOD) — the "given a requirement, design the classes" discipline that shows up as its own interview round at most product companies. Every code example in this track is written twice, in Python and C#, shown side by side as switchable tabs (click "Python" or "C#" — your choice is remembered as you move between pages). Zero prior programming in either language is assumed. Modules 00–01 teach both languages from the ground up — plain variables and control flow first, then classes and OOP building blocks — before any design content begins.

This is a large curriculum, being built out one module at a time. Modules are added in dependency order; if a module's folder doesn't exist yet, it hasn't been built out yet — check back.

This folder is a sibling to ../backend/ and ../learn/, not a replacement for either. learn/ is operating infrastructure. backend/ is building and operating a networked application end to end. lld/ is narrower and deeper on one thing both of those touch only briefly: how you design the classes and objects inside a single component — the skill tested directly in an LLD interview round, independent of any framework, network, or database.

Naming convention

Same convention as backend/ and learn/:

• Modules are top-level folders directly under lld/, named NN-module-name — a zero-padded two-digit sequence number (the order you do them in) plus a lowercase kebab-case slug.
• Every module folder contains exactly one README.md. No separate exercise files or scripts — everything a module needs is written inline.
• The track closes with two open-ended, no-solution-given capstones: 22-capstone-project (generic — you choose the domain) and 23-supply-chain-platform (a themed second capstone applying everything to one specific, meaty domain end to end). Both skip the quiz, interview-question, and independent-challenge scaffolding — they are the open-ended integration test.
• This file (lld/README.md) is the single index for the whole track.

How code samples work: tabs, not two separate walls of code

Every non-trivial snippet appears as a tabbed block:

{{tabs}}
{{tab Python}}
...python code...
{{tab C#}}
...C# code...
{{/tabs}}

The browser viewer renders this as clickable Python | C# tabs. Read a concept once; see it expressed idiomatically in both languages; pick whichever you're actively practicing.

How to use this

• Go in order — later modules assume every pattern and principle taught earlier. Modules 00–01 are not optional even if you already write code elsewhere; they're where both languages get taught from scratch, and every later module's tabs assume you can read both.
• Every standard module has: concepts explained plainly with a class diagram or code reference, hands-on exercises (do these, in both languages if the module says so), an independent challenge with no code given, common mistakes, a checkpoint quiz, and interview questions — real/likely questions asked on this exact topic, each with a model answer. Every 3–4 modules there's also a cumulative review mixing questions from everything so far.
• Modules 12–18 (the classic problems: parking lot, elevator, library, vending machine, tic-tac-toe, chess, Splitwise, ticket booking, ride-sharing, LRU/LFU cache, rate limiter) get a full worked solution — requirements → class diagram → complete Python and C# implementation → tradeoffs and extensions. Their independent challenge is a scoped extension to the already-solved problem, not the base problem itself.

How to actually retain this (read this once, seriously)

• Attempt every quiz and interview question in writing before opening the answer. LLD interviews are verbal and whiteboard-based — if you can't articulate the answer out loud or on paper, you don't have it yet.
• Implement the independent challenge in both languages, not just the one you're more comfortable in. The point of the dual-language format is to prove the design is language-independent — if you can only build it in one language, you've memorized code, not learned design.
• Redraw the class diagram from memory before starting a new classic problem, using the previous problem's diagram as a warm-up.
• Take the cumulative reviews closed-book.

Modules

Prerequisites already confirmed

• Zero prior programming assumed, in either language — not Python, not C#. Modules 00–01 start from print("hello") and build up to classes; nothing before module 02 assumes you've written code before.
• Practicing wherever's convenient — unlike learn/, nothing here depends on WSL2, Docker, or Azure; a Python interpreter and a C# environment (dotnet CLI or an IDE) are all you need.

Start here → 00-programming-basics-python-and-csharp/README.md