LLD: Parking Lot System

1. Introduction

The design of a multi-level, automated Parking Lot System represents the canonical foundation of Low-Level Design (LLD) and Object-Oriented Programming (OOP) interviews. On the surface, allocating an open parking space to an incoming car seems trivial. However, designing a system capable of managing a municipal transit hub operating thousands of spaces across numerous structural levels reveals profound domain complexities:

• Spatial Resolution & Optimizations: How do you map varied architectural constraints—such as structural ceiling clearances, electric charging equipment, handicapped zoning, and compact dimensions—to heterogeneous vehicle class types without writing fragile conditional execution trees?
• High-Concurrency & Race Conditions: When a sporting event concludes or a busy morning rush occurs, how do you prevent simultaneous entry booth gate operators from assigning the exact same physical parking spot to two distinct drivers simultaneously?
• Pluggable Pricing & Fee Evaluation Strategy: How do you design an extensible calculation architecture capable of parsing intricate real-world tariff models—such as tiered hourly structures, member validations, surge demand pricing, and lost ticket liabilities—without hardcoding business logic inside transaction orchestrators?
• Distributed State & Sensor Telemetry: How do you preserve structural tracking consistency when analog spatial presence hardware (e.g., ultrasound overhead spot occupancy sensors, OCR camera ALPR systems) registers ghost readings or unexpected operational disconnects?

2. Requirements & System Scope

Core Functional Requirements

1. Multi-Level Topology Representation: Support a customizable physical structure composed of $N$ vertical floors (ParkingFloor), each containing $M$ categorized individual spaces (ParkingSpot).
2. Heterogeneous Space Classifications: Provide segregated support for specialized space topologies: Compact bays, Large truck berths, Handicapped spaces, Electric Vehicle (EV) inductive charging docks, and Motorcycle corrals.
3. Automated Entrance & Exit Terminal Processing:
   • Entry Panels (EntryPanel): Generate time-stamped transaction receipts (ParkingTicket), capture license plate strings, display real-time floor vacancy metrics on external LED signboards, and open physical security boom barriers.
   • Exit Panels (ExitPanel): Validate ticket validity, evaluate cumulative elapsed parking durations, assess financial liabilities via automated payment gateways, and lift exit barriers upon payment confirmation.
4. Dynamic Spot Allocation Algorithm: Employ deterministic discovery routines to assign incoming drivers to the spatially nearest appropriate space matching their specific vehicle sizing and electrical charging requirements.

Non-Functional Requirements & SOLID Observance

• Single Responsibility Principle (SRP): A ParkingSpot object purely manages physical dimensions and boolean occupancy status; it must never implement pricing computation rules or database logging.
• Open-Closed Principle (OCP): Integrating new vehicle structures (such as automated autonomous drones or electric delivery bicycles) or custom municipal tax surcharges must occur entirely through polymorphic extension without modifying existing entry routing code.
• Dependency Inversion Principle (DIP): Entrance gate orchestrators must communicate exclusively through generalized interface abstractions (PricingStrategy, PaymentProcessor, SpotAssignmentStrategy) rather than tightly coupled implementations.

3. Object-Oriented Architectural Topology & Class Design

To enforce encapsulation and high domain separation, we partition our system into four cohesive subsystems: Physical Asset Topology (ParkingLot, ParkingFloor, ParkingSpot), Vehicle Classification Models (Vehicle, Car, Truck), Transactional Execution Artifacts (ParkingTicket, EntryPanel, ExitPanel), and Financial Strategy Routines (PricingStrategy, PaymentProcessor).

Complete UML Class Diagram

