System Design (LLD)Ride-Sharing Service

Case Study: Ride-Sharing Service Design

LevelAdvanced

Duration120 mins

TopicRide-Sharing Service

4 / 6

Pricing and State Management

The Economics and Lifecycle of a Ride

Two interrelated systems govern every ride: pricing determines what the rider pays and driver earns, while state management ensures the trip progresses correctly from request to completion. Both require careful design—pricing for flexibility and fairness, state management for consistency and robustness.

Why these topics together:

Pricing depends on trip state (estimated fare at request, actual fare at completion). State transitions trigger pricing calculations, payment processing, and notifications. Understanding both together reveals how they orchestrate the complete ride experience.

What You Will Learn

By the end of this page, you will understand multi-component fare calculation, surge pricing implementation, the Strategy pattern for pricing policies, and comprehensive state machine design that handles all trip lifecycle events including edge cases and cancellations.

Understanding Fare Components

Ride-sharing fares typically consist of multiple components combined into a final price. Understanding these components is essential for designing a flexible pricing system.

Core fare formula:

Fare = (BaseFare + (Distance × PerKmRate) + (Time × PerMinRate)) × SurgeMultiplier
     + BookingFee + Tolls - Discounts

This formula provides levers for various business objectives: base fare ensures minimum payout, distance and time rates reflect actual trip cost, surge balances supply and demand, and discounts enable marketing.

Fare Components Breakdown
Component	Description	Typical Value	When Applied
Base Fare	Minimum charge for any trip	$2-5	Always
Per-Kilometer Rate	Distance-based charge	$1-2/km	Based on route distance
Per-Minute Rate	Time-based charge	$0.20-0.40/min	Trip duration
Booking Fee	Platform service fee	$1-3	Per booking
Surge Multiplier	Supply/demand factor	1.0x - 3.0x+	High demand periods
Tolls/Fees	Pass-through costs	Variable	If route includes tolls
Minimum Fare	Floor for short trips	$5-8	If calculated < minimum
Cancellation Fee	Penalty for late cancel	$3-10	Post-threshold cancellation

Estimated vs Actual Fare

At request time, we calculate estimated fare based on predicted route distance and time. At completion, we calculate actual fare based on the real route taken. The difference is why riders sometimes see 'Your trip cost $X.XX' that differs from the initial estimate.

Pricing Strategy Pattern

Different ride types, regions, and times may have different pricing rules. The Strategy pattern allows us to swap pricing algorithms without modifying the booking flow.

Why Strategy for pricing:

Standard rides use basic distance + time formula
Premium rides have higher base and per-km rates
Pool rides use per-seat pricing with discounts
Subscription members get percentage discounts
Promotional periods apply special rates

Each is a PricingStrategy implementation.

PricingStrategy.ts
TypeScript
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
interface Fare {
    baseFare: number;
    distanceFare: number;
    timeFare: number;
    bookingFee: number;
    surgeMultiplier: number;
    surgeFare: number;     // Additional surge amount
    tolls: number;
    discount: number;
    totalFare: number;
    currency: string;
}
 
interface TripDetails {
    distanceKm: number;
    durationMinutes: number;
    vehicleType: VehicleType;
    pickupLocation: Location;
    isEstimate: boolean;
}
 
interface PricingStrategy {
    calculateFare(details: TripDetails, surgeMultiplier: number): Fare;
    getName(): string;
}
 
/**
 * Standard ride pricing
 */
class StandardPricingStrategy implements PricingStrategy {
    private readonly baseFare = 2.50;
    private readonly perKmRate = 1.20;
    private readonly perMinRate = 0.25;
    private readonly bookingFee = 1.50;
    private readonly minimumFare = 6.00;
 
    getName(): string { return 'STANDARD'; }
 
    calculateFare(details: TripDetails, surgeMultiplier: number): Fare {
        const distanceFare = details.distanceKm * this.perKmRate;
        const timeFare = details.durationMinutes * this.perMinRate;
        
        const subtotal = this.baseFare + distanceFare + timeFare;
        const surgedSubtotal = subtotal * surgeMultiplier;
        const surgeFare = surgedSubtotal - subtotal;
        
        let totalFare = surgedSubtotal + this.bookingFee;
        totalFare = Math.max(totalFare, this.minimumFare);
 
        return {
            baseFare: this.baseFare,
            distanceFare,
            timeFare,
            bookingFee: this.bookingFee,
            surgeMultiplier,
            surgeFare,
            tolls: 0,
            discount: 0,
            totalFare: Math.round(totalFare * 100) / 100,
            currency: 'USD',
        };
    }
}
 
/**
 * Premium/luxury vehicle pricing
 */
