Low-Level Design

• Classes & ObjectscoreLessonBlueprints vs instances; fields, methods, constructors.
• Object lifecycleLessonConstruction, initialization, and cleanup / destructors.
• EncapsulationcoreLessonHide state behind behavior; getters/setters done right.
• AbstractioncoreLessonExpose intent, hide the implementation details.
• InheritanceLessonReuse and specialization through an "is-a" relationship.
• PolymorphismcoreLessonOne interface, many forms; overriding vs overloading.
• Static vs instance membersLessonClass-level state and behavior vs per-object.
• Access modifiersLessonpublic, private, protected, package — controlling visibility.
• Abstract classes vs InterfacesinterviewLessonShared base vs pure contract — when to use which.
• Composition vs InheritancecoreLessonFavor composition; "has-a" beats "is-a" more often than you think.
• Association, Aggregation, CompositionLessonObject relationships and who owns whose lifecycle.
• Coupling & CohesioncoreLessonThe two metrics that quietly decide design quality.
• equals(), hashCode() & identityLessonContracts that bite the moment objects enter collections.
• Immutability & value objectsLessonObjects that can't change are simpler and thread-safe by default.
• Generics / TemplatesLessonType-safe reuse without casting everywhere.
• Enums & constantsLessonModeling a fixed, finite set of options cleanly.

• Requirement gathering & clarifying questionsinterviewLessonPin down scope and assumptions before designing anything.
• Identifying entities, attributes & behaviorscoreLessonNouns become classes, verbs become methods.
• Responsibility assignment (GRASP)LessonInformation Expert, Creator, Controller, and friends.
• CRC cardsLessonClass–Responsibility–Collaborator brainstorming on paper.
• Domain modelingLessonEntities, value objects, and services that mirror the real domain.
• Designing the API firstcoreLessonAgree on contracts and method signatures before implementing.

• Class diagramscoreLessonStructure, relationships, multiplicity — the LLD workhorse.
• Object diagramsLessonA concrete snapshot of instances at one moment.
• Sequence diagramsinterviewLessonHow objects collaborate over time, message by message.
• Use case diagramsLessonActors and the goals they pursue with the system.
• Activity diagramsLessonWorkflows, branches, and parallel paths.
• State diagramsLessonAn object's lifecycle and its valid transitions.
• Component & deployment diagramsLessonZooming out to modules and where they run.
• Relationship notationLessonAssociation, dependency, generalization, realization.

• Single Responsibility (SRP)coreLessonA class should have one, and only one, reason to change.
• Open/Closed (OCP)coreLessonOpen for extension, closed for modification.
• Liskov Substitution (LSP)interviewLessonSubtypes must be usable anywhere their base type is.
• Interface Segregation (ISP)LessonMany small, focused interfaces beat one fat one.
• Dependency Inversion (DIP)coreLessonDepend on abstractions, never on concretions.

• DRY, KISS, YAGNIcoreLessonDon't repeat yourself, keep it simple, don't build what you don't need.
• Law of DemeterLessonTalk to your friends, not to strangers' internals.
• Separation of ConcernsLessonEach module owns one well-defined job.
• Program to interfacescoreLessonCode against contracts, not concrete implementations.
• Dependency Injection & IoCinterviewLessonHand dependencies in instead of creating them inside.
• Injection styles: constructor vs setter vs fieldinterviewLessonThe trade-offs interviewers probe — and why constructor injection usually wins.
• Tell, Don't AskLessonPush behavior to the data instead of pulling data out.
• Command–Query SeparationLessonA method either does something or answers something — not both.

Creational

• SingletonLessonOne shared instance, globally reachable.
• Factory MethodLessonDefer which class to instantiate to subclasses.
• Abstract FactoryLessonCreate families of related objects.
• BuilderLessonAssemble complex objects step by step.
• PrototypeLessonClone an existing object instead of building anew.
• Object PoolLessonReuse expensive objects instead of recreating them.

Structural

• AdapterLessonMake incompatible interfaces work together.
• BridgeLessonSplit abstraction from implementation so both can vary.
• CompositeLessonTreat trees of objects like a single object.
• DecoratorLessonAdd behavior by wrapping, not subclassing.
• FacadeLessonOne simple front door to a complex subsystem.
• FlyweightLessonShare common state across many objects to save memory.
• ProxyLessonA stand-in that controls access to the real object.