classDiagram
    class ParkingLot {
      -String facilityName
      -List~ParkingFloor~ floors
      -List~EntryPanel~ entryPanels
      -List~ExitPanel~ exitPanels
      -SpotAssignmentStrategy spotAllocator
      -PricingStrategy pricingEngine
      +getAvailableSpot(Vehicle v) ParkingSpot
      +registerEntry(Vehicle v, int gateId) ParkingTicket
      +processExit(ParkingTicket ticket, PaymentProcessor pay) double
    }

    class ParkingFloor {
      -int floorNumber
      -int maxCeilingHeightCm
      -HashMap~SpotType, List~ParkingSpot~~ spotsMap
      -DisplayBoard displayBoard
      +getVacantSpot(VehicleType type) ParkingSpot
      +updateDisplayBoard() void
    }

    class ParkingSpot {
      <<abstract>>
      -String spotId
      -SpotType type
      -boolean isOccupied
      -Vehicle parkedVehicle
      -int distanceToElevator
      +isVacant() boolean
      +assignVehicle(Vehicle v)* boolean
      +vacateSpot()* void
    }

    class CompactSpot {
      +assignVehicle(Vehicle v) boolean
    }

    class LargeSpot {
      +assignVehicle(Vehicle v) boolean
    }

    class HandicappedSpot {
      +assignVehicle(Vehicle v) boolean
    }

    class ElectricSpot {
      -double chargingKilowattRate
      -boolean chargerConnected
      +assignVehicle(Vehicle v) boolean
      +startCharging() void
    }

    class Vehicle {
      <<abstract>>
      -String licensePlate
      -VehicleType type
      +getType() VehicleType
    }

    class Car {
      +getType() VehicleType
    }

    class Truck {
      +getType() VehicleType
    }

    class Motorcycle {
      +getType() VehicleType
    }

    class ParkingTicket {
      -String ticketId
      -String vehiclePlate
      -ParkingSpot assignedSpot
      -Date entryTime
      -Date paymentTime
      -TicketStatus status
      +calculateDurationHours(Date current) double
    }

    class SpotAssignmentStrategy {
      <<interface>>
      +findBestSpot(List~ParkingFloor~ floors, Vehicle v) ParkingSpot
    }

    class NearestElevatorStrategy {
      +findBestSpot(List~ParkingFloor~ floors, Vehicle v) ParkingSpot
    }

    class PricingStrategy {
      <<interface>>
      +calculateTotalFee(ParkingTicket ticket, Date exitTime) double
    }

    class TieredHourlyPricingStrategy {
      -double baseFirstHourRate
      -double subsequentHourRate
      -double maxDailyCap
      +calculateTotalFee(ParkingTicket ticket, Date exitTime) double
    }

    class PaymentProcessor {
      <<interface>>
      +executeTransaction(double amount, String paymentToken) boolean
    }

    class SpotType {
      <<enumeration>>
      COMPACT
      LARGE
      HANDICAPPED
      ELECTRIC
      MOTORCYCLE
    }

    class VehicleType {
      <<enumeration>>
      CAR
      TRUCK
      VAN
      MOTORCYCLE
    }

    class TicketStatus {
      <<enumeration>>
      ACTIVE
      PAID
      LOST
      CANCELLED
    }

    ParkingLot "1" *-- "1..*" ParkingFloor
    ParkingLot "1" --> "1" SpotAssignmentStrategy
    ParkingLot "1" --> "1" PricingStrategy
    ParkingFloor "1" *-- "1..*" ParkingSpot
    ParkingSpot <|-- CompactSpot
    ParkingSpot <|-- LargeSpot
    ParkingSpot <|-- HandicappedSpot
    ParkingSpot <|-- ElectricSpot
    Vehicle <|-- Car
    Vehicle <|-- Truck
    Vehicle <|-- Motorcycle
    ParkingSpot "0..1" o-- "1" Vehicle
    ParkingTicket "1" --> "1" ParkingSpot
    SpotAssignmentStrategy <|-- NearestElevatorStrategy
    PricingStrategy <|-- TieredHourlyPricingStrategy

4. Design Patterns Applied

1. The Strategy Pattern (Pluggable Spot Assignment & Pricing Architecture)

A primary architectural design challenge in modern automated structures involves handling diverse regional rules and optimization goals without disrupting baseline transaction loops.

• Spot Assignment Strategies: A suburban mall parking lot might prioritize consumer comfort by deploying a NearestElevatorStrategy that sorts space vacancies by proximity to shopping elevators. A high-density downtown corporate garage, however, might implement a FillLowerFloorsFirstStrategy to minimize vehicle travel times inside structural ramps.
• Pricing Strategies: Similarly, tariff algorithms vary wildly between daytime hourly structures, flat weekend rates, electric charging kilowatt surcharges, and executive monthly memberships. Encapsulating financial formulas behind a clean PricingStrategy contract ($O(1)$ integration) guarantees total Open/Closed Principle compliance.

2. The Factory Method & Prototype Patterns