class PremiumPricingStrategy implements PricingStrategy {
    private readonly baseFare = 5.00;
    private readonly perKmRate = 2.50;
    private readonly perMinRate = 0.45;
    private readonly bookingFee = 2.50;
    private readonly minimumFare = 12.00;
 
    getName(): string { return 'PREMIUM'; }
 
    calculateFare(details: TripDetails, surgeMultiplier: number): Fare {
        const distanceFare = details.distanceKm * this.perKmRate;
        const timeFare = details.durationMinutes * this.perMinRate;
        
        const subtotal = this.baseFare + distanceFare + timeFare;
        const surgedSubtotal = subtotal * surgeMultiplier;
        const surgeFare = surgedSubtotal - subtotal;
        
        let totalFare = surgedSubtotal + this.bookingFee;
        totalFare = Math.max(totalFare, this.minimumFare);
 
        return {
            baseFare: this.baseFare,
            distanceFare,
            timeFare,
            bookingFee: this.bookingFee,
            surgeMultiplier,
            surgeFare,
            tolls: 0,
            discount: 0,
            totalFare: Math.round(totalFare * 100) / 100,
            currency: 'USD',
        };
    }
}
 
/**
 * Factory to get appropriate pricing strategy
 */
class PricingStrategyFactory {
    private strategies: Map<VehicleType, PricingStrategy> = new Map();
 
    constructor() {
        this.strategies.set(VehicleType.STANDARD, new StandardPricingStrategy());
        this.strategies.set(VehicleType.PREMIUM, new PremiumPricingStrategy());
        // Add more as needed
    }
 
    getStrategy(vehicleType: VehicleType): PricingStrategy {
        return this.strategies.get(vehicleType) || new StandardPricingStrategy();
    }
}

Surge Pricing Design

Surge pricing (or dynamic pricing) adjusts fares based on supply and demand. When rider demand exceeds driver supply in an area, prices increase to incentivize more drivers to that area and discourage price-sensitive riders, helping balance the market.

Surge calculation factors:

Demand: Number of pending ride requests in a zone
Supply: Number of available drivers in a zone
Ratio: Demand / Supply
Thresholds: Map ratio ranges to multiplier levels

Design considerations:

Surge is zone-based (geographic areas, not individual locations)
Surge updates periodically (every 1-5 minutes)
Surge is capped (usually 2x-3x maximum)
Riders must confirm surge before booking

SurgePricingService.ts
TypeScript
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
interface Zone {
    id: string;
    name: string;
    polygon: Location[];  // Bounding polygon
}
 
class SurgePricingService {
    private zoneSurgeMultipliers: Map<string, number> = new Map();
    private readonly updateIntervalMs = 60000;  // Update every minute
    private readonly maxSurge = 3.0;
    private readonly surgeThresholds: { ratio: number; multiplier: number }[] = [
        { ratio: 0.0, multiplier: 1.0 },   // Supply >= Demand
        { ratio: 1.5, multiplier: 1.25 },  // 1.5x demand vs supply
        { ratio: 2.0, multiplier: 1.5 },
        { ratio: 2.5, multiplier: 1.75 },
        { ratio: 3.0, multiplier: 2.0 },
        { ratio: 4.0, multiplier: 2.5 },
        { ratio: 5.0, multiplier: 3.0 },   // 5x+ demand = max surge
    ];
 
    /**
     * Get current surge multiplier for a location.
     */
    getSurgeMultiplier(location: Location): number {
        const zone = this.findZone(location);
        if (!zone) return 1.0;
        return this.zoneSurgeMultipliers.get(zone.id) || 1.0;
    }
 
    /**
     * Recalculate surge for all zones.
     * Called periodically by a background job.
     */
    async recalculateSurge(
        demandByZone: Map<string, number>,
        supplyByZone: Map<string, number>
    ): Promise<void> {
        for (const [zoneId, demand] of demandByZone) {
            const supply = supplyByZone.get(zoneId) || 0;
            
            let ratio: number;
            if (supply === 0) {
                ratio = demand > 0 ? Infinity : 0;
            } else {
                ratio = demand / supply;
            }
 
            const multiplier = this.ratioToMultiplier(ratio);
            this.zoneSurgeMultipliers.set(zoneId, multiplier);
        }
    }
 
    private ratioToMultiplier(ratio: number): number {
        for (let i = this.surgeThresholds.length - 1; i >= 0; i--) {
            if (ratio >= this.surgeThresholds[i].ratio) {
                return Math.min(this.surgeThresholds[i].multiplier, this.maxSurge);
            }
        }
        return 1.0;
    }
 
