Design a Parking Garage System for Your Next Interview

Designing a Parking Garage System for a technical interview involves breaking down the problem into manageable components, defining key requirements, and creating a scalable, efficient solution. Below is a comprehensive guide to designing a parking garage system, tailored for system design interviews.

1. Problem Understanding and Requirements

Start by clarifying the requirements. A parking garage typically involves managing parking spots, handling multiple vehicles, and ensuring vehicles can enter, park, and exit efficiently.

Functional Requirements:

• Park Vehicle: The system should allow a vehicle to park in an available space.

• Retrieve Vehicle: The system should allow retrieval of the vehicle from its designated parking spot.

• Multiple Vehicle Types: The system should support cars, motorcycles, and potentially large vehicles like trucks.

• Track Parking Time: Track how long a vehicle has been parked to calculate charges.

• Parking Space Availability: Display available parking spots, categorized by type (compact, standard, oversized).

• Payment Handling: Calculate parking fees based on time spent and handle payments.

• Exit: Ensure smooth exit for vehicles once they’ve been retrieved.

Non-Functional Requirements:

• Scalability: The system should scale as more parking spots are added or as the garage expands.

• Performance: Responses to parking requests should be fast, and the retrieval of vehicles should be efficient.

• Concurrency: Multiple vehicles can enter or leave the garage at the same time.

2. Identify Key Components

The system needs to handle several components, each of which will interact with others. These are:

• Parking Spots Management: Tracks available and occupied parking spaces.

• Parking Ticketing System: Manages ticket creation, time tracking, and payment.

• Vehicle Tracking: Keeps track of which vehicle is parked where.

• Payment Gateway: Handles calculations and payments.

• Entrance and Exit Management: Manages vehicle access and exit.

3. Class Design and Object Modeling

Let’s break down the object-oriented design of the system into its core classes.

3.1. Vehicle Class

This will represent a vehicle parked in the garage.

python
CopyEdit
class Vehicle:
    def __init__(self, vehicle_id, vehicle_type, entry_time):
        self.vehicle_id = vehicle_id
        self.vehicle_type = vehicle_type  # 'car', 'motorcycle', 'truck'
        self.entry_time = entry_time
        self.exit_time = None
        self.ticket = None

3.2. ParkingSpot Class

This represents a parking spot in the garage.

python
CopyEdit
class ParkingSpot:
    def __init__(self, spot_id, spot_type, is_available=True):
        self.spot_id = spot_id
        self.spot_type = spot_type  # 'compact', 'standard', 'oversized'
        self.is_available = is_available
        self.vehicle = None  # Reference to the vehicle occupying this spot

    def park_vehicle(self, vehicle):
        if self.is_available:
            self.vehicle = vehicle
            self.is_available = False
            return True
        return False

    def retrieve_vehicle(self):
        self.vehicle.exit_time = datetime.now()
        self.is_available = True
        self.vehicle = None

3.3. ParkingTicket Class

Handles ticket management.

python
CopyEdit
class ParkingTicket:
    def __init__(self, ticket_id, vehicle, entry_time):
        self.ticket_id = ticket_id
        self.vehicle = vehicle
        self.entry_time = entry_time
        self.exit_time = None
        self.amount_due = 0.0
    
    def calculate_amount(self, rate_per_hour):
        if self.exit_time:
            duration = self.exit_time - self.entry_time
            self.amount_due = duration.total_seconds() / 3600 * rate_per_hour
        return self.amount_due

3.4. ParkingGarage Class

The main controller that interacts with the parking spots and vehicles.

python
CopyEdit
class ParkingGarage:
    def __init__(self, total_spots):
        self.total_spots = total_spots
        self.parking_spots = {spot_id: ParkingSpot(spot_id, "standard") for spot_id in range(total_spots)}
        self.vehicle_registry = {}

    def park_vehicle(self, vehicle):
        for spot in self.parking_spots.values():
            if spot.is_available:
                spot.park_vehicle(vehicle)
                ticket = ParkingTicket(vehicle.vehicle_id, vehicle, vehicle.entry_time)
                vehicle.ticket = ticket
                self.vehicle_registry[vehicle.vehicle_id] = vehicle
                return ticket
        return None  # No available spots

    def retrieve_vehicle(self, vehicle_id):
        vehicle = self.vehicle_registry.get(vehicle_id)
        if vehicle and vehicle.ticket:
            vehicle.ticket.exit_time = datetime.now()
            for spot in self.parking_spots.values():
                if spot.vehicle == vehicle:
                    spot.retrieve_vehicle()
                    return vehicle.ticket.calculate_amount(5)  # Charge 5 per hour
        return None

4. Database Design

For large-scale systems, consider a database schema for storing parking tickets, vehicles, and parking spots.

Tables:

• Vehicles: Stores vehicle information (vehicle_id, vehicle_type, entry_time, exit_time).

• ParkingSpots: Stores information about each spot (spot_id, spot_type, availability, vehicle_id).

• ParkingTickets: Stores ticket information (ticket_id, vehicle_id, entry_time, exit_time, amount_due).

5. System Design Considerations

• Concurrency Control: Use locks or queues to ensure that two vehicles do not park in the same spot at the same time. For a more scalable solution, consider using a distributed lock or centralized controller.

• Scalability: If the garage system grows, we can scale vertically by adding more servers or horizontally by using a distributed system to handle requests.

• Rate Calculation: Introduce dynamic rate adjustments based on time (e.g., different rates during peak hours).

• Fault Tolerance: Implement failover systems in case of system crashes (for example, using a replication system for the database).

6. Edge Cases and Error Handling

• Full Parking Garage: When no spots are available, the system should notify the user that the garage is full.

• Invalid Vehicle ID: Ensure that vehicle IDs and ticket IDs are validated before proceeding with actions.

• Overstay: If a vehicle stays beyond the allowed time, the system may impose additional fees or penalties.

7. Conclusion

In a system design interview, presenting a clean and scalable solution is key. Make sure to focus on clear abstractions like Vehicle, ParkingSpot, and ParkingTicket that allow the system to manage the parking process smoothly. Ensure the system can handle scalability and concurrency, as these are often core concerns in system design interviews.