← Flipster Interview Insights

Flipster·Software Engineer·Onsite - System Design / Architecture·Senior

SeniorPrefer not to say
Apr 2026Remote

Summary

Flipster system design round, focused entirely on a parking lot OOP problem that went way deeper than I expected. Thought it'd be a quick class diagram exercise but they kept pushing on concurrency, EVs, and reservations.

Questions Asked (4)

Q1

Design a parking lot system: walk through the class hierarchy (ParkingLot, Level, Spot, Vehicle types, Ticket), how spot types are assigned, and the full entry and exit flow including payment.

System DesignData ModelingTechnical Trade-offs
Author's notes

I jumped straight into the class diagram which felt right, but I fumbled the spot assignment policy for a few minutes.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying requirements and constraints (e.g., multiple levels, vehicle types, payment methods) to scope the design. Then present a clean class hierarchy with clear responsibilities, and walk through the entry/exit flows step-by-step, highlighting key design decisions and trade-offs. Emphasize extensibility and concurrency considerations where relevant.

Pro tip: Demonstrate awareness of real-world constraints like concurrent access to spots and payment processing failures; mention how you'd handle them (e.g., locking, idempotency) to show production maturity.

1. Clarify Requirements and Scope

Ask questions to understand expected scale, vehicle types, payment methods, and any special features (e.g., EV charging, valet). This ensures the design meets actual needs and avoids over-engineering.

2. Define Class Hierarchy and Responsibilities

Outline core classes: ParkingLot (singleton), Level, ParkingSpot (with type), Vehicle (abstract with subclasses), Ticket, and Payment. Explain relationships and why certain fields/methods belong where.

3. Explain Spot Assignment Strategy

Describe how spots are assigned based on vehicle type (e.g., motorcycle, car, truck) and spot size. Discuss allocation algorithms (e.g., first available, nearest to entrance) and how to handle full capacity.

4. Walk Through Entry Flow

Detail steps: vehicle arrives, ticket generated with timestamp and assigned spot, gate opens. Mention concurrency control (e.g., locking spots) and data persistence.

5. Walk Through Exit and Payment Flow

Detail steps: vehicle arrives at exit, ticket validated, fee calculated based on duration and vehicle type, payment processed, spot freed, gate opens. Discuss payment integration, error handling, and receipt generation.

Key Points to Mention

  • Use of inheritance and polymorphism for Vehicle and ParkingSpot types to support extensibility.
  • Concurrency handling for spot allocation and ticket generation (e.g., locks, atomic operations).
  • Payment calculation strategy (e.g., hourly rate, flat fee) and integration with external payment gateways.
  • Data persistence and recovery (e.g., database for tickets, spots) to handle system failures.
  • Design patterns like Singleton for ParkingLot, Factory for spot/vehicle creation, Strategy for payment.
  • Trade-offs between simplicity and scalability (e.g., single lot vs. distributed, in-memory vs. persistent).

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

Q2

How would you handle concurrency when multiple entry and exit gates are operating simultaneously on the same parking lot?

System DesignTechnical Trade-offs
Author's notes

This is where I started sweating.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying the requirements and scale, then propose a concurrency control strategy that ensures atomicity and consistency across gates. Discuss trade-offs between pessimistic and optimistic locking, and how to handle failures and edge cases.

Pro tip: Mention that you would use a centralized service with database transactions or a distributed lock, but also consider idempotency and retries to handle network partitions. Showing awareness of real-world failure modes like double-booking or lost updates will set you apart.

1. Clarify Requirements

Ask about expected traffic, number of gates, latency requirements, and consistency needs (e.g., is overbooking acceptable?).

2. Identify Shared State

Determine what data is shared: parking spot availability, entry/exit logs, and payment status. This will be the focus of concurrency control.

3. Choose Concurrency Control

Propose a mechanism: database transactions with row-level locking, optimistic concurrency with versioning, or a distributed lock (e.g., Redis). Discuss trade-offs.

4. Handle Failures and Edge Cases

