DoorDash Interview Guide

DoorDash Interview Guide 2026: Last-Mile Logistics, Marketplace Engineering, and Delivery Infrastructure

DoorDash is the #1 food delivery platform in the US with 67%+ market share, operating in 27+ countries. Their engineering solves hard last-mile logistics problems: routing, real-time dispatch, merchant onboarding, and marketplace equilibrium. This guide covers SWE interviews from L3 to L6.

The DoorDash Interview Process

Recruiter screen (30 min) — background, interest in logistics/marketplace
Technical phone screen (1 hour) — 1–2 LeetCode-style coding problems
Virtual onsite (4–5 rounds):
- 2× coding (medium-hard algorithms)
- 1× system design (delivery dispatch, merchant onboarding, or payments)
- 1× product-engineering discussion (business impact of technical decisions)
- 1× behavioral (DoorDash values)

DoorDash uniquely emphasizes product thinking in engineering interviews. They want engineers who understand business metrics (order volume, Dasher utilization, merchant retention) and can connect technical choices to business outcomes.

Core Algorithms: Logistics and Routing

Order Assignment with Priority Queue

import heapq
from dataclasses import dataclass, field
from typing import List, Optional, Tuple
import math

@dataclass
class Order:
    order_id: int
    pickup_lat: float
    pickup_lng: float
    dropoff_lat: float
    dropoff_lng: float
    placed_at: float   # timestamp
    priority: int = 0  # 0=normal, 1=DashPass, 2=priority

@dataclass
class Dasher:
    dasher_id: int
    lat: float
    lng: float
    is_available: bool
    rating: float
    acceptance_rate: float

def haversine_km(lat1, lng1, lat2, lng2) -> float:
    R = 6371
    dlat = math.radians(lat2 - lat1)
    dlng = math.radians(lng2 - lng1)
    a = (math.sin(dlat/2)**2 +
         math.cos(math.radians(lat1)) * math.cos(math.radians(lat2)) *
         math.sin(dlng/2)**2)
    return 2 * R * math.asin(math.sqrt(a))

class DoorDashDispatcher:
    """
    Order dispatch system for DoorDash.

    Real DoorDash uses 'Dasher Assignment Algorithm' — an optimization
    model that considers:
    1. Dasher proximity to restaurant (pickup distance)
    2. Dasher current route (batching multiple orders)
    3. Predicted pickup time (restaurant wait vs. Dasher arrival)
    4. Dasher utilization (don't starve any Dasher)
    5. Historical acceptance rates

    This simplified version does greedy nearest-Dasher assignment.
    """

    def __init__(self):
        self.pending_orders: List[Order] = []
        self.available_dashers: List[Dasher] = []

    def assign_order(self, order: Order) -> Optional[int]:
        """
        Find best available Dasher for an order.
        Returns dasher_id or None if no Dasher available.

        Score: weighted combination of pickup distance and Dasher quality.
        Lower score = better match.

        Time: O(D) where D = available Dashers
        """
        if not self.available_dashers:
            return None

        candidates = []
        for dasher in self.available_dashers:
            if not dasher.is_available:
                continue

            pickup_dist = haversine_km(
                dasher.lat, dasher.lng,
                order.pickup_lat, order.pickup_lng
            )

            # Quality factor: prefer higher-rated Dashers with good acceptance
            quality_score = 2.0 - dasher.rating / 5.0  # 5★ → 0, 1★ → 1.6
            acceptance_penalty = max(0, 0.7 - dasher.acceptance_rate) * 2

            # Priority boost for DashPass orders: allow slightly farther Dashers
            priority_factor = 0.8 if order.priority >= 1 else 1.0

            total_score = (priority_factor * pickup_dist * 0.6 +
                          quality_score * 0.3 +
                          acceptance_penalty * 0.1)

            candidates.append((total_score, dasher.dasher_id))

        if not candidates:
            return None

        candidates.sort()
        return candidates[0][1]

    def batch_orders(
        self,
        orders: List[Order],
        max_batch_size: int = 2
    ) -> List[List[Order]]:
        """
        Group orders for batch delivery (DoorDash's 'Stacked' feature).
        Orders are batchable if pickups are within 0.5km of each other.

        Time: O(N^2) — greedy clustering
        """
        batches = []
        assigned = set()

        for i, order in enumerate(orders):
            if i in assigned:
                continue

            batch = [order]
            assigned.add(i)

            for j, other_order in enumerate(orders):
                if j in assigned or len(batch) >= max_batch_size:
                    continue
                pickup_dist = haversine_km(
                    order.pickup_lat, order.pickup_lng,
                    other_order.pickup_lat, other_order.pickup_lng
                )
                if pickup_dist <= 0.5:
                    batch.append(other_order)
                    assigned.add(j)

            batches.append(batch)

        return batches

Delivery Time Prediction

