Uber·Software Engineer·Onsite - System Design / Architecture·Intermediate

IntermediatePrefer not to say

May 2026

Summary

Uber SWE interview with a classic OOP system design question. The parking lot problem sounds like a warm-up but they want real depth on class hierarchies, spot compatibility logic, and fee calculation. Pretty standard for this kind of role but you need to actually know your design patterns.

Questions Asked (1)

Design an object-oriented model for a parking lot system that supports multiple levels, spot sizes, different vehicle types, vehicle entry and exit with fee calculation, and availability queries.

System DesignData ModelingTechnical Trade-offs

Author's notes

This question has a lot of moving parts and I underestimated how much they'd push on the bus/truck multi-spot adjacency logic.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying requirements and constraints, then define core entities and their relationships using object-oriented principles. Walk through key use cases like entry, exit, and availability queries, discussing design patterns and trade-offs for scalability and concurrency.

Pro tip: Emphasize extensibility and separation of concerns: use interfaces for vehicle and spot types, and consider how pricing strategies can be plugged in without modifying core logic. This shows you think beyond basic functionality.

1. Clarify Requirements and Scope

Ask questions to understand expected scale, concurrency needs, payment handling, and any special features like reservations or electric vehicle charging.

2. Identify Core Entities and Relationships

Define classes such as ParkingLot, Level, ParkingSpot, Vehicle, Ticket, and Payment, and establish their associations (e.g., a lot has levels, a level has spots).

3. Design Entry and Exit Flows

Model how a vehicle enters (find available spot, issue ticket) and exits (calculate fee based on duration and vehicle type, process payment, free spot).

4. Incorporate Design Patterns and Extensibility

Apply patterns like Strategy for pricing, Factory for vehicle/spot creation, and Singleton for the parking lot instance to allow future extensions.

5. Discuss Trade-offs and Scalability

Address concurrency (locking, atomic operations), data consistency, and potential bottlenecks; consider how to scale to multiple lots or distributed systems.

Key Points to Mention

Use of interfaces/abstract classes for Vehicle and ParkingSpot to support multiple types and sizes.
Strategy pattern for flexible fee calculation based on vehicle type, duration, and dynamic pricing.
Concurrency control mechanisms (e.g., locks, optimistic concurrency) for spot allocation and ticket generation.
Availability queries: efficient data structures (e.g., maps by spot size) and possibly caching for real-time updates.
Ticket and payment handling: ticket as a record of entry/exit, integration with payment gateways.
Extensibility: how to add new vehicle types, spot sizes, or pricing models without major refactoring.

AI-generated suggestions, not part of the candidate's original notes. May be inaccurate — verify before relying on them.