Ride-Sharing Service - Learning Module

Loading content...

0/246

Complete Design Walkthrough

Bringing It All Together

We've covered requirements, entities, matching algorithms, pricing, state management, and design patterns. Now we consolidate everything into a complete, presentable design—the kind you'd present in an interview or use as the blueprint for implementation.

This page covers:

Complete class diagram with all entities and relationships
Sequence diagrams for key flows
Architecture overview
Interview presentation strategy
Extension points and future considerations

What You Will Learn

By the end of this page, you will have a complete mental model of the ride-sharing system that you can confidently present in interviews. You'll know how to structure your explanation, what to emphasize, and how to handle follow-up questions about extensions and trade-offs.

Complete Class Diagram

The class diagram shows all entities, their attributes, and relationships. This is typically what you'd draw on a whiteboard during an interview.

ClassDiagram.txt

Class Diagram

┌───────────────────────────────────────────────────────────────────────────────┐
│                        RIDE-SHARING SYSTEM CLASS DIAGRAM                       │
└───────────────────────────────────────────────────────────────────────────────┘
 
┌─────────────────────┐         ┌─────────────────────┐
│      Location       │         │       Vehicle       │
├─────────────────────┤         ├─────────────────────┤
│ -latitude: number   │         │ -id: string         │
│ -longitude: number  │         │ -make: string       │
│ -address?: string   │         │ -model: string      │
├─────────────────────┤         │ -licensePlate: str  │
│ +distanceTo(): km   │         │ -type: VehicleType  │
│ +equals(): boolean  │         │ -capacity: number   │
└─────────────────────┘         └──────────┬──────────┘
         △                                 │ 1
         │                                 │
         │ uses                            │ has
         │                                 │
┌────────┴────────┐             ┌──────────┴──────────┐
│                 │             │       Driver        │
│      Rider      │             ├─────────────────────┤
├─────────────────┤             │ -id: string         │
│ -id: string     │             │ -name: string       │
│ -name: string   │             │ -status: DriverStat │
│ -email: string  │             │ -location: Location │
│ -status: RiderSt│             │ -rating: number     │
│ -rating: number │             │ -acceptanceRate: num│
│ -paymentMethods │             ├─────────────────────┤
├─────────────────┤             │ +goOnline()         │
│ +requestRide()  │             │ +goOffline()        │
│ +cancelRide()   │             │ +updateLocation()   │
│ +rateDriver()   │             │ +isAvailable(): bool│
└────────┬────────┘             └──────────┬──────────┘
         │ 1                               │ 0..1
         │ requests                        │ executes
         │                                 │
         ▼ *                               ▼ *
┌─────────────────────────────────────────────────────┐
│                        Trip                          │
├─────────────────────────────────────────────────────┤
│ -id: string                                         │
│ -rider: Rider                                       │
│ -driver?: Driver                                    │
│ -pickupLocation: Location                           │
│ -destination: Location                              │
│ -state: TripState                                   │
│ -estimatedFare: Fare                                │
│ -actualFare?: Fare                                  │
│ -requestedAt: Date                                  │
│ -matchedAt?: Date                                   │
│ -completedAt?: Date                                 │
├─────────────────────────────────────────────────────┤
│ +assignDriver(driver): void                         │
│ +driverArrived(): void                              │
│ +startTrip(): void                                  │
│ +completeTrip(fare): void                           │
│ +cancel(reason): void                               │
│ +getState(): TripState                              │
└─────────────────────────────────────────────────────┘
         │
         │ uses
         ▼
┌─────────────────────┐         ┌─────────────────────┐
│        Fare         │         │    <<interface>>    │
├─────────────────────┤         │  PricingStrategy    │
│ -baseFare: number   │         ├─────────────────────┤
│ -distanceFare: num  │◄────────│ +calculateFare():   │
│ -timeFare: number   │ creates │   Fare              │
│ -surgeMultiplier    │         └─────────┬───────────┘
│ -totalFare: number  │                   △
└─────────────────────┘         ┌─────────┴───────────┐
                                │                     │
                    ┌───────────┴───────┐   ┌────────┴────────┐
                    │ StandardPricing   │   │ PremiumPricing  │
                    └───────────────────┘   └─────────────────┘
 
┌─────────────────────┐         ┌─────────────────────┐
│    <<interface>>    │         │   MatchingEngine    │
│  MatchingStrategy   │◄────────├─────────────────────┤
├─────────────────────┤ uses    │ -strategy           │
│ +rankDrivers():     │         │ -locationService    │
│   Driver[]          │         ├─────────────────────┤
└─────────┬───────────┘         │ +findMatch(request) │
          △                     │   : MatchResult     │
   ┌──────┴──────┬───────┐      └─────────────────────┘
   │             │       │