When incoming cars pass high-speed optical license plate cameras (ALPR) at automated tollbooths, raw sensor payloads must be deserialized into proper concrete OOP abstractions. A VehicleFactory parses incoming geometric profiles and registration plate formats to instantiate the exact required child class (Car, Truck, or Motorcycle) before submitting the object to the spot assignment engine.

3. The Observer Pattern (Automated Signboard Telemetry)

At the base of every entry structural ramp sits an automated digital display board indicating current real-time vacancies per floor (Floor 1: FULL | Floor 2: 14 Compact, 2 EV | Floor 3: 84 Available). Rather than forcing the display board software to poll database counts continuously in an inefficient $O(N)$ infinite loop, each ParkingFloor functions as an observable event subject. Whenever any local space transforms its occupancy state (assignVehicle() or vacateSpot()), the parent floor triggers an asynchronous event alert directly to the registered DisplayBoardObserver, instantly updating LED readouts with zero polling latency.

5. Production-Grade Reference Implementation

Below is a concurrent, type-safe Python implementation demonstrating thread-safe spatial reservation locking, polymorphic spot matching, Strategy-driven tiered financial fee evaluation, and automated observer vacancy dashboard signaling.

import time
from abc import ABC, abstractmethod
from enum import Enum, auto
from datetime import datetime, timedelta
from typing import List, Dict, Optional
import threading

class VehicleType(Enum):
    MOTORCYCLE = auto()
    CAR = auto()
    TRUCK = auto()
    ELECTRIC_CAR = auto()

class SpotType(Enum):
    MOTORCYCLE = auto()
    COMPACT = auto()
    LARGE = auto()
    ELECTRIC = auto()

class TicketStatus(Enum):
    ACTIVE = auto()
    PAID = auto()
    LOST = auto()

class Vehicle(ABC):
    def __init__(self, license_plate: str, vehicle_type: VehicleType):
        self.license_plate = license_plate
        self.vehicle_type = vehicle_type
    def __str__(self) -> str:
        return f"{self.vehicle_type.name} [{self.license_plate}]"

class Car(Vehicle):
    def __init__(self, license_plate: str):
        super().__init__(license_plate, VehicleType.CAR)

class Truck(Vehicle):
    def __init__(self, license_plate: str):
        super().__init__(license_plate, VehicleType.TRUCK)

class ElectricCar(Vehicle):
    def __init__(self, license_plate: str):
        super().__init__(license_plate, VehicleType.ELECTRIC_CAR)

class ParkingSpot(ABC):
    """Abstract base representing a single spatial coordinate unit."""
    def __init__(self, spot_id: str, spot_type: SpotType, floor_number: int):
        self.spot_id = spot_id
        self.spot_type = spot_type
        self.floor_number = floor_number
        self.is_occupied = False
        self.parked_vehicle: Optional[Vehicle] = None
        self.lock = threading.Lock()

    def is_vacant(self) -> bool:
        with self.lock:
            return not self.is_occupied

    @abstractmethod
    def can_fit_vehicle(self, vehicle: Vehicle) -> bool:
        """Polymorphic validation checking whether vehicle sizing matches spot parameters."""
        pass

    def assign_vehicle(self, vehicle: Vehicle) -> bool:
        """Thread-safe acquisition locking to eliminate double-parking race conditions."""
        with self.lock:
            if not self.is_occupied and self.can_fit_vehicle(vehicle):
                self.is_occupied = True
                self.parked_vehicle = vehicle
                return True
            return False

    def vacate_spot(self) -> Optional[Vehicle]:
        with self.lock:
            if self.is_occupied:
                v = self.parked_vehicle
                self.is_occupied = False
                self.parked_vehicle = None
                return v
            return None

    def __str__(self) -> str:
        status = f"OCCUPIED by {self.parked_vehicle.license_plate}" if self.is_occupied else "VACANT"
        return f"[Spot {self.spot_id} ({self.spot_type.name}) - {status}]"

class CompactSpot(ParkingSpot):
    def __init__(self, spot_id: str, floor_number: int):
        super().__init__(spot_id, SpotType.COMPACT, floor_number)
    def can_fit_vehicle(self, vehicle: Vehicle) -> bool:
        return vehicle.vehicle_type in [VehicleType.CAR, VehicleType.MOTORCYCLE]

