Platform ScaleProblem 15 of 29

Platform ScaleAdvanced

Food Delivery (Swiggy)

Strategy PatternObserver PatternState Pattern

Order lifecycle via state machine, delivery agent assignment via strategy pattern, and real-time tracking via observer. A three-sided marketplace where coordination timing is everything.

Key Abstractions

DeliveryPlatform

Orchestrator that coordinates restaurants, customers, agents, and order lifecycle

Restaurant

Menu provider that confirms or rejects incoming orders

Customer

Orderer who places orders and receives delivery status updates

DeliveryAgent

Driver with location and current load who picks up and delivers orders

Order

Core entity with state machine: PLACED -> CONFIRMED -> PREPARING -> OUT_FOR_DELIVERY -> DELIVERED

MenuItem

Individual food item with name, price, and availability flag

AssignmentStrategy

Algorithm for picking a delivery agent: nearest, load-balanced, or rating-based

Class Diagram

The Key Insight

Food delivery looks like ride-sharing with an extra participant. It is not. The critical difference is the three-sided coordination problem. In ride-sharing, you match two parties and go. In food delivery, you have a customer, a restaurant, and a delivery agent, and they all operate on different timelines. The customer wants speed. The restaurant needs preparation time. The agent needs to be assigned at the right moment, not too early and not too late.

If you assign the agent when the order is placed, that agent sits idle for 20 minutes while the kitchen works. If you assign too late, the food gets cold waiting for pickup. The state machine is what makes this coordination possible. Each transition represents a real-world handoff between participants, and the system enforces that handoffs happen in order.

Requirements

Functional

Customer places an order from a restaurant's menu with item quantities
Restaurant confirms or rejects the order
Order progresses through states: placed, confirmed, preparing, out for delivery, delivered
Delivery agent assigned when food is ready for pickup
Agent assignment uses a configurable strategy (nearest, load-balanced)
Customer and restaurant receive status updates at each transition
Orders can be cancelled before dispatch

Non-Functional

Thread-safe agent assignment to prevent double-booking
Assignment strategy swappable at runtime for peak vs off-peak hours
State machine enforces valid transitions only
Agent capacity tracked to prevent overloading a single agent

Design Decisions

Why does the order go through CONFIRMED before PREPARING?

This is the restaurant acceptance gate. Without it, you charge the customer and then discover the restaurant is closed or out of a key ingredient. The CONFIRMED state means the restaurant has explicitly accepted the order. If they reject it, the order goes to CANCELLED with a refund. Skipping this step is how you get angry customers who paid for food that never gets made.

Why is agent assignment a strategy, not hardcoded logic?

During lunch rush, you want load balancing so no single agent gets buried with five orders while others sit idle. During off-peak hours, nearest-agent minimizes delivery time. Different cities might have different traffic patterns requiring different algorithms entirely. Strategy lets you configure this per-market without touching order logic.

Why track agent load instead of just available/unavailable?

A binary available flag means an agent can only handle one order at a time. In reality, agents batch deliveries. An agent heading to Koramangala can pick up two orders from nearby restaurants heading the same direction. The load counter with a max allows this. The LoadBalancedStrategy then spreads orders evenly across agents who still have capacity.

Why is Order the state machine owner, not DeliveryPlatform?

The platform orchestrates but should not own transition logic. If the platform validates transitions, you need to duplicate that validation everywhere an order status could change. Putting the state machine inside Order means the rules follow the entity. No matter who calls confirm() or dispatch(), the same transition rules apply.

Interview Follow-ups

"How would you handle order modifications after placement?" Allow modifications only in PLACED state. Once CONFIRMED, the restaurant has started planning. Add a modifyItems() method on Order that checks the current status before allowing changes.
"How would you implement real-time tracking?" The observer pattern is already in place. Add a LocationUpdateObserver that receives agent GPS coordinates. The customer-facing app subscribes to updates for their specific order.
"How would you handle restaurant prep time estimates?" Add a prepTimeMinutes field to the CONFIRMED state. The dispatch timer waits until confirmTime + prepTime before calling the assignment strategy. This prevents early agent assignment.
"How would you add ratings and reviews?" After DELIVERED, prompt the customer to rate both the restaurant and the agent. Store ratings as a rolling average. The assignment strategy can factor in agent ratings for premium customers.

Code Implementation

