Common LLD Patterns

Why Only 8 Patterns? (And Not All 23)

The original GoF book lists 23 patterns. If you tried to memorise all of them before an interview you'd burn out and remember none. The good news: most LLD interviews surface the same eight. The other fifteen exist — Bridge, Flyweight, Memento, Visitor, Mediator and friends — but if you reach for one of those in a 45-minute interview, the interviewer will ask "why?" and you'd better have a sharp answer because they're rarely the cleanest fit.

The eight on this page cover the four problem shapes that almost every LLD prompt reduces to:

The Cheat-Sheet — Pattern Smells in One Table

This is the table to keep open during practice. When you see the smell on the left, the pattern on the right is almost always the right reach. Skim it now; the rest of the page details each row.

① Strategy — Swap an Algorithm Without Touching Its Caller

interface PricingStrategy {
  double calculate(Duration stay, VehicleSize size);
}

class HourlyPricing implements PricingStrategy {
  private final double rate;
  HourlyPricing(double rate) { this.rate = rate; }
  public double calculate(Duration d, VehicleSize s) {
    return Math.ceil(d.toMinutes() / 60.0) * rate;
  }
}

// Adding weekend pricing = one new file. Zero edits to ParkingLot.
class WeekendPricing implements PricingStrategy { /* ... */ }

② Factory — Hide the "new" From the Caller

class SpotFactory {
  static Spot create(String id, VehicleSize size) {
    return switch (size) {
      case BIKE  -> new BikeSpot(id);
      case CAR   -> new CarSpot(id);
      case TRUCK -> new TruckSpot(id);
    };
  }
}

// Caller never sees the subclasses
Spot s = SpotFactory.create("S-42", VehicleSize.CAR);

③ Singleton — Exactly One, Globally Reachable

enum ParkingLot {
  INSTANCE;
  private final List<Floor> floors = new ArrayList<>();
  public Ticket park(Vehicle v) { /* ... */ }
}

// Usage
ParkingLot.INSTANCE.park(car);

class ParkingLot {
  private static ParkingLot instance;
  public static ParkingLot get() {
    if (instance == null)         // race!
      instance = new ParkingLot();
    return instance;
  }
}

④ Observer — One Publisher, Many Subscribers

interface SpotListener { void onSpotFreed(Spot s); }

abstract class Spot {
  private final List<SpotListener> listeners = new CopyOnWriteArrayList<>();
  public void subscribe(SpotListener l) { listeners.add(l); }
  public void vacate() {
    occupant.set(null);
    listeners.forEach(l -> l.onSpotFreed(this));   // fire-and-forget
  }
}

⑤ State — Behaviour Changes With the Lifecycle Stage

interface VendingState {
  void insertCoin(VendingMachine m, Coin c);
  void selectItem(VendingMachine m, String code);
}

class IdleState implements VendingState {
  public void insertCoin(VendingMachine m, Coin c) {
    m.addBalance(c);
    m.setState(new CoinInsertedState());     // state owns the transition
  }
  public void selectItem(VendingMachine m, String code) {
    throw new IllegalStateException("Insert coin first");
  }
}

class VendingMachine {
  private VendingState state = new IdleState();
  public void insertCoin(Coin c)        { state.insertCoin(this, c); }
  public void selectItem(String code)    { state.selectItem(this, code); }
  public void setState(VendingState s)   { this.state = s; }
}

⑥ Decorator — Stack Optional Features Around a Base

class PeakHourSurcharge implements PricingStrategy {
  private final PricingStrategy wrapped;
  PeakHourSurcharge(PricingStrategy w) { this.wrapped = w; }
  public double calculate(Duration d, VehicleSize s) {
    double base = wrapped.calculate(d, s);
    return isPeakHour() ? base * 1.30 : base;
  }
}

class WeekendDiscount implements PricingStrategy {
  private final PricingStrategy wrapped;
  WeekendDiscount(PricingStrategy w) { this.wrapped = w; }
  public double calculate(Duration d, VehicleSize s) {
    double base = wrapped.calculate(d, s);
    return isWeekend() ? base * 0.80 : base;
  }
}

// Compose at runtime — order matters
PricingStrategy p = new WeekendDiscount(
                       new PeakHourSurcharge(
                         new HourlyPricing(40.0)));

⑦ Builder — Object Construction When You Have More Than 3 Params

class Pizza {
  private final Size size;
  private final Crust crust;
  private final List<Topping> toppings;

  private Pizza(Builder b) {           // private — only Builder constructs
    this.size = b.size; this.crust = b.crust; this.toppings = List.copyOf(b.toppings);
  }

  public static class Builder {
    private Size size = Size.MEDIUM;
    private Crust crust = Crust.REGULAR;
    private final List<Topping> toppings = new ArrayList<>();

    public Builder size(Size s)            { this.size = s;  return this; }
    public Builder crust(Crust c)          { this.crust = c; return this; }
    public Builder addTopping(Topping t)   { toppings.add(t); return this; }

    public Pizza build() {
      if (toppings.size() > 8) throw new IllegalStateException("Max 8");
      return new Pizza(this);
    }
  }
}

Pizza p = new Pizza.Builder()
            .size(Size.LARGE).crust(Crust.THIN)
            .addTopping(Topping.MUSHROOM).addTopping(Topping.PEPPER)
            .build();

⑧ Command — Wrap an Action so You Can Queue, Log, or Undo It

interface Command { void execute(); void undo(); }

class InsertTextCommand implements Command {
  private final Document doc;
  private final int pos;
  private final String text;
  InsertTextCommand(Document d, int p, String t) { doc=d; pos=p; text=t; }
  public void execute() { doc.insert(pos, text); }
  public void undo()    { doc.delete(pos, text.length()); }
}

class Editor {
  private final Deque<Command> history = new ArrayDeque<>();
  public void run(Command c) { c.execute(); history.push(c); }
  public void undoLast()         { history.pop().undo(); }
}

Composing Patterns — How They Stack in Real Designs

The interview move that separates senior from mid-level isn't naming patterns in isolation — it's showing how two or three of them compose to solve one problem. Real designs always layer patterns. Here are three common stacks you'll see across the LLD case studies on this site.

Anti-patterns — Pattern Misuse That Loses Loops

Knowing patterns is half the skill; knowing when not to use them is the other half. Here are the four patterns-mistakes interviewers actively flag.