class LargeSpot(ParkingSpot):
    def __init__(self, spot_id: str, floor_number: int):
        super().__init__(spot_id, SpotType.LARGE, floor_number)
    def can_fit_vehicle(self, vehicle: Vehicle) -> bool:
        return vehicle.vehicle_type in [VehicleType.TRUCK, VehicleType.CAR, VehicleType.MOTORCYCLE]

class ElectricSpot(ParkingSpot):
    def __init__(self, spot_id: str, floor_number: int):
        super().__init__(spot_id, SpotType.ELECTRIC, floor_number)
        self.charging_connected = False
    def can_fit_vehicle(self, vehicle: Vehicle) -> bool:
        return vehicle.vehicle_type == VehicleType.ELECTRIC_CAR

class DisplayBoardObserver:
    """Observer pattern endpoint managing real-time digital entry vacancy displays."""
    def __init__(self, floor_number: int):
        self.floor_number = floor_number
        self.vacancy_counts: Dict[SpotType, int] = {t: 0 for t in SpotType}
        self.lock = threading.Lock()

    def notify_change(self, spot_type: SpotType, count_delta: int):
        with self.lock:
            self.vacancy_counts[spot_type] += count_delta
            self._render_display()

    def _render_display(self):
        readouts = ", ".join([f"{k.name}: {v}" for k, v in self.vacancy_counts.items() if v > 0])
        display_str = readouts if readouts else "FULL"
        print(f"[LED Signboard - Floor {self.floor_number}] {display_str}")

class ParkingFloor:
    def __init__(self, floor_number: int):
        self.floor_number = floor_number
        self.spots: List[ParkingSpot] = []
        self.display_board = DisplayBoardObserver(floor_number)
        self.lock = threading.Lock()

    def register_spot(self, spot: ParkingSpot):
        with self.lock:
            self.spots.append(spot)
            self.display_board.notify_change(spot.spot_type, +1)

    def find_vacant_spot(self, vehicle: Vehicle) -> Optional[ParkingSpot]:
        for spot in self.spots:
            if spot.is_vacant() and spot.can_fit_vehicle(vehicle):
                return spot
        return None

    def reserve_spot(self, spot: ParkingSpot, vehicle: Vehicle) -> bool:
        if spot.assign_vehicle(vehicle):
            self.display_board.notify_change(spot.spot_type, -1)
            return True
        return False

    def release_spot(self, spot: ParkingSpot):
        if spot.vacate_spot() is not None:
            self.display_board.notify_change(spot.spot_type, +1)

class ParkingTicket:
    def __init__(self, ticket_id: str, vehicle_plate: str, assigned_spot: ParkingSpot, entry_time: datetime):
        self.ticket_id = ticket_id
        self.vehicle_plate = vehicle_plate
        self.assigned_spot = assigned_spot
        self.entry_time = entry_time
        self.payment_time: Optional[datetime] = None
        self.status = TicketStatus.ACTIVE

    def compute_elapsed_hours(self, exit_time: datetime) -> float:
        duration = exit_time - self.entry_time
        return max(0.1, duration.total_seconds() / 3600.0)

class PricingStrategy(ABC):
    @abstractmethod
    def calculate_fee(self, ticket: ParkingTicket, exit_time: datetime) -> float:
        pass

class TieredHourlyPricingStrategy(PricingStrategy):
    """Tiered tariff: $5 base first hour, $3/hr subsequent, capped at $30/day max."""
    def __init__(self, first_hour_rate: float = 5.0, extension_rate: float = 3.0, daily_cap: float = 30.0):
        self.first_hour_rate = first_hour_rate
        self.extension_rate = extension_rate
        self.daily_cap = daily_cap

    def calculate_fee(self, ticket: ParkingTicket, exit_time: datetime) -> float:
        hours = ticket.compute_elapsed_hours(exit_time)
        if hours <= 1.0:
            total = self.first_hour_rate
        else:
            total = self.first_hour_rate + ((hours - 1.0) * self.extension_rate)
        return min(total, self.daily_cap)