from __future__ import annotations
from abc import ABC, abstractmethod
from enum import Enum
from dataclasses import dataclass, field
from typing import Protocol
from threading import Lock
import uuid
import math


class OrderStatus(Enum):
    PLACED = "placed"
    CONFIRMED = "confirmed"
    PREPARING = "preparing"
    OUT_FOR_DELIVERY = "out_for_delivery"
    DELIVERED = "delivered"
    CANCELLED = "cancelled"


VALID_TRANSITIONS: dict[OrderStatus, set[OrderStatus]] = {
    OrderStatus.PLACED: {OrderStatus.CONFIRMED, OrderStatus.CANCELLED},
    OrderStatus.CONFIRMED: {OrderStatus.PREPARING, OrderStatus.CANCELLED},
    OrderStatus.PREPARING: {OrderStatus.OUT_FOR_DELIVERY, OrderStatus.CANCELLED},
    OrderStatus.OUT_FOR_DELIVERY: {OrderStatus.DELIVERED},
    OrderStatus.DELIVERED: set(),
    OrderStatus.CANCELLED: set(),
}


@dataclass
class Location:
    lat: float
    lng: float

    def distance_to(self, other: "Location") -> float:
        """Haversine distance in km."""
        R = 6371
        lat1, lat2 = math.radians(self.lat), math.radians(other.lat)
        dlat = math.radians(other.lat - self.lat)
        dlng = math.radians(other.lng - self.lng)
        a = (math.sin(dlat / 2) ** 2
             + math.cos(lat1) * math.cos(lat2) * math.sin(dlng / 2) ** 2)
        return R * 2 * math.atan2(math.sqrt(a), math.sqrt(1 - a))


@dataclass
class MenuItem:
    name: str
    price: float
    available: bool = True


@dataclass
class OrderItem:
    menu_item: MenuItem
    quantity: int

    @property
    def subtotal(self) -> float:
        return self.menu_item.price * self.quantity


@dataclass
class Customer:
    id: str
    name: str
    address: Location


class Restaurant:
    def __init__(self, restaurant_id: str, name: str, location: Location,
                 menu: list[MenuItem]):
        self.id = restaurant_id
        self.name = name
        self.location = location
        self._menu = {item.name: item for item in menu}

    def get_item(self, name: str) -> MenuItem | None:
        return self._menu.get(name)

    def get_available_items(self) -> list[MenuItem]:
        return [item for item in self._menu.values() if item.available]


class DeliveryAgent:
    def __init__(self, agent_id: str, name: str, location: Location,
                 max_load: int = 3):
        self.id = agent_id
        self.name = name
        self.location = location
        self.current_load = 0
        self.max_load = max_load
        self.rating = 4.5

    def is_available(self) -> bool:
        return self.current_load < self.max_load

    def assign_order(self) -> None:
        if not self.is_available():
            raise RuntimeError(f"Agent {self.name} is at max capacity")
        self.current_load += 1

    def complete_order(self) -> None:
        self.current_load = max(0, self.current_load - 1)


class OrderObserver(ABC):
    @abstractmethod
    def on_status_change(self, order_id: str, customer_name: str,
                         restaurant_name: str, agent_name: str | None,
                         old_status: OrderStatus,
                         new_status: OrderStatus) -> None: ...


class ConsoleNotifier(OrderObserver):
    def on_status_change(self, order_id: str, customer_name: str,
                         restaurant_name: str, agent_name: str | None,
                         old_status: OrderStatus,
                         new_status: OrderStatus) -> None:
        agent_info = f" | agent: {agent_name}" if agent_name else ""
        print(f"  [ORDER {order_id}] {old_status.value} -> {new_status.value} | "
              f"{customer_name} from {restaurant_name}{agent_info}")


