Uber Interview Guide 2026: Dispatch Systems, Geospatial Algorithms, and Marketplace Engineering

Uber Interview Guide 2026: Marketplace Systems, Real-Time Dispatch, and Distributed Engineering

Uber’s engineering interviews reflect the company’s core challenges: real-time geospatial matching, surge pricing algorithms, and distributed systems at massive scale. This guide covers what to expect across software engineer levels, from L3 to L6.

The Uber Interview Process

The typical Uber interview pipeline for SWE roles:

Recruiter screen (30 min) — background, motivation, timeline
Technical phone screen (1 hour) — one medium/hard coding problem on a shared editor
Virtual onsite (4–5 rounds):
- 2× coding rounds (data structures, algorithms)
- 1× system design round
- 1× Uber-specific domain round (marketplace, maps, payments)
- 1× behavioral round (Uber leadership principles)
Hiring committee review → offer

Uber recruiters will tell you the level band upfront. L3 (junior) focuses on fundamentals; L5+ expects system design depth and cross-functional thinking about tradeoffs.

Core Data Structures and Algorithms

Uber interviews weight graphs and geospatial problems heavily. Expect BFS/DFS, shortest path (Dijkstra), and spatial indexing (quadtrees, geohashing).

Geohashing and Spatial Indexing

import heapq
from collections import defaultdict

def geohash_encode(lat: float, lng: float, precision: int = 6) -> str:
    """Encode lat/lng into a geohash string."""
    BASE32 = '0123456789bcdefghjkmnpqrstuvwxyz'
    lat_range = [-90.0, 90.0]
    lng_range = [-180.0, 180.0]

    bits = []
    is_lng = True  # alternate between lng and lat

    for _ in range(precision * 5):
        if is_lng:
            mid = (lng_range[0] + lng_range[1]) / 2
            if lng >= mid:
                bits.append(1)
                lng_range[0] = mid
            else:
                bits.append(0)
                lng_range[1] = mid
        else:
            mid = (lat_range[0] + lat_range[1]) / 2
            if lat >= mid:
                bits.append(1)
                lat_range[0] = mid
            else:
                bits.append(0)
                lat_range[1] = mid
        is_lng = not is_lng

    result = []
    for i in range(0, len(bits), 5):
        idx = int(''.join(str(b) for b in bits[i:i+5]), 2)
        result.append(BASE32[idx])

    return ''.join(result)


def find_drivers_in_radius(
    driver_locations: dict,  # driver_id -> (lat, lng)
    rider_lat: float,
    rider_lng: float,
    radius_km: float
) -> list:
    """
    Find nearby drivers using geohash prefix matching.
    Real Uber uses S2 geometry library for this.

    Time: O(D * P) where D=drivers, P=precision
    Space: O(D)
    """
    from math import radians, cos, sin, asin, sqrt

    def haversine(lat1, lng1, lat2, lng2):
        R = 6371  # Earth radius in km
        dlat = radians(lat2 - lat1)
        dlng = radians(lng2 - lng1)
        a = sin(dlat/2)**2 + cos(radians(lat1)) * cos(radians(lat2)) * sin(dlng/2)**2
        return 2 * R * asin(sqrt(a))

    rider_hash = geohash_encode(rider_lat, rider_lng, precision=5)
    prefix = rider_hash[:4]  # ~20km cells at precision 4

    nearby = []
    for driver_id, (dlat, dlng) in driver_locations.items():
        dhash = geohash_encode(dlat, dlng, precision=5)
        # Quick filter: geohash prefix match
        if dhash.startswith(prefix) or True:  # fallback to haversine
            dist = haversine(rider_lat, rider_lng, dlat, dlng)
            if dist <= radius_km:
                nearby.append((dist, driver_id))

    nearby.sort()
    return [(driver_id, dist) for dist, driver_id in nearby]

Surge Pricing with Reinforcement Learning (Conceptual)