class ParkingLotEngine:
    """Singleton architectural controller managing gates, routing, and checkout flows."""
    def __init__(self, facility_name: str, pricing_strategy: PricingStrategy):
        self.facility_name = facility_name
        self.pricing_strategy = pricing_strategy
        self.floors: List[ParkingFloor] = []
        self.active_tickets: Dict[str, ParkingTicket] = {}
        self.ticket_counter = 50000
        self.lock = threading.Lock()

    def add_floor(self, floor: ParkingFloor):
        self.floors.append(floor)

    def process_vehicle_entry(self, vehicle: Vehicle, entry_gate_id: int) -> Optional[ParkingTicket]:
        print(f"\n[Entry Gate #{entry_gate_id}] Approached by {vehicle}")
        
        # Spot Discovery Routine
        for floor in self.floors:
            spot = floor.find_vacant_spot(vehicle)
            if spot and floor.reserve_spot(spot, vehicle):
                with self.lock:
                    self.ticket_counter += 1
                    t_id = f"TICK-{self.ticket_counter}"
                    ticket = ParkingTicket(t_id, vehicle.license_plate, spot, datetime.now())
                    self.active_tickets[ticket.ticket_id] = ticket
                    print(f"[Entry Gate #{entry_gate_id}] SUCCESS: Issued Ticket {ticket.ticket_id}. Assigned to Floor {floor.floor_number}, Spot {spot.spot_id}.")
                    return ticket

        print(f"[Entry Gate #{entry_gate_id}] REJECTED: Facility at complete capacity for {vehicle.vehicle_type.name} class!")
        return None

    def process_vehicle_exit(self, ticket_id: str, exit_gate_id: int, exit_timestamp: datetime) -> bool:
        print(f"\n[Exit Gate #{exit_gate_id}] Processing Check-Out for Ticket ID: {ticket_id}")
        with self.lock:
            ticket = self.active_tickets.pop(ticket_id, None)
            if not ticket or ticket.status != TicketStatus.ACTIVE:
                print(f"[Exit Gate #{exit_gate_id}] ERROR: Invalid or already settled ticket ID!")
                return False

        # Fee computation
        fee = self.pricing_strategy.calculate_fee(ticket, exit_timestamp)
        ticket.payment_time = exit_timestamp
        ticket.status = TicketStatus.PAID

        # Release parking spot physical resource
        assigned_spot = ticket.assigned_spot
        for floor in self.floors:
            if floor.floor_number == assigned_spot.floor_number:
                floor.release_spot(assigned_spot)
                break

        print(f"[Exit Gate #{exit_gate_id}] TRANSACTION COMPLETED: Assessed Fee: ${fee:.2f}. Barrier raising for vehicle [{ticket.vehicle_plate}].")
        return True


# --- Production Verification Simulation Script ---
if __name__ == "__main__":
    pricing = TieredHourlyPricingStrategy(first_hour_rate=6.0, extension_rate=4.0, daily_cap=35.0)
    garage = ParkingLotEngine(facility_name="Metro Central Hub", pricing_strategy=pricing)

    # Initialize facility with 1 floor containing 2 Compact and 1 EV charging spot
    floor_1 = ParkingFloor(floor_number=1)
    floor_1.register_spot(CompactSpot("A-101", 1))
    floor_1.register_spot(CompactSpot("A-102", 1))
    floor_1.register_spot(ElectricSpot("EV-001", 1))
    garage.add_floor(floor_1)

    # Simulate Vehicle Arrivals
    car_1 = Car(license_plate="KA-01-EQ-4421")
    ev_1 = ElectricCar(license_plate="MH-12-EV-9901")
    car_2 = Car(license_plate="DL-08-CC-1192")
    truck_1 = Truck(license_plate="TN-22-TK-8888")

    print("--- Phase 1: Entry Gate Processing ---")
    ticket_car1 = garage.process_vehicle_entry(car_1, entry_gate_id=1)
    ticket_ev1 = garage.process_vehicle_entry(ev_1, entry_gate_id=1)
    ticket_car2 = garage.process_vehicle_entry(car_2, entry_gate_id=2)

    print("--- Phase 2: Structural Capacity Ceiling Test ---")
    # Truck attempts entry into garage possessing zero remaining Large spots
    garage.process_vehicle_entry(truck_1, entry_gate_id=2)

    print("--- Phase 3: Exit Toll Gate Settlement & Fee Assessment ---")
    # Car 1 exits after sitting parked for 3.5 elapsed hours
    simulated_exit_time = datetime.now() + timedelta(hours=3, minutes=30)
    if ticket_car1:
        garage.process_vehicle_exit(ticket_car1.ticket_id, exit_gate_id=1, exit_timestamp=simulated_exit_time)