    private findZone(location: Location): Zone | null {
        // Implementation would check which zone polygon contains the location
        return null;  // Simplified
    }
 
    /**
     * Check if surge requires rider confirmation.
     */
    requiresConfirmation(multiplier: number): boolean {
        return multiplier > 1.0;
    }
}

Ethical Considerations

Surge pricing is controversial. Some view it as efficient market pricing; others see it as exploitative during emergencies. Many ride-sharing companies now cap surge during declared emergencies and disasters. Your design should support configurable caps and surge suspension.

Trip State Machine Implementation

The trip state machine is the control center of ride lifecycle management. Every action—driver acceptance, arrival, trip start, completion, cancellation—is a state transition with validation, side effects, and notifications.

State machine implementation approaches:

Enum + switch: Simple, state logic in Trip methods
State pattern: Each state is a class with allowed transitions
External state machine library: Configurable, visual tooling

For interviews, Enum + careful validation is usually sufficient. Let's see a robust implementation:

TripStateMachine.ts
TypeScript
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
enum TripState {
    REQUESTED = 'REQUESTED',
    MATCHING = 'MATCHING',
    DRIVER_ASSIGNED = 'DRIVER_ASSIGNED',
    DRIVER_ARRIVED = 'DRIVER_ARRIVED',
    TRIP_IN_PROGRESS = 'TRIP_IN_PROGRESS',
    TRIP_COMPLETED = 'TRIP_COMPLETED',
    CANCELLED_BY_RIDER = 'CANCELLED_BY_RIDER',
    CANCELLED_BY_DRIVER = 'CANCELLED_BY_DRIVER',
    CANCELLED_NO_SHOW = 'CANCELLED_NO_SHOW',
    NO_DRIVERS_AVAILABLE = 'NO_DRIVERS_AVAILABLE',
}
 
enum TripEvent {
    START_MATCHING = 'START_MATCHING',
    DRIVER_ASSIGNED = 'DRIVER_ASSIGNED',
    MATCHING_FAILED = 'MATCHING_FAILED',
    DRIVER_ARRIVED = 'DRIVER_ARRIVED',
    START_TRIP = 'START_TRIP',
    COMPLETE_TRIP = 'COMPLETE_TRIP',
    RIDER_CANCEL = 'RIDER_CANCEL',
    DRIVER_CANCEL = 'DRIVER_CANCEL',
    NO_SHOW = 'NO_SHOW',
}
 
interface StateTransition {
    from: TripState;
    event: TripEvent;
    to: TripState;
    guard?: (trip: Trip) => boolean;
    action?: (trip: Trip) => Promise<void>;
}
 
class TripStateMachine {
    private transitions: StateTransition[] = [
        // Happy path
        { from: TripState.REQUESTED, event: TripEvent.START_MATCHING, to: TripState.MATCHING },
        { from: TripState.MATCHING, event: TripEvent.DRIVER_ASSIGNED, to: TripState.DRIVER_ASSIGNED },
        { from: TripState.DRIVER_ASSIGNED, event: TripEvent.DRIVER_ARRIVED, to: TripState.DRIVER_ARRIVED },
        { from: TripState.DRIVER_ARRIVED, event: TripEvent.START_TRIP, to: TripState.TRIP_IN_PROGRESS },
        { from: TripState.TRIP_IN_PROGRESS, event: TripEvent.COMPLETE_TRIP, to: TripState.TRIP_COMPLETED },
        
        // Matching failures
        { from: TripState.MATCHING, event: TripEvent.MATCHING_FAILED, to: TripState.NO_DRIVERS_AVAILABLE },
        
        // Rider cancellation (from multiple states)
        { from: TripState.REQUESTED, event: TripEvent.RIDER_CANCEL, to: TripState.CANCELLED_BY_RIDER },
        { from: TripState.MATCHING, event: TripEvent.RIDER_CANCEL, to: TripState.CANCELLED_BY_RIDER },
        { from: TripState.DRIVER_ASSIGNED, event: TripEvent.RIDER_CANCEL, to: TripState.CANCELLED_BY_RIDER },
        { from: TripState.DRIVER_ARRIVED, event: TripEvent.RIDER_CANCEL, to: TripState.CANCELLED_BY_RIDER },
        
        // Driver cancellation
        { from: TripState.DRIVER_ASSIGNED, event: TripEvent.DRIVER_CANCEL, to: TripState.CANCELLED_BY_DRIVER },
        { from: TripState.DRIVER_ARRIVED, event: TripEvent.NO_SHOW, to: TripState.CANCELLED_NO_SHOW },
    ];
 
