Question 1

How do you structure a 45-Minute Low-Level Design (LLD) Interview step-by-step?

Accepted Answer

A structured 6-step framework to crack LLD / Object-Oriented Design interviews:

1. Clarify Requirements (5-7 mins):
- Identify Functional Requirements (e.g. Parking Lot: park vehicle, unpark vehicle, calculate fee) and Non-Functional Requirements (e.g. thread-safety, extensibility).
- Define scope boundaries (What to include vs exclude).

2. Identify Core Domain Entities & Enums (5 mins):
- Identify Nouns in requirement statements (e.g. Vehicle, Spot, Ticket, Payment, ParkingFloor).
- Define Enums for fixed states (VehicleType: CAR, BIKE, TRUCK; SpotType: COMPACT, LARGE, ELECTRIC; TicketStatus: ACTIVE, PAID).

3. Define Class Diagrams & UML Relationships (8-10 mins):
- Establish relationships: Inheritance (Is-A), Composition (Has-A strict life cycle), Aggregation (Has-A weak relationship), Association (Uses-A).

4. Apply Appropriate Design Patterns (5 mins):
- Identify extension points (e.g. Pricing Strategy -> Strategy Pattern; Vehicle Creation -> Factory Pattern; State transitions -> State Pattern).

5. Write Clean Object-Oriented Code (15 mins):
- Use Interfaces, Abstract Classes, Dependency Injection, and Encapsulation. Follow SOLID principles.

6. Address Concurrency & Edge Cases (5 mins):
- Handle thread-safety for shared mutable state (e.g. double booking, spot allocation race conditions using Mutex/Locks or Atomic operations).
Code Example:
/* Standard LLD Class Architecture Template
Domain Models -> Enums -> Strategy Interfaces -> Service Controllers -> Repository/Store */

// 1. Enum Definition
const VehicleType = Object.freeze({
  CAR: 'CAR',
  BIKE: 'BIKE',
  TRUCK: 'TRUCK'
});

// 2. Base Entity (Abstraction)
class Vehicle {
  constructor(licensePlate, type) {
    this.licensePlate = licensePlate;
    this.type = type;
  }
}

// 3. Subclass (Inheritance)
class Car extends Vehicle {
  constructor(licensePlate) {
    super(licensePlate, VehicleType.CAR);
  }
}

Question 2

Explain UML Class Diagram Relationships: Association, Aggregation, Composition, and Generalization.

Accepted Answer

UML Class Diagram relationships describe how classes interact:

1. Association (Uses-A):
- A loose relationship between two independent classes where one object uses the services of another (e.g. `Driver` uses `Car`). Both can exist independently.

2. Aggregation (Has-A Weak):
- A whole-part relationship where the child can exist independently of the parent container (e.g. `Department` has `Professors`. If `Department` is deleted, `Professors` still exist).

3. Composition (Has-A Strict):
- A strong whole-part relationship where the child CANNOT exist without the parent container. The child's lifecycle is bound to the parent (e.g. `House` has `Rooms`. If `House` is destroyed, `Rooms` cease to exist).

4. Generalization (Is-A / Inheritance):
- A subclass inherits attributes and methods from a superclass (e.g. `Dog` extends `Animal`).

5. Realization (Implements):
- A concrete class implements the contract defined by an interface.
Code Example:
/* UML Relationships Code Representation

1. Composition (Strict Ownership) */
class House {
  constructor() {
    this.rooms = [new Room('Living Room'), new Room('Bedroom')]; // Created inside House
  }
}

/* 2. Aggregation (Weak Ownership) */
class Department {
  constructor(professors = []) {
    this.professors = professors; // Injected from outside
  }
}

/* 3. Association (Uses-A) */
class Driver {
  drive(car) {
    car.startEngine(); // Uses car transiently
  }
}

Question 3

Design a Parking Lot System (Object-Oriented Design).

Accepted Answer