6. Mathematical Modeling & Concurrency Architecture

When an infrastructure operates at massive scale—such as an international airport parking deck boasting 15,000 stalls across 8 towers—concurrency lock management and occupancy forecasting require mathematical framing.

Dynamic Surge Pricing Formula (Occupancy Demand Elasticity)

To optimize income yields and regulate ingress traffic during peak congestion spikes, pricing strategies implement real-time surge multipliers modeled on exponential capacity saturation ($U(t)$):

$P(t) = P_{\text{base}} \times \left( 1 + \alpha \cdot e^{\beta \cdot U(t)} \right)$

Where:

• $U(t) = \frac{\text{Active Occupied Spots}}{\text{Total Facility Capacity}}$ = Real-time parking lot saturation percentage ($0 \le U(t) \le 1$).
• $P_{\text{base}}$ = Standard municipal baseline hourly billing rate (e.g., \5.00/\text$).
• $\alpha, \beta$ = Configurable financial shaping coefficient parameters (typically $\alpha = 0.2, \beta = 3.0$).
• When utilization $U(t) \le 0.60$ ($60\%$ occupancy), the exponential modifier remains practically dormant, charging standard baseline rates. However, as utilization sweeps past $85\%$ to $95\%$, the tariff curve shoots upward exponentially, naturally disincentivizing non-essential long-term storage and reserving remaining bays for urgent high-yield travelers.

Concurrency Lock Granularity (Avoiding Bottleneck Contention)

A naive architectural mistake is slapping an exclusive global synchronization lock (synchronized / Mutex) straight across the primary ParkingLotEngine.process_vehicle_entry() workflow.

• The Mathematical Failure: If executing an ALPR license scan and DB allocation query consumes an operational processing duration ($W$) of $200\text{ ms}$, a global mutex physically caps total system entry capacity ($\lambda$) across all facility gates combined to just:

$\lambda_{\text{max}} = \frac{1\text{ second}}{0.200\text{ seconds}} = 5\text{ vehicles per second}$

During peak sporting event arrivals across 16 access lanes, queue wait times erupt instantly into hour-long gridlocks.

• The Optimal Engineering Fix (Fine-Grained Striped Locking): We completely decompose global synchronization locks down to Individual Space Level Mutexes (ParkingSpot.lock) or utilize optimistic concurrency versioning in relational storage schemas (UPDATE ParkingSpot SET is_occupied = TRUE, vehicle_id = ? WHERE spot_id = ? AND is_occupied = FALSE). This allows hundreds of multi-threaded entrance gate booths to scan, assign, and process unrelated floor spaces simultaneously in completely decoupled non-blocking parallel execution streams.

7. Edge Cases & Fault Recovery Protocols

An industrial automated parking controller must handle messy real-world physical discrepancies cleanly without stalling structural operations:

1. The Lost Ticket Resolution Protocol

• Mechanism: A patron approaches an exit payment booth having completely misplaced their paper barcode ParkingTicket. A standard exit lookup (active_tickets.get(id)) returns None, threatening to leave the barrier boom locked shut indefinitely and paralyzing exit queue traffic behind them.
• Remediation: The system invokes an ALPR Camera Recovery Routine. The exit booth ALPR camera scans the departing car's rear license plate string (KA-01-EQ-4421) and executes a reverse secondary database index lookup against active active parking records (SELECT * FROM ActiveTickets WHERE license_plate = ? AND status = 'ACTIVE'). If a clean match succeeds, the system computes standard hourly fees based on original automated entry timestamps without applying penal lost-ticket charges. If plate recognition fails entirely, the payment processor defaults to assessing a flat maximum structural liability fee (F_{\text{lost}} = \50.00$) before overriding barrier interlocks.

2. Ghost Occupancy & Sensor Disconnection Drift

• Mechanism: Ultrasonic overhead presence sensors wired above every bay occasionally broadcast false readings (e.g., a fluttering plastic trash bag or stray dog triggers an occupancy state flag on an entirely vacant stall). Over several weeks, automated digital signboard counters drift out of synchronization with physical reality, reporting a floor as FULL while 20 stalls remain wide open.
• Remediation: Implement a dual-tier Self-Reconciling Event Loop. While high-speed daily routing depends on rapid in-memory boolean sensor counters (is_occupied), a low-priority automated reconciliation thread runs nightly at 03:00 UTC. It cross-references actual open database ticket count records against active mechanical sensor reads, resetting drifted display counters to match verifiable active ticket sums and tagging mismatched sensory stalls with an alert status (ItemStatus.SENSOR_MAINTENANCE).