    async transition(trip: Trip, event: TripEvent): Promise<TripState> {
        const currentState = trip.getState();
        const transition = this.transitions.find(
            t => t.from === currentState && t.event === event
        );
 
        if (!transition) {
            throw new Error(
                `Invalid transition: ${event} not allowed from ${currentState}`
            );
        }
 
        // Check guard condition if present
        if (transition.guard && !transition.guard(trip)) {
            throw new Error(`Guard condition failed for ${event}`);
        }
 
        // Execute action if present
        if (transition.action) {
            await transition.action(trip);
        }
 
        return transition.to;
    }
 
    getValidEvents(state: TripState): TripEvent[] {
        return this.transitions
            .filter(t => t.from === state)
            .map(t => t.event);
    }
 
    isTerminal(state: TripState): boolean {
        return !this.transitions.some(t => t.from === state);
    }
}

State Transition Side Effects

State transitions trigger important side effects: updating entity statuses, sending notifications, processing payments, and recording events. A well-designed system handles these consistently.

State Transition Side Effects
Transition	Side Effects
MATCHING → DRIVER_ASSIGNED	Update driver status to ASSIGNED; Notify rider with driver details; Start ETA tracking
DRIVER_ASSIGNED → DRIVER_ARRIVED	Notify rider driver has arrived; Start wait timer for no-show
DRIVER_ARRIVED → TRIP_IN_PROGRESS	Begin route tracking; Update rider/driver UI to trip mode
TRIP_IN_PROGRESS → TRIP_COMPLETED	Calculate final fare; Process payment; Credit driver; Prompt ratings; Archive trip
Any → CANCELLED_BY_RIDER	Free driver; Possibly charge cancellation fee; Notify driver; Log reason
Any → CANCELLED_BY_DRIVER	Notify rider; Attempt rematch; Record against driver metrics
DRIVER_ARRIVED → CANCELLED_NO_SHOW	Charge rider cancellation fee; Free driver; Record as rider no-show

TripService.ts
TypeScript
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
class TripService {
    private stateMachine: TripStateMachine;
    private notificationService: NotificationService;
    private paymentService: PaymentService;
    private fareCalculator: FareCalculator;
 
    async completeTrip(trip: Trip): Promise<void> {
        // 1. Validate transition
        const newState = await this.stateMachine.transition(
            trip, TripEvent.COMPLETE_TRIP
        );
 
        // 2. Calculate final fare
        const actualFare = this.fareCalculator.calculateActualFare(trip);
        trip.setActualFare(actualFare);
        trip.setState(newState);
 
        // 3. Process payment
        await this.paymentService.charge(
            trip.getRider(),
            actualFare.totalFare,
            trip.getId()
        );
 
        // 4. Credit driver (minus platform fee)
        const driverEarning = actualFare.totalFare * 0.75;  // 75% to driver
        await this.paymentService.credit(
            trip.getDriver()!,
            driverEarning,
            trip.getId()
        );
 
        // 5. Update statuses
        trip.getDriver()!.setStatus(DriverStatus.AVAILABLE);
        trip.getRider().setStatus(RiderStatus.IDLE);
 
        // 6. Request ratings
        await this.notificationService.sendRatingRequest(trip.getRider(), trip);
        await this.notificationService.sendRatingRequest(trip.getDriver()!, trip);
 
        // 7. Record for analytics
        await this.recordTripCompletion(trip);
    }
 
    async cancelByRider(trip: Trip, reason?: string): Promise<void> {
        const newState = await this.stateMachine.transition(
            trip, TripEvent.RIDER_CANCEL
        );
        trip.setState(newState);
 
        // Check if cancellation fee applies
        const shouldChargeFee = this.shouldChargeCancellationFee(trip);
        if (shouldChargeFee) {
            await this.paymentService.charge(
                trip.getRider(),
                this.getCancellationFee(trip),
                trip.getId()
            );
        }
 
        // Free the driver if one was assigned
        if (trip.getDriver()) {
            trip.getDriver()!.setStatus(DriverStatus.AVAILABLE);
            await this.notificationService.notifyRiderCancelled(trip.getDriver()!);
        }
 
        trip.getRider().setStatus(RiderStatus.IDLE);
    }
 
    private shouldChargeCancellationFee(trip: Trip): boolean {
        // Free cancellation within 2 minutes of driver assignment
        if (!trip.getMatchedAt()) return false;
        const elapsedMs = Date.now() - trip.getMatchedAt()!.getTime();
        return elapsedMs > 120000; // 2 minutes
    }
 
    private getCancellationFee(trip: Trip): number {
        return 5.00; // Configurable
    }
}

Pricing and State Management Summary

Key Takeaways