class Order:
    def __init__(self, order_id: str, customer: Customer,
                 restaurant: Restaurant, items: list[OrderItem]):
        self.id = order_id
        self.customer = customer
        self.restaurant = restaurant
        self.items = items
        self.agent: DeliveryAgent | None = None
        self._status = OrderStatus.PLACED
        self.total = sum(item.subtotal for item in items)
        self._observers: list[OrderObserver] = []

    @property
    def status(self) -> OrderStatus:
        return self._status

    def add_observer(self, observer: OrderObserver) -> None:
        self._observers.append(observer)

    def _transition(self, new_status: OrderStatus) -> None:
        if new_status not in VALID_TRANSITIONS[self._status]:
            raise ValueError(
                f"Cannot transition from {self._status.value} to "
                f"{new_status.value}")
        old = self._status
        self._status = new_status
        agent_name = self.agent.name if self.agent else None
        for obs in self._observers:
            obs.on_status_change(
                self.id, self.customer.name, self.restaurant.name,
                agent_name, old, new_status)

    def confirm(self) -> None:
        self._transition(OrderStatus.CONFIRMED)

    def start_preparing(self) -> None:
        self._transition(OrderStatus.PREPARING)

    def dispatch(self, agent: DeliveryAgent) -> None:
        agent.assign_order()
        self.agent = agent
        self._transition(OrderStatus.OUT_FOR_DELIVERY)

    def deliver(self) -> None:
        self._transition(OrderStatus.DELIVERED)
        if self.agent:
            self.agent.complete_order()

    def cancel(self) -> None:
        self._transition(OrderStatus.CANCELLED)
        if self.agent:
            self.agent.complete_order()


class AssignmentStrategy(Protocol):
    def assign_agent(self, agents: list[DeliveryAgent],
                     restaurant: Restaurant) -> DeliveryAgent | None: ...


class NearestAgentStrategy:
    """Pick the closest available agent to the restaurant."""
    def assign_agent(self, agents: list[DeliveryAgent],
                     restaurant: Restaurant) -> DeliveryAgent | None:
        available = [a for a in agents if a.is_available()]
        if not available:
            return None
        return min(available,
                   key=lambda a: a.location.distance_to(restaurant.location))


class LoadBalancedStrategy:
    """Pick the available agent with the fewest current orders."""
    def assign_agent(self, agents: list[DeliveryAgent],
                     restaurant: Restaurant) -> DeliveryAgent | None:
        available = [a for a in agents if a.is_available()]
        if not available:
            return None
        return min(available, key=lambda a: a.current_load)


class DeliveryPlatform:
    def __init__(self, assignment: AssignmentStrategy | None = None):
        self._restaurants: dict[str, Restaurant] = {}
        self._agents: list[DeliveryAgent] = []
        self._orders: dict[str, Order] = {}
        self._assignment = assignment or NearestAgentStrategy()
        self._notifier = ConsoleNotifier()
        self._lock = Lock()

    def register_restaurant(self, restaurant: Restaurant) -> None:
        self._restaurants[restaurant.id] = restaurant

    def register_agent(self, agent: DeliveryAgent) -> None:
        self._agents.append(agent)

    def set_assignment_strategy(self, strategy: AssignmentStrategy) -> None:
        self._assignment = strategy

    def place_order(self, customer: Customer, restaurant_id: str,
                    item_requests: list[tuple[str, int]]) -> Order:
        """Place an order. item_requests is a list of (item_name, quantity)."""
        with self._lock:
            restaurant = self._restaurants.get(restaurant_id)
            if not restaurant:
                raise ValueError(f"Restaurant {restaurant_id} not found")

            order_items = []
            for item_name, qty in item_requests:
                menu_item = restaurant.get_item(item_name)
                if menu_item is None:
                    raise ValueError(f"Item '{item_name}' not on menu")
                if not menu_item.available:
                    raise ValueError(f"Item '{item_name}' is unavailable")
                order_items.append(OrderItem(menu_item, qty))

            order_id = str(uuid.uuid4())[:8]
            order = Order(order_id, customer, restaurant, order_items)
            order.add_observer(self._notifier)
            self._orders[order_id] = order
            return order

    def confirm_order(self, order_id: str) -> None:
        """Restaurant confirms it can fulfill the order."""
        self._orders[order_id].confirm()

    def mark_preparing(self, order_id: str) -> None:
        self._orders[order_id].start_preparing()

    def dispatch_order(self, order_id: str) -> None:
        """Assign an agent and send the order out for delivery."""
        with self._lock:
            order = self._orders[order_id]
            agent = self._assignment.assign_agent(
                self._agents, order.restaurant)
            if agent is None:
                raise RuntimeError("No delivery agents available")
            order.dispatch(agent)

    def complete_delivery(self, order_id: str) -> None:
        with self._lock:
            self._orders[order_id].deliver()

    def cancel_order(self, order_id: str) -> None:
        with self._lock:
            self._orders[order_id].cancel()