┌──┴───┐    ┌────┴───┐ ┌─┴────────────┐
│Nearest│   │Weighted│ │FairDistribut.│
│Driver │   │Score   │ │Strategy      │
└───────┘   └────────┘ └──────────────┘

Whiteboard Strategy

Don't draw everything at once. Start with core entities (Rider, Driver, Trip, Location). Add relationships. Then layer in services (MatchingEngine, PricingStrategy). Finally, show patterns (Strategy interfaces). This progressive disclosure helps interviewers follow your thinking.

Key Sequence Diagrams

Sequence diagrams show the dynamic behavior—how objects interact over time. Here are the critical flows:

SequenceDiagrams.txt

Rider    RideService   TripFactory  MatchingEngine   Driver
  │            │              │              │              │
  │──request(pickup,dest)────►│              │              │
  │            │              │              │              │
  │            │──createTrip()─►│            │              │
  │            │              │──estimate────►│              │
  │            │              │◄─fare────────│              │
  │            │◄─trip────────│              │              │
  │            │              │              │              │
  │◄──estimated fare, confirm?│              │              │
  │            │              │              │              │
  │──confirm()─►│              │              │              │
  │            │──trip.startMatching()       │              │
  │            │              │              │              │
  │            │──────────findMatch(trip)────►│              │
  │            │              │              │──getNearby()─►│
  │            │              │              │◄─drivers─────│
  │            │              │              │              │
  │            │              │              │──rank()──────►│
  │            │              │              │◄─ordered─────│
  │            │              │              │              │
  │            │              │              │──offer()─────►│
  │            │              │              │       ◄──────│accept
  │            │◄─────────────match result───│              │
  │            │              │              │              │
  │            │──trip.assignDriver(driver)  │              │
  │            │──notify───────────────────────────────────►│
  │◄──driver assigned, ETA────│              │              │

Service Layer Architecture

Beyond entities, several services orchestrate the ride-sharing system:

Key Services and Responsibilities
Service	Responsibility	Key Dependencies
RideService	Orchestrates ride request through completion	TripFactory, MatchingEngine, TripRepository
MatchingEngine	Finds and ranks drivers for requests	DriverLocationService, MatchingStrategy
DriverLocationService	Tracks real-time driver positions	Spatial index (Redis/GeoHash)
FareCalculator	Calculates estimated and actual fares	PricingStrategy, SurgePricingService
SurgePricingService	Manages dynamic pricing zones	Zone definitions, demand/supply metrics
PaymentService	Processes payments and payouts	Payment gateway (abstracted)
NotificationService	Sends push notifications to apps	FCM/APNS adapters (abstracted)
RatingService	Manages bidirectional ratings	User repositories

RideService.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
class RideService {
    constructor(
        private tripFactory: TripFactory,
        private tripRepository: TripRepository,
        private matchingEngine: MatchingEngine,
        private fareCalculator: FareCalculator,
        private paymentService: PaymentService,
        private notificationService: NotificationService,
        private eventPublisher: TripEventPublisher
    ) {}
 
    async requestRide(
        rider: Rider,
        pickupLocation: Location,
        destination: Location,
        vehicleType: VehicleType
    ): Promise<Trip> {
        // Validate rider can request
        if (!rider.isAvailableForTrip()) {
            throw new Error('Rider already has an active trip');
        }
        if (!rider.hasValidPayment()) {
            throw new Error('Rider has no valid payment method');
        }
 
        // Create trip with estimated fare
        const trip = this.tripFactory.createTrip(
            rider, pickupLocation, destination, vehicleType
        );
 
        // Persist trip
        await this.tripRepository.save(trip);
 
        // Update rider status
        rider.setStatus(RiderStatus.REQUESTING);
 
        return trip;
    }
 
    async confirmRide(tripId: string): Promise<MatchResult> {
        const trip = await this.tripRepository.findById(tripId);
        
        // Start matching
        trip.startMatching();
        await this.tripRepository.save(trip);
 
        // Find driver
        const matchResult = await this.matchingEngine.findMatch(trip);
 
        if (matchResult.success && matchResult.driver) {
            // Assign driver
            trip.assignDriver(matchResult.driver);
            matchResult.driver.setStatus(DriverStatus.ASSIGNED);
            
            await this.tripRepository.save(trip);
 
            // Publish event for notifications
            this.eventPublisher.publish({
                tripId: trip.getId(),
                eventType: TripEventType.DRIVER_ASSIGNED,
                timestamp: new Date(),
                data: {
                    riderId: trip.getRider().getId(),
                    driverId: matchResult.driver.getId(),
                    eta: matchResult.estimatedPickupSeconds,
                }
            });
        } else {
            trip.failMatching();
            await this.tripRepository.save(trip);
        }
 
        return matchResult;
    }
 