3. Straddle Parking (Double-Space Consumption)

• Mechanism: A poorly positioned Ford F-150 truck parks diagonally across two adjacent Compact spaces (A-101 and A-102), physically destroying the capacity of spot A-102 while only possessing an administrative ticket assigned solely to A-101.
• Remediation: When an incoming driver subsequently receives a system assignment instructing them to dock at spot A-102, they arrive to discover it blocked. The system provides an interactive reporting feedback loop via mobile app or facility call box ("Spot Obstructed"). Upon receiving an obstruction trigger, the central dispatcher instantly toggles spot A-102 status into OUT_OF_SERVICE_OBSTRUCTED, dynamically generates a replacement high-priority parking assignment ticket for the displaced driver on an upgraded adjacent level, and dispatches a roving security towing officer to inspect the offending vehicle.

8. Senior Technical Interview Q&A

Q1: In an automated parking lot architecture, how do you handle concurrency when two entrance gates attempt to assign the single last remaining vacant space on Floor 1 to two distinct drivers simultaneously?

Answer: We protect spatial inventory allocations from race condition collisions by implementing Optimistic Concurrency Control (OCC) or atomicity primitives at the database execution layer, totally abandoning vulnerable application-level read-then-write logical loops. When an entrance booth thread selects target candidate spot A-101, it executes an atomic SQL conditional update statement:

UPDATE ParkingSpot 
SET is_occupied = TRUE, vehicle_plate = 'DL-08-CC-1192', lock_version = lock_version + 1
WHERE spot_id = 'A-101' AND is_occupied = FALSE AND lock_version = 0;

If two concurrent threads fire this query precisely at the exact same millisecond, the relational SQL engine's ACID transaction serialization guarantees that only one execution succeeds (returning 1 row affected). The competing thread instantaneously receives an execution result of 0 rows affected. Upon registering the failure, the rejected thread loops safely back into the allocation strategy engine to locate and claim the next available secondary space without ever exposing the driver to a collision.

Q2: Explain why you chose to represent space topologies via Inheritance (CompactSpot, ElectricSpot extending ParkingSpot) versus utilizing a simple composition field (String spotType = "COMPACT" on a single universal class).

Answer: While simple string composition works for trivial CRUD storage representations, an industrial OOP domain engine requires Behavioral Polymorphism across space classifications. An ElectricSpot is not merely a geometric box; it embodies distinct hardware control states and domain capabilities—such as tracking kilowatt charging draw rates (currentKwDraw), monitoring inductive plug connections (chargerConnected), and triggering high-voltage charging cutoff relays (stopCharging()). A standard CompactSpot possesses none of these behaviors or variables. By utilizing proper subclasses, we obey the Interface Segregation and Liskov Substitution principles: the pricing engine can dynamically down-cast or query interfaces (e.g., if isinstance(spot, Chargeable) to evaluate internal electrical kilowatt usage costs directly during checkout billing) without cluttering standard non-electric parking objects with irrelevant null fields and awkward operational methods.

Q3: Describe how you would extend your architectural design to support automated valet robotic parking systems (such as automated storage & retrieval garages - AS/RS), where robotic lifts transport unattended cars into inaccessible structural stacking racks.

Answer: We evolve our system seamlessly by abstracting the vehicle positioning mechanism:

1. Introduction of Robotic Conveyorship Abstractions: Create an operational manager class RoboticLiftController that orchestrates physical hardware conveyance dollies (ValetRobot).
2. Decoupled Customer Intake Sandbox: Replace traditional multi-level driver navigation ramps with a dedicated transfer sandbox zone (IntakeBay). When a patron arrives, they abandon their unattended vehicle inside an automated IntakeBay.
3. Asynchronous Dispatch Event Engine: The entry terminal triggers an asynchronous delivery event instruction (ConveyVehicleCommand(vehicle, intakeBay, targetSpot)). An available ValetRobot picks up the vehicle, utilizes optimal orthogonal rack transport grids to elevate the vehicle into a high-density, inaccessible stacking shelf (AutomatedStackingSpot), and records the rack coordinates. When the patron returns to pay, the system executes an inverted retrieval event (RetrieveVehicleCommand), returning the vehicle to a Ground Departure Bay while billing completes.