if __name__ == "__main__":
    platform = DeliveryPlatform(assignment=NearestAgentStrategy())

    # Set up a restaurant
    biryani_house = Restaurant("r1", "Biryani House", Location(12.9716, 77.5946), [
        MenuItem("Chicken Biryani", 250.0),
        MenuItem("Paneer Biryani", 220.0),
        MenuItem("Raita", 40.0),
        MenuItem("Gulab Jamun", 60.0),
    ])
    platform.register_restaurant(biryani_house)

    # Set up delivery agents
    platform.register_agent(DeliveryAgent("a1", "Rahul", Location(12.9720, 77.5950)))
    platform.register_agent(DeliveryAgent("a2", "Meena", Location(12.9600, 77.6100)))
    platform.register_agent(DeliveryAgent("a3", "Vijay", Location(12.9800, 77.5800)))

    # Customer places an order
    customer = Customer("c1", "Priya", Location(12.9352, 77.6245))

    print("=== Placing order ===")
    order = platform.place_order(
        customer, "r1",
        [("Chicken Biryani", 2), ("Raita", 1)])
    print(f"  Order {order.id}: Rs {order.total}")

    print("\n=== Restaurant confirms ===")
    platform.confirm_order(order.id)

    print("\n=== Kitchen starts preparing ===")
    platform.mark_preparing(order.id)

    print("\n=== Dispatching delivery agent ===")
    platform.dispatch_order(order.id)
    print(f"  Assigned to: {order.agent.name}")

    print("\n=== Delivered ===")
    platform.complete_delivery(order.id)

    # Second order with load balancing
    print("\n=== Switching to load-balanced assignment ===")
    platform.set_assignment_strategy(LoadBalancedStrategy())
    customer2 = Customer("c2", "Amit", Location(12.9400, 77.6000))
    order2 = platform.place_order(
        customer2, "r1",
        [("Paneer Biryani", 1), ("Gulab Jamun", 2)])
    platform.confirm_order(order2.id)
    platform.mark_preparing(order2.id)
    platform.dispatch_order(order2.id)
    print(f"  Order {order2.id} assigned to: {order2.agent.name} "
          f"(load: {order2.agent.current_load}/{order2.agent.max_load})")
    platform.complete_delivery(order2.id)

    print("\n=== Invalid transition test ===")
    try:
        platform.dispatch_order(order.id)  # already delivered
    except ValueError as e:
        print(f"  Correctly rejected: {e}")

    print("\n=== Cancellation test ===")
    order3 = platform.place_order(
        customer, "r1", [("Gulab Jamun", 3)])
    print(f"  Placed order {order3.id}")
    platform.cancel_order(order3.id)
    print(f"  Status after cancel: {order3.status.value}")

import java.util.*;
import java.util.concurrent.locks.ReentrantLock;

enum OrderStatus {
    PLACED, CONFIRMED, PREPARING, OUT_FOR_DELIVERY, DELIVERED, CANCELLED;

    private static final Map<OrderStatus, Set<OrderStatus>> VALID = new EnumMap<>(OrderStatus.class);
    static {
        VALID.put(PLACED, EnumSet.of(CONFIRMED, CANCELLED));
        VALID.put(CONFIRMED, EnumSet.of(PREPARING, CANCELLED));
        VALID.put(PREPARING, EnumSet.of(OUT_FOR_DELIVERY, CANCELLED));
        VALID.put(OUT_FOR_DELIVERY, EnumSet.of(DELIVERED));
        VALID.put(DELIVERED, EnumSet.noneOf(OrderStatus.class));
        VALID.put(CANCELLED, EnumSet.noneOf(OrderStatus.class));
    }

    boolean canTransitionTo(OrderStatus next) {
        return VALID.getOrDefault(this, EnumSet.noneOf(OrderStatus.class)).contains(next);
    }
}

class Location {
    final double lat;
    final double lng;

    Location(double lat, double lng) { this.lat = lat; this.lng = lng; }

    double distanceTo(Location other) {
        double dLat = Math.toRadians(other.lat - this.lat);
        double dLng = Math.toRadians(other.lng - this.lng);
        double a = Math.sin(dLat / 2) * Math.sin(dLat / 2)
                 + Math.cos(Math.toRadians(this.lat)) * Math.cos(Math.toRadians(other.lat))
                 * Math.sin(dLng / 2) * Math.sin(dLng / 2);
        return 6371 * 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
    }
}