Design Requirements:
- Multi-floor parking lot supporting Vehicle Types: Bike, Car, Truck.
- Spot Types: Small, Medium, Large, EV Spot.
- Features: Issue Parking Ticket upon entry, Assign nearest available spot, Calculate parking fee dynamically upon exit (Hourly vs Flat pricing), Process Payment.
- Design Patterns Used: Strategy Pattern (PricingStrategy, SpotAssignmentStrategy), Factory Pattern (VehicleFactory).
Code Example:
// Enums
const VehicleType = { BIKE: 'BIKE', CAR: 'CAR', TRUCK: 'TRUCK' };
const SpotType = { SMALL: 'SMALL', MEDIUM: 'MEDIUM', LARGE: 'LARGE' };

// Entities
class ParkingSpot {
  constructor(id, type, floor) {
    this.id = id;
    this.type = type;
    this.floor = floor;
    this.isOccupied = false;
    this.vehicle = null;
  }

assignVehicle(vehicle) {
    this.vehicle = vehicle;
    this.isOccupied = true;
  }

removeVehicle() {
    this.vehicle = null;
    this.isOccupied = false;
  }
}

class Ticket {
  constructor(id, vehicle, spot) {
    this.id = id;
    this.vehicle = vehicle;
    this.spot = spot;
    this.entryTime = new Date();
    this.exitTime = null;
    this.fee = 0;
  }
}

// Strategy Pattern for Pricing
class PricingStrategy {
  calculateFee(ticket) {
    const hours = Math.ceil((new Date() - ticket.entryTime) / (1000 * 60 * 60));
    const rates = { BIKE: 10, CAR: 20, TRUCK: 50 };
    return hours * (rates[ticket.vehicle.type] || 20);
  }
}

// Main Parking Lot Manager
class ParkingLot {
  constructor(name, pricingStrategy) {
    this.name = name;
    this.spots = [];
    this.tickets = new Map();
    this.pricingStrategy = pricingStrategy;
  }

addSpot(spot) { this.spots.push(spot); }

parkVehicle(vehicle) {
    const spot = this.spots.find(s => !s.isOccupied && this._isCompatible(vehicle.type, s.type));
    if (!spot) throw new Error("No available spot for vehicle type: " + vehicle.type);

spot.assignVehicle(vehicle);
    const ticket = new Ticket("TICK-" + Date.now(), vehicle, spot);
    this.tickets.set(ticket.id, ticket);
    return ticket;
  }

unparkVehicle(ticketId) {
    const ticket = this.tickets.get(ticketId);
    if (!ticket) throw new Error("Invalid Ticket ID");

ticket.exitTime = new Date();
    ticket.fee = this.pricingStrategy.calculateFee(ticket);
    ticket.spot.removeVehicle();
    return ticket;
  }

_isCompatible(vType, sType) {
    if (vType === VehicleType.BIKE) return true;
    if (vType === VehicleType.CAR) return sType === SpotType.MEDIUM || sType === SpotType.LARGE;
    if (vType === VehicleType.TRUCK) return sType === SpotType.LARGE;
    return false;
  }
}

Question 4

Design an Elevator Control System (State & Strategy Patterns).

Accepted Answer

