May we use cookies so Meta, Google, LinkedIn and ChatGPT see your visit and we learn which ads work? PrivacyMay we use cookies to see which pages help, and let Meta, Google, LinkedIn and ChatGPT see your visit, so we know which of our ads work? That way we spend less on ads that do not work. We do not sell your data, and the site works the same if you decline. You can change your answer at any time under Cookie settings at the foot of the page. Privacy policy
Loading...
System Design and AI Engineering, by Roni Das. 989 interactive lessons in two courses.: 770 in System Design and 219 in AI Engineering.
Start LearningSystem design interview guide
Short answer
Uber Eats system design connects three groups at once: eaters, restaurants and couriers. The read path finds restaurants that can deliver to your location using H3 hexagons and a search index. The write path places the order, sends it to the restaurant, assigns a courier through dispatch, predicts the delivery time and streams live tracking.
in this guide
7 parts open to everyone · 3 with a free account · 3 with the course
You can read 7 of 13 parts. A free account opens the deep dive; the course opens all of it.
Interviewers like this problem because it refuses to collapse into a single well-known pattern. A candidate has to reason about a three-sided marketplace where supply (couriers) and demand (orders) are both moving and both perishable, since a courier idle for ten minutes and food going cold both cost money. It tests geospatial indexing, streaming ingestion of GPS, a real optimization or matching algorithm, machine learning for ETA, and the classic distributed-transaction question of how to place an order across payments, the restaurant, and dispatch without leaving the system in a half-committed state. It also rewards candidates who can separate the cheap, cacheable read path from the expensive, consistency-sensitive write path, and who can talk about degradation when a region gets hot.
This page is the free part.
₹1,111 in India$35 everywhere elseonce, for the whole course
The System Design course covers the Uber Eats design across a run of lessons, not one page. These 4 alone are about 118 minutes of step-by-step reading, 1 of them with code you run in the browser, all with a quiz.
Always clarify these in the first 5 minutes of the interview. Do not start drawing boxes until both lists are agreed.
This guide is built on these 5 lessons. Each one teaches one piece of the Uber Eats design above, step by step.
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.
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.
The ride-hailing half, with Uber's own numbers: Uber system design: H3, matching, push and trip state
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
Uber Eats connects three parties at once: eaters browsing for food, restaurants preparing orders, and couriers moving through traffic. The dispatch layer evaluates a very large number of possible order-to-courier assignments continuously, and Uber has said its matching engine generates on the order of tens of millions of match-pair predictions per minute across its mobility and delivery products (Uber engineering, estimate for the combined platform). Every order stitches together a geospatial search, a food-prep-time prediction, a travel-time prediction, and a live tracking stream, and it all has to feel instant on a phone.
Uber Eats is a three-sided real-time marketplace. Eaters open the app at a delivery address and expect a ranked list of nearby restaurants that can actually deliver to them quickly, which makes search fundamentally geospatial rather than purely lexical. When an order is placed, the platform runs a distributed transaction across payments, the restaurant point-of-sale, and courier dispatch, then keeps everyone updated with a live map. The hardest parts are dispatch and timing: the system has to predict how long the food will take to cook, when a courier will reach the restaurant, and how long the final leg to the eater will take, then solve a global assignment problem that pairs orders with couriers to minimize total wait and keep food hot. On top of that sit geo-sharded search indexes, streaming location pipelines, surge pricing during demand spikes, and a payment split that pays the restaurant, the courier, and captures Uber's fee. A good design separates the read-heavy discovery path from the write-heavy order and dispatch path, and treats ETA prediction as a first-class machine learning system rather than a fixed constant.
Where it shows up
Asked at Uber, DoorDash, Grubhub, Deliveroo, Amazon, and most large marketplace and logistics companies. It is a favorite because it combines geospatial systems, real-time matching, ML-driven predictions, and a multi-party distributed transaction in one problem.
Spec sheetUber Eats
worked through below, with the maths
The hard parts of this design are taught step by step in the System Design course: Data Partitioning, Stream Processing and Real-Time Analytics: How Live Dashboards Stay Fresh and Fast, Measured in ClickHouse.
Data partitioning splits a large dataset across many machines. Hash, range and directory partitioning compared, consistent hashing, and when to partition.
Process data as it arrives, real-time analytics, fraud detection, and event-driven architectures.
How real-time analytics turns a stream of events into live dashboard numbers. A Kafka and ClickHouse lab measures freshness, pre-aggregation, unique counts and late events.
Long-lived transactions without distributed locking, orchestration vs choreography for microservices.
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
You own this course
Continue with Data Partitioningpay once,
yours for life
Live from the course bench
Real interview questions, live diagrams and measured lab results, pulled at random from the lessons. A new set every time you come back.
Show your math. Pulling numbers from thin air signals you have not thought about the load.
Daily orders
~15-25M orders/day (estimate)
Uber has publicly reported Delivery gross bookings in the tens of billions of dollars per year. Assuming an average order value near 30 to 35 dollars, annual order volume lands in the billions, which divided by 365 gives roughly 15 to 25 million orders per day. Derived, order of magnitude only.
Peak order rate
~1,700-3,000 orders/sec at dinner peak (estimate)
20M orders/day is ~230/sec averaged over 24h, but demand is spiky and concentrated in lunch and dinner windows. Applying a peak-to-average factor of 8 to 12 for those windows gives roughly 1,700 to 3,000 orders per second. Derived estimate.
Active couriers emitting GPS
Hundreds of thousands concurrently, pings every ~4s (estimate)
With hundreds of thousands of couriers online at peak and each phone sending a location update every few seconds, the location pipeline ingests on the order of 10^5 writes per second. This is the highest-volume write stream in the system. Derived estimate.
Search queries
Billions of queries/day across verticals
Uber engineering has described the search stack as serving billions of daily queries across restaurants, grocery, and retail. Browsing generates far more queries than orders because most sessions do not convert. Reported by Uber, exact split not public.
Match-pair predictions
Tens of millions per minute (platform estimate)
Dispatch evaluates many candidate courier-order pairings per decision, scored by predicted travel and prep times. Uber has cited tens of millions of match predictions per minute for its combined matching engine. Reported for the platform, not Eats alone.
Restaurant and store catalog
Millions of merchants, tens of millions of menu items (estimate)
Uber Eats operates across thousands of cities with growth into grocery and retail. Assuming millions of active merchants and an average of tens to hundreds of items each yields tens of millions to low billions of indexed documents. Derived estimate.
The read path and the write path are deliberately different systems. On the read path, an eater opens the app with a delivery location. The client hits an API gateway that routes to a search service, which resolves the address to an H3 hexagon and queries a geo-sharded, Lucene-based restaurant and store index scoped to the hexagons that can deliver to that point. A first-pass ranker does cheap lexical and geo filtering on the data nodes, then results are hydrated with per-store ETAs, promotions, and availability, and a second-pass personalized ranker orders them using conversion history and business signals. Menus and store metadata are served from caches because they change slowly. On the write path, placing an order kicks off an order service that acts as an orchestrator: it authorizes payment, sends the order to the restaurant's point-of-sale or tablet, and hands the order to dispatch. Dispatch is where the real-time work happens. A prediction layer estimates food prep time, courier travel time to the restaurant, and travel time from restaurant to eater, and a matching engine solves a global assignment of open orders to nearby couriers to minimize total time and idle. Couriers stream GPS continuously into a location pipeline built on Kafka-style streams; those positions feed both the matching engine and the live tracking map that eaters and restaurants watch. State transitions of the order flow through an event log so that timeouts, retries, and compensation can be handled cleanly, and so analytics and ETA models can learn from the completed trips.
In a real interview, sketch this on the whiteboard before diving into any single box.
Walk through each service. The interviewer wants to hear what each one owns, not just the names.
Resolves the eater's delivery address to H3 cells and queries geo-sharded search indexes for stores that can deliver there. It runs multi-stage retrieval and ranking, first cheap geo and lexical filtering on data nodes, then hydration and a personalized second-pass rank. It is read-heavy and heavily cached.
Owns the order lifecycle as a state machine from cart to delivered. It coordinates payment authorization, restaurant acceptance, and dispatch as a saga, issuing compensating actions such as refunds if a downstream step fails. It is the source of truth for order state.
Continuously pairs open orders with available couriers by solving a global optimization rather than greedily matching one order at a time. It scores candidate pairs using predicted prep and travel times and can batch several orders onto one courier when their routes align. This is the latency-sensitive heart of the platform.
A set of machine learning models that predict food preparation time, courier arrival time at the restaurant, and the final delivery leg. Prep time uses gradient-boosted trees over order and restaurant features, and travel time uses deep models like DeepETA on top of a routing engine. These predictions drive both dispatch timing and the ETA the eater sees.
Ingests high-frequency GPS pings from every active courier through a streaming system, cleans and map-matches them, and fans the positions out to the matching engine and to live tracking. It is the highest-write-volume component and is tuned for throughput and low end-to-end latency.
Charges the eater once with an idempotency key, then splits funds into a restaurant payout, a courier payout, and Uber's service fee, applying surge and tips. It integrates with external payment processors and must reconcile money movement exactly, so it leans on an event log and ledger rather than in-place updates.
Computes delivery fees and busy-area multipliers from live supply and demand within each geographic zone. When couriers are scarce relative to orders in a hexagon cluster, it raises fees to balance the marketplace and protect delivery times. It reads from the same location and order streams that dispatch uses.
restaurants. Store metadata and location, indexed by H3 cell so search can scope queries to hexagons that can deliver to the eater. Slowly changing, so it is aggressively cached and…
Every table for Uber Eats, its keys, and which store fits it and why.
Geospatial search: why hexagons and how the index is sharded. Search on Uber Eats is not text-first, it is location-first, because the only stores worth returning are the ones that can deliver to the eater's exact point. Uber…
7 deep dives on the parts that break at scale: Geospatial search: why hexagons and how the index is sharded; The dispatch problem: greedy versus global matching; Predicting three clocks: prep time, arrival time, and delivery time.
Global matching versus greedy nearest-courier assignment. Greedy is simpler and lower latency but leaves efficiency on the table by committing couriers before better pairings are known. Global matching over a short window…
6 decisions an interviewer expects you to defend, each with the alternative and why it loses here.
The payment is authorized but the restaurant tablet never answers. What does the order service do?
4 follow-up questions with model answers, the interview scorecard for this question, and a mock interview on Design Uber Eats with the AI tutor.
The details here follow Uber's own engineering writing. Uber open-sourced H3, its hexagonal hierarchical spatial index, and uses it to shard delivery zones and power features like Orders Near You. Its dispatch system moved from greedy to global matching, and its time predictions run on the Michelangelo ML platform, with food prep time modeled by XGBoost gradient-boosted trees and travel time by DeepETA, a deep network that corrects a routing engine's estimates under a tight global latency budget. Because restaurants do not report when food is ready, Uber infers prep time from courier sensor data using a conditional random field trip-state model that fuses GPS with phone motion and activity signals, then closes the loop by correcting inferred labels and retraining. The search stack is a multi-stage Lucene-based system with Kafka ingestion, geo-sharding, and two-pass ranking, and Uber has publicly discussed how naive changes like doubling the ranking candidate pool caused large latency regressions. Numbers for daily orders, peak rates, and location write volume in this write-up are labeled estimates unless attributed to Uber.
Sources
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.
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.
interview readiness
Three questions from this guide. Answer them without scrolling up, the way you would have to in the room.
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
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.
Free PDF · 79 pages
25 real tech interview questions, answered in full
Five from each of our AI, GenAI, Inference, Maths for ML and Forward Deployed packs. Each with a diagram and a model answer. Free by email.
free tool
Check these numbers yourself
Put in your own guesses for Uber Eats and see requests per second, storage, bandwidth and servers, with every sum written out.
Open the Capacity EstimatorIt is really nice and good Please join the course