class DeliveryTimePredictor:
    """
    Predict total delivery time: place_order → food_at_door.

    Components:
    1. Restaurant prep time (varies by item, time-of-day, day-of-week)
    2. Dasher to restaurant ETA (drive time + parking)
    3. Order handoff time (wait at restaurant)
    4. Restaurant to customer drive time
    5. Customer handoff (parking, apt building, etc.)

    DoorDash's actual model uses gradient boosted trees with
    hundreds of features and real-time restaurant delay signals.
    """

    def predict_total_time(
        self,
        restaurant_id: int,
        items: List[str],
        restaurant_to_dasher_km: float,
        restaurant_to_customer_km: float,
        hour_of_day: int,
        is_weekend: bool,
        is_raining: bool
    ) -> float:
        """
        Predict delivery time in minutes.
        """
        # 1. Restaurant prep time (base + item-count factor)
        base_prep = 12.0  # minutes
        item_factor = max(0, len(items) - 3) * 1.5
        time_of_day_factor = 1.3 if 11 <= hour_of_day <= 13 else 1.0  # lunch rush
        weekend_factor = 1.15 if is_weekend else 1.0
        prep_time = base_prep * time_of_day_factor * weekend_factor + item_factor

        # 2. Dasher arrival at restaurant (drive + parking buffer)
        avg_speed_kmh = 25.0  # urban average
        dasher_eta = (restaurant_to_dasher_km / avg_speed_kmh) * 60 + 2

        # 3. Wait at restaurant (Dasher may arrive before food is ready)
        restaurant_wait = max(0, prep_time - dasher_eta)

        # 4. Delivery drive time
        weather_factor = 1.2 if is_raining else 1.0
        delivery_drive = (restaurant_to_customer_km / avg_speed_kmh) * 60 * weather_factor

        # 5. Handoff buffer
        handoff_time = 2.5

        total = (dasher_eta + restaurant_wait + delivery_drive + handoff_time)
        return round(total, 1)

System Design: DoorDash Order Orchestration

Common DoorDash system design question: “Design DoorDash’s order management system — from customer placing order to Dasher completing delivery.”

"""
DoorDash Order Lifecycle:

Customer places order → [Order Service] → creates order record
    |
[Payment Service] → charges card (idempotent, pre-auth then capture)
    |
[Merchant Notification] → POS integration (Olo, Toast, Square)
    |
[Dispatch Service] → assigns Dasher
    - broadcasts offer to nearby Dashers
    - first accept wins (or auto-assign if no response in 60s)
    |
[Order Tracking] → real-time GPS updates via WebSocket
    - Customer sees Dasher on map
    - ETA recalculates every 30 seconds
    |
[Delivery Confirmation] → Dasher marks delivered
    - Photo proof for contactless
    - Rating prompt to customer
    |
[Post-Order] → Dasher payout (weekly ACH), merchant settlement

Key data stores:
- Orders: PostgreSQL (ACID, strong consistency for financial data)
- Dasher locations: Redis (fast geospatial, TTL eviction)
- Order tracking events: Kafka → S3 (audit trail)
- Menu/pricing: Redis cache + PostgreSQL (reads >> writes)
- Notifications: SNS → Dasher app push + SMS fallback

Scale: 2M+ orders/day at peak; system must handle Super Bowl Sunday
(largest single-day spike) without pre-scaling indefinitely.
"""

DoorDash Engineering Focus Areas

Marketplace dynamics: Three-sided marketplace (customers, merchants, Dashers) — balance all incentives
Logistics optimization: Vehicle routing problem (NP-hard), heuristic solutions (nearest-neighbor, 2-opt)
Reliability: Orders are time-sensitive; system failures = cold food + angry customers
ML applications: Demand forecasting (pre-position Dashers), prep time prediction, fraud detection
International expansion: Wolt acquisition (Europe); multi-currency, local regulations, different market dynamics

Behavioral at DoorDash

DoorDash values: 1% better every day, act like an owner, be a 10x Dasher:

“Tell me about a time you improved something that wasn’t your responsibility.”
Speed and execution: DoorDash moves fast; show bias toward action
Customer obsession: “Tell me about a time you advocated for the customer.”
Data-driven: Back decisions with metrics, not opinions

Compensation (L3–L6, US, 2025 data)

Level	Title	Base	Total Comp
L3	SWE	$150–180K	$190–240K
L4	Senior SWE	$180–215K	$260–360K
L5	Staff SWE	$215–260K	$370–500K
L6	Principal	$260–310K	$500–700K+

DoorDash is publicly traded (NASDAQ: DASH). RSUs vest quarterly over 4 years. Stock has been volatile since IPO; check current trajectory.

Interview Tips

Use DoorDash: Order food, notice how ETA updates, understand the Dasher experience via the Dasher app
Logistics intuition: Know vehicle routing problem, traveling salesman, and greedy approximations
Three-sided marketplace: Understand how changes affect all three parties (a fee hike might improve unit economics but hurt Dasher supply)
LeetCode: Medium difficulty; graph problems, priority queues, and interval scheduling weighted

Practice problems: LeetCode 743 (Network Delay Time), 1129 (Shortest Path Alternating Colors), 56 (Merge Intervals), 1235 (Maximum Profit in Job Scheduling).