Address network partitions, gate failures, and retries. Ensure operations are idempotent and consider compensating transactions.

5. Evaluate Trade-offs

Compare latency, scalability, and complexity of your approach. Suggest monitoring and metrics to detect contention.

Key Points to Mention

  • Atomic operations for entry/exit (e.g., check-and-set)
  • Pessimistic vs. optimistic locking trade-offs
  • Distributed locking with Redis or ZooKeeper
  • Idempotency and retry mechanisms
  • Database isolation levels and transactions
  • Handling partial failures and eventual consistency

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

Q3

How would you extend the design to support electric vehicle charging spots, and what changes would that require to your existing class structure?

System DesignTechnical Trade-offs
Author's notes

Honestly a fun one.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying the current design and requirements for EV charging, then propose an abstraction that separates charging behavior from parking spot logic. Use inheritance or composition to extend the class structure while minimizing changes to existing code, and discuss trade-offs of each approach.

Pro tip: Emphasize the Open/Closed Principle: extend without modifying existing classes, and mention how you'd handle backward compatibility and testing.

1. Clarify requirements

Ask questions to understand the scope: what types of charging (Level 1/2/DC fast), payment integration, real-time availability, and whether existing parking spot classes can be modified.

2. Identify extension points

Analyze the current class structure to find where charging-specific attributes and behaviors can be added, such as a new subclass or a decorator.

3. Propose design changes

Suggest introducing an interface like ChargingCapable or a separate ChargingStation class, and explain how it integrates with existing ParkingSpot hierarchy.

4. Discuss trade-offs

Compare inheritance vs. composition, and consider impacts on database schema, APIs, and client code. Mention scalability and maintainability.

5. Summarize and validate

Recap the proposed changes, confirm they meet requirements, and suggest a migration or testing strategy.

Key Points to Mention

  • Use of interfaces or abstract classes to define charging behavior
  • Composition over inheritance to avoid deep hierarchies
  • Impact on database schema (e.g., adding charging attributes)
  • API changes for clients to query and reserve charging spots
  • Backward compatibility and migration strategy
  • Testing approach for new charging functionality

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

Q4

How would you add a reservation system to the parking lot, where users can book a spot in advance?

System DesignData Modeling
Author's notes

I blanked for a second on how reservations interact with walk-in availability.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying requirements such as scale, user types, and booking rules. Then design the data model and core components for reservation, ensuring concurrency control and integration with existing parking lot systems. Finally, discuss trade-offs and potential optimizations.

Pro tip: Emphasize idempotency and handling of edge cases like no-shows and overbooking, as these are common pitfalls in reservation systems. Also, consider how the system integrates with real-time spot availability and payment processing.

1. Clarify Requirements

Ask questions to understand the expected scale, user flow, booking policies (e.g., advance booking window, cancellation), and integration points with existing systems.

2. Design Data Model

Define entities like User, ParkingSpot, Reservation, and Payment, and their relationships. Consider using a relational database for ACID transactions or NoSQL for scalability.

3. Architect Core Components

Outline services for reservation management, spot availability, payment processing, and notifications. Discuss how to handle concurrency (e.g., optimistic locking, distributed locks).

4. Address Edge Cases and Scalability

Cover scenarios like double-booking, no-shows, cancellations, and peak load. Propose solutions like idempotent APIs, queueing, and caching.

5. Discuss Trade-offs and Extensions

Compare design choices (e.g., SQL vs NoSQL, synchronous vs asynchronous booking) and suggest future enhancements like dynamic pricing or mobile integration.

Key Points to Mention

  • Concurrency control mechanisms (e.g., optimistic locking, distributed locks) to prevent double-booking.
  • Data model design with clear relationships and indexes for efficient queries.
  • Integration with existing parking lot systems for real-time spot availability.
  • Handling of edge cases: no-shows, cancellations, overbooking, and payment failures.
  • Scalability considerations: partitioning, caching, and asynchronous processing.
  • Idempotency of reservation APIs to handle retries safely.

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