    async completeTrip(tripId: string): Promise<Fare> {
        const trip = await this.tripRepository.findById(tripId);
        const driver = trip.getDriver()!;
 
        // Calculate actual fare
        const actualFare = this.fareCalculator.calculateActualFare(trip);
 
        // Complete trip
        trip.completeTrip(actualFare);
 
        // Process payment
        await this.paymentService.charge(
            trip.getRider(),
            actualFare.totalFare,
            tripId
        );
 
        // Credit driver
        const driverEarning = actualFare.totalFare * 0.75;
        await this.paymentService.credit(driver, driverEarning, tripId);
 
        // Update statuses
        driver.setStatus(DriverStatus.AVAILABLE);
        trip.getRider().setStatus(RiderStatus.IDLE);
 
        // Persist
        await this.tripRepository.save(trip);
 
        // Publish completion event
        this.eventPublisher.publish({
            tripId,
            eventType: TripEventType.TRIP_COMPLETED,
            timestamp: new Date(),
            data: { fare: actualFare }
        });
 
        return actualFare;
    }
}

Interview Presentation Strategy

Presenting this design in a 45-minute interview requires structure. Here's a recommended approach:

Recommended Interview Flow

•Clarify Requirements (5 min): Ask about scope, ride types, pricing, matching model. Document answers visibly.
•State Functional Requirements (3 min): List key capabilities: request ride, match driver, track trip, calculate fare, rate.
•Identify Core Entities (5 min): Draw Rider, Driver, Trip, Location. Explain their responsibilities briefly.
•Show Key Relationships (5 min): Trip connects Rider and Driver. Trip owns Locations and Fare. Driver has Vehicle.
•Design the Trip State Machine (7 min): Draw states and transitions. This shows you understand the lifecycle complexity.
•Explain Matching Flow (8 min): DriverLocationService → MatchingStrategy → Offer cascade. Show Strategy pattern.
•Cover Pricing (5 min): Fare components, PricingStrategy interface, surge calculation.
•Discuss Patterns Used (3 min): Name patterns: Strategy, Observer, State, Factory. Tie to requirements.
•Handle Extensions (4 min): Be ready for 'How would you add pooling?' or 'What about scheduled rides?'

Common Follow-up Questions

Be prepared for: 'How would you handle driver cancellation affecting rider?' (State machine + rematch). 'What if two requests target the same driver?' (Optimistic locking, OFFERED status). 'How does surge get calculated?' (Zone-based demand/supply ratio). 'How would you add tipping?' (Post-completion tip amount on Trip, PaymentService handles).

Extension Points and Future Considerations

A good design anticipates future evolution. Here's how our design accommodates common extensions:

Design Extensions
Feature	How to Extend	Affected Components
Ride Pooling	Trip holds List<Rider>; PoolMatchingStrategy; shared fare calculation	Trip, MatchingStrategy, PricingStrategy
Scheduled Rides	Trip.scheduledTime field; ScheduledRideService; delayed matching	Trip, new ScheduledRideService
Multiple Vehicle Types	New VehicleType enum values; new PricingStrategy implementations	VehicleType enum, PricingStrategyFactory
International Support	Location includes country/region; region-based pricing; currency handling	Location, Fare, PricingStrategy
Promotions/Discounts	DiscountStrategy applied to Fare; PromoCode entity	Fare, new DiscountStrategy
Driver Earnings Dashboard	New DriverEarningsService querying trip history	New service, Trip repository queries
Real-time Map Tracking	More frequent location observer; WebSocket push to rider app	Observer pattern, new tracking observer

Complete Design Summary

What We've Built

•Core Entities: Rider, Driver, Trip, Location, Vehicle, Fare—each with clear attributes and responsibilities
•Trip State Machine: 10+ states governing the complete ride lifecycle with validated transitions
•Matching System: Geospatial driver queries, Strategy-based ranking, offer-accept cascade flow
•Pricing Engine: Multi-component fares, vehicle-specific strategies, zone-based surge pricing
•Event System: Observer pattern for decoupled notifications, analytics, and auditing
•Service Layer: RideService orchestrating the full request-to-completion flow

This design demonstrates:

Requirements-driven design: Every class and pattern traces to a documented requirement
SOLID principles: Single responsibility per class, Open/Closed via Strategy, Dependency Inversion via interfaces
Design patterns: Strategy, Observer, State, Factory—each solving specific extensibility challenges
Scalability awareness: Geospatial indexing, concurrent matching, zone-based calculations
Production readiness: Error handling, state validation, audit logging, payment abstraction

Module Complete

Congratulations! You've completed the Ride-Sharing Service case study. You now have a comprehensive, interview-ready design covering requirements analysis, entity modeling, matching algorithms, pricing strategies, state management, and design patterns. This knowledge applies to any real-time, multi-party coordination system you'll encounter.