Design Requirements: - Multi-elevator system servicing requests across N floors. - Elevator States: IDLE, MOVING_UP, MOVING_DOWN. - Requests: Internal Buttons (inside elevator car) & External Hall Buttons (Up/Down arrows on floor). - Dispatcher Strategy: Optimal assignment using SCAN / LOOK algorithm (minimizing total wait time & direction changes). - Design Patterns Used: State Pattern (Elevator State), Strategy Pattern (ElevatorDispatcher). Code Example: const Direction = { UP: 'UP', DOWN: 'DOWN', IDLE: 'IDLE' }; class ElevatorCar { constructor(id, totalFloors) { this.id = id; this.currentFloor = 0; this.direction = Direction.IDLE; this.upRequests = new Set(); // Min-Heap / Sorted Set concept this.downRequests = new Set(); // Max-Heap / Sorted Set concept } addRequest(floor) { if (floor > this.currentFloor) { this.upRequests.add(floor); if (this.direction === Direction.IDLE) this.direction = Direction.UP; } else if (floor < this.currentFloor) { this.downRequests.add(floor); if (this.direction === Direction.IDLE) this.direction = Direction.DOWN; } } step() { if (this.direction === Direction.UP) { this.currentFloor++; if (this.upRequests.has(this.currentFloor)) { this.upRequests.delete(this.currentFloor); console.log(`Elevator ${this.id} stopped at Floor ${this.currentFloor}`); } if (this.upRequests.size === 0) { this.direction = this.downRequests.size > 0 ? Direction.DOWN : Direction.IDLE; } } else if (this.direction === Direction.DOWN) { this.currentFloor--; if (this.downRequests.has(this.currentFloor)) { this.downRequests.delete(this.currentFloor); console.log(`Elevator ${this.id} stopped at Floor ${this.currentFloor}`); } if (this.downRequests.size === 0) { this.direction = this.upRequests.size > 0 ? Direction.UP : Direction.IDLE; } } } } // Dispatcher Strategy class ElevatorController { constructor(elevators) { this.elevators = elevators; } requestElevator(floor, direction) { // Select elevator closest moving in same direction, or idle let bestElevator = this.elevators[0]; let minDistance = Infinity; for (let elevator of this.elevators) { let distance = Math.abs(elevator.currentFloor - floor); if (distance < minDistance) { minDistance = distance; bestElevator = elevator; } } bestElevator.addRequest(floor); return bestElevator.id; } }

Question 5

Design a Rate Limiter (Token Bucket Algorithm with Thread-Safety).

Accepted Answer

Design Requirements:
- Limit API client requests (e.g. max 10 requests per second per IP).
- Algorithms: Token Bucket (allows bursts), Leaky Bucket (smooth output rate), Fixed Window Counter, Sliding Window Log.
- Thread-Safety: Handles concurrent requests safely without race conditions.

Token Bucket Mechanism:
1. Bucket has a maximum `capacity` and is refilled at a constant `refillRate` (tokens per second).
2. When a request arrives, if tokens >= 1, consume 1 token and allow request (`return true`).
3. If tokens < 1, reject request (`return false`).
4. Refill calculation: `newTokens = (currentTime - lastRefillTime) * refillRate`.
Code Example:
class TokenBucketRateLimiter {
  constructor(capacity, refillRate) {
    this.capacity = capacity;       // Max tokens bucket can hold
    this.refillRate = refillRate;   // Tokens per millisecond
    this.tokens = capacity;
    this.lastRefillTime = Date.now();
  }

allowRequest(tokensRequested = 1) {
    this._refill();

if (this.tokens >= tokensRequested) {
      this.tokens -= tokensRequested;
      return true;  // Request Allowed
    }
    return false; // Rate Limit Exceeded (HTTP 429)
  }

_refill() {
    const now = Date.now();
    const elapsedTime = now - this.lastRefillTime;
    const tokensToAdd = elapsedTime * this.refillRate;

this.tokens = Math.min(this.capacity, this.tokens + tokensToAdd);
    this.lastRefillTime = now;
  }
}

Question 6

Design a Vending Machine using the State Pattern.

Accepted Answer

Design Requirements:
- Vending Machine dispenses items (Snacks, Drinks) based on coin/cash insertion.
- States: IdleState (Waiting for money), HasMoneyState (Money inserted, select item), DispensingState (Dispensing item & change), SoldOutState.
- State Pattern Benefit: Eliminates messy nested `if-else` or `switch-case` statements by encapsulating state-specific behavior into dedicated State classes.
Code Example:
// State Interface
class VendingMachineState {
  insertCoin(machine, amount) {}
  selectItem(machine, code) {}
  dispense(machine) {}
}

class IdleState extends VendingMachineState {
  insertCoin(machine, amount) {
    machine.balance += amount;
    console.log(`Inserted $${amount}. Total Balance: $${machine.balance}`);
    machine.setState(machine.hasMoneyState);
  }
}

class HasMoneyState extends VendingMachineState {
  selectItem(machine, code) {
    const item = machine.inventory.get(code);
    if (!item || item.quantity === 0) {
      console.log("Item out of stock!");
      return;
    }
    if (machine.balance < item.price) {
      console.log(`Insufficient balance. Item costs $${item.price}`);
      return;
    }
    machine.selectedItemCode = code;
    machine.setState(machine.dispensingState);
    machine.dispense();
  }
}

class DispensingState extends VendingMachineState {
  dispense(machine) {
    const item = machine.inventory.get(machine.selectedItemCode);
    item.quantity--;
    machine.balance -= item.price;
    console.log(`Dispensed ${item.name}. Remaining change returned: $${machine.balance}`);
    machine.balance = 0;
    machine.selectedItemCode = null;
    machine.setState(machine.idleState);
  }
}

class VendingMachine {
  constructor() {
    this.idleState = new IdleState();
    this.hasMoneyState = new HasMoneyState();
    this.dispensingState = new DispensingState();
    this.currentState = this.idleState;
    this.balance = 0;
    this.inventory = new Map();
  }

setState(state) { this.currentState = state; }
  insertCoin(amount) { this.currentState.insertCoin(this, amount); }
  selectItem(code) { this.currentState.selectItem(this, code); }
  dispense() { this.currentState.dispense(this); }
}

Question 7

Design Tic-Tac-Toe Game with O(1) Move Validation.

Accepted Answer

Design Requirements:
- 2-Player turn-based Tic-Tac-Toe game on an N x N board.
- Move Validation: Check if move is valid (within bounds, cell empty).
- Efficient Win Condition Checker: Instead of scanning entire rows/cols/diagonals in O(N) per move, maintain row & col sum counters to detect win in O(1) time!
  - Player 1 (X) adds +1.
  - Player 2 (O) adds -1.
  - If any row/col sum reaches +N or -N, Player 1 or 2 wins!
Code Example:
class TicTacToe {
  constructor(n = 3) {
    this.n = n;
    this.rows = new Array(n).fill(0);
    this.cols = new Array(n).fill(0);
    this.diag = 0;
    this.antiDiag = 0;
    this.board = Array(n).fill(0).map(() => Array(n).fill(0));
  }

// Make Move - Returns 1 if Player 1 wins, 2 if Player 2 wins, 0 if game continues
  makeMove(row, col, player) {
    if (this.board[row][col] !== 0) throw new Error("Cell already occupied!");

this.board[row][col] = player;
    const value = player === 1 ? 1 : -1;

this.rows[row] += value;
    this.cols[col] += value;
    if (row === col) this.diag += value;
    if (row + col === this.n - 1) this.antiDiag += value;

// O(1) Win Check!
    if (
      Math.abs(this.rows[row]) === this.n ||
      Math.abs(this.cols[col]) === this.n ||
      Math.abs(this.diag) === this.n ||
      Math.abs(this.antiDiag) === this.n
    ) {
      return player; // Winner!
    }

return 0; // Game continues
  }
}

Question 8

Design BookMyShow (Movie Ticket Booking System with Temporary Seat Locking).

Accepted Answer

Design Requirements:
- Users search for Movies, Cities, Theaters, and Showtimes.
- Seat Selection: Users select seats (VIP, Regular).
- Temporary Seat Locking: When a user selects seats, lock them for 10 minutes (TTL) during payment checkout to prevent Double Booking.
- Payment Processing & Ticket Confirmation: If payment succeeds, convert lock to BOOKED. If payment fails or timeout expires, release lock back to AVAILABLE.
- Design Patterns Used: Strategy Pattern (SeatPricingStrategy), Adapter Pattern (PaymentGateway), Observer Pattern (Booking Notification).
Code Example:
const SeatStatus = { AVAILABLE: 'AVAILABLE', LOCKED: 'LOCKED', BOOKED: 'BOOKED' };

class Seat {
  constructor(id, row, number, price) {
    this.id = id;
    this.row = row;
    this.number = number;
    this.price = price;
    this.status = SeatStatus.AVAILABLE;
    this.lockedUntil = null;
    this.lockedBy = null;
  }

lock(userId, timeoutMinutes = 10) {
    if (this.status === SeatStatus.BOOKED) return false;
    if (this.status === SeatStatus.LOCKED && new Date() < this.lockedUntil) return false;

this.status = SeatStatus.LOCKED;
    this.lockedBy = userId;
    this.lockedUntil = new Date(Date.now() + timeoutMinutes * 60 * 1000);
    return true;
  }

confirmBooking() {
    if (this.status === SeatStatus.LOCKED) {
      this.status = SeatStatus.BOOKED;
      this.lockedUntil = null;
    }
  }

releaseLock() {
    this.status = SeatStatus.AVAILABLE;
    this.lockedBy = null;
    this.lockedUntil = null;
  }
}

Question 9

Design an E-Commerce Shopping Cart & Checkout System (Strategy Pattern for Discounts).

Accepted Answer

Design Requirements:
- Cart manages Products and Quantities.
- Dynamic Discount Coupon System: Support Flat Discount ($10 off), Percentage Discount (20% off), Buy-1-Get-1-Free, and Tiered Discounts.
- Payment Integration: Support PayPal, Stripe, Credit Card via Payment Adapter.
- Design Pattern Used: Strategy Pattern for DiscountCalculation and PaymentProcessing.
Code Example:
// Strategy Pattern for Discount Coupons
class DiscountStrategy {
  applyDiscount(totalAmount) { return totalAmount; }
}

class PercentageDiscount extends DiscountStrategy {
  constructor(percent) { super(); this.percent = percent; }
  applyDiscount(totalAmount) {
    return totalAmount - (totalAmount * (this.percent / 100));
  }
}

class FlatDiscount extends DiscountStrategy {
  constructor(discountAmount) { super(); this.discountAmount = discountAmount; }
  applyDiscount(totalAmount) {
    return Math.max(0, totalAmount - this.discountAmount);
  }
}

// Shopping Cart Context
class ShoppingCart {
  constructor() {
    this.items = [];
    this.discountStrategy = new DiscountStrategy(); // Default no discount
  }

addItem(product, quantity = 1) {
    this.items.push({ product, quantity });
  }

setDiscountStrategy(strategy) {
    this.discountStrategy = strategy;
  }

calculateSubtotal() {
    return this.items.reduce((sum, item) => sum + (item.product.price * item.quantity), 0);
  }

calculateFinalTotal() {
    const subtotal = this.calculateSubtotal();
    return this.discountStrategy.applyDiscount(subtotal);
  }
}

Question 10

Design a Multi-Channel Notification Service (Factory & Observer Patterns).

Accepted Answer

Design Requirements:
- Support sending notifications via Email, SMS, Push Notification, and Slack.
- Decouple notification triggers from channel transport logic.
- Support priority queues and retry mechanisms for failed deliveries.
- Design Patterns Used: Factory Pattern (Channel Creation), Observer Pattern (Event Notification Trigger).
Code Example:
// Channel Abstraction
class NotificationSender {
  send(user, message) {}
}

class EmailSender extends NotificationSender {
  send(user, message) { console.log(`[EMAIL] To ${user.email}: ${message}`); }
}

class SMSSender extends NotificationSender {
  send(user, message) { console.log(`[SMS] To ${user.phone}: ${message}`); }
}

// Factory Pattern
class NotificationFactory {
  static getSender(channel) {
    switch (channel) {
      case 'EMAIL': return new EmailSender();
      case 'SMS': return new SMSSender();
      default: throw new Error('Unsupported channel');
    }
  }
}

// Observer Pattern Notification Service
class NotificationService {
  constructor() {
    this.subscribers = new Map(); // Event -> Array of channels
  }

subscribe(event, channels) {
    this.subscribers.set(event, channels);
  }

notify(event, user, message) {
    const channels = this.subscribers.get(event) || ['EMAIL'];
    for (let channel of channels) {
      const sender = NotificationFactory.getSender(channel);
      sender.send(user, message);
    }
  }
}

Question 11

Design a Logger Framework (Chain of Responsibility Pattern).

Accepted Answer

Design Requirements:
- Support Log Levels: INFO (1), DEBUG (2), ERROR (3).
- Multiple Output Destinations (Appenders): Console, File, Database.
- Chain of Responsibility Pattern: Each logger level processes its own logs and passes requests down the chain to higher level handlers.
Code Example:
const LogLevel = { INFO: 1, DEBUG: 2, ERROR: 3 };

class AbstractLogger {
  constructor(level) {
    this.level = level;
    this.nextLogger = null;
  }

setNextLogger(nextLogger) {
    this.nextLogger = nextLogger;
    return nextLogger;
  }

logMessage(level, message) {
    if (this.level <= level) {
      this.write(message);
    }
    if (this.nextLogger !== null) {
      this.nextLogger.logMessage(level, message);
    }
  }

write(message) {}
}

class InfoLogger extends AbstractLogger {
  constructor() { super(LogLevel.INFO); }
  write(message) { console.log(`[INFO]: ${message}`); }
}

class DebugLogger extends AbstractLogger {
  constructor() { super(LogLevel.DEBUG); }
  write(message) { console.log(`[DEBUG]: ${message}`); }
}

class ErrorLogger extends AbstractLogger {
  constructor() { super(LogLevel.ERROR); }
  write(message) { console.error(`[ERROR]: ${message}`); }
}

// Chain Construction
const errorLogger = new ErrorLogger();
const debugLogger = new DebugLogger();
const infoLogger = new InfoLogger();

infoLogger.setNextLogger(debugLogger).setNextLogger(errorLogger);

// Usage: Logging message triggers appropriate level in chain
infoLogger.logMessage(LogLevel.ERROR, "Database connection lost!");

Question 12

Design an In-Memory File System (Composite Pattern for Files and Directories).

Accepted Answer

Design Requirements:
- Represent Files and Directories in a hierarchical tree structure.
- Operations: `mkdir(path)`, `addFileContent(path, content)`, `readContent(path)`, `ls(path)`.
- Composite Design Pattern: Treat individual File objects and Directory containers uniformly through a common Component interface.
Code Example:
class FileSystemNode {
  constructor(name, isDirectory = false) {
    this.name = name;
    this.isDirectory = isDirectory;
    this.content = "";
    this.children = new Map(); // Name -> FileSystemNode
  }
}

class InMemoryFileSystem {
  constructor() {
    this.root = new FileSystemNode("/", true);
  }

_traverse(path) {
    const parts = path.split("/").filter(Boolean);
    let curr = this.root;
    for (let part of parts) {
      if (!curr.children.has(part)) return null;
      curr = curr.children.get(part);
    }
    return curr;
  }

mkdir(path) {
    const parts = path.split("/").filter(Boolean);
    let curr = this.root;
    for (let part of parts) {
      if (!curr.children.has(part)) {
        curr.children.set(part, new FileSystemNode(part, true));
      }
      curr = curr.children.get(part);
    }
  }

addFileContent(filePath, content) {
    const parts = filePath.split("/").filter(Boolean);
    const fileName = parts.pop();
    const dirPath = "/" + parts.join("/");
    this.mkdir(dirPath);

const dirNode = this._traverse(dirPath);
    if (!dirNode.children.has(fileName)) {
      dirNode.children.set(fileName, new FileSystemNode(fileName, false));
    }
    const fileNode = dirNode.children.get(fileName);
    fileNode.content += content;
  }

readContent(filePath) {
    const node = this._traverse(filePath);
    return node ? node.content : "";
  }
}

Low-Level Design (LLD) Interview Questions

Difficulty Filters

Tools & Options

How do you structure a 45-Minute Low-Level Design (LLD) Interview step-by-step?

Explain UML Class Diagram Relationships: Association, Aggregation, Composition, and Generalization.

Design a Parking Lot System (Object-Oriented Design).

Design an Elevator Control System (State & Strategy Patterns).

Design a Rate Limiter (Token Bucket Algorithm with Thread-Safety).

Design a Vending Machine using the State Pattern.

Design Tic-Tac-Toe Game with O(1) Move Validation.

Design BookMyShow (Movie Ticket Booking System with Temporary Seat Locking).

Design an E-Commerce Shopping Cart & Checkout System (Strategy Pattern for Discounts).

Design a Multi-Channel Notification Service (Factory & Observer Patterns).

Design a Logger Framework (Chain of Responsibility Pattern).

Design an In-Memory File System (Composite Pattern for Files and Directories).

Technical Interview Mastery Blueprint

1. The Engineering STAR Technique

2. Defending Architectural Trade-Offs

3. Clean Code & Edge-Case Proactivity

4. Antipatterns to Avoid

Explore Related Tools

Angular Interview Questions

Aws Interview Questions

Bootstrap Interview Questions

Dsa Interview Questions

Golang Interview Questions

Nextjs Interview Questions

Follow Us

Our Tools

Our Company

Special Tools