•Fares have multiple components — Base fare, distance rate, time rate, surge, fees, and discounts combine into the total. Design for each component's configurability.
•Use Strategy pattern for pricing — Different vehicle types and promotions have different pricing rules. Strategy allows flexible swapping.
•Surge pricing balances supply and demand — Zone-based, periodically updated, with configurable thresholds and caps.
•State machine governs trip lifecycle — Explicit states and transitions prevent invalid operations and ensure consistency.
•Transitions trigger side effects — Notifications, payments, status updates, and logging are orchestrated by state transitions.

What's next:

We'll consolidate the design patterns used throughout—Strategy, Observer, State, and Factory—showing how they work together to create a maintainable, extensible ride-sharing system.

Page Complete

You now understand ride-sharing pricing (multi-component fares, Strategy pattern, surge pricing) and state management (explicit state machine, transition validation, side effects). These systems work together to manage the complete lifecycle of every ride.

4 / 6

Loading learning content...

System Design (LLD)Ride-Sharing Service

Case Study: Ride-Sharing Service Design

LevelAdvanced

Duration120 mins

TopicRide-Sharing Service

4 / 6

Pricing and State Management

The Economics and Lifecycle of a Ride

Why these topics together:

What You Will Learn

Understanding Fare Components

Ride-sharing fares typically consist of multiple components combined into a final price. Understanding these components is essential for designing a flexible pricing system.

Core fare formula:

Fare = (BaseFare + (Distance × PerKmRate) + (Time × PerMinRate)) × SurgeMultiplier
     + BookingFee + Tolls - Discounts

Fare Components Breakdown
Component	Description	Typical Value	When Applied
Base Fare	Minimum charge for any trip	$2-5	Always
Per-Kilometer Rate	Distance-based charge	$1-2/km	Based on route distance
Per-Minute Rate	Time-based charge	$0.20-0.40/min	Trip duration
Booking Fee	Platform service fee	$1-3	Per booking
Surge Multiplier	Supply/demand factor	1.0x - 3.0x+	High demand periods
Tolls/Fees	Pass-through costs	Variable	If route includes tolls
Minimum Fare	Floor for short trips	$5-8	If calculated < minimum
Cancellation Fee	Penalty for late cancel	$3-10	Post-threshold cancellation

Estimated vs Actual Fare

Pricing Strategy Pattern

Different ride types, regions, and times may have different pricing rules. The Strategy pattern allows us to swap pricing algorithms without modifying the booking flow.

Why Strategy for pricing:

Standard rides use basic distance + time formula
Premium rides have higher base and per-km rates
Pool rides use per-seat pricing with discounts
Subscription members get percentage discounts
Promotional periods apply special rates

Each is a PricingStrategy implementation.

PricingStrategy.ts
TypeScript
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
interface Fare {
    baseFare: number;
    distanceFare: number;
    timeFare: number;
    bookingFee: number;
    surgeMultiplier: number;
    surgeFare: number;     // Additional surge amount
    tolls: number;
    discount: number;
    totalFare: number;
    currency: string;
}
 
interface TripDetails {
    distanceKm: number;
    durationMinutes: number;
    vehicleType: VehicleType;
    pickupLocation: Location;
    isEstimate: boolean;
}
 
interface PricingStrategy {
    calculateFare(details: TripDetails, surgeMultiplier: number): Fare;
    getName(): string;
}
 
/**
 * Standard ride pricing
 */
class StandardPricingStrategy implements PricingStrategy {
    private readonly baseFare = 2.50;
    private readonly perKmRate = 1.20;
    private readonly perMinRate = 0.25;
    private readonly bookingFee = 1.50;
    private readonly minimumFare = 6.00;
 
    getName(): string { return 'STANDARD'; }
 
    calculateFare(details: TripDetails, surgeMultiplier: number): Fare {
        const distanceFare = details.distanceKm * this.perKmRate;
        const timeFare = details.durationMinutes * this.perMinRate;
        
        const subtotal = this.baseFare + distanceFare + timeFare;
        const surgedSubtotal = subtotal * surgeMultiplier;
        const surgeFare = surgedSubtotal - subtotal;
        
        let totalFare = surgedSubtotal + this.bookingFee;
        totalFare = Math.max(totalFare, this.minimumFare);
 
        return {
            baseFare: this.baseFare,
            distanceFare,
            timeFare,
            bookingFee: this.bookingFee,
            surgeMultiplier,
            surgeFare,
            tolls: 0,
            discount: 0,
            totalFare: Math.round(totalFare * 100) / 100,
            currency: 'USD',
        };
    }
}
 
/**
 * Premium/luxury vehicle pricing
 */