Behavioral

• Chain of ResponsibilityLessonPass a request along a chain of handlers.
• CommandLessonWrap an action as an object you can queue or undo.
• IteratorLessonTraverse a collection without exposing its internals.
• MediatorLessonCentralize tangled object-to-object communication.
• MementoLessonCapture and restore an object's state.
• ObserverinterviewLessonNotify dependents automatically when state changes.
• StateLessonChange behavior when the internal state changes.
• StrategyinterviewLessonSwap interchangeable algorithms at runtime.
• Template MethodLessonFix the skeleton, let subclasses fill the steps.
• VisitorLessonAdd operations to a hierarchy without touching it.
• Null ObjectLessonA do-nothing default that removes null checks.

Architectural

• MVC / MVP / MVVMLessonSeparating data, presentation, and control.
• RepositoryLessonAbstract data access behind a collection-like API.
• Pub/Sub & Event-drivenLessonDecouple producers from consumers via events.

Using patterns wisely

• Pattern overuse & anti-patternsinterviewLessonSingleton abuse, speculative generality, and knowing when a pattern is the wrong call.

• Threads & lifecycleLessonCreating, starting, and coordinating threads.
• Locks, Mutex, SemaphorecoreLessonThe core tools for guarding shared state.
• Thread-safe SingletoninterviewLessonDouble-checked locking and the holder idiom.
• Producer–ConsumerinterviewLessonBounded buffers and blocking queues.
• Read-Write locksLessonLet many readers in, one writer at a time.
• Deadlock, race conditions, starvationcoreLessonThe three classic ways concurrency goes wrong.
• Atomic operations & CASLessonLock-free updates with compare-and-swap.
• Memory visibility & the memory modelinterviewLessonvolatile, happens-before, and why one thread sees another's stale values.
• Thread pools & ExecutorsLessonReuse a fixed set of workers instead of spawning threads.
• Futures, Promises & asyncLessonComposing results that aren't ready yet.
• Immutable objects for safetyLessonShare freely when nothing can change underneath.

The approach

• A repeatable 5-step frameworkinterviewLessonClarify → entities → APIs → class diagram → code → test.

Beginner

• Parking LotThe canonical warm-up problem.
• Vending MachineState machine over products and coins.
• ATMTransactions, balances, and a state flow.
• Tic-Tac-ToeBoard, players, and win detection.
• Snake & LadderDice, board, and turn management.
• Coffee MachineRecipes, ingredients, and inventory.

Intermediate

• Elevator / Lift systemScheduling and request dispatch.
• Library ManagementCatalog, members, and loans.
• Logging frameworkLevels, appenders, and formatting.
• Rate LimiterToken bucket and sliding windows.
• Notification systemChannels, templates, and routing.
• Cache (LRU / LFU)Eviction policy behind a clean API.
• SplitwiseExpenses, balances, and settlements.
• Meeting room schedulerIntervals, conflicts, and booking.
• In-memory key-value storeGet/set with TTL and eviction.

Advanced

• BookMyShowSeats, shows, and concurrent booking.
• Food delivery (Swiggy / Zomato)Restaurants, carts, and dispatch.
• Ride sharing (Uber / Ola)Matching, pricing, and trips.
• Hotel bookingInventory, availability, and rates.
• ChessPieces, moves, and rule validation.
• Stock exchange / Order matchingOrder book and a matching engine.
• Online IDE / Code editorFiles, sessions, and execution.
• Distributed task schedulerJobs, workers, and retries.

• Code smells & how to spot themcoreThe early warning signs of a decaying design.
• Refactoring techniquesExtract, inline, rename, replace-conditional-with-polymorphism.
• Anti-patterns to avoidGod object, spaghetti, golden hammer, and friends.
• Unit testing basicscoreArrange–act–assert and what makes a good test.
• Test doubles: mocks, stubs, fakesIsolating the unit under test from its collaborators.
• TDD basicsRed → green → refactor as a design tool.
• Writing testable codecoreSeams, dependency injection, and pure functions.
• Clean code principlesNaming, small functions, and comments that earn their place.
• Design & code review checklistA repeatable lens for catching problems before they ship.