How to Pass the Rapido SDE-2 LLD Interview

Interviewing for an SDE-2 role at Rapido means facing a brutal Low-Level Design (LLD) and machine coding round. It's the ultimate test of your object-oriented design and concurrency skills. Because Rapido operates at massive scale—processing millions of ride requests, driver locations, and dynamic fare calculations daily—interviewers aren't just looking for code that compiles. They expect a production-ready, extensible architecture that handles race conditions without breaking a sweat.

The most common LLD question in Rapido's SDE-2 loop asks you to design the core ride lifecycle and fare engine. You'll need to manage a strict state machine for the ride itself, handle multiple drivers competing for the exact same booking, and calculate fares dynamically based on shifting variables like traffic or weather. I'll break down exactly how to approach this problem, structure your entities, and implement the design patterns you need to ace the round.

The Anatomy of Rapido's SDE-2 Hiring Process

Before we get into the actual code structure, you should know where the LLD round fits into the overall loop. Rapido's interview process leans heavily on practical engineering skills rather than abstract brain teasers.

The Core Challenge: Ride Lifecycle and Dynamic Fares

When the interviewer drops the ride-sharing problem on you, they'll usually list a few core functional requirements. First, riders need to request a ride from a source to a destination. Next, nearby drivers receive a notification and can choose to accept the ride. From there, the ride follows a strict lifecycle: requested, accepted, arrived, in-progress, and finally completed or cancelled. Once the ride wraps up, your system has to calculate the final fare by factoring in base rates, distance, time, and potential surge pricing.

But the hidden non-functional requirements are usually where candidates crash and burn. You absolutely have to guarantee thread safety, mostly because multiple drivers might tap 'accept' at the exact same time. You also need serious extensibility since pricing rules change constantly. If you hardcode a massive switch-statement to handle the ride state or fare calculations, expect an immediate rejection.

Designing the Domain Model and Database Schema

Any solid LLD solution kicks off with a clean domain model. In a live machine coding round, you'll likely just build these as in-memory classes. Still, you should always discuss the database schema with your interviewer to prove you actually understand data persistence.

• Rider: Contains rider_id, name, rating, and payment_info.
• Driver: Contains driver_id, name, vehicle_details, current_location, and status (AVAILABLE, BUSY, OFFLINE).
• Location: A value object representing latitude and longitude.
• Ride: The central aggregate root. Contains ride_id, rider_id, driver_id, pickup_location, drop_location, status, start_time, end_time, and fare.
• Fare: Contains breakdown details like base_fare, distance_fare, time_fare, surge_multiplier, and total_amount.

While you're coding, make sure to mention that a real-world relational database would need a composite index on rider_id and status on the Ride table to quickly fetch a user's active rides. You'd also want an index on driver_id. For driver locations, you'd typically store those in a geospatial database or an in-memory datastore like Redis, relying on GeoHashes for blazing-fast proximity queries.

Implementing the State Pattern for Thread-Safe Ride Transitions

Every ride transitions through a specific sequence of states. If you just throw a 'status' enum into a single class and write methods packed with if-else checks to validate those transitions, your codebase will turn into an unmaintainable mess almost instantly. Instead, you need to reach for the State Design Pattern.

Start by defining a RideState interface featuring methods like acceptRide(), cancelRide(), startRide(), and endRide(). From there, build out concrete classes for each specific state: RequestedState, AcceptedState, InProgressState, and CompletedState. Your main Ride context class will simply hold a reference to the current RideState object.

Here's how it plays out: if a ride sits in the RequestedState, calling acceptRide() transitions the context right over to the AcceptedState. But if a rider tries to cancel a ride that's already in the InProgressState, the InProgressState class just throws an InvalidTransitionException. This approach completely wipes out conditional spaghetti code and keeps you strictly aligned with the Open/Closed Principle.

Solving Concurrency: Mitigating the Double-Accept Race Condition

The ultimate trap in this specific interview is the concurrent acceptance problem. Imagine a new ride gets broadcast to three nearby drivers. Driver A and Driver B both tap 'Accept' at the exact same millisecond. If your code just checks whether the ride status is 'REQUESTED' and blindly assigns the driver, both threads might pass the check. Suddenly, you have two drivers showing up at the same pickup location.

To handle this during an in-memory machine coding round, you can wrap the accept method for a specific ride object in synchronized blocks or ReentrantLocks in Java (or Mutexes if you're writing Go/C++). That solves the local problem, but you still have to explain how this actually scales in a distributed system.

This is where you explain Optimistic Concurrency Control (OCC) to your interviewer. You add a 'version' integer to your Ride entity. When a driver attempts to accept, your SQL update should look exactly like this: UPDATE rides SET driver_id = 'D1', status = 'ACCEPTED', version = version + 1 WHERE id = 'R1' AND status = 'REQUESTED' AND version = 1. If Driver B's request hits the database a millisecond later, the version will already be 2. The WHERE clause fails, zero rows get updated, and your application safely throws a RideAlreadyAcceptedException.

Plugging in Extensible Fare Strategies via the Strategy Pattern

Fares at Rapido are never static. Sure, a basic fare calculation just multiplies distance by a rate and time by a rate. But what happens when a rainstorm hits, peak rush hour starts, or marketing runs a special promotional event? If you hardcode all those rules into a single FareCalculator service, you completely violate the Single Responsibility Principle.

The fix here is the Strategy Design Pattern. You'll want to create a FareCalculationStrategy interface with a single calculateFare(Ride ride) method. Then, build out concrete implementations like DefaultFareStrategy, SurgeFareStrategy, and FlatDiscountFareStrategy.

To tie the whole thing together, build a FareStrategyFactory. When a ride ends, the system passes the current context—like weather, time of day, and active promo codes—straight to the factory. The factory evaluates those rules, instantiates the correct strategy (like SurgeFareStrategy if demand is spiking), and returns it to the ride manager to compute the final price. Showing off this kind of modularity proves you know how to build software that adapts to shifting business requirements.

How AcePrompt Helps You Live-Code LLD Systems under Pressure

Knowing these design patterns is one thing, but remembering to actually apply them while an engineering manager stares at your screen is a totally different story. High-pressure interview environments often push candidates into defaulting to messy if-else statements just to get the code working—which usually costs them the offer.

This is exactly where AcePrompt AI steps in as your real-time interview copilot. As the interviewer explains the requirements for the ride lifecycle, AcePrompt quietly analyzes the conversation and displays structured, context-aware suggestions right on your screen. So, if the interviewer suddenly asks how you'd handle two drivers accepting the same ride, AcePrompt instantly surfaces the Optimistic Concurrency Control approach. You get to deliver a senior-level answer without missing a single beat.