Low Level System Design (LLD)

You can model complex domain problems into extensible object structures using polymorphism and clean encapsulation.

1. The four pillars: encapsulation, abstraction, inheritance, polymorphism90 min
   • private fields
   • protected access
   • runtime polymorphism
   • abstract keyword
2. Classes, objects, interfaces and abstract classes90 min
   • interface contracts
   • multiple implementation
   • abstract class inheritance
   • constructor chaining
3. Composition versus inheritance90 min
   • has-a relationship
   • is-a relationship
   • delegation
   • fragile base class problem
4. Coupling, cohesion and why they matter90 min
   • high cohesion
   • low coupling
   • modular design
   • dependency tracking
5. Modelling a problem as objects90 min
   • domain noun extraction
   • responsibility assignment
   • CRC cards
   • class interaction mapping

Hands-on project: Model a robust domain model for a library catalog using abstract base classes and composition, ensuring zero tight coupling between inventory and user accounts.

You can refactor rigidly coupled codebases to strictly obey the five SOLID principles for maximum maintainability.

1. Single Responsibility Principle90 min
   • separation of concerns
   • actor-based responsibility
   • class reason to change
   • domain partitioning
2. Open/Closed Principle90 min
   • extension via subclasses
   • strategy injection
   • plugin architecture
   • preventing switch-case bloat
3. Liskov Substitution Principle90 min
   • behavioral subtyping
   • preconditions and postconditions
   • invariant preservation
   • avoiding instanceof checks
4. Interface Segregation Principle90 min
   • fat interfaces
   • client-specific contracts
   • role interfaces
   • interface splitting
5. Dependency Inversion and dependency injection90 min
   • high-level modules
   • abstractions over details
   • constructor injection
   • inversion of control containers

Hands-on project: Refactor a monolithic billing engine that violates every SOLID rule into separated, testable services using dependency inversion and interface segregation.

You can communicate complex class architectures clearly using standardized UML class and sequence diagrams.

1. DRY, KISS and YAGNI90 min
   • code duplication elimination
   • simplicity metrics
   • speculative generality
   • maintainability index
2. Programming to interfaces, not implementations90 min
   • interface variables
   • factory creation
   • decoupling concrete types
   • mockability
3. The Law of Demeter90 min
   • talk only to immediate friends
   • chaining mitigation
   • information hiding
   • encapsulating navigation
4. UML class diagrams90 min
   • visibility modifiers
   • associations and aggregations
   • composition notation
   • multiplicity rules
5. UML sequence diagrams90 min
   • lifelines
   • synchronous calls
   • asynchronous messages
   • activation boxes

Hands-on project: Design complete UML class and sequence diagrams for an inventory checkout workflow adhering strictly to the Law of Demeter and DRY principles.

You can instantiate complex object hierarchies cleanly using Gang of Four creational patterns.

1. Singleton and thread-safe variants90 min
   • double-checked locking
   • enum singleton
   • bill pugh singleton
   • serialization safety
2. Factory Method90 min
   • creator subclasses
   • deferred instantiation
   • object creation encapsulation
   • runtime type selection
3. Abstract Factory90 min
   • families of related objects
   • concrete factory setup
   • client decoupling
   • product consistency
4. Builder90 min
   • telescoping constructors
   • fluent interface
   • director class
   • immutable objects
5. Prototype90 min
   • cloneable interface
   • deep copy vs shallow copy
   • prototype registry
   • runtime object duplication

Hands-on project: Implement a thread-safe configuration loader with Singleton and a multi-database connection pool using Abstract Factory.

You can compose classes and objects into larger structures while keeping designs flexible and efficient.

1. Adapter90 min
   • incompatible interfaces
   • wrapper class
   • object adapter
   • class adapter
2. Decorator90 min
   • dynamic behavior addition
   • wrapping components
   • stream filters
   • composition over subclassing
3. Facade and Proxy90 min
   • subsystem simplification
   • virtual proxy
   • protection proxy
   • remote proxy stubbing
4. Composite90 min
   • tree structures
   • leaf and container uniform handling
   • recursive operations
   • component interface
5. Bridge and Flyweight90 min
   • abstraction separation
   • state sharing
   • intrinsic vs extrinsic state
   • memory optimization

Hands-on project: Build an API response transformer using Decorator and an access control layer using Proxy for a REST gateway.

You can manage complex control flows and communication paths between objects using behavioral patterns.

1. Strategy90 min
   • algorithm encapsulation
   • interchangeable behaviors
   • runtime strategy switching
   • context class
2. Observer90 min
   • publish-subscribe relationship
   • event notification
   • weak references
   • decoupled listeners
3. Command and Chain of Responsibility90 min
   • command encapsulation
   • receiver execution
   • handler chains
   • request filtering
4. State and Template Method90 min
   • state machine transitions
   • algorithm skeleton
   • hook methods
   • subclass customization
5. Iterator, Mediator and Memento90 min
   • sequential traversal
   • centralized communication
   • state snapshotting
   • encapsulation preservation

Hands-on project: Build a multi-step checkout workflow with State and Command patterns, complete with undo-redo functionality.

You can gather requirements, clarify edge cases, and write production-grade code under strict interview time limits.

1. What interviewers actually look for90 min
   • code extensibility
   • error handling
   • testability
   • naming conventions
2. Requirement gathering and clarifying assumptions90 min
   • functional scope
   • non-functional constraints
   • concurrency edge cases
   • scale estimations