Q4: If a sudden structural power outage terminates network internet connectivity to cloud payment processors (Stripe/PayPal), how does your local gate architecture gracefully degrade to permit exiting drivers to depart without paralyzing the entire municipal traffic grid?

Answer: A life-safety traffic facility can never lock barrier booms closed simply because an external WAN API gateway drops connection. We architect an Offline Store-and-Forward Failover Mechanism:

1. Local Edge Cache Verification: Every individual physical exit gate control terminal maintains a resilient local embedded database shard (e.g., SQLite or RocksDB) mirroring active open ticket cryptographic signature hashes.
2. Offline Credit Capture Mode: Upon detecting network timeout failure to primary cloud payment gateways, the gate transits automatically into OFFLINE_TRANSACTION_MODE. Instead of executing live bank authorization holds, the payment device captures the patron's encrypted EMV chip payment card authorization token and stores the transaction payload inside an encrypted local append-only persistence spool.
3. Immediate Barrier Release: The ticket status toggles to PENDING_SETTLEMENT_OFFLINE and the exit barrier opens immediately, ensuring unimpeded physical vehicular evacuation.
4. Asynchronous Batch Reconciliation: When facility WAN network connectivity subsequently re-establishes, a background daemon processes the local encrypted transaction spool sequentially, submitting delayed payment authorizations to cloud gateways and reconciling final revenue ledgers.

Q5: How would you structure real-time spatial analytics to display guidance navigation arrows on smartphone apps, leading an entering driver straight to their specific reserved bay inside a labyrinthine underground garage?

Answer: We synthesize low-latency IoT mesh tracking with indoor spatial routing graph topologies:

1. Indoor Localization Mesh: Because standard satellite GPS signals fail completely inside underground concrete parking subterranean towers, deploy a localized Bluetooth Low Energy (BLE) Beacon Mesh or Ultra-Wideband (UWB) transceiver grid across parking ceiling nodes.
2. Graph Topology Routing Engine: Model the entire parking deck floor structures, directional drive ramps, one-way concrete lanes, and turning radiuses as a weighted directed adjacency graph ($G = \langle V, E \rangle$). Vertices represent vehicular intersection nodes and space docking entrances; edges represent drivable asphalt path segments weighted by current travel distance and congestion latency.
3. Dynamic A Shortest-Path Computation:* When an arriving driver is issued ticket assignment targeting spot B-204, the edge routing controller executes an instant A (A-Star) search heuristic algorithm* over the facility graph, computing the absolute shortest unblocked navigational driving route from Entry Gate #2 to Spot B-204.
4. Real-Time Turn-by-Turn Streaming: The facility telemetry routing server streams sequential directional vector instructions via persistent WebSockets down to the driver’s connected mobile device or automated vehicle display console, dynamically updating navigational guidance arrows as BLE beacon trilateration monitors the vehicle's progress across the garage floor.

9. Summary & Quick Architectural Reference

| Design Dimension | Novice Monolithic Approach | Senior Professional LLD Architecture | | :--- | :--- | :--- | | Space Topology Representation | A monolithic flat array or database table containing simple strings (type="COMPACT") | Decoupled Object-Oriented polymorphism with dedicated subclasses (CompactSpot, ElectricSpot) | | Concurrency & Lock Control | Coarse-grained global execution lock spanning the entire entry booth assignment method | Fine-grained striped row locking or Optimistic Concurrency versioning (lock_version) | | Fee Fee Pricing Calculation | Hardcoded conditional if/else loops inside the checkout exit method | Open/Closed modular formulations using the Strategy Pattern (PricingStrategy) | | Display Signboards | Infinite continuous relational polling queries executing in background CPU loops | Asynchronous real-time event alerts triggered by Observable floor design patterns (Observer) | | System Resilience | Freezing exit barrier booms shut when external payment network APIs time out | Local embedded database caching with offline encrypted Store-and-Forward batch processing | | Spot Discovery Routing | Naive chronological sequential scanning from spot index zero | Graph heuristic evaluation (A*) and pluggable allocation strategies (NearestElevatorStrategy) |