class MenuItem {
    final String name;
    final double price;
    boolean available;

    MenuItem(String name, double price) {
        this.name = name;
        this.price = price;
        this.available = true;
    }
}

class OrderItem {
    final MenuItem menuItem;
    final int quantity;

    OrderItem(MenuItem menuItem, int quantity) {
        this.menuItem = menuItem;
        this.quantity = quantity;
    }

    double subtotal() { return menuItem.price * quantity; }
}

class Customer {
    final String id;
    final String name;
    final Location address;

    Customer(String id, String name, Location address) {
        this.id = id;
        this.name = name;
        this.address = address;
    }
}

class Restaurant {
    final String id;
    final String name;
    final Location location;
    private final Map<String, MenuItem> menu = new LinkedHashMap<>();

    Restaurant(String id, String name, Location location, List<MenuItem> items) {
        this.id = id;
        this.name = name;
        this.location = location;
        for (MenuItem item : items) menu.put(item.name, item);
    }

    MenuItem getItem(String name) { return menu.get(name); }

    List<MenuItem> getAvailableItems() {
        List<MenuItem> result = new ArrayList<>();
        for (MenuItem item : menu.values())
            if (item.available) result.add(item);
        return result;
    }
}

class DeliveryAgent {
    final String id;
    final String name;
    Location location;
    int currentLoad;
    final int maxLoad;
    double rating;

    DeliveryAgent(String id, String name, Location location, int maxLoad) {
        this.id = id;
        this.name = name;
        this.location = location;
        this.currentLoad = 0;
        this.maxLoad = maxLoad;
        this.rating = 4.5;
    }

    DeliveryAgent(String id, String name, Location location) {
        this(id, name, location, 3);
    }

    boolean isAvailable() { return currentLoad < maxLoad; }

    void assignOrder() {
        if (!isAvailable())
            throw new RuntimeException(name + " at max capacity");
        currentLoad++;
    }

    void completeOrder() { currentLoad = Math.max(0, currentLoad - 1); }
}

interface OrderObserver {
    void onStatusChange(String orderId, String customerName,
                        String restaurantName, String agentName,
                        OrderStatus oldStatus, OrderStatus newStatus);
}

class ConsoleNotifier implements OrderObserver {
    public void onStatusChange(String orderId, String customerName,
                               String restaurantName, String agentName,
                               OrderStatus oldStatus, OrderStatus newStatus) {
        String agentInfo = (agentName != null) ? " | agent: " + agentName : "";
        System.out.printf("  [ORDER %s] %s -> %s | %s from %s%s%n",
            orderId, oldStatus, newStatus, customerName, restaurantName, agentInfo);
    }
}

class Order {
    final String id;
    final Customer customer;
    final Restaurant restaurant;
    final List<OrderItem> items;
    final double total;
    DeliveryAgent agent;
    private OrderStatus status;
    private final List<OrderObserver> observers = new ArrayList<>();

    Order(String id, Customer customer, Restaurant restaurant,
          List<OrderItem> items) {
        this.id = id;
        this.customer = customer;
        this.restaurant = restaurant;
        this.items = items;
        this.total = items.stream().mapToDouble(OrderItem::subtotal).sum();
        this.status = OrderStatus.PLACED;
    }

    OrderStatus getStatus() { return status; }

    void addObserver(OrderObserver obs) { observers.add(obs); }

    private void transition(OrderStatus next) {
        if (!status.canTransitionTo(next))
            throw new IllegalStateException(
                "Cannot go from " + status + " to " + next);
        OrderStatus old = status;
        status = next;
        String agentName = (agent != null) ? agent.name : null;
        for (OrderObserver obs : observers)
            obs.onStatusChange(id, customer.name, restaurant.name,
                agentName, old, next);
    }

    void confirm() { transition(OrderStatus.CONFIRMED); }
    void startPreparing() { transition(OrderStatus.PREPARING); }

    void dispatch(DeliveryAgent agent) {
        agent.assignOrder();
        this.agent = agent;
        transition(OrderStatus.OUT_FOR_DELIVERY);
    }

    void deliver() {
        transition(OrderStatus.DELIVERED);
        if (agent != null) agent.completeOrder();
    }

