System design interview guide
Grab System Design Interview: How Ride-Hailing Dispatch Matches Drivers in Southeast Asia
Short answer
A good scenario to practise for a Grab system design interview is ride-hailing dispatch. Picture a busy Southeast Asian city. We have no public source that Grab asks it. The key idea: the nearest driver by straight line is often not the best one. So Grab searches real roads and weighs over 40 factors. A booking first passes an area check in Redis, which Grab calls Spampede. A storm in one district then cannot slow the rest. Pharos, Grab's in-memory index of drivers on the road network, returns nearby drivers. An ETA model ranks them by arrival time. Allocation can match a batch of bookings at once and offers the job to one driver. In this design, the driver is reserved during the offer.
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
Grab crossed 50 million monthly transacting users in 2025. It serves over 800 cities in eight Southeast Asian countries. Its mobility business had a gross merchandise value, the total value of rides booked, of US$7,901 million that year. In 2020, Grab measured its nearby-driver search at 50 milliseconds for 99 of every 100 requests.
Designing Grab dispatch means matching a booking to a driver in a crowded Southeast Asian city. It must happen in well under a second. Drivers move all the time, so their positions live in memory, on a map of real roads. A booking first gets a list of nearby drivers. Then an ETA model, which estimates time of arrival, ranks them. Then allocation weighs over 40 factors and offers the job to one driver. Grab has written about each part. Pharos finds nearby drivers. Allocation can match many bookings at once as one problem. Spampede protects the system when rain hits one district. Supply and demand are measured per geohash, a small rectangle of the map.
Where it shows up
A common type of question for backend, platform and data roles at ride-hailing and delivery companies. It is a variant of the classic design Uber question. We have no public source that Grab uses this exact question. This guide is built from Grab's own engineering writing, so you can reason with real numbers.
Spec sheetGrab
- 01Monthly users
- 50M+
- 02Bookings per second, estimated
- ~58 average, ~174 peak
- 03Pickup ETA calls, estimated
- ~3,500 a second
- 04Driver position writes, estimated
- ~200,000 a second
worked through below, with the maths
Grab in its own numbers
Every figure below is quoted from Grab's own engineering writing. Tap a source to check it.
50M+
monthly transacting users, crossed in 2025
Grab results release, Feb 2026US$7,901M
Mobility gross merchandise value (total paid for rides) in 2025, up 19%
Grab results release, Feb 2026800+
cities in eight Southeast Asian countries
Grab Tech blog, 202540+
real-time factors weighed when matching a driver
Inside Grab, 202650 ms
P99 nearby-driver search in Pharos (99 of 100 requests this fast or faster)
Grab Tech blog, 2020200+ to 16
ETA models consolidated on Catwalk, which cut compute cost by 95%
Inside Grab, 2023
Why this question is asked
Dispatch tests four things in one question. Can you keep fast-changing state, like driver positions, in the right kind of store? Can you see that the nearest driver by straight line is often not the best one? Can you protect a shared system from a local spike, like a storm in one district? And can you explain a matching choice in terms of riders and drivers, not only code? A candidate who draws one database and one matching service has missed most of it.
What the interviewer asks
“How would you design ride-hailing dispatch and allocation at Grab? A rider in Jakarta or Singapore books a car. Find a good driver, offer the job and confirm it within seconds. Keep it working when it rains and half the city books at once.”
Ask these back before you draw
- 1.Rides only, or food and parcel delivery too? (Start with rides; say where delivery differs.)
- 2.Do we pick one booking at a time, or can we match a batch of bookings together?
- 3.How often do driver apps send their position? (Grab's 2020 Pharos post gives every second as an example.)
- 4.Is price in scope? Surge pricing changes demand, so it is part of the same loop.
- 5.Which cities? Road networks, traffic rules and vehicle types differ by country.
This page is the free part.
The course goes deeper on the Grab design
₹1,111 in India$35 everywhere elseonce, for the whole course
The System Design course covers the Grab design across a run of lessons, not one page. These 4 alone are about 72 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.
- In-Memory Databases
Databases that live entirely in RAM, trading durability for speed measured in microseconds.
- Redis Cache
The same small GET measured 0.3 ms at worst on an idle server and 59.1 ms while one other client ran KEYS. Reading one field cost 0.934 ms as a blob and 0.040 ms as a hash.
- Key-Value Stores
How key-value databases work, how to design good keys, and how Redis, DynamoDB and etcd compare. Includes a diagram of a GET and SET operation.
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 Grab, 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 rider sets a pickup and drop-off and sees a fare and an ETA before booking
- Driver apps send their position many times a minute while online
- A booking is matched to one suitable driver, who can accept or decline
- If the driver declines or times out, the booking is offered to another driver
- Rider and driver both see the trip move through its states: booked, allocated, picked up, completed
- Fares rise when demand outruns supply in an area, and drivers see where demand is
- Local rules apply, such as Jakarta's odd-even licence plate days
Non-functional requirements
- Low latency: in 2020 Grab's Pharos answered a nearby-driver search in 50 ms at P99
- High write rate for positions: drivers can move over 20 metres a second, so positions go stale fast
- A storm in one district must not slow down booking for the rest of the city
- Trip and payment state must be correct; a driver position a second old is fine
- Survive the loss of one machine or one availability zone (a separate data centre inside one cloud region)
- Cost aware: every byte copied between AWS availability zones is billed
02Scale estimates
Back-of-envelope scale estimates
Show your math. Pulling numbers from thin air signals you have not thought about the load.
Monthly users
50M+
Grab's own results release for 2025 says it crossed 50 million monthly transacting users. That counts all services, not only rides.
Bookings per second, estimated
~58 average, ~174 peak
In 2023 Grab wrote that ETAs are calculated for the millions of trips on Grab every day. Assume 5 million bookings a day; that is our assumption. 5,000,000 / 86,400 seconds is about 58 a second. Assume the evening peak is three times the average: about 174 a second.
Pickup ETA calls, estimated
~3,500 a second
Assume each booking ranks 20 candidate drivers; that is our assumption. 174 peak bookings x 20 candidates is about 3,500 pickup ETAs a second. That is before any fare-check traffic. This is why the pickup ETA must be cheap.
Driver position writes, estimated
~200,000 a second
Grab does not publish how many drivers are online. Assume 200,000 at the peak across all cities. Grab's 2020 Pharos post gives every second as an example update rate. 200,000 drivers x 1 update a second is 200,000 writes a second. This dwarfs the booking rate, which is why positions live in memory.
Matching graph size
~400,000 road nodes (Singapore)
Grab's 2021 matching post says the road network of Singapore alone has around 400,000 nodes. Distances for matching are computed on that graph, not as straight lines.
Nearby search budget
50 ms
Pharos's measured P99 for a nearby-driver search, from Grab's 2020 post. The ETA model, fraud checks and allocation must fit in the time left before the offer goes out.
03Architecture
High-level architecture
Draw the booking path top to bottom. The rider app sends a booking to a booking service. Before any heavy work, the booking service checks a Redis counter for the pickup area. Redis is a fast in-memory key-value store. Grab calls this filter Spampede. If too many bookings in that area are already waiting without a driver, it rejects the new one at once. Next, the booking service asks Pharos for nearby drivers. Pharos is Grab's in-memory index of driver positions on the road network, partitioned by city. It returns the nearest drivers by road distance or travel time, not straight-line distance. In this design, that road-graph answer is cheap enough to narrow a whole city to a short list. The machine learning ETA model then gives a more accurate arrival time for the short list only. It uses live traffic and weather. Allocation takes the ranked list and weighs over 40 factors. Among them are arrival time, the driver's preferences, vehicle type, fraud checks and local traffic rules. It can match a batch of bookings and drivers together. The chosen driver gets an offer in the driver app. In this design, booking state goes to DynamoDB, as Grab's food order platform does. Events flow on Kafka to analytics and to the supply and demand jobs. Kafka is an event log that services write to and read from.
In a real interview, sketch this on the whiteboard before diving into any single box.

04One request
What happens when a rider books a car, step by step
Grab's own outline is: find drivers nearby, narrow by ETA, run fraud checks, then match. The Spampede check comes first, from Grab's 2020 post. The store, the reservation and the offer channel are this design's choices, because Grab has not published the ride version.
- 1
The rider books
The rider app sends pickup, drop-off and vehicle type to the booking service. The fare and ETA shown before booking came from the same pricing and ETA services.
- 2
The area check
The booking service turns the pickup point into a geohash bucket. It reads a Redis counter of unallocated bookings in that bucket for this time window. If the counter is over the limit, the booking is rejected at once, before any other service call.
- 3
Find nearby drivers
The booking service asks Pharos for drivers near the pickup. Pharos searches its in-memory road graph for the city. It returns drivers within a range, such as three kilometres, sorted by road distance or travel time.
- 4
Rank by arrival time
The ETA model estimates each candidate's time to the pickup, using live traffic and weather. The list is narrowed to drivers who can arrive soon.
- 5
Allocate
Allocation runs fraud checks and weighs over 40 factors, including driver preferences and local rules. It may match a batch of bookings at once. Allocated means a driver has been chosen and offered the job, not that the trip is final.
- 6
Offer and confirm
In this design, the chosen driver is marked as reserved before the offer goes out. No other booking can then be offered the same driver. The reservation is released if the driver declines or the offer times out. On accept, the trip moves on and both apps update. On decline, the booking goes back to booked for another round. If allocation finds no driver at all, the booking service adds one to the area counter for that pickup area.
05Components
Core components
Walk through each service. The interviewer wants to hear what each one owns, not just the names.
Booking service
Accepts the booking, owns its state and runs the steps in order. In this design it is stateless; the booking itself lives in the transactional store. Grab has not published the internals of its ride booking service.
Spampede filter (Redis)
A guard against local demand spikes, from Grab's 2020 post. It counts unallocated bookings per service type, geohash bucket and time bucket in Redis. Over the limit, new bookings in that area are rejected early. Grab built it because a storm or a concert in one place slowed the system for everyone.
Pharos (nearby-driver index)
Grab's in-memory store of driver positions, as described in 2020. It sits on OpenStreetMap road graphs, partitioned by city and vertical (rides, food and so on). OpenStreetMap is a free, community-built map of the world. Drivers are stored in Adaptive Radix Trees, a compact in-memory tree keyed by ID. Each partition has two replicas in different availability zones.
ETA service
Predicts how long a driver needs to reach a pickup, and how long the trip takes. In 2023 Grab wrote that it had cut over 200 separate models to 16. They are trained on its Catwalk machine learning platform and retrained weekly.
Allocation (dispatch)
Chooses the driver. Grab says it weighs over 40 real-time factors beyond distance, runs fraud checks and respects local rules. It can treat a batch of bookings and drivers as one matching problem. In 2025 Grab described DispatchGym, a simulator for testing changes to dispatch settings safely before they reach riders.
Supply and demand jobs
In Grab's 2019 post, these measure idle drivers against riders checking fares, per geohash and short time slot. In this design, the ratio feeds surge pricing and the driver heat map. Grab says fares respond to supply and demand but has not published which metric drives them.
Data layer: DynamoDB, MySQL and Kafka
In 2022 Grab wrote that its food and mart order platform kept live orders in DynamoDB. History was in MySQL on RDS, with a Kafka stream in between. In 2023 Grab's Coban team ran Kafka as a shared platform. This design reuses the same split for ride bookings.
06Data model
Data model
Pick the right store per table. Justify each choice with the access pattern, not by reflex.
driver_position (in memory, Pharos)driver_idcity and vertical (partition)road edge or node the driver is snapped tostatus (idle, reserved, on trip)updated_atNever in a disk database on the hot path. Each update snaps the GPS point onto the road graph. Pharos stores drivers in Adaptive Radix Trees, and in 2020 cleared expired drivers every midnight. The reserved status is this design's addition, used during an offer.
bookingbooking_id (partition key)rider_idpickup, drop-offservice typestate (booked, allocated, picked up, completed, cancelled)driver_idfarecreated_atIn this design: DynamoDB keyed by booking ID, the same pattern Grab published for food orders. A sparse index holds only ongoing bookings, so 'my current trip' is a cheap query. A time-to-live removes old items after the retention period; Grab keeps three months for orders.
spampede_counter (Redis)key = service type + geohash bucket + time bucketvalue = unallocated countexpiryIncremented for each booking left without a driver. In Grab's post, the expiry is set on the first increment, so old buckets delete themselves. The limit per area is also stored in Redis, so it can change without a deploy.
supply_demand (per geohash, per time slot)geohashtime_slotidle driversriders checking faressupply demand ratiosupply demand differenceBuilt from driver pings and fare checks. In 2019 Grab counted a rider checking a fare as demand, not only completed bookings. In this design, the output feeds surge pricing and the driver heat map.
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.
Finding nearby drivers: from straight lines to the road network
The obvious first answer is a grid. Put each driver in a cell, search the cells around the pickup, and sort by straight-line distance. Grab's earlier system, Sextant, worked like this. It split the region into grids and measured haversine distance, the straight-line distance on a sphere. Grab wrote in 2020 that this has a flaw. The nearest driver by straight line may need a long drive to reach you. A river or a one-way street can be in the way. So Grab built Pharos. It loads OpenStreetMap road graphs into memory, partitioned by city and vertical. Each driver update is snapped onto a road edge. A nearby search walks outward along the roads from the pickup. This method is called Incremental Network Expansion. It returns the K nearest drivers by road distance or travel time. K is a number you choose, such as 20. Pharos keeps everything in memory because positions change every second. It chooses high throughput over perfectly consistent results. Each partition had two replicas on machines in different availability zones. If one machine dies, the other keeps serving. In this design, drivers keep sending positions, so a rebuilt replica catches up quickly. In 2020 Grab measured 10 ms for an update and 50 ms for a nearby search, both at P99.
Why Grab does not always send the nearest driver
Grab's own explainer says it plainly: the closest driver may not be the best match. Allocation evaluates over 40 real-time factors beyond distance. First it lists available drivers inside the allocation radius. Then it narrows the list by estimated time of arrival. Then it runs fraud checks. It also tries to give drivers the kind of rides they tend to accept, so fewer offers are declined. Local rules matter in Southeast Asia. In Jakarta, the system knows the odd-even licence plate rule and picks only cars allowed on that route that day. For food, larger vehicles go to larger orders when available. In an interview, say that matching is a ranking problem with constraints, not a nearest-neighbour lookup. Then name a few of the constraints.
Matching a batch: one big assignment problem
Matching one booking at a time is greedy. The first booking takes the best driver, even if that driver was the only good option for the next booking. A better way is to collect bookings for a short window, then solve them together. Grab's 2021 post frames this as minimum weight bipartite matching. Bookings are one side, drivers the other. Each pair has a cost, the fastest driving time between them. The solver picks pairs so the total cost is lowest. In a 2021 research collaboration with the National University of Singapore, Grab's engineers found a surprise. Building the cost matrix, the driving time for every pair, took longer than solving the assignment. The road graph of Singapore alone has around 400,000 nodes. The matrix must be rebuilt before every matching round, every X seconds in Grab's words; Grab did not publish X. Assignment time only overtakes matrix time when more than about 2,500 drivers and riders are matched at once. So Grab sped up the matrix, using the fact that the best partner is usually near. It used an incremental version of the Kuhn-Munkres algorithm. That is also called the Hungarian algorithm, the standard method for this kind of pairing problem. Running time fell by over an order of magnitude. The window size is a trade-off. Longer windows give better matches but make each rider wait longer for the offer.
ETA: from over 200 models to 16
Every booking needs ETAs: for the fare, for the rider's screen and for ranking drivers. Grab wrote in 2023 that it once kept over 200 separate machine learning models. There was one for each aspect of a ride, such as time of day, vehicle type or city. That many models are hard to keep accurate as traffic changes. Grab consolidated them down to just 16, on its internal machine learning platform, Catwalk. Grab said Catwalk cut compute cost by 95% and raised accuracy by 5%. Inputs include real-time traffic and weather. The models retrain weekly to handle drift, which is when the data changes and an old model slowly becomes wrong. In the interview, separate two ETAs. The pickup ETA ranks drivers and must be fast. The trip ETA sets the fare and can take a little longer.
Supply, demand and surge, measured per geohash
A geohash is a short code for a rectangle of the map. Each extra character splits the cell into 32 smaller ones. Points with the same prefix are close together. But two close points on either side of a cell edge can have very different codes. So a search must also check the neighbouring cells. In 2023 Grab wrote that it uses geohashes to mark places, measure distance and help with fares and ETAs. Grab's 2019 post shows how it measured balance. One unit of supply is a driver who is online and idle. One unit of demand is a rider checking a fare in the app, not only a completed booking. Each driver is shared among riders in the neighbouring geohashes, weighted so nearer riders count more. The result, per geohash and short time slot, is a supply demand ratio and a supply demand difference. When demand outpaces supply, fares rise. Grab's explainer gives the reason. Higher fares signal more drivers to turn on their apps, and drivers see a heat map of demand. Some riders also wait for the higher prices to pass. Grab notes that only pushing fares down would make drivers drop off. Grab has not published its surge formula or caps, so do not invent them in an interview.
Spampede: stop one storm from slowing the whole city
Grab wrote in 2020 about a problem every candidate should mention. A sudden spike, like rain at rush hour or a concert ending, floods one area with bookings. There are no drivers there, so the bookings stay unallocated. Grab wrote that this load hurt users outside that area too. The root cause is a lack of drivers in one place, so more servers do not help. Grab's answer was a filter called Spampede. It turns the pickup point into a coarse geohash bucket. Then it counts unallocated bookings per service type, area and time bucket in Redis. When the count passes a limit, new bookings in that area are rejected immediately, before any other service call. It works like a circuit breaker scoped to one area. A circuit breaker is a switch that stops sending work to something that is failing. Grab did not publish its limits or bucket sizes. The listing below shows the idea. It is an illustration, not Grab's code.
def area_key(service, geohash, now_s):
# coarser area: first 5 geohash characters; one-minute time bucket
return f"spampede:{service}:{geohash[:5]}:{now_s // 60}"
def area_is_full(r, service, geohash, now_s, limit):
return int(r.get(area_key(service, geohash, now_s)) or 0) >= limit
def record_unallocated(r, service, geohash, now_s):
key = area_key(service, geohash, now_s)
if r.incr(key) == 1:
r.expire(key, 120) # in production, send INCR and EXPIRE in one
# pipeline or Lua script so a crash cannot
# leave a key with no expiryWhere the booking lives: DynamoDB, MySQL and Kafka
Grab has not published the store behind ride bookings. In 2022 it published its order platform for GrabFood and GrabMart, which processed millions of orders a day. The pattern fits rides well. Grab split the data in two. Live orders sat in DynamoDB, keyed by order ID, with strong consistency for the transaction. A sparse index held only ongoing orders, so finding a user's active order was cheap. A time-to-live deleted items after three months. History and statistics sat in MySQL on RDS, partitioned by month. A Kafka stream copied data from one to the other. If producing to Kafka failed, the message waited in Amazon SQS, a managed queue, and was retried. Duplicates were dropped by a unique key, such as order ID plus creation time. The analytics side was eventually consistent: it catches up a few seconds later, which is fine for reports. In 2023 Grab's Coban team ran Kafka as a shared platform. That year it found that copying data between AWS availability zones was half the cost of the Kafka platform. Letting consumers read from the replica in their own zone cut that traffic by 25%. The cost was up to 500 ms more end-to-end latency.
Common mistakes candidates make
Mistake one: storing driver positions in a relational database and updating a row every second. At our assumed 200,000 position writes a second, a row update per driver is the wrong store. Say instead that positions live in memory, partitioned by city, with replicas. Losing a second of position is acceptable. Mistake two: sorting candidates by straight-line distance. In a city of rivers, flyovers and one-way roads, that picks drivers who are close but slow to arrive. Say that Grab moved from haversine distance to road-network search in Pharos. Mistake three: matching each booking to the nearest free driver, one at a time. Explain batching and the assignment problem, and the trade-off of the window length. Mistake four: answering a rainstorm with 'add more servers'. The shortage is drivers, not CPU. Say you would shed load per area, raise prices to bring drivers online and show riders an honest wait. Mistake five: offering one driver to two bookings at once. Reserve the driver during the offer, and release the reservation on decline or timeout. Mistake six: inventing Grab's numbers. Grab has not published a radius, a surge cap or a batch window. Say that, and state your own assumption.
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.
In-memory driver index vs a database or Redis geo set
A Redis geo set is a fine start and is simple to run. It sorts by straight-line distance, though. Grab chose a custom in-memory road graph so it could rank by road distance and travel time. The cost is a service to build and operate, with its own partitioning and replicas.
Road distance vs straight-line distance
Straight-line distance is cheap and needs no map. Road distance needs a road graph in memory and a graph search per booking. It pays back because the driver who arrives first is what the rider feels.
Batch matching vs one booking at a time
One at a time gives the fastest first offer and is simple. Batching over a short window finds better pairs for everyone and fewer long pickups. The cost is a small wait and a heavy computation, mostly in building the cost matrix.
Reject bookings early in a hot area vs accept and queue them
Accepting everything feels kinder. But in this design we assume riders with no driver book again, which loads the shared system. Spampede rejects early in that one area, so the rest of the city stays fast. The cost is an honest 'no drivers' message to some riders.
A few general ETA models vs many specialised ones
Many models can each fit one case well, but they are hard to retrain and keep accurate. Grab went from over 200 to 16 on its Catwalk platform. It reported 95% lower compute cost and 5% better accuracy. The cost is a richer model that must learn the differences between cities itself.
Read from the nearest Kafka replica vs always from the leader
Reading from the leader gives the lowest latency. Reading from a replica in the same availability zone saves the cross-zone data fee. Grab cut cross-zone traffic by 25% this way. The cost was up to 500 ms more end-to-end latency. So Grab kept its most latency-sensitive consumers reading from the leader.
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.
It starts raining hard in one district at 6 pm. Walk me through what happens.
In this design, fare checks jump, so the supply demand ratio in those geohashes falls. Fares rise and drivers see the demand on their heat map, so some come online. Bookings that find no driver raise the Spampede counter for that area. Past the limit, new bookings there are rejected at once, so the rest of the city is not slowed.
How do driver positions get from the app into Pharos?
In this design, the driver app sends a timestamped position to a location gateway. The gateway routes it to the Pharos partition for that city. Pharos keeps only the newest update per driver and drops any update older than the one it holds. Each point is snapped onto the nearest road edge, which also absorbs GPS noise. Grab has not published its ingest path, so say this is your assumption.
How would you add shared rides, like GrabShare?
A driver can take a second booking only if seats are free and the detour is acceptable. Grab's 2017 GrabShare post scores matches on trip angle, ETA, detour and efficiency. Its example served two bookings in 23.72 km instead of 39.13 km driven separately. Allocation then searches drivers who are already on a trip, not only idle ones.
How do you safely test a change to the allocation rules?
Not on live riders first. In 2025 Grab described DispatchGym, a simulator of booking creation, dispatch, driver movement and completion. It is not exact in absolute numbers, but Grab says the direction of metric changes matches the real world. Grab used it to tune dispatch settings with contextual bandits. That method learns which setting works best in which conditions.
What changes for food orders?
Pharos already partitions its index by vertical, so food has its own partition on the same system. Food adds a restaurant preparation time, so the pickup ETA must not bring the driver too early. Grab also groups several food orders onto one delivery partner when partners are scarce. That is a different kind of batching from the batch matching above. Grab also sends larger vehicles to larger orders.
10In production
How Grab actually does it
Every fact about Grab on this page comes from Grab's own writing. The estimates and anything marked 'in this design' or 'assume' are ours. The nearby-driver index, its road graphs, replicas and latencies are from the 2020 Pharos post. The 40-plus factors, the allocation radius, fraud checks and the Jakarta plate rule are from one Grab explainer. It is titled: why Grab does not always assign the nearest driver. Batch matching and the Singapore graph size are from the 2021 post with the National University of Singapore. Spampede is from the 2020 post on demand spikes. Supply and demand per geohash is from the 2019 post. The ETA consolidation is from Grab's 2023 article. The order data layer is from the 2022 post on storing millions of orders. It describes food and mart orders, not rides. User, city and gross merchandise value figures are from Grab's 2025 results and the 2025 DispatchGym post. Grab has not published its surge formula, allocation radius, batch window, driver counts or ride booking store.
Sources
- Grab Tech: Pharos, searching nearby drivers on road network at scale (2020)
- Inside Grab: Grab doesn't always assign the nearest driver to you, here's why (2026)
- Grab Tech: Using real-world patterns to improve matching in theory and practice (2021)
- Grab Tech: How we prevented app performance degradation from sudden ride demand spikes (2020)
- Grab Tech: Understanding supply and demand in ride-hailing through the lens of data (2019)
- Inside Grab: How we got more accurate ETAs while pushing down tech costs (2023)
- Inside Grab: How the Grab app knows exactly where users are, geohashing (2023)
- Inside Grab: Surge and dynamic pricing explained (2023)
- Grab Tech: How we store and process millions of orders daily (2022)
- Grab Tech: Zero traffic cost for Kafka consumers (2023)
- Grab Tech: DispatchGym, Grab's reinforcement learning research framework (2025)
- Grab Tech: The data and science behind GrabShare, Part I (2017)
- Grab: Fourth quarter and full year 2025 results (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
In-Memory Databases
intermediate / database types storage
Redis Cache
foundation / caching strategies
Key-Value Stores
intermediate / database types storage
Load Shedding
advanced / reliability resilience
Rate Limiting
intermediate / api design protocols
Circuit Breaker Pattern
intermediate / microservices architecture
Database Sharding
foundation / database fundamentals
Availability Zones
intermediate / cloud infrastructure
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
Rides and maps
- Grab system design (this page) (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 Grab design above, step by step.
- Geospatial IndexingSystem Design · database types storage · 16 min
- In-Memory DatabasesSystem Design · database types storage · 15 min
- Redis CacheSystem Design · caching strategies · 26 min
- Key-Value StoresSystem Design · database types storage · 15 min
- Load SheddingSystem Design · reliability resilience · 20 min
- Rate LimitingSystem Design · api design protocols · 22 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.


