System design interview guide
DoorDash System Design Interview: How Food Delivery Dispatch Assigns Orders to Dashers
Short answer
A good problem to practise for a DoorDash system design interview is dispatch. It decides which Dasher, the delivery driver, carries which order, and when. We have no public source that DoorDash asks it. The key idea is to predict first, then decide for a whole region at once. DoorDash's own dispatcher, DeepRed, works in three layers. It builds candidate offers from nearby Dashers and orders that could share a trip. Models predict when the food will be ready, how long each trip takes and whether the Dasher will accept. Then one optimization picks the best offers for each region; in 2020 DoorDash ran it several times a minute. Walk through those layers and the ETA (estimated time of arrival) shown at checkout. Then explain how you would test a change safely.
Want the generic food delivery design instead of DoorDash's own? Read the Uber Eats system design guide
Two courses by the author of this page:
770 lessons · 18 free to read
₹1,111 in India · $35 elsewhere, once
Get System DesignYou own this course
219 lessons · 10 free to read
₹1,333 in India · $35 elsewhere, once
Get Generative AI and Agentic AIYou own this course
Save your progress and get the interview checklist PDF
DoorDash reported 903 million orders in the last three months of 2025, across its DoorDash, Wolt and Deliveroo marketplaces. It operated in over 40 countries in 2025. On the DoorDash marketplace, a Dasher, the company's name for a delivery driver, carries the food. A system called DeepRed decides which Dasher gets which order. DoorDash wrote in 2020 that its optimizer solves this for each region several times a minute.
Designing DoorDash dispatch means answering one question many times a minute: which Dasher should carry which order, and when? DoorDash's dispatch system is called DeepRed. It works in three layers. First it builds candidate offers: nearby Dashers, plus other orders that one Dasher could carry together. Then machine learning models, programs trained on past deliveries, predict three things. When will the food be ready? How long will each trip take? Will the Dasher accept? Last, an optimization model picks the best set of offers for the whole region at once. Around that core sit the checkout ETA (estimated time of arrival) and the real-time signals that feed the models. There are also the order services, which DoorDash moved from a Python monolith to Kotlin. We have no public source that DoorDash asks this exact question; the guide is built from its engineering blog.
Where it shows up
A common type of question for backend, machine learning and logistics roles at delivery and marketplace companies. We have no public source that DoorDash uses this exact question. This guide is built from DoorDash's own engineering writing so you can reason with real numbers.
Spec sheetDoorDash
- 01Orders per day, estimated
- ~9.8M
- 02Orders per second, estimated
- ~113 avg, ~340 peak
- 03Deliveries in flight at peak, estimated
- ~610,000
- 04Matching runs per region
- several a minute
worked through below, with the maths
DoorDash in its own numbers
Every figure below is quoted from DoorDash's own engineering writing. Tap a source to check it.
903M
orders in Q4 2025, up 32% year over year
DoorDash Q4 2025 results, 202640+
countries where merchants sold on DoorDash in 2025
DoorDash Q4 2025 results, 2026up to 10x
faster: Gurobi vs the Hungarian algorithm on the matching problem
DoorDash engineering, 202020%
relative gain in ETA accuracy from the deep learning model
DoorDash engineering, 2024~6B
precomputed cell-to-cell travel estimates in the Geo-Grid-Cache
DoorDash engineering, 202580M+
requests per second through the service mesh at peak
DoorDash engineering, 2025
Why this question is asked
Dispatch tests whether you can design a system that makes decisions, not only one that stores and serves data. The inputs are uncertain: the kitchen may be slow, the road may be busy, and the Dasher may say no. The decision must be good for three groups at once: customers, merchants and Dashers. A candidate who answers "send the nearest driver" has missed most of the problem. The interviewer wants to hear about prediction, batching and when to wait. They also want to know how you would test a change safely.
What the interviewer asks
“Design the dispatch system for a food delivery service like DoorDash. A customer orders from a restaurant. The system must pick a Dasher and offer them the order. The food must reach the customer fast and on time. Then tell me what ETA we show the customer at checkout.”
Ask these back before you draw
- 1.How many orders, and how many at the dinner peak? (Use DoorDash's published order count below.)
- 2.Can one Dasher carry more than one order at a time? (Yes: batching is in scope.)
- 3.Can a Dasher decline an offer? (Yes. Dashers choose to accept or decline each offer.)
- 4.Do we decide one order at a time, or many orders together?
- 5.What do we optimize for: Dasher time, delivery speed, or a mix of both?
- 6.Is the checkout ETA in scope, or only the assignment?
This page is the free part.
The course goes deeper on the DoorDash design
₹1,111 in India$35 everywhere elseonce, for the whole course
The System Design course covers the DoorDash design across a run of lessons, not one page. These 4 alone are about 89 minutes of step-by-step reading, every one with a quiz.
- Geospatial Indexing
How databases efficiently answer 'find everything near me'. R-trees, geohashes, and spatial queries.
- Event-Driven Architecture
Build systems where everything reacts to events, the architecture powering Netflix, Uber, and LinkedIn at massive scale.
- Stateful Stream Processing
Maintaining state across events, aggregations, joins, and pattern detection in streaming data.
- Monolithic Architecture
The single-unit application architecture that every system starts with, and why it works until it doesn't.
all part of
System Design Masterclass
770 lessons · about 290 hours · 18 free to read
₹1,111in India, by UPI
$35everywhere else, by card or PayPal
It is really nice and good Please join the course
You own this course
Continue with Geospatial Indexingpay once,
yours for life
Live from the course bench
Before you design DoorDash, try the questions it rests on.
Real interview questions, live diagrams and measured lab results, pulled at random from the lessons. A new set every time you come back.
01Requirements
Requirements
Always clarify these in the first 5 minutes of the interview. Do not start drawing boxes until both lists are agreed.
Functional requirements
- A customer sees an ETA before placing the order
- When an order is confirmed, the system finds a Dasher and sends an offer
- A Dasher can accept or decline; a declined order is offered again
- One Dasher can carry several orders from the same or nearby stores (batching)
- The Dasher should reach the store close to the time the food is ready
- Customers and merchants can track the order until it is delivered
- Teams can change dispatch settings per business or store without a code release
Non-functional requirements
- Dispatch is critical: in 2020 DoorDash called its dispatch service tier zero, meaning the most critical kind; if it stops, no order moves
- Decisions within seconds: in 2020 the optimizer ran several times a minute per region
- Load: about 9.8 million orders a day on average in Q4 2025 (our estimate: 903 million / 92 days), with sharp peaks at lunch and dinner
- Accurate ETAs, especially for the rare, very late orders: a late order hurts more than an early one
- Every change to the models must be measurable in production without fooling ourselves
- A slow downstream service must not take the whole order flow down
02Scale estimates
Back-of-envelope scale estimates
Show your math. Pulling numbers from thin air signals you have not thought about the load.
Orders per day, estimated
~9.8M
DoorDash reported 903 million orders in Q4 2025, a quarter of 92 days. 903 million / 92 is about 9.8 million a day. The count covers the DoorDash, Wolt and Deliveroo marketplaces (Deliveroo from October 2, 2025) plus DoorDash's Commerce Platform. DoorDash has not said how many of these go through DeepRed, so treat this as an upper bound for dispatch.
Orders per second, estimated
~113 avg, ~340 peak
9.8 million / 86,400 seconds is about 113 orders a second on average. Food orders bunch at lunch and dinner. Assume the peak is three times the average: about 340 new orders a second. The 3x is our assumption, not a DoorDash figure.
Deliveries in flight at peak, estimated
~610,000
DoorDash wrote in 2021 that the vast majority of deliveries arrive in under 30 minutes. Assume 30 minutes, or 1,800 seconds, per delivery. 340 orders a second x 1,800 seconds is about 610,000 open deliveries at once. This is Little's law: things in flight = arrival rate x time each one takes. Thirty minutes is an upper bound, so this estimate errs high.
Matching runs per region
several a minute
DoorDash's 2020 post says the optimizer ran on several instances split by regional boundaries, multiple times a minute. So no single solve sees the whole country. Each one sees one region's Dashers and orders.
Dasher location writes, assumed
~125,000 a second
DoorDash has not published how many Dashers are online or how often the app reports location. Assume 500,000 Dashers online at the peak, each sending a location every 4 seconds. 500,000 / 4 is about 125,000 writes a second. Both inputs are our assumptions.
Travel estimates stored
~6 billion
DoorDash's 2025 post counts about 6 billion cell-to-cell travel estimates across three map resolutions. They are precomputed offline with Spark, a tool for large batch jobs, and served from Redis. A routing engine call took over 100 ms (milliseconds).
03Architecture
High-level architecture
Draw four parts. The first is the order path. The customer app calls an order service, which validates the cart, takes payment and creates a delivery. DoorDash rebuilt this checkout flow in 2020 as a Kotlin microservice. It used Cassandra (a distributed database) and Kafka (an event log). It also used Cadence, a workflow engine that retries failed steps. Services call each other with gRPC, a fast remote call protocol. The second part is the real-time signal pipeline, as DoorDash described it in 2020. Services publish business events, such as "store confirmed an order", to Kafka. Flink, a stream processor, counts them in time windows. The results land in Redis, an in-memory store, as features for the models. In this design, the Dasher app also sends its location every few seconds. A location service keeps each free Dasher in an in-memory index by H3 cell, a hexagon on a map grid. The offer builder can then ask for every free Dasher within a few cells of the store. DoorDash has not published how it does this. The third part is prediction. Models predict food preparation time, travel time and the chance a Dasher accepts. Another predicts the ETA the customer sees. In this design, travel times come from a cache of precomputed estimates, not a live routing call. DoorDash described such a cache in 2025. The fourth part is DeepRed, the dispatcher. For each region, several times a minute, it builds candidate offers and scores them with the models. Then it solves one optimization problem for the whole region. The chosen offers go to the Dasher app. When a Dasher declines, DoorDash finds another Dasher; in this design, the order simply joins the next run. Settings per business and per store come from a configuration service, so dispatch rules can change without a release.
In a real interview, sketch this on the whiteboard before diving into any single box.

04One request
What happens to one order, step by step
This follows the order's journey through DeepRed as DoorDash described it in 2021. The real-time signals and the ETA come from DoorDash's other posts.
- 1
Show an ETA
Before the customer orders, the checkout page shows an ETA. A model predicts the total delivery time. It uses features such as the store, the time of day and recent orders at that store.
- 2
Place and confirm the order
The order service saves the order and processes payment. The merchant confirms it. Right after the merchant confirms, DoorDash starts matching and dispatch.
- 3
Build candidate offers
DeepRed looks for Dashers who are nearby and free, or about to finish a delivery. It also looks for other orders at the same store or on the same block. One Dasher could carry those together.
- 4
Predict how each offer would play out
The ML layer estimates when the food will be ready and how long each trip and parking stop takes. It also estimates how likely each Dasher is to accept.
- 5
Choose for the whole region
The optimization layer scores every candidate offer. It solves a mixed-integer program (an optimization where each answer is yes or no) with Gurobi, a commercial solver. It decides which offers to make, which orders to batch, and whether to wait for a better Dasher.
- 6
Offer, then deliver or retry
The Dasher app shows the offer. If the Dasher accepts, they drive to the store and then to the customer. If they decline, DoorDash finds another Dasher; in this design, the order simply joins the next run.
05Components
Core components
Walk through each service. The interviewer wants to hear what each one owns, not just the names.
Order service (Kotlin)
Takes the cart, checks the items, the merchant and delivery availability, and saves the order to Cassandra. It then runs a state machine, a fixed list of steps the order moves through. The steps include fraud check, payment and delivery creation. Cadence retries a failed step. Each step is idempotent, meaning it is safe to run twice.
Real-time signal pipeline
Services publish events to Kafka. Flink keeps counts over time windows, such as orders at one store in the last 20 minutes. The results sit in Redis under clear names, so many models can read the same feature.
Prediction models
Separate models predict food ready time, travel time, parking and pickup time, and the chance a Dasher accepts. Another model predicts the ETA the customer sees. In 2024 DoorDash moved that ETA model from trees (many small decision trees) to a deep learning model.
Travel time service (Geo-Grid-Cache)
Answers "how long from here to there" from a cache instead of a routing call that took over 100 ms. DoorDash described it in 2025. The map is cut into H3 hexagon cells at three resolutions. Travel times between cells are computed ahead of time with OSRM, an open source routing engine, and kept in Redis.
DeepRed: offer generation
Builds the candidate offers for each new order. It finds Dashers who could take it now or soon. It also finds other orders that could ride with it in one batch.
DeepRed: optimization layer
Scores every candidate offer, then solves a mixed-integer program (MIP) for the whole region with the Gurobi solver. A MIP is a math problem where some answers must be whole numbers. Here each answer is yes or no for one offer.
Logistics configuration service
Stores dispatch settings at many levels, such as per business or per store, and even per time of day. DoorDash described it in 2024. It runs on CockroachDB, a distributed SQL database, so teams can change settings without editing files in GitHub.
Experiment platform
Runs switchback tests, which flip whole regions between the old and new algorithm in random time windows. Dispatch changes affect every order in a region, so a normal A/B test by customer would give wrong answers.
06Data model
Data model
Pick the right store per table. Justify each choice with the access pattern, not by reflex.
ordersorder_id (partition key)consumer_idstore_iditemsstate (submitted, paid, delivery_created, ...)updated_atCassandra, as in DoorDash's 2020 checkout rebuild. The key and the state names are this design's, since DoorDash has not published the schema. The order service saves the state after each step of its state machine. A retry can then resume where it stopped.
deliveriesdelivery_idorder_idstore_locationdrop_off_locationquoted_etadasher_id (null until accepted)statusOne row per delivery, read by dispatch on every run. DoorDash has not published this store's schema. In this design it is split by region, so a regional solve reads only its own rows.
dasher_statedasher_idregion_idlocationstatus (idle, to_store, to_customer)current_route[]updated_atWhere each Dasher is and what they are doing. DoorDash has not published how it stores this. In this design it lives in memory per region, rebuilt from location updates, because it changes every few seconds.
realtime_features (Redis)feature_name.entity_idvaluewindowDoorDash's own example key is saf_st_p20mi_order_count_sum.st_123: the count of orders in the last 20 minutes at store 123. Written by Flink, read by the prep time and ETA models.
travel_estimates (Redis)from_h3_cellto_h3_cellresolutionduration_sdistance_mAbout 6 billion rows across three resolutions, built offline with Spark and OSRM. A lookup checks all three tiers and uses the highest-resolution one that has an answer.
07Deep dives
Deep dives
These are the conversations the interviewer is steering you toward. Practice each one until you can talk through it without notes.
DeepRed: three layers between an order and a Dasher
DoorDash wrote in 2021 that DeepRed is "the system at the center of our last-mile logistics platform". Last mile means the final trip from store to door. It has three layers. The first builds candidate offers. It finds Dashers who are free or about to finish a delivery. It also looks for orders at the same store or on the same block, which one Dasher could carry together. The second layer is machine learning. It predicts when the order will be ready and how long each trip will take. It also predicts how likely each Dasher is to accept. DoorDash even models parking time at each store, sometimes as simply as last month's average. The third layer is optimization: choosing the best option under limits. Here the question changes from "what will happen to this order" to "what is best for the whole region". In the interview, say it in that order: generate, predict, then decide. Each layer can then be improved on its own.
Why a MIP solver replaced the Hungarian algorithm
Matching Dashers to orders looks like a textbook assignment problem. DoorDash's older dispatcher treated it that way. It gave one delivery per route and solved it with the Hungarian algorithm, a classic method for one-to-one matching. DoorDash wrote in 2020 that this had two limits. Large instances took too long for a real-time system. And it could not express a route with two or more deliveries. So DoorDash rewrote the problem as a mixed-integer program. A yes-or-no variable says whether a Dasher gets an order. The objective scores both delivery speed and Dasher efficiency. Gurobi, a commercial solver, solved the matching up to 10 times faster than the Hungarian algorithm. In DoorDash's benchmarks it was 34 times faster on average than CBC, an open source solver. In 2020 the optimizer ran on several instances split by region, multiple times a minute. DoorDash also swapped it in safely. It ran the new MIP next to the old optimizer in shadow, meaning its answers were only logged. The two matched more than 99% of the time, and the rest were ties, so DoorDash switched with no downtime. The sketch below is an illustration, not DoorDash's code.
# x[o] = 1 if candidate offer o (a Dasher + one or more orders) is made
maximize sum(score[o] * x[o] for o in offers)
subject to
for d in dashers: sum(x[o] for o in offers if o.dasher == d) <= 1
for k in orders: sum(x[o] for o in offers if k in o.orders) <= 1
x[o] in {0, 1}
# score[o] mixes speed and Dasher time, minus a penalty for risky routesBatching and the choice to wait
Batching means one Dasher carries more than one order in a trip. In 2026 DoorDash defined batch rate as the percentage of deliveries assigned to the same Dasher in a single trip. Batching works best when orders come from the same store, which saves pickups, or nearby stores, which saves parking. The food's preparation time helps: while the kitchen cooks, a Dasher can collect another order. Batching matters most when Dashers are scarce. In 2021 DoorDash noted that rain lowers acceptance when many Dashers ride motorbikes. But each extra stop adds uncertainty. DoorDash adds a penalty to the score that grows with route complexity, so risky routes are discouraged. The optimizer can also wait. It may hold an order for a better Dasher who will be free soon. Or it may wait until closer to the ready time, so the Dasher does not stand in the store. In a 2026 post, DoorDash described choosing the batch rate and peak pay together. Peak pay is extra money for Dashers at busy times. It picks both for each area and time, inside a budget.
Time the Dasher to the food
A Dasher who arrives early waits at the counter and loses time. A Dasher who arrives late leaves food to go cold. So the ready time prediction matters as much as the travel time. DoorDash wrote in 2023 about quick service restaurants, which have very short prep times. Some of them did not start cooking until the Dasher arrived. DoorDash built Auto Order Release. The merchant confirms the order, but the kitchen does not see it yet. It is released when the Dasher comes within a set distance of the store, called a geofence. That distance was first set by hand per store. DoorDash then moved to a per-order decision. A model predicts the prep time and decides whether to release the order now or wait for the Dasher. The goal was shorter Dasher waits without longer food waits.
The ETA shown at checkout
The ETA (estimated time of arrival) is a promise made before the order exists. In 2024 DoorDash defined it as order creation time plus delivery duration. The duration has stages: assigning a Dasher, travel to the store, pickup, and travel to the customer. In 2020, DoorDash used a gradient boosting model, built from many small decision trees, with dozens of features. Real-time signals, such as Dasher wait at the store and recent order counts, were among the top ten. In 2021, DoorDash wrote that a too-short ETA makes orders late, and a too-long one makes customers leave. It switched to an asymmetric loss, a training penalty that punishes late more than early. Accuracy on the rare, very late orders improved by 10%. In 2024 it moved to a deep learning model called a mixture of experts. It combines several smaller networks and reads minute-by-minute market signals. That gave a 20% relative gain in accuracy. The model also predicts a spread, not only one number.
Travel times in milliseconds: the Geo-Grid-Cache
Dispatch needs a travel time for every candidate Dasher and order pair; assume thousands per run. DoorDash wrote in 2025 that calling a routing engine such as OSRM took over 100 milliseconds. Straight-line distance is fast, but wrong when a river or a highway is in the way. DoorDash's answer was to compute ahead of time. It split its service areas into H3 cells, a grid of hexagons, at three sizes. The finest tier serves trips of up to about a mile; the coarsest serves trips of up to 100 miles. Travel times between cell centers are computed offline with Spark and OSRM, about 6 billion of them. They are stored in Redis. A request checks all three tiers and uses the highest-resolution one that has an answer. In the interview, this is the move to name: precompute the expensive call when the inputs can be bucketed.
From a Python monolith to Kotlin services
DoorDash's early backend was one Django application on Python 2, with most data in one Postgres cluster. DoorDash wrote in 2021 that deploys were slow, ownership was unclear and Python 2 was reaching end of life. It chose Kotlin for its ecosystem, its Java interoperability and developer friendliness. The checkout flow moved in 2020. It now runs as a Kotlin service on Cassandra, Kafka, Cadence and gRPC. Running data fetches in parallel with Kotlin coroutines tripled that part's speed. The move had costs too. DoorDash warned that two services at 99.9% uptime make a workflow of 99.8%. In mid-2021, a slow payment service plus aggressive retries caused an outage of more than two hours. DoorDash decided safety features had to live in the platform. A circuit breaker stops calls to a failing service; load shedding drops extra work to stay alive. DoorDash moved over 1,000 services to a service mesh, a network layer between services that handles retries and timeouts. In 2025 it wrote that the mesh carries over 80 million requests a second at peak.
Common mistakes candidates make
The first mistake is "assign the nearest Dasher". It ignores when the food will be ready, whether the Dasher will accept, and batching. Say instead that you predict ready time, travel time and acceptance, then optimize across the region. The second mistake is matching one order at a time as orders arrive. Greedy choices block better ones a minute later. Say that you solve each region in short rounds, so the optimizer sees many orders and Dashers together. The third mistake is calling a routing API inside the matching loop. Assume thousands of pairs per run; at 100 milliseconds each, that is far too slow. Say that you cache or precompute travel times. The fourth mistake is testing a dispatch change with a normal A/B test by customer. Both groups share the same Dashers, so the result leaks. Say that you would use switchback tests by region and time window. Here is a good order for the 45 minutes. Clarify the problem (5 minutes) and do rough numbers (5). Draw the four-part diagram (10) and go deep on matching (10). Cover the ETA and testing (10), then trade-offs.
08Trade-offs
Trade-offs to discuss
Every senior interviewer expects you to surface at least 3 of these. Pick the decisions, state the alternatives, and justify your choice.
Optimize a region in batches vs assign each order as it arrives
Assigning on arrival is simple and fast. But it is greedy, and an early choice can block a better match a minute later. Solving each region several times a minute sees more orders and Dashers at once. So it can batch and make trade-offs. The cost is a short delay and a solver that must finish inside each round.
Commercial MIP solver vs a hand-written matching algorithm
The Hungarian algorithm is free and well understood, but it only matches one order to one route. A MIP can express batches, waits and many constraints, and in 2020 Gurobi solved DoorDash's matching up to 10x faster. The cost is a license and a dependency on a vendor, which DoorDash judged worth it.
Higher batch rate vs faster single deliveries
Batching saves Dasher time and money and can even speed up delivery when Dashers are scarce. But each extra stop adds wait and uncertainty for the customer. In 2026 DoorDash described treating the batch rate as a setting, not a fixed rule. It is chosen per area and time, together with peak pay.
Precomputed travel times vs live routing calls
A live call to a routing engine is the most accurate. But in 2025 DoorDash said it took over 100 ms. Straight-line distance is instant but often wrong. Precomputing cell-to-cell times keeps accuracy close to the engine at a fraction of the latency. The cost is an offline job and a few billion rows to store and refresh.
Asymmetric ETA loss vs plain average error
Training for the average treats early and late the same. Customers do not: a late order hurts trust more. An asymmetric loss lets the team say how much worse late is, in numbers. The cost is that the team must choose how much worse late is than early. A wrong choice either pads quotes or keeps orders late.
Switchback tests vs A/B tests by customer
An A/B test by customer is quick and powerful, but dispatch changes leak between groups through shared Dashers. A switchback flips whole regions in random time windows, so the comparison is fair. The cost is lower statistical power, so tests run longer.
Free PDF · 18 pages
Get the free System Design Interview Cheat Sheet
The interview in seven stages, the numbers worth knowing by heart, and twelve classic systems on one page each, every line linked to the lesson it comes from.
09Follow-ups
Follow-up questions to expect
After the main design, the interviewer usually picks one part and asks more. Here is what to say.
A Dasher declines the offer. What happens next?
DoorDash's 2021 post says it finds another Dasher to offer the order to, until it is picked up and delivered. In this design the order simply stays open and joins the next optimization run, usually within the minute. The quoted ETA already allows for some declines. If an order is declined again and again, its score should rise so the next run treats it as urgent.
How would you test a new scoring function before full launch?
Start offline in a simulator of customers, Dashers and merchants. Then run a switchback test: each region flips between old and new in random time windows. DoorDash's 2018 example, for pricing, used 30-minute windows. In 2021 DoorDash wrote that it screens many ideas in one group, then confirms at most three in another.
A big retailer wants one Dasher to carry dozens of orders. Does this design hold?
Not as is. That becomes a vehicle routing problem with many stops. In 2021 DoorDash described adding its own ruin-and-recreate routing algorithm to DeepRed for large orders. Ruin-and-recreate removes and reinserts stops to improve a route. It runs per geographic shard, a slice of the map, in parallel, with a greedy fallback on timeout. That cut 10,000-delivery benchmarks from minutes to a few seconds.
What stops the next run from offering the same order, or the same Dasher, twice?
In this design, an order with an open offer is left out of the next run. So is a Dasher with an open offer. They come back when the Dasher answers or the offer times out. DoorDash has not published how it handles this.
What if the solver does not finish in time?
In this design, the solver gets a time limit and returns its best answer so far. A simple greedy match, nearest free Dasher first, is the fallback. DoorDash's 2021 routing post uses the same idea: on a timeout, the greedy result is used.
10In production
How DoorDash actually does it
Every fact about DoorDash on this page comes from DoorDash's own writing and filings. The estimates and anything marked 'in this design' or 'assume' are ours. DeepRed's three layers, batching and the choice to wait are from the 2021 post on ML and optimization for dispatch. The MIP, Gurobi and the shadow switch are from the 2020 post on next-generation dispatch. Large routes and ruin-and-recreate are from the 2021 routing post. Travel times are from the 2025 Geo-Grid-Cache post. The ETA work spans the 2020 real-time features post, the 2021 long-tail post and the 2024 deep learning post. Auto Order Release is from the 2023 post on Dasher wait times. The Kotlin move, the checkout rebuild, the monolith pain points and the service mesh each have their own post. Order counts and countries are from DoorDash's Q4 2025 results. Older posts describe the system at that date, so say the year when you quote a number.
Sources
- DoorDash: Using ML and Optimization to Solve DoorDash's Dispatch Problem (2021)
- DoorDash: Next-Generation Optimization for Dasher Dispatch (2020)
- DoorDash: Scaling a routing algorithm using multithreading and ruin-and-recreate (2021)
- DoorDash: How DoorDash achieves fast travel estimates (2025)
- DoorDash: Precision in Motion, deep learning for smarter ETA predictions (2024)
- DoorDash: Improving ETA Prediction Accuracy for Long-tail Events (2021)
- DoorDash: Supercharging Marketplace Decision-Making with Real-Time Knowledge (2020)
- DoorDash: Lifecycle of a Successful ML Product, Reducing Dasher Wait Times (2023)
- DoorDash: Supercharging logistics through causal ML and joint optimization (2026)
- DoorDash: Switchback Tests and Randomized Experimentation Under Network Effects (2018)
- DoorDash: Migrating From Python to Kotlin for Our Backend Services (2021)
- DoorDash: Building a More Reliable Checkout Service at Scale with Kotlin (2021)
- DoorDash: From Monolith to Microservices, Reducing the Migration's Pain Points (2021)
- DoorDash: Inside DoorDash's Service Mesh Journey, Part 1 (2025)
- DoorDash: Meeting Growth with a Self-Service Logistics Configuration Platform (2024)
- DoorDash: Fourth Quarter and Full Year 2025 Financial Results (PDF, 2026)
Lessons to study before this interview
If any of these topics are fuzzy, the interviewer will catch it. Each lesson is 15 to 60 minutes with diagrams, code, and a quiz.
Geospatial Indexing
intermediate / database types storage
Event-Driven Architecture
intermediate / messaging event systems
Stateful Stream Processing
advanced / stream batch processing
Monolithic Architecture
intermediate / microservices architecture
Retry Logic
intermediate / microservices architecture
Circuit Breaker Pattern
intermediate / microservices architecture
Saga Pattern
advanced / distributed systems core
Distributed SQL
intermediate / database types storage
Capstone: Design Uber Ride-Sharing
capstone / capstone
System design interviews at companies in the US, UK, Canada and Singapore
41 walkthroughs of real systems at well-known companies, each built from that company's own engineering blog, talks or filings, with the numbers cited.
Banking, payments and trading
Commerce and delivery
- Shopify system design (Canada)
- DoorDash system design (this page)
- Amazon system design
- Airbnb system design
- Agoda system design (Singapore)
- Uber Eats system design
Rides and maps
- Grab system design (Singapore)
- Uber system design
Feeds, social and messaging
Streaming and media
AI labs and big tech
Developer and collaboration tools
11FAQ
Frequently asked questions
Go deeper
This guide is built on these 6 lessons. Each one teaches one piece of the DoorDash design above, step by step.
- Geospatial IndexingSystem Design · database types storage · 16 min
- Event-Driven ArchitectureSystem Design · messaging event systems · 28 min
- Stateful Stream ProcessingSystem Design · stream batch processing · 25 min
- Monolithic ArchitectureSystem Design · microservices architecture · 20 min
- Retry LogicSystem Design · microservices architecture · 18 min
- Circuit Breaker PatternSystem Design · microservices architecture · 35 min
Practice with 770 system design lessons
Lifetime access for ₹1,111 in India or $35 elsewhere. Interactive diagrams, quizzes, and 20 capstone projects to practise on.
This one question is not enough for the interview.
Get all 200 questions in the System Design and Distributed Systems pack
Each question has why it is asked, a full answer, what the interviewer listens for, the follow-ups, the common mistakes and a diagram (268 diagrams in all). A PDF you keep, junior to staff level.
Pay by UPI, cards or netbanking through Razorpay. Pay by card or PayPal, in US dollars. Download at once from My packs.
NEWSystem Design Hands-On
Included in the System Design course: real systems, built live
Postgres Sharding: Complete Hands-On (PgBouncer + Citus). 2 h 36 min and 20 chapters: one PostgreSQL loaded until it breaks, then four shards behind a router you write, PgBouncer and Citus, with the 139-page slide deck. The first 15 minutes are free to watch.


