Design a coffee machine - Low-Level Design Guide

Overview

Design a coffee machine that makes beverages (espresso, latte, cappuccino) from ingredients (water, milk, coffee beans, sugar) with optional add-ons (extra shot, syrup, oat milk). Requirements: show available beverages based on ingredient levels, compute price including add-ons, check and deduct ingredients atomically, brew following a sequence of steps, and alert when ingredients are low.

The design highlights Decorator (or a list of add-ons) for customizations and pricing, Builder for orders, a Recipe (ingredient quantities) per beverage, Template Method for the brewing process (grind, brew, add milk, dispense), and Observer for low-ingredient alerts. The machine itself can be a small state machine (ready, brewing, needs refill).

A barista with a recipe book

The barista checks the recipe (18 g beans, 150 ml milk), confirms there is enough in stock, prepares the drink in the usual order, and adds your extras. When the milk is nearly gone, they tell the manager.

When to use it

Common LLD question for Decorator and Builder.
Practicing inventory checks and recipes.
Extensible menus with add-ons.

Where it shows up in interviews

Customizable products

Recognize it when: base item plus combinable add-ons.

Design a coffee machine
Design a pizza ordering system
Design a burger builder

Resource-constrained production

Recognize it when: recipes consume limited stock.

Design a coffee machine
Design a restaurant kitchen

Where it is used in real software

Starbucks ordering

Base drinks with modifiers (sizes, shots, syrups, milk types) priced per add-on.

Smart coffee machines

Machines track bean, water, and milk levels and alert when refills are needed.

Point-of-sale modifiers

Restaurant POS systems model menu items with modifier groups.

Key terms

Recipe: Ingredient quantities for a beverage.
Add-on: Extra that changes price and ingredients.
Ingredient store: Current stock with atomic reserve/consume.
Low-stock threshold: Level that triggers alerts.

How it works, step by step

1
Clarify
Beverages, add-ons, payment, concurrency (single dispenser?), alerts.
2
Entities
Ingredient, Recipe, Beverage, AddOn, Order, IngredientStore, CoffeeMachine.
3
Order building
Beverage + add-ons -> total recipe and price.
4
Check and consume atomically
All ingredients or none.
5
Brew and alert
Template steps; notify observers on low stock.

Latte with extra shot and vanilla

Latte: 18 g coffee, 30 ml water, 150 ml milk, price 3.50

Component	Coffee (g)	Milk (ml)	Syrup (ml)	Price
Latte	18	150	0	3.50
+ extra shot	+9	0	0	+0.80
+ vanilla	0	0	+15	+0.60
Total	27	150	15	4.90

NOWComponent: Latte | Coffee (g): 18 | Milk (ml): 150 | Syrup (ml): 0 | Price: 3.50

Add-ons combine both price and ingredient requirements; the store checks the total before brewing.

Implementation

1type Ingredient = "coffee" | "water" | "milk" | "syrup" | "sugar";2type Recipe = Partial<Record<Ingredient, number>>;3 4interface Drink { name(): string; price(): number; recipe(): Recipe }5 6const base = (name: string, price: number, recipe: Recipe): Drink => ({ name: () => name, price: () => price, recipe: () => recipe });7const menu = {8  espresso: base("Espresso", 250, { coffee: 18, water: 30 }),9  latte: base("Latte", 350, { coffee: 18, water: 30, milk: 150 }),10  cappuccino: base("Cappuccino", 330, { coffee: 18, water: 30, milk: 100 }),11};12 13// Decorator: add-ons wrap drinks and add price and ingredients14const merge = (a: Recipe, b: Recipe): Recipe => {15  const out: Recipe = { ...a };16  for (const [k, v] of Object.entries(b) as [Ingredient, number][]) out[k] = (out[k] ?? 0) + v;17  return out;18};19const addOn = (label: string, price: number, extra: Recipe) => (d: Drink): Drink => ({20  name: () => `${d.name()} + ${label}`,21  price: () => d.price() + price,22  recipe: () => merge(d.recipe(), extra),23});24const extraShot = addOn("extra shot", 80, { coffee: 9, water: 15 });25const vanilla = addOn("vanilla", 60, { syrup: 15 });26 27class IngredientStore {28  constructor(private stock: Record<Ingredient, number>, private lowAt: Record<Ingredient, number>, private onLow: (i: Ingredient, left: number) => void) {}29  canMake(r: Recipe) { return (Object.entries(r) as [Ingredient, number][]).every(([k, v]) => this.stock[k] >= v); }30  consume(r: Recipe) {31    if (!this.canMake(r)) throw new Error("Insufficient ingredients");32    for (const [k, v] of Object.entries(r) as [Ingredient, number][]) {33      this.stock[k] -= v;34      if (this.stock[k] <= this.lowAt[k]) this.onLow(k, this.stock[k]); // observer35    }36  }37}38 39class CoffeeMachine {40  private busy = false;41  constructor(private store: IngredientStore) {}42  available() { return Object.values(menu).filter((d) => this.store.canMake(d.recipe())).map((d) => d.name()); }43  brew(drink: Drink) {44    if (this.busy) throw new Error("Machine busy");45    this.busy = true;46    try {47      this.store.consume(drink.recipe());                       // atomic check + consume48      return [`grind`, `brew ${drink.name()}`, `dispense`].join(" -> ");49    } finally { this.busy = false; }50  }51}52 53const machine = new CoffeeMachine(new IngredientStore(54  { coffee: 500, water: 2000, milk: 1000, syrup: 200, sugar: 300 },55  { coffee: 50, water: 200, milk: 150, syrup: 30, sugar: 30 },56  (i, left) => console.log(`Low ${i}: ${left}`),57));58const order = vanilla(extraShot(menu.latte));59order.price(); // 49060machine.brew(order);

Complexity and performance

Price / recipeO(add-ons)

Decorator chain.

ConsumeO(ingredients)

Atomic under lock.

Trade-offs

Decorator vs list of add-ons

Decorators are elegant for arbitrary stacking; a simple list of AddOn objects on an Order is easier to serialize and display.

Hard-coded menu vs configuration

Recipes and prices in config let operators change the menu without code changes.

Variants and related techniques

Sizes

Size multipliers on recipes and prices.

Multiple dispensers

Concurrent brewing with shared ingredient store locks.

Common mistakes

Checking ingredients then consuming separately without locking.
Fix: Check and consume atomically.
A subclass per drink and add-on combination.
Fix: Use decorators or add-on lists.

Interview questions

How would you add a new add-on like oat milk?

Create one new decorator (or AddOn entry) that replaces milk with oat milk in the recipe and adjusts price; no changes to existing drinks or the machine.

How do you prevent brewing with insufficient ingredients?

Compute the full recipe including add-ons, check and deduct all ingredients in one synchronized operation, and fail before brewing if any is short.

Practice problems

Problem	Difficulty	What it trains
Coffee machine with add-ons and low-stock alerts	Medium	Decorator + Observer.
Support sizes and multiple dispensers	Hard	Concurrency.