    void cancel() {
        transition(OrderStatus.CANCELLED);
        if (agent != null) agent.completeOrder();
    }
}

interface AssignmentStrategy {
    DeliveryAgent assignAgent(List<DeliveryAgent> agents, Restaurant restaurant);
}

class NearestAgentStrategy implements AssignmentStrategy {
    public DeliveryAgent assignAgent(List<DeliveryAgent> agents,
                                     Restaurant restaurant) {
        return agents.stream()
            .filter(DeliveryAgent::isAvailable)
            .min(Comparator.comparingDouble(
                a -> a.location.distanceTo(restaurant.location)))
            .orElse(null);
    }
}

class LoadBalancedStrategy implements AssignmentStrategy {
    public DeliveryAgent assignAgent(List<DeliveryAgent> agents,
                                     Restaurant restaurant) {
        return agents.stream()
            .filter(DeliveryAgent::isAvailable)
            .min(Comparator.comparingInt(a -> a.currentLoad))
            .orElse(null);
    }
}

class DeliveryPlatform {
    private final Map<String, Restaurant> restaurants = new HashMap<>();
    private final List<DeliveryAgent> agents = new ArrayList<>();
    private final Map<String, Order> orders = new HashMap<>();
    private AssignmentStrategy assignmentStrategy;
    private final OrderObserver notifier = new ConsoleNotifier();
    private final ReentrantLock lock = new ReentrantLock();

    DeliveryPlatform(AssignmentStrategy strategy) {
        this.assignmentStrategy = strategy;
    }

    DeliveryPlatform() { this(new NearestAgentStrategy()); }

    void registerRestaurant(Restaurant r) { restaurants.put(r.id, r); }
    void registerAgent(DeliveryAgent a) { agents.add(a); }
    void setAssignmentStrategy(AssignmentStrategy s) {
        this.assignmentStrategy = s;
    }

    Order placeOrder(Customer customer, String restaurantId,
                     List<String[]> itemRequests) {
        lock.lock();
        try {
            Restaurant restaurant = restaurants.get(restaurantId);
            if (restaurant == null)
                throw new IllegalArgumentException("Restaurant not found");

            List<OrderItem> orderItems = new ArrayList<>();
            for (String[] req : itemRequests) {
                String itemName = req[0];
                int qty = Integer.parseInt(req[1]);
                MenuItem item = restaurant.getItem(itemName);
                if (item == null)
                    throw new IllegalArgumentException(
                        "Item '" + itemName + "' not on menu");
                if (!item.available)
                    throw new IllegalArgumentException(
                        "Item '" + itemName + "' is unavailable");
                orderItems.add(new OrderItem(item, qty));
            }

            String orderId = UUID.randomUUID().toString().substring(0, 8);
            Order order = new Order(orderId, customer, restaurant, orderItems);
            order.addObserver(notifier);
            orders.put(orderId, order);
            return order;
        } finally { lock.unlock(); }
    }

    void confirmOrder(String orderId) { orders.get(orderId).confirm(); }
    void markPreparing(String orderId) {
        orders.get(orderId).startPreparing();
    }

    void dispatchOrder(String orderId) {
        lock.lock();
        try {
            Order order = orders.get(orderId);
            DeliveryAgent agent = assignmentStrategy.assignAgent(
                agents, order.restaurant);
            if (agent == null)
                throw new RuntimeException("No agents available");
            order.dispatch(agent);
        } finally { lock.unlock(); }
    }

    void completeDelivery(String orderId) {
        lock.lock();
        try { orders.get(orderId).deliver(); }
        finally { lock.unlock(); }
    }

    void cancelOrder(String orderId) {
        lock.lock();
        try { orders.get(orderId).cancel(); }
        finally { lock.unlock(); }
    }
}

public class FoodDelivery {
    public static void main(String[] args) {
        DeliveryPlatform platform = new DeliveryPlatform();

        Restaurant biryaniHouse = new Restaurant(
            "r1", "Biryani House", new Location(12.9716, 77.5946),
            List.of(
                new MenuItem("Chicken Biryani", 250.0),
                new MenuItem("Paneer Biryani", 220.0),
                new MenuItem("Raita", 40.0),
                new MenuItem("Gulab Jamun", 60.0)
            ));
        platform.registerRestaurant(biryaniHouse);

        platform.registerAgent(new DeliveryAgent("a1", "Rahul",
            new Location(12.9720, 77.5950)));
        platform.registerAgent(new DeliveryAgent("a2", "Meena",
            new Location(12.9600, 77.6100)));
        platform.registerAgent(new DeliveryAgent("a3", "Vijay",
            new Location(12.9800, 77.5800)));

        Customer priya = new Customer("c1", "Priya",
            new Location(12.9352, 77.6245));

        System.out.println("=== Placing order ===");
        Order order = platform.placeOrder(priya, "r1",
            List.of(new String[]{"Chicken Biryani", "2"},
                    new String[]{"Raita", "1"}));
        System.out.println("  Order " + order.id + ": Rs " + order.total);

        System.out.println("\n=== Restaurant confirms ===");
        platform.confirmOrder(order.id);

        System.out.println("\n=== Kitchen starts preparing ===");
        platform.markPreparing(order.id);

        System.out.println("\n=== Dispatching delivery agent ===");
        platform.dispatchOrder(order.id);
        System.out.println("  Assigned to: " + order.agent.name);

        System.out.println("\n=== Delivered ===");
        platform.completeDelivery(order.id);

        // Load-balanced assignment
        System.out.println("\n=== Load-balanced assignment ===");
        platform.setAssignmentStrategy(new LoadBalancedStrategy());
        Customer amit = new Customer("c2", "Amit",
            new Location(12.9400, 77.6000));
        Order order2 = platform.placeOrder(amit, "r1",
            List.of(new String[]{"Paneer Biryani", "1"},
                    new String[]{"Gulab Jamun", "2"}));
        platform.confirmOrder(order2.id);
        platform.markPreparing(order2.id);
        platform.dispatchOrder(order2.id);
        System.out.println("  Order " + order2.id + " assigned to: "
            + order2.agent.name + " (load: " + order2.agent.currentLoad
            + "/" + order2.agent.maxLoad + ")");
        platform.completeDelivery(order2.id);

        System.out.println("\n=== Invalid transition test ===");
        try {
            platform.dispatchOrder(order.id);
        } catch (IllegalStateException e) {
            System.out.println("  Correctly rejected: " + e.getMessage());
        }

        System.out.println("\n=== Cancellation test ===");
        // Single-item order — explicit List.<String[]>of avoids varargs inference ambiguity.
        Order order3 = platform.placeOrder(priya, "r1",
            List.<String[]>of(new String[]{"Gulab Jamun", "3"}));
        System.out.println("  Placed order " + order3.id);
        platform.cancelOrder(order3.id);
        System.out.println("  Status after cancel: " + order3.getStatus());
    }
}

Common Mistakes

✗Skipping the CONFIRMED state. Without restaurant confirmation, you charge the customer before knowing if the food can be made.
✗Assigning a delivery agent at order placement. The agent should be assigned when food is almost ready, not 30 minutes early.
✗Hardcoding agent assignment logic. Load balancing during peak hours and nearest-agent during off-peak need different strategies.
✗Not tracking agent load. Assigning five orders to one agent while others sit idle kills delivery times.

Key Points

✓State machine on Order enforces valid transitions. An order cannot jump from PLACED to DELIVERED.
✓Strategy pattern for agent assignment: swap between nearest-agent, load-balanced, or rating-based without changing order logic
✓Observer notifies customer and restaurant on every status change for real-time tracking
✓Restaurant confirmation is an explicit state. The order waits for the restaurant to accept before preparation begins.

Food Delivery (Swiggy)

Key Abstractions

Class Diagram

The Key Insight

Requirements

Functional

Non-Functional

Design Decisions

Why does the order go through CONFIRMED before PREPARING?

Why is agent assignment a strategy, not hardcoded logic?

Why track agent load instead of just available/unavailable?

Why is Order the state machine owner, not DeliveryPlatform?

Interview Follow-ups

Code Implementation

Common Mistakes

Key Points

Related Designs

Food Delivery (Swiggy)

Key Abstractions

Class Diagram

The Key Insight

Requirements

Functional

Non-Functional

Design Decisions

Why does the order go through CONFIRMED before PREPARING?

Why is agent assignment a strategy, not hardcoded logic?

Why track agent load instead of just available/unavailable?

Why is Order the state machine owner, not DeliveryPlatform?

Interview Follow-ups

Code Implementation

Common Mistakes

Key Points

Related Designs