Patternwise

LLD track

Low-Level Design

Turn fuzzy requirements into clean, extensible class designs under interview pressure.

Low-level design interviews test whether you can model a real problem as cooperating objects, defend your trade-offs, and keep the design open for change. This track builds that skill from OOP and SOLID up through design patterns, concurrency, and a repeatable interview framework, all in idiomatic Python.

3stages
12modules
41lessons
20problems
6hours
Start the first lesson
0/41 lessons
Stage 1

Principles

The vocabulary every design discussion is built on: OOP, SOLID, coupling and cohesion, and how to sketch it all on a whiteboard.

Module 015 lessons · 44 min

OOP Foundations

Explain and apply the four pillars of OOP in Python, and choose composition over inheritance with a clear reason.

  1. ✓EncapsulationHide state behind behaviour so objects protect their own invariants.8m
  2. ✓AbstractionExpose what an object does, not how it does it.8m
  3. ✓Inheritance vs CompositionWhy 'has-a' usually beats 'is-a', and when inheritance is still the right call.10m
  4. ✓PolymorphismOne interface, many implementations: the engine behind most design patterns.8m
  5. ✓Interfaces, ABCs and Protocols in PythonExpress contracts in Python with abc.ABC and typing.Protocol.10m
Module 025 lessons · 41 min

SOLID Principles

Spot SOLID violations in a design and refactor them, explaining the concrete benefit of each change.

  1. ✓Single Responsibility PrincipleA class should have one reason to change.8m
  2. ✓Open/Closed PrincipleAdd behaviour by adding code, not by editing working code.8m
  3. ✓Liskov Substitution PrincipleSubtypes must honour the promises of their parent type.9m
  4. ✓Interface Segregation PrincipleMany small, focused interfaces beat one fat one.7m
  5. ✓Dependency Inversion PrincipleDepend on abstractions and inject the concrete pieces.9m
Module 033 lessons · 23 min

Everyday Design Principles

Use DRY, KISS, YAGNI, the Law of Demeter, and coupling/cohesion as quick heuristics to judge a design.

  1. ✓DRY, KISS and YAGNIThree rules of thumb that keep designs small and honest.8m
  2. ✓Law of DemeterTalk to your friends, not to your friends' friends.7m
  3. ✓Coupling and CohesionThe two dials that decide how painful your design is to change.8m
Module 042 lessons · 17 min

UML for Interviews

Draw a clear class diagram and sequence sketch quickly, using only the notation interviewers actually care about.

  1. ✓Class Diagrams That CommunicateThe minimal UML you need to whiteboard a design in minutes.9m
  2. ✓Association, Aggregation and CompositionName relationships precisely and pick the right multiplicity.8m
Stage 2

Patterns

The classic Gang-of-Four patterns, each framed by the problem it solves and how it shows up in LLD interviews.

Module 055 lessons · 40 min

Creational Patterns

Pick the right way to construct objects so that creation logic stays flexible and testable.

  1. ✓SingletonExactly one instance, and why you should be suspicious of it.8m
  2. ✓Factory MethodLet a method decide which concrete class to create.8m
  3. ✓Abstract FactoryCreate families of related objects that must be used together.9m
  4. ✓BuilderAssemble complex objects step by step with validation at the end.8m
  5. ✓PrototypeCreate new objects by cloning a configured template.7m
Module 065 lessons · 38 min

Structural Patterns

Compose objects into larger structures and wrap existing code without rewriting it.

  1. ✓AdapterMake an incompatible interface fit the one your code expects.7m
  2. ✓DecoratorStack behaviour onto an object at runtime without subclass explosion.8m
  3. ✓FacadeOne simple front door to a complicated subsystem.7m
  4. ✓ProxyA stand-in that controls access, caching, or lazy loading.8m
  5. ✓CompositeTreat single objects and trees of objects the same way.8m
Module 074 lessons · 34 min

Behavioral Patterns I

Model swappable algorithms, event notification, state machines, and undoable actions cleanly.

  1. ✓StrategySwap algorithms at runtime behind a common interface.8m
  2. ✓ObserverNotify many listeners when something changes, without knowing who they are.9m
  3. ✓StateReplace sprawling if/else on status with state objects.9m
  4. ✓CommandTurn a request into an object you can queue, log, or undo.8m
Module 083 lessons · 22 min

Behavioral Patterns II

Build processing pipelines, reusable algorithm skeletons, and clean traversal over collections.

  1. ✓Chain of ResponsibilityPass a request along a chain of handlers until one deals with it.8m
  2. ✓Template MethodFix the algorithm's skeleton, let subclasses fill in the steps.7m
  3. ✓IteratorTraverse a collection without exposing how it is stored.7m
Stage 3

Architecture & Interview

Make designs safe under concurrency, give them clean boundaries, and run the interview itself with a repeatable framework.

Module 093 lessons · 28 min

Concurrency in LLD

Identify shared mutable state in a design and protect it with the right locking or queueing strategy.

  1. ✓Thread Safety and LocksFind race conditions and fix them with the smallest correct lock.10m
  2. ✓Producer-ConsumerDecouple work creation from work execution with a bounded queue.9m
  3. ✓Optimistic vs Pessimistic LockingPrevent double-booking with version checks or held locks.9m
Module 102 lessons · 18 min

APIs and Error Handling

Design class and service interfaces that are hard to misuse and fail loudly and predictably.

  1. ✓Designing Class and Service APIsShape method signatures, return types, and boundaries that are hard to misuse.9m
  2. ✓Error Handling in DesignsDomain exceptions, validation at the edges, and idempotent retries.9m
Module 112 lessons · 18 min

Layering and Clean Architecture

Separate domain logic from storage and delivery so the core design survives infrastructure changes.

  1. ✓Layered and Clean ArchitectureControllers, services, and domain: who may depend on whom.10m
  2. ✓Repository PatternHide persistence behind a collection-like interface.8m
Module 122 lessons · 24 min

Running the LLD Interview

Drive a 45-minute LLD round end to end with a framework that shows structure, judgement, and extensibility.

  1. ✓The LLD Interview FrameworkSeven steps from vague prompt to defended design.12m
  2. ✓Worked Walkthrough and PitfallsThe framework applied to a real prompt, minute by minute, plus the traps to avoid.12m

Then practise

LLD Problems

Classic machine-coding and LLD prompts, each with clarified requirements, a class skeleton, key flows, and the follow-ups interviewers like to push on. Try sketching your own design for 30 minutes before opening the solution.

Open lld problems →