class PremiumPricingStrategy implements PricingStrategy {
    private readonly baseFare = 5.00;
    private readonly perKmRate = 2.50;
    private readonly perMinRate = 0.45;
    private readonly bookingFee = 2.50;
    private readonly minimumFare = 12.00;
 
    getName(): string { return 'PREMIUM'; }
 
    calculateFare(details: TripDetails, surgeMultiplier: number): Fare {
        const distanceFare = details.distanceKm * this.perKmRate;
        const timeFare = details.durationMinutes * this.perMinRate;
        
        const subtotal = this.baseFare + distanceFare + timeFare;
        const surgedSubtotal = subtotal * surgeMultiplier;
        const surgeFare = surgedSubtotal - subtotal;
        
        let totalFare = surgedSubtotal + this.bookingFee;
        totalFare = Math.max(totalFare, this.minimumFare);
 
        return {
            baseFare: this.baseFare,
            distanceFare,
            timeFare,
            bookingFee: this.bookingFee,
            surgeMultiplier,
            surgeFare,
            tolls: 0,
            discount: 0,
            totalFare: Math.round(totalFare * 100) / 100,
            currency: 'USD',
        };
    }
}
 
/**
 * Factory to get appropriate pricing strategy
 */
class PricingStrategyFactory {
    private strategies: Map<VehicleType, PricingStrategy> = new Map();
 
    constructor() {
        this.strategies.set(VehicleType.STANDARD, new StandardPricingStrategy());
        this.strategies.set(VehicleType.PREMIUM, new PremiumPricingStrategy());
        // Add more as needed
    }
 
    getStrategy(vehicleType: VehicleType): PricingStrategy {
        return this.strategies.get(vehicleType) || new StandardPricingStrategy();
    }
}

Surge Pricing Design

Surge calculation factors:

Demand: Number of pending ride requests in a zone
Supply: Number of available drivers in a zone
Ratio: Demand / Supply
Thresholds: Map ratio ranges to multiplier levels

Design considerations:

Surge is zone-based (geographic areas, not individual locations)
Surge updates periodically (every 1-5 minutes)
Surge is capped (usually 2x-3x maximum)
Riders must confirm surge before booking

SurgePricingService.ts
TypeScript
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
interface Zone {
    id: string;
    name: string;
    polygon: Location[];  // Bounding polygon
}
 
class SurgePricingService {
    private zoneSurgeMultipliers: Map<string, number> = new Map();
    private readonly updateIntervalMs = 60000;  // Update every minute
    private readonly maxSurge = 3.0;
    private readonly surgeThresholds: { ratio: number; multiplier: number }[] = [
        { ratio: 0.0, multiplier: 1.0 },   // Supply >= Demand
        { ratio: 1.5, multiplier: 1.25 },  // 1.5x demand vs supply
        { ratio: 2.0, multiplier: 1.5 },
        { ratio: 2.5, multiplier: 1.75 },
        { ratio: 3.0, multiplier: 2.0 },
        { ratio: 4.0, multiplier: 2.5 },
        { ratio: 5.0, multiplier: 3.0 },   // 5x+ demand = max surge
    ];
 
    /**
     * Get current surge multiplier for a location.
     */
    getSurgeMultiplier(location: Location): number {
        const zone = this.findZone(location);
        if (!zone) return 1.0;
        return this.zoneSurgeMultipliers.get(zone.id) || 1.0;
    }
 
    /**
     * Recalculate surge for all zones.
     * Called periodically by a background job.
     */
    async recalculateSurge(
        demandByZone: Map<string, number>,
        supplyByZone: Map<string, number>
    ): Promise<void> {
        for (const [zoneId, demand] of demandByZone) {
            const supply = supplyByZone.get(zoneId) || 0;
            
            let ratio: number;
            if (supply === 0) {
                ratio = demand > 0 ? Infinity : 0;
            } else {
                ratio = demand / supply;
            }
 
            const multiplier = this.ratioToMultiplier(ratio);
            this.zoneSurgeMultipliers.set(zoneId, multiplier);
        }
    }
 
    private ratioToMultiplier(ratio: number): number {
        for (let i = this.surgeThresholds.length - 1; i >= 0; i--) {
            if (ratio >= this.surgeThresholds[i].ratio) {
                return Math.min(this.surgeThresholds[i].multiplier, this.maxSurge);
            }
        }
        return 1.0;
    }
 
    private findZone(location: Location): Zone | null {
        // Implementation would check which zone polygon contains the location
        return null;  // Simplified
    }
 
    /**
     * Check if surge requires rider confirmation.
     */
    requiresConfirmation(multiplier: number): boolean {
        return multiplier > 1.0;
    }
}

Ethical Considerations

Trip State Machine Implementation