3. Designing classes under time pressure90 min
   • time boxing
   • skeleton first approach
   • prioritizing core entities
   • simplifying non-critical paths
4. Writing clean, extensible, working code90 min
   • solid adherence
   • pattern application
   • compilable syntax
   • modular organization
5. Demonstrating and extending your solution90 min
   • walkthrough presentation
   • handling feature additions
   • defending design trade-offs
   • answering interviewer probes

Hands-on project: Complete a timed 75-minute mock machine coding session building an expense splitter from scratch under direct observation.

You can design physical and stateful systems like parking lots, elevators, and board games using clean domain models.

1. Designing a Parking Lot90 min
   • spot types
   • pricing strategy
   • entrance and exit terminals
   • ticket management
2. Designing a Vending Machine90 min
   • state pattern implementation
   • coin insertion
   • inventory dispense
   • refund handling
3. Designing an Elevator system90 min
   • request scheduling
   • direction management
   • floor queuing
   • dispatch algorithms
4. Designing Tic-Tac-Toe and Snake & Ladder90 min
   • board representation
   • player turns
   • win condition checkers
   • dice rolling abstractions
5. Designing a Chess game90 min
   • piece move validation
   • check and checkmate rules
   • move history
   • board state management

Hands-on project: Build a multi-floor parking lot system supporting multiple vehicle types, payment calculators, and real-time slot allocation.

You can design concurrent booking and financial split systems like BookMyShow, Splitwise, and Uber.

1. Designing BookMyShow (movie ticket booking)90 min
   • shows and theaters
   • seat locking mechanisms
   • booking timeouts
   • payment integration
2. Designing Splitwise90 min
   • expense balancing
   • exact vs percentage splits
   • simplifying debts graph
   • user balance ledgers
3. Designing a Cab Booking system (Uber/Ola)90 min
   • driver matching
   • geospatial indexing
   • trip lifecycle management
   • surge pricing strategy
4. Designing a Food Delivery app90 min
   • restaurant catalogs
   • cart management
   • order dispatching
   • delivery partner assignment
5. Designing an Online Shopping Cart90 min
   • discount coupons
   • tax calculation
   • inventory reservation
   • checkout workflow

Hands-on project: Implement a movie ticket booking engine (BookMyShow) handling concurrent seat locks and pricing tiers.

You can design foundational infrastructure frameworks like loggers, rate limiters, and notification dispatchers.

1. Designing a Logging framework90 min
   • log levels
   • appenders
   • formatters
   • asynchronous queueing
2. Designing a Rate Limiter90 min
   • token bucket algorithm
   • sliding window counter
   • thread-safe token refill
   • client request filtering
3. Designing a Notification system90 min
   • multi-channel dispatch (SMS, Email, Push)
   • template rendering
   • retry queues
   • provider failover
4. Designing an ATM and a Library Management System90 min
   • cash dispensation logic
   • account validation
   • book lending rules
   • fine calculations
5. Concurrency considerations in design90 min
   • thread safety
   • locks vs atomic operations
   • deadlock prevention
   • concurrent collections

Hands-on project: Build a thread-safe pluggable logging framework supporting multi-level logging and asynchronous file appenders.

You can design a class that stays correct when several threads use it at once.

1. Why shared mutable state breaks90 min
   • Race conditions
   • Visibility and memory model
   • Atomicity vs volatility
2. Designing for immutability first90 min
   • Immutable value objects
   • Copy-on-write
   • Confining state
3. When you must lock90 min
   • Lock granularity
   • Deadlock by lock ordering
   • Read-write locks
4. Classic concurrent designs90 min
   • Producer-consumer queue
   • Thread pool and task submission
   • Double-checked locking

Hands-on project: Design and implement a thread-safe bounded in-memory cache with expiry: state guarded correctly, a documented locking strategy, and a test that fails reliably on the unsynchronised version.

You can take untestable code and introduce the seams that let it be tested.

1. What makes code untestable90 min
   • Hidden dependencies
   • Static and singleton coupling
   • Time and randomness
2. Dependency injection by hand90 min
   • Constructor injection
   • Interfaces at the boundary
   • Composition root
3. Test doubles used correctly90 min
   • Stub vs mock vs fake
   • Verifying interaction vs state
   • Over-mocking smell
4. Refactoring safely toward seams90 min
   • Extract interface
   • Sprout method
   • Characterisation tests first

Hands-on project: Refactor a supplied class that constructs its own dependencies and reads the clock directly so it can be tested: inject the collaborators and a clock, then write tests that pin behaviour without touching real time or I/O.

You can refactor messy codebases and ship a complete, production-grade LLD capstone system with full test coverage.

1. Clean code and meaningful naming90 min
   • intention-revealing names
   • small methods
   • comment minimization
   • formatting standards
2. Identifying and removing code smells90 min
   • long methods
   • large classes
   • primitive obsession
   • feature envy
3. Refactoring toward patterns90 min
   • replace conditional with polymorphism
   • extract class
   • introduce parameter object
   • safe refactoring steps
4. LLD versus HLD and how they fit together90 min
   • system boundary mapping
   • service-level interfaces
   • distributed object design
   • interview integration
5. Capstone Integration & Review90 min
   • end-to-end wiring
   • unit testing with JUnit 5
   • code review defense
   • portfolio preparation

Hands-on project: Build, test, and containerize a fully concurrent ride-sharing platform (Uber clone) incorporating 5+ design patterns and rigorous unit tests, pushed to GitHub.