class SurgePricingEngine:
    """
    Simplified surge pricing model.
    Real Uber uses ML models trained on historical supply/demand.

    Key insight: surge = f(demand_rate / supply_rate)
    Fare = base_fare * surge_multiplier
    """

    def __init__(self):
        self.surge_table = [
            (1.0, 1.0),   # demand/supply  1.0x surge
            (1.5, 1.25),
            (2.0, 1.5),
            (2.5, 1.75),
            (3.0, 2.0),
            (4.0, 2.5),
            (float('inf'), 3.0),
        ]

    def compute_surge(
        self,
        active_requests: int,
        available_drivers: int,
        eta_minutes: float
    ) -> float:
        """
        Compute surge multiplier based on supply/demand ratio.
        Also factors in ETA (proxy for effective supply shortage).

        Time: O(1)
        """
        if available_drivers == 0:
            return 3.0  # cap at 3x

        ratio = active_requests / available_drivers
        eta_factor = max(1.0, eta_minutes / 5.0)  # penalize long ETAs
        adjusted_ratio = ratio * eta_factor

        for threshold, multiplier in self.surge_table:
            if adjusted_ratio  float:
        rate_per_km = 1.20
        rate_per_min = 0.25
        booking_fee = 1.75

        trip_cost = base_fare + (distance_km * rate_per_km) + (duration_min * rate_per_min)
        return (trip_cost * surge) + booking_fee

System Design: Uber Dispatch System

A common Uber system design question: “Design the Uber real-time driver dispatch system.”

Requirements

Match riders to nearest available driver within 1–2 seconds
Handle 1M+ concurrent users, 500K active drivers
Global deployment across 70+ countries
Maintain location freshness (drivers update every 4 seconds)

Architecture

Rider App / Driver App
        |
   [Load Balancer]
        |
  [API Gateway] ---- Auth / Rate Limiting
        |
   [WebSocket Gateway] (maintains persistent connections)
        |
   [Dispatch Service]
     |         |
[Location    [Trip
 Service]    Service]
     |         |
 [Redis Geo]  [Postgres]
 (driver locs) (trip state)
     |
 [Kafka] ---- [ML Matching Service]
              (optimal assignment)

Key Design Decisions

Location storage: Redis GEOADD/GEORADIUS — O(N+log M) spatial queries, sub-millisecond for 500K drivers
Matching algorithm: Hungarian algorithm for batch matching; greedy nearest-driver for real-time
Consistency: Location data is eventually consistent (acceptable); trip state uses strong consistency (Postgres with serializable transactions)
Sharding: By geographic region (city/country) — keeps latency local
Driver heartbeat: Drivers send GPS pings every 4s; TTL-based eviction removes stale entries

Uber-Specific Domain Questions

Uber interviewers often ask about:

Double-charging prevention: Idempotency keys on trip creation; deduplication in payment service
Ghost drivers: Driver app crashes but GPS still pings; solved with heartbeat + explicit “accept/reject” state machine
ETA accuracy: Traffic-aware routing (OSRM), historical trip data, time-of-day features
Fraud detection: GPS spoofing detection via accelerometer correlation, speed plausibility checks

Behavioral: Uber Leadership Principles

Uber’s core values as of 2026 include: Build with Heart, Reimagine, Think Deeply, Plan for the Long Term, Make Big Bold Bets.

Prepare STAR stories for:

A time you had to make a decision with incomplete data
How you handled a production incident
A time you changed direction based on new information
Conflict resolution with a cross-functional team

Compensation (L3–L6, US, 2025 data)

Level	Title	Base	Total Comp
L3	SWE	$155–175K	$190–230K
L4	SWE II	$175–200K	$240–300K
L5	Senior SWE	$200–240K	$320–420K
L6	Staff SWE	$240–280K	$450–600K+

Uber refreshes RSUs annually and has a 4-year vest (1-year cliff, quarterly after). Negotiate base + sign-on; refresh grants are merit-based.

Tips for Uber Interviews

Know Uber’s products: Rides, Eats, Freight, Autonomous. Domain context shows genuine interest
Practice geospatial problems: LeetCode 973 (K Closest Points), 1584 (Min Cost to Connect All Points)
Real-time systems depth: WebSockets vs SSE vs polling; when to use each
Concurrency: Race conditions in booking (double assignment); distributed locks with TTL
Internationalization: Phone number formats, currency, regulatory compliance across markets

Practice problems: LeetCode 743 (Network Delay Time), 787 (Cheapest Flights), 1334 (Find the City), 1609 (Even Odd Tree).