State machine implementation approaches:

Enum + switch: Simple, state logic in Trip methods
State pattern: Each state is a class with allowed transitions
External state machine library: Configurable, visual tooling

For interviews, Enum + careful validation is usually sufficient. Let's see a robust implementation:

TripStateMachine.ts
TypeScript
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
enum TripState {
    REQUESTED = 'REQUESTED',
    MATCHING = 'MATCHING',
    DRIVER_ASSIGNED = 'DRIVER_ASSIGNED',
    DRIVER_ARRIVED = 'DRIVER_ARRIVED',
    TRIP_IN_PROGRESS = 'TRIP_IN_PROGRESS',
    TRIP_COMPLETED = 'TRIP_COMPLETED',
    CANCELLED_BY_RIDER = 'CANCELLED_BY_RIDER',
    CANCELLED_BY_DRIVER = 'CANCELLED_BY_DRIVER',
    CANCELLED_NO_SHOW = 'CANCELLED_NO_SHOW',
    NO_DRIVERS_AVAILABLE = 'NO_DRIVERS_AVAILABLE',
}
 
enum TripEvent {
    START_MATCHING = 'START_MATCHING',
    DRIVER_ASSIGNED = 'DRIVER_ASSIGNED',
    MATCHING_FAILED = 'MATCHING_FAILED',
    DRIVER_ARRIVED = 'DRIVER_ARRIVED',
    START_TRIP = 'START_TRIP',
    COMPLETE_TRIP = 'COMPLETE_TRIP',
    RIDER_CANCEL = 'RIDER_CANCEL',
    DRIVER_CANCEL = 'DRIVER_CANCEL',
    NO_SHOW = 'NO_SHOW',
}
 
interface StateTransition {
    from: TripState;
    event: TripEvent;
    to: TripState;
    guard?: (trip: Trip) => boolean;
    action?: (trip: Trip) => Promise<void>;
}
 
class TripStateMachine {
    private transitions: StateTransition[] = [
        // Happy path
        { from: TripState.REQUESTED, event: TripEvent.START_MATCHING, to: TripState.MATCHING },
        { from: TripState.MATCHING, event: TripEvent.DRIVER_ASSIGNED, to: TripState.DRIVER_ASSIGNED },
        { from: TripState.DRIVER_ASSIGNED, event: TripEvent.DRIVER_ARRIVED, to: TripState.DRIVER_ARRIVED },
        { from: TripState.DRIVER_ARRIVED, event: TripEvent.START_TRIP, to: TripState.TRIP_IN_PROGRESS },
        { from: TripState.TRIP_IN_PROGRESS, event: TripEvent.COMPLETE_TRIP, to: TripState.TRIP_COMPLETED },
        
        // Matching failures
        { from: TripState.MATCHING, event: TripEvent.MATCHING_FAILED, to: TripState.NO_DRIVERS_AVAILABLE },
        
        // Rider cancellation (from multiple states)
        { from: TripState.REQUESTED, event: TripEvent.RIDER_CANCEL, to: TripState.CANCELLED_BY_RIDER },
        { from: TripState.MATCHING, event: TripEvent.RIDER_CANCEL, to: TripState.CANCELLED_BY_RIDER },
        { from: TripState.DRIVER_ASSIGNED, event: TripEvent.RIDER_CANCEL, to: TripState.CANCELLED_BY_RIDER },
        { from: TripState.DRIVER_ARRIVED, event: TripEvent.RIDER_CANCEL, to: TripState.CANCELLED_BY_RIDER },
        
        // Driver cancellation
        { from: TripState.DRIVER_ASSIGNED, event: TripEvent.DRIVER_CANCEL, to: TripState.CANCELLED_BY_DRIVER },
        { from: TripState.DRIVER_ARRIVED, event: TripEvent.NO_SHOW, to: TripState.CANCELLED_NO_SHOW },
    ];
 
    async transition(trip: Trip, event: TripEvent): Promise<TripState> {
        const currentState = trip.getState();
        const transition = this.transitions.find(
            t => t.from === currentState && t.event === event
        );
 
        if (!transition) {
            throw new Error(
                `Invalid transition: ${event} not allowed from ${currentState}`
            );
        }
 
        // Check guard condition if present
        if (transition.guard && !transition.guard(trip)) {
            throw new Error(`Guard condition failed for ${event}`);
        }
 
        // Execute action if present
        if (transition.action) {
            await transition.action(trip);
        }
 
        return transition.to;
    }
 
    getValidEvents(state: TripState): TripEvent[] {
        return this.transitions
            .filter(t => t.from === state)
            .map(t => t.event);
    }
 
