Design a Parking Lot, Low Level Design (LLD) Interview

It is the cleanest test of core OOD skills: can you take a messy real-world description, carve it into the right classes with single responsibilities, model has-a vs is-a relationships correctly, and pick design patterns for the parts that genuinely vary (pricing, spot allocation, payment). It also exposes whether a candidate thinks about concurrency, because two cars racing for the last spot is the obvious failure mode. There is enough surface to extend (EV charging, reservations, multiple gates) so interviewers can scale difficulty, yet it is small enough to write real working code inside the round.

• ParkingLot → composition → ParkingFloor. A lot owns its floors; floors do not exist without the lot.
• ParkingFloor → composition → ParkingSpot. Each floor owns its physical spots; destroying the floor destroys the spots.
• ParkingSpot → association → Vehicle. A spot references the vehicle currently parked on it; the vehicle lives independently of the spot.
• Car → inheritance → Vehicle. Car, Bike, Truck, ElectricCar are concrete subclasses of the abstract Vehicle; they differ only by VehicleType and charging need.
• Ticket → association → Vehicle. A ticket points at the vehicle it was issued for.
• Ticket → association → ParkingSpot. A ticket records which spot was assigned so exit can free exactly that spot.
• ParkingLot → aggregation → Ticket. The lot keeps a registry of active tickets but a ticket is a value-like record with its own lifecycle.
• ParkingLot → association → SpotAllocationStrategy. The lot holds an injected allocation strategy (Strategy pattern); it can be swapped at runtime.
• ParkingLot → association → PricingStrategy. The lot holds an injected pricing strategy; the fee rule is decided here, not hard-coded in exit.
• EntryGate → inheritance → Gate. EntryGate and ExitGate specialize the abstract Gate.
• ParkingLot → aggregation → Gate. The lot has a set of entry and exit gates.
• ParkingFloor → composition → DisplayBoard. Each floor owns a display board that reflects its availability (Observer relationship in behavior).
• PaymentProcessor → association → PaymentMethod. The processor is configured with a concrete payment method strategy (cash/card/UPI).

// ---------- Enums ----------
enum VehicleType { MOTORCYCLE, CAR, TRUCK, ELECTRIC_CAR }
enum SpotType { MOTORCYCLE, COMPACT, LARGE, HANDICAPPED, ELECTRIC }
enum SpotStatus { FREE, RESERVED, OCCUPIED, OUT_OF_SERVICE }
enum TicketStatus { ACTIVE, PAID, CLOSED, LOST }
enum PaymentMethod { CASH, CARD, UPI }

// ---------- Vehicle hierarchy ----------
abstract class Vehicle {
 protected final String licensePlate;
 protected final VehicleType type;
 Vehicle(String plate, VehicleType type) { this.licensePlate = plate; this.type = type; }
 VehicleType getType() { return type; }
 boolean needsCharging() { return type == VehicleType.ELECTRIC_CAR; }
}
class Car extends Vehicle { Car(String p) { super(p, VehicleType.CAR); } }
class Bike extends Vehicle { Bike(String p) { super(p, VehicleType.MOTORCYCLE); } }
class Truck extends Vehicle{ Truck(String p){ super(p, VehicleType.TRUCK); } }
class ElectricCar extends Vehicle { ElectricCar(String p){ super(p, VehicleType.ELECTRIC_CAR); } }

// ---------- ParkingSpot (concurrency-safe transition) ----------
class ParkingSpot {
 final String id; final SpotType spotType; final int floor; final int distanceFromEntry;
 final boolean hasCharger;
 private volatile SpotStatus status = SpotStatus.FREE;
 private Vehicle parkedVehicle;

 boolean canFit(Vehicle v) {
 switch (v.getType()) {
 case MOTORCYCLE: return true; // fits any
 case CAR: return spotType == SpotType.COMPACT || spotType == SpotType.LARGE;
 case TRUCK: return spotType == SpotType.LARGE;
 case ELECTRIC_CAR: return spotType == SpotType.ELECTRIC || spotType == SpotType.COMPACT
 || spotType == SpotType.LARGE;
 default: return false;
 }
 }
 // compare-and-set: only the first caller wins the spot
 synchronized boolean assign(Vehicle v) {
 if (status != SpotStatus.FREE && status != SpotStatus.RESERVED) return false;
 this.parkedVehicle = v; this.status = SpotStatus.OCCUPIED; return true;
 }
 synchronized void vacate() { this.parkedVehicle = null; this.status = SpotStatus.FREE; }
 boolean isFree() { return status == SpotStatus.FREE; }
}

// ---------- Strategy interfaces ----------
interface SpotAllocationStrategy {
 Optional<ParkingSpot> findSpot(ParkingLot lot, Vehicle vehicle, EntryGate gate);
}
interface PricingStrategy { long calculatePrice(Ticket ticket); }
interface PaymentProcessor { PaymentStatus pay(long amount); }