    isTerminal(state: TripState): boolean {
        return !this.transitions.some(t => t.from === state);
    }
}

State Transition Side Effects

State transitions trigger important side effects: updating entity statuses, sending notifications, processing payments, and recording events. A well-designed system handles these consistently.

State Transition Side Effects
Transition	Side Effects
MATCHING → DRIVER_ASSIGNED	Update driver status to ASSIGNED; Notify rider with driver details; Start ETA tracking
DRIVER_ASSIGNED → DRIVER_ARRIVED	Notify rider driver has arrived; Start wait timer for no-show
DRIVER_ARRIVED → TRIP_IN_PROGRESS	Begin route tracking; Update rider/driver UI to trip mode
TRIP_IN_PROGRESS → TRIP_COMPLETED	Calculate final fare; Process payment; Credit driver; Prompt ratings; Archive trip
Any → CANCELLED_BY_RIDER	Free driver; Possibly charge cancellation fee; Notify driver; Log reason
Any → CANCELLED_BY_DRIVER	Notify rider; Attempt rematch; Record against driver metrics
DRIVER_ARRIVED → CANCELLED_NO_SHOW	Charge rider cancellation fee; Free driver; Record as rider no-show

TripService.ts
TypeScript
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
class TripService {
    private stateMachine: TripStateMachine;
    private notificationService: NotificationService;
    private paymentService: PaymentService;
    private fareCalculator: FareCalculator;
 
    async completeTrip(trip: Trip): Promise<void> {
        // 1. Validate transition
        const newState = await this.stateMachine.transition(
            trip, TripEvent.COMPLETE_TRIP
        );
 
        // 2. Calculate final fare
        const actualFare = this.fareCalculator.calculateActualFare(trip);
        trip.setActualFare(actualFare);
        trip.setState(newState);
 
        // 3. Process payment
        await this.paymentService.charge(
            trip.getRider(),
            actualFare.totalFare,
            trip.getId()
        );
 
        // 4. Credit driver (minus platform fee)
        const driverEarning = actualFare.totalFare * 0.75;  // 75% to driver
        await this.paymentService.credit(
            trip.getDriver()!,
            driverEarning,
            trip.getId()
        );
 
        // 5. Update statuses
        trip.getDriver()!.setStatus(DriverStatus.AVAILABLE);
        trip.getRider().setStatus(RiderStatus.IDLE);
 
        // 6. Request ratings
        await this.notificationService.sendRatingRequest(trip.getRider(), trip);
        await this.notificationService.sendRatingRequest(trip.getDriver()!, trip);
 
        // 7. Record for analytics
        await this.recordTripCompletion(trip);
    }
 
    async cancelByRider(trip: Trip, reason?: string): Promise<void> {
        const newState = await this.stateMachine.transition(
            trip, TripEvent.RIDER_CANCEL
        );
        trip.setState(newState);
 
        // Check if cancellation fee applies
        const shouldChargeFee = this.shouldChargeCancellationFee(trip);
        if (shouldChargeFee) {
            await this.paymentService.charge(
                trip.getRider(),
                this.getCancellationFee(trip),
                trip.getId()
            );
        }
 
        // Free the driver if one was assigned
        if (trip.getDriver()) {
            trip.getDriver()!.setStatus(DriverStatus.AVAILABLE);
            await this.notificationService.notifyRiderCancelled(trip.getDriver()!);
        }
 
        trip.getRider().setStatus(RiderStatus.IDLE);
    }
 
    private shouldChargeCancellationFee(trip: Trip): boolean {
        // Free cancellation within 2 minutes of driver assignment
        if (!trip.getMatchedAt()) return false;
        const elapsedMs = Date.now() - trip.getMatchedAt()!.getTime();
        return elapsedMs > 120000; // 2 minutes
    }
 
    private getCancellationFee(trip: Trip): number {
        return 5.00; // Configurable
    }
}

Pricing and State Management Summary

Key Takeaways

•Fares have multiple components — Base fare, distance rate, time rate, surge, fees, and discounts combine into the total. Design for each component's configurability.
•Use Strategy pattern for pricing — Different vehicle types and promotions have different pricing rules. Strategy allows flexible swapping.
•Surge pricing balances supply and demand — Zone-based, periodically updated, with configurable thresholds and caps.
•State machine governs trip lifecycle — Explicit states and transitions prevent invalid operations and ensure consistency.
•Transitions trigger side effects — Notifications, payments, status updates, and logging are orchestrated by state transitions.

What's next:

We'll consolidate the design patterns used throughout—Strategy, Observer, State, and Factory—showing how they work together to create a maintainable, extensible ride-sharing system.

Page Complete

4 / 6