// Nearest-spot allocation: scan per-floor free index, smallest distance wins
class NearestSpotStrategy implements SpotAllocationStrategy {
 public Optional<ParkingSpot> findSpot(ParkingLot lot, Vehicle v, EntryGate gate) {
 return lot.getFloors().stream()
 .flatMap(f -> f.candidateFreeSpots(v).stream())
 .min(Comparator.comparingInt(s -> s.distanceFromEntry));
 }
}

// Progressive pricing: first hour flat, then per-hour, rounded up
class ProgressivePricing implements PricingStrategy {
 public long calculatePrice(Ticket t) {
 long mins = t.getDurationMinutes();
 if (mins <= 10) return 0; // grace period
 long hours = (long) Math.ceil(mins / 60.0);
 long rate = (t.getSpot().spotType == SpotType.LARGE) ? 40 : 20;
 return 20 + Math.max(0, hours - 1) * rate; // base + per extra hour
 }
}

// ---------- Ticket with state guard ----------
class Ticket {
 final String id; final Vehicle vehicle; final ParkingSpot spot; final Instant entryTime;
 Instant exitTime; long amount; TicketStatus status = TicketStatus.ACTIVE;
 long getDurationMinutes() {
 return Duration.between(entryTime, exitTime != null ? exitTime : Instant.now()).toMinutes();
 }
 void markPaid(long amt, Instant exit) {
 if (status != TicketStatus.ACTIVE) throw new IllegalStateException("ticket not active");
 this.amount = amt; this.exitTime = exit; this.status = TicketStatus.PAID;
 }
}

// ---------- ParkingLot facade (Singleton-ish, thread-safe) ----------
class ParkingLot {
 private final List<ParkingFloor> floors;
 private final SpotAllocationStrategy allocation;
 private final PricingStrategy pricing;
 private final Map<String, Ticket> activeTickets = new ConcurrentHashMap<>();

 Ticket parkVehicle(Vehicle vehicle, EntryGate gate) {
 // retry loop handles the race for the last spot
 for (int attempt = 0; attempt < 3; attempt++) {
 Optional<ParkingSpot> chosen = allocation.findSpot(this, vehicle, gate);
 if (chosen.isEmpty()) throw new LotFullException(vehicle.getType());
 ParkingSpot spot = chosen.get();
 if (spot.assign(vehicle)) { // atomic win
 Ticket t = new Ticket(UUID.randomUUID().toString(), vehicle, spot, Instant.now());
 activeTickets.put(t.id, t);
 spot.floorRef().notifyAvailabilityChanged(spot.spotType);
 return t;
 } // else someone beat us; loop and try the next nearest
 }
 throw new LotFullException(vehicle.getType());
 }

 Receipt unparkVehicle(String ticketId, ExitGate gate, PaymentProcessor processor) {
 Ticket t = activeTickets.get(ticketId);
 if (t == null || t.status != TicketStatus.ACTIVE)
 throw new InvalidTicketException(ticketId); // idempotent: no double charge
 long amount = pricing.calculatePrice(t.withExit(Instant.now()));
 if (processor.pay(amount) != PaymentStatus.SUCCESS)
 throw new PaymentFailedException(ticketId); // spot stays held until paid
 t.markPaid(amount, Instant.now());
 t.getSpot().vacate(); // free ONLY after payment
 t.getSpot().floorRef().notifyAvailabilityChanged(t.getSpot().spotType);
 t.status = TicketStatus.CLOSED;
 activeTickets.remove(ticketId);
 return new Receipt(ticketId, amount, t.exitTime);
 }
}

• Two cars race for the last compact spot from different gates. Solved by reserving the spot atomically (compare-and-set on SpotStatus or a per-floor lock); the loser retries the allocation strategy for the next spot.
• Lot or a specific spot type is full. Return a clean LotFullException / null Optional and have the gate refuse entry, not a 500 or a half-created ticket.
• Vehicle-spot fit edge: a motorcycle should be allowed into a compact or large spot when its own type is exhausted (fallback ladder), but a truck must never be squeezed into a compact spot. canFit() encodes this asymmetric rule.
• EV with no EV spot free: allow parking in a normal spot but mark charging unavailable, do not block entry just because chargers are taken.
• Lost ticket: vehicle present but ticketId unknown. Move ticket to LOST, charge a flat lost-ticket penalty using vehicle lookup by plate, and still free the spot.
• Free duration / grace period: a car that leaves within, say, 10 minutes pays zero. The pricing strategy must handle a zero or rounded-up first slab correctly (off-by-one on the first hour is the classic bug).
• Clock and rounding: partial hours must round consistently (ceil to the hour) and the same Clock must be injected for entry and exit so tests are deterministic.
• Double exit / replayed exit scan: unparking an already-CLOSED ticket must be idempotent and not double-charge or free a spot now occupied by someone else.
• Spot taken out of service for maintenance: status OUT_OF_SERVICE removes it from the free index so it is never allocated, without deleting it.
• Payment failure mid-exit: do not free the spot or close the ticket until payment SUCCESS, otherwise a non-payer drives off with a freed spot and an unpaid ticket.