Zomato System Design Interview: Food Delivery at Scale
On New Year's Eve 2023, Zomato took 8,422 orders in a single peak minute at 8:06 pm, which works out to about 140 orders every second. That was on a platform that served 753 million food delivery orders across more than 800 cities that year, with a fleet of roughly 400,000 delivery partners.
Designing Zomato is the hyperlocal food delivery problem at India scale. You have to decide which restaurants can actually reach an address in milliseconds, place and track an order through a state machine shared by the customer, the restaurant and the delivery partner, assign and batch delivery partners efficiently, and predict a delivery time the customer can trust while the kitchen, the traffic and even the weather keep changing. The constraint that shapes everything is that most of a day's two million orders arrive in two short meal windows, so the system has to be built for a spike that is many times its daily average.
Asked at: Commonly asked at Zomato and Eternal, Swiggy, Zepto, Blinkit, Uber, DoorDash, Rapido, Meesho, and most Indian product companies such as Flipkart, PhonePe and Razorpay, for SDE2 and SDE3 rounds. Design a food delivery app, or design Zomato, is the standard hyperlocal logistics and geospatial matching question in the Indian market. It stays popular because the lunch and dinner peak forces a real capacity conversation instead of a generic three tier diagram.
Why this question is asked
Food delivery breaks a simple CRUD design almost immediately. You have three independent actors, the customer, the restaurant and the delivery partner, whose actions overlap in time. You have a geospatial layer that has to answer can this restaurant serve this address in a few milliseconds on the busiest read path in the product. And you have an assignment problem that is a real optimization, minimizing partner idle time and customer wait under capacity and freshness limits, not a simple lookup. Add a traffic pattern where the large majority of orders arrive in two short windows, and a delivery time that depends on kitchen load, traffic and weather, and the question quickly separates candidates who have memorized a load balancer and cache diagram from candidates who can reason about a live, multi party, peak driven system. Interviewers also use it to check that you keep strong consistency on money and order state while using eventual consistency for everything else.
Requirements
Always clarify these in the first 5 minutes of the interview. Do not start drawing boxes until both lists are agreed.
Functional requirements
- Customer enters a delivery address and the system returns only restaurants that can actually serve that address (serviceability)
- Customer browses menus, searches and filters restaurants, builds a cart, and places an order with UPI, card, wallet, or cash on delivery
- Restaurant receives the order on a partner app or tablet and accepts or rejects it within a short window
- System assigns a delivery partner to pick up the order, and batches nearby orders when that improves efficiency
- Customer sees a live delivery time that accounts for weather and traffic, plus the delivery partner's location on a map once the order is picked up
- Order moves through a strict state machine: placed, confirmed, preparing, ready, picked up, on the way, delivered, with rejected, canceled and refunded branches
- Delivery partner app shows the pickup, the drop, an optimized route, earnings, and, for idle partners, where to reposition for the next order
- Customer can rate the restaurant and the delivery partner, and get support for a disputed order
- Surge or dynamic delivery fee is applied during peak demand when partner supply is tight
Non-functional requirements
- Serviceability and restaurant listing reads under about 100 ms at p99, because this is the home screen hot path and it far outweighs order writes
- A dispatch assignment decision within a few seconds of an order becoming ready to assign
- Live tracking location updates every few seconds per active trip, delivered to the customer app in under a second
- Sized for instantaneous meal peak load that is many times the daily average, concentrated in two windows of about 90 minutes each, and able to absorb a New Year scale spike of around 140 orders per second
- Strong consistency on order state transitions and payment capture, with no double charges and no lost orders
- Availability of 99.9 percent or better for order placement and tracking, degrading gracefully with wider delivery times, fewer batches, and paused kitchens rather than failing under peak
- Geo partitioned by city so that one busy city does not starve the others
Back-of-envelope scale estimates
Show your math. Pulling numbers from thin air signals you have not thought about the load.
Annual orders (food delivery)
753M (FY24)
Zomato's FY24 annual report gives 753 million food delivery orders, rising to 853 million in FY25. This is the anchor for all the capacity math.
Average orders per day
~2M/day
This is derived, not an official figure. 753 million divided by 365 is about 2.06 million orders per day on average across FY24. The interviewer cares that you show the derivation from the annual total, not that you quote a headline daily number.
Peak orders per second
~140 OPS (NYE), 700+ intra peak
On New Year's Eve 2023 Zomato recorded 8,422 orders in the peak minute, about 140 per second, a figure stated publicly by the CEO. On an ordinary day, if roughly 70 percent of about 2 million orders land in around 3 hours of combined lunch and dinner peak, that is about 1.4 million over roughly 10,800 seconds, near 130 orders per second on average across the peak, with bursts several times higher. The daily mean of about 24 orders per second is not the number to design for. You provision for the peak, not the average.
Monthly transacting customers
18.4M (FY24)
Average monthly transacting customers for food delivery in FY24, rising to 20.6 million in FY25. This drives the read path and catalog cache sizing.
Delivery partners, restaurants, cities
~400K partners, ~247K restaurants, 800+ cities
FY24 averages of monthly active delivery partners at about 400,000 and monthly active restaurant partners at about 247,000, across more than 800 cities. These drive the geo partitioning and the size of the dispatch candidate pool.
Serviceability and listing reads
Tens of thousands of reads/s at peak
Every home screen open and every address change triggers a serviceability check plus a restaurant list fetch. This read volume is two orders of magnitude larger than order writes, so it is the path that has to be cached and kept in memory.
High-level architecture
Split Zomato into four planes that talk to each other through an asynchronous event backbone. Keeping them separate is the difference between a clear design and a confused one. One note on honesty: the plane split, the serviceability geo indexing and the streaming stack below are the standard hyperlocal delivery architecture. Where a detail is something Zomato has actually published, which is the ETA and dispatch machine learning, it is called out as such. Plane one is discovery, the read path. A customer opens the app and sends a delivery latitude and longitude, and a Serviceability service answers which restaurants can reach you. Cities are divided into delivery zone polygons. The usual way to make this fast is a geospatial cell index in the style of geohash or H3. Each polygon is pre registered against the cells it overlaps, so a request maps the customer's cell to a small candidate set of zones and runs the precise point in polygon test only on those, using actual road distance rather than a straight line. Menus, prices and ratings come from a search and listing store plus a heavy read cache, because this path runs at tens of thousands of reads per second and has to stay near 100 ms. Plane two is order placement and the state machine. The Order service writes the order to a strongly consistent transactional store that is sharded by city, captures payment idempotently, and emits an order placed event. The restaurant's partner app receives the order over a push channel and accepts or rejects it. Every transition, from placed to confirmed to preparing to ready to picked up to on the way to delivered, along with the rejected, canceled and refunded branches, is a guarded state machine step that is written atomically and appended to an order events audit log. This is the strongly consistent core. Making it eventually consistent is how you get double charges and lost orders. Plane three is dispatch and the machine learning behind it, which is the hard part and the place where Zomato has published real detail. Assignment does not fire the instant an order is placed. It waits until the order is close to ready so the partner arrives about when the food does, then matches nearby available partners to orders that are ready to assign, batching where it helps. Zomato has publicly described a system called Active Dispatch, a deep Q network multi agent reinforcement learning model that recommends where idle delivery partners should move to close demand and supply gaps and raise their earnings. It runs on an in house machine learning runtime made of a feature compute engine, a feature store, a model store, and a model serving API gateway. Plane four is ETA and live tracking, the other place where Zomato has published specifics. Once a partner is on a trip, their app sends its location every few seconds into an in memory geo store, and a tracking service streams that to the customer over a push channel and recomputes the delivery time. Zomato's ETA is not a single number. It predicts food preparation time per order in real time with a bidirectional LSTM, predicts the delivery partner leg separately, and then applies real time dynamic buffers that react to traffic, road closures, partner supply, and local weather. The weather signal comes from Zomato's own Weather Union network of about 650 on ground weather stations across roughly 45 cities, with specialized rain and quantile sub models for the hard cases. Across all four planes, the event backbone carries the order, assignment, pickup and delivery events that fan out to notifications, surge computation, analytics, and partner payouts.
In a real interview, sketch this on the whiteboard before diving into any single box.
Core components
Walk through each service. The interviewer wants to hear what each one owns, not just the names.
Serviceability service
Answers which restaurants can deliver to this address in about 100 ms. Cities are modeled as delivery zone polygons, and a geospatial cell index in the geohash or H3 style registers each polygon against the cells it overlaps, so a request resolves to a small candidate set and then runs the precise point in polygon test only on those. It uses road distance, not a straight line, to decide eligibility and the base fee. The geo indexing here is the standard approach, not a Zomato published detail.
Catalog, listing and search
Serves restaurant lists, menus, prices, photos and ratings. It is read heavy, at tens of thousands of reads per second at peak, backed by a search index for filtering and autocomplete and an aggressive cache such as Redis or a CDN for the home feed, with personalization and ranking on top. It is kept separate from the transactional order store.
Order service and state machine
The strongly consistent core. It persists the order, captures payment idempotently, and enforces the state machine across all three actors. Each transition is atomic and is appended to an immutable order events log. It is sharded by city. This is where double charge and lost order bugs live, so it gets the strictest consistency guarantees.
Restaurant partner channel
A push connection to the restaurant's partner app or tablet. It delivers new orders, collects accept or reject, and surfaces preparation signals that feed the food preparation time model. A reject triggers customer notification and the refund flow. Zomato has published work on improving the client performance of the Restaurant Partner App.
Dispatch engine and Active Dispatch
Matches orders that are ready to assign to nearby available partners, batching where it improves efficiency, and times assignment so partners are not left idle at the restaurant during preparation. Zomato's published Active Dispatch is a deep Q network reinforcement learning model that proactively recommends where idle partners should reposition to close demand and supply gaps. It sits as a supply shaping layer on top of per order assignment.
Geo and location index
An in memory store of every online partner's live position, keyed by geo cell so proximity queries are cheap. It takes in the large volume of location updates at peak, feeds both dispatch, which needs nearby idle partners, and live tracking, and is never written to durable storage at full fidelity.
ETA prediction service
Zomato's published ETA system. Food preparation time is predicted per order in real time with a bidirectional LSTM, using features such as dish quantity and type, the restaurant's behavior, time of day, day of week, and footfall. The delivery partner leg is predicted separately and then adjusted by real time dynamic buffers that react to traffic, road closures and repairs, partner supply, system stress, and local weather, with specialized rain and quantile sub models. Because preparation and the partner's ride to the restaurant happen at the same time, the binding constraint is whichever one finishes later.
Weather Union for weather aware ETA
Zomato's own crowd supported hyperlocal weather network, roughly 650 on ground weather stations across about 45 cities, measuring temperature, humidity, wind and rainfall. It feeds the rain and ETA models and delivery partner safety decisions, and it is a genuinely distinctive part of Zomato's stack. The data is even published openly.
Surge and pricing service
A streaming job aggregates demand, meaning orders in a zone, against supply, meaning available partners, per minute per geo cell. It publishes a smoothed, clamped delivery fee multiplier, and the order service reads it at checkout. The price is locked in at order time so the customer pays what they agreed to. This is a general food delivery pattern.
Machine learning runtime and event backbone
Zomato has described an in house machine learning runtime with four parts, a feature compute engine, a feature store, a model store, and a model serving API gateway, that powers ETA, dispatch and ranking. An asynchronous event backbone carries the order placed, confirmed, assigned, picked up and delivered events that fan out to notifications, surge, analytics, and partner payout accrual, so slow side effects are kept off the synchronous order path.
Data model
Pick the right store per table. Justify each choice with the access pattern, not by reflex.
restaurantsrestaurant_id (PK)namelatlngcity_idzone_idprep_time_p50_minutesis_onlineratinggeo_cellListing and discovery data. It lives in the catalog store and the search index and is heavily cached. The geo_cell and zone_id fields let serviceability narrow the candidate set quickly. The is_online flag flips often, for a busy kitchen, a closed restaurant, or an item that is out of stock.
delivery_zoneszone_id (PK)city_idpolygon (geometry)geo_cells[]is_activeThe serviceability polygons. The polygon is the precise boundary for the point in polygon test. The geo_cells field is the denormalized list of cells the polygon overlaps, used to build the in memory index that avoids scanning every polygon on each request.
ordersorder_id (PK)customer_idrestaurant_idzone_idstateitems (jsonb)subtotal_paisedelivery_fee_paisesurge_multiplierpayment_idplaced_atdelivered_atThe transactional core, sharded by city_id and zone_id. The state field is the current state machine state. It needs strong consistency. It is mostly append only, since mutations are state transitions, each mirrored into order_events.
order_eventsevent_id (PK)order_id (FK)from_stateto_stateactor (customer|restaurant|partner|system)reasoncreated_atAn immutable audit log of every state transition. It lets you reconstruct exactly who did what and when, which is essential for disputes, refunds, and replaying state if the orders row is ever corrupted.
delivery_partnerspartner_id (PK)namevehicle_typeis_onlinecurrent_zone_idbag_capacityratingThe mostly static partner profile. The live position is not here. It lives in the in memory geo index. The bag_capacity field feeds the dispatch capacity limit, and is_online and current_zone_id scope the assignment candidate pool.
partner_locationspartner_id (PK)latlngheadinggeo_cellupdated_atIn memory only, in Redis or a custom geo service, keyed by geo cell so proximity queries are cheap. It is overwritten every few seconds. A downsampled trace of completed trips is logged to the data lake, while idle pings expire.
assignmentsassignment_id (PK)partner_idbatch_idorder_ids[]assigned_atpickup_etadrop_etastatusThe output of the dispatch engine. A batch can hold more than one order, which is the batching case. The status field tracks accepted, picked up, completed and reassigned. A cancel or an unreachable partner creates a new assignment row and puts the order back into the next round.
paymentspayment_id (PK)order_id (FK)amount_paisemethod (upi|card|cod|wallet)statusidempotency_keyprovider_refStrongly consistent. Indexed by order_id and idempotency_key so a retried capture never double charges. UPI is the dominant method in India, while cash on delivery skips the pre capture and reconciles on delivery. Provider webhooks update the status asynchronously.
Deep dives
These are the conversations the interviewer is steering you toward. Practice each one until you can talk through it without notes.
Serviceability: answering can this restaurant reach me in about 100 ms
This is the home screen hot path. It runs at tens of thousands of reads per second, far above order writes, so it has to be fast and cacheable. Cities are divided into delivery zone polygons. The naive approach, running point in polygon for the customer's location against every polygon, is order of the number of zones per request and does not hold up at scale. The standard fix, used across hyperlocal delivery and not a Zomato published specific, is a geospatial cell index. You pick a resolution and, for each zone, register it against every geo cell in the geohash or H3 sense that its polygon overlaps. At request time you compute the customer's cell key, fetch the small set of zones for that cell from memory, and then run the precise point in polygon test only on that handful. Two refinements are worth calling out. First, eligibility uses the actual road distance the partner will travel, not the straight line, because a river or a flyover can turn a one kilometer straight line into a six kilometer drive. Second, the result is cacheable per cell for a short time to live, so two customers in the same cell share the computation.
Just in time dispatch, and why you do not assign on order placed
The most common mistake is assigning a partner the moment the order is placed. If the kitchen needs 20 minutes and you assign right away, the partner waits idle at the restaurant for about 18 minutes, which wastes supply during a peak when supply is the bottleneck. So assignment is deliberately delayed until the order is close to ready, using the predicted food preparation time. When a pool of orders in a zone becomes ready to assign, the engine matches them to nearby available partners while minimizing a blend of partner idle time, customer wait, and travel cost, subject to capacity, meaning the bag or load limit, uniqueness, meaning a partner gets one batch this round, and freshness windows, meaning the partner should arrive after the food is ready but before it gets cold. The point to make is to pool and optimize per zone on a short cadence rather than decide each order greedily on its own, because a greedy choice is fine locally but wastes batching and balance across a zone with hundreds of orders at once.
Active Dispatch: reinforcement learning to position idle partners
This is a Zomato published detail and a strong point to raise. Beyond assigning existing orders, Zomato runs Active Dispatch, a deep Q network multi agent reinforcement learning model that recommends where free or idle delivery partners should move to close expected demand and supply gaps. It nudges supply toward the areas that are about to generate orders, so that when the order lands a partner is already nearby. Zomato reports that it beats both no recommendation and rule based baselines and improves partner earnings. A clean way to frame it in the interview is that assignment answers who takes this order now, while Active Dispatch answers where idle supply should be so the next order is cheap to fulfill. It is a predictive, supply shaping layer on top of reactive matching, and it runs on Zomato's machine learning runtime of a feature compute engine, feature store, model store, and model serving gateway.
Decomposed, weather aware ETA, which is Zomato's published approach
A naive ETA predicts one number end to end and is wrong the moment traffic or the kitchen behaves differently. Zomato breaks it into parts. Food preparation time is predicted per order in real time with a bidirectional LSTM, using dish quantity and type, the specific restaurant's history, time of day, day of week, and live footfall. The delivery partner leg, meaning the ride to the restaurant plus the restaurant to customer trip, is predicted separately and then adjusted by real time dynamic buffers that react to live traffic, road closures and repairs, delivery partner supply, overall system stress, and local weather. Weather is not a hand wave here. Zomato built Weather Union, a network of about 650 on ground weather stations across roughly 45 cities, precisely because public weather data was too coarse for hyperlocal ETA, since rain in one neighborhood changes ride times and partner availability in that specific area. Zomato also runs specialized rain and quantile sub models for hard cases such as sparse road mapping in smaller towns. Because cooking and the partner's ride to the restaurant happen at the same time, the binding constraint is whichever one finishes later, so the model has to reason about both legs together rather than add them.
The three party order state machine and its failure branches
The order state machine has a clean happy path, from placed to confirmed when the restaurant accepts, then preparing, ready, picked up, on the way, and delivered. The interview, though, is about the unhappy branches, because three independent people can each break the flow. If the restaurant rejects, out of an item or too busy, the order goes to rejected, the payment auto refunds, the customer is notified, and any batch is re optimized. If no partner accepts, or the assigned partner cancels, the order goes back into the next dispatch round, and after a set number of failures or a timeout it escalates, by surging the fee, widening the radius, or canceling with a refund. If the partner becomes unreachable mid trip, from a dead phone or a GPS gap, tracking holds the last known position and widens the delivery time, and past a threshold the system auto reassigns or operations steps in. If the payment webhook arrives late, the order sits in a pending payment state with a timeout, and idempotency keys make sure a delayed and then retried capture never double charges. Every transition is guarded, so you cannot jump from preparing to delivered, and every transition is written atomically with an order events entry, so the system can always answer what state this order is in and how it got there.
Surviving the meal peaks and the New Year spike
This is the requirement that makes food delivery distinctive. The bulk of a day's orders arrive in two windows of about 90 minutes, and the extreme case is New Year's Eve, when Zomato recorded 8,422 orders in the peak minute, about 140 per second, on 31 December 2023. Sizing to the daily average, about 24 orders per second for two million a day, is not useful. You provision for the instantaneous peak and for a partner pool that is heavily concurrent. The concrete tactics are these. First, autoscale the stateless order, listing and tracking services ahead of the peak on a schedule rather than reactively, because reactive scaling lags the 8 pm jump. Second, lean on batching harder during the peak, since it is both an efficiency win and a way to shed load, as each batch is one trip instead of two. Third, use Active Dispatch and surge to pre position and pull in supply and to flatten demand at the edges of the peak. Fourth, degrade gracefully, by widening delivery times, temporarily marking overloaded kitchens as unavailable rather than letting them build a long backlog, and shedding non critical work such as analytics and recommendations to protect the order path. The honest way to state it is that this system is over provisioned and idle for most of the day, and that is an accepted cost of hyperlocal food delivery.
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.
Geospatial cell index versus raw point in polygon versus PostGIS
Raw point in polygon against every zone is the simplest option but it is order of the number of zones per request and too slow at tens of thousands of reads per second. PostGIS with a spatial index works but adds load on the busiest read path. An in memory geo cell index, where you precompute which cells each polygon overlaps, look up by cell, and then run point in polygon only on the few candidates, keeps the request in memory and near 100 ms. The cost is that you have to rebuild the index when zones change and pick a cell resolution that balances candidate set size against memory.
Just in time delayed assignment versus assign on order placed
Assigning right away is simpler and feels faster, but it pins a partner idle at the restaurant for the whole preparation time, which is very costly when supply is the peak bottleneck. Delaying assignment until the order is near ready, driven by the predicted preparation time, keeps partners productive but risks under supply if the prediction is wrong and no partner is free when the food is ready. The delayed approach wins because partner idle time is the dominant cost lever at peak, and you reduce the risk by widening the candidate pool as readiness approaches and by pre positioning idle supply with Active Dispatch.
Reinforcement learning Active Dispatch versus static heuristics for supply positioning
A rule based heuristic, such as send idle partners to the nearest busy hub, is easy to build and explain, but it reacts to current demand rather than anticipating it and does not learn from outcomes. Zomato's deep Q network reinforcement learning approach learns a positioning policy that anticipates demand and supply gaps and, in their reporting, beats both no recommendation and rule based baselines. The cost is that reinforcement learning systems are harder to build, train, monitor and debug, and they need the machine learning runtime, with a feature store and model serving, to operate in real time. That is worth it only at Zomato's order density.
Decomposed, weather aware ETA versus a single end to end model
One end to end ETA number is the simplest but it is brittle. It cannot explain itself and it mispredicts whenever the kitchen, the roads, or the weather shift. Breaking it into food preparation time, from a bidirectional LSTM, plus a separately modeled delivery leg with dynamic buffers for traffic and weather, is more accurate and easier to debug, and it lets each part improve on its own. The cost is more models to train and serve, plus the whole Weather Union sensor network to build and maintain, which is a large investment that Zomato judged worthwhile because ETA accuracy directly affects conversion and trust.
In memory geo index for live location versus durable writes
Writing every partner's few second location update to the durable order store would overwhelm it, and almost nothing reads historical pings in real time. Keeping live positions only in an in memory geo cell keyed store gives cheap proximity queries and cheap writes, while a downsampled trace goes to the data lake for analytics. The cost is that a node failure loses live positions, but partners re send within seconds so the index heals itself, which is an acceptable trade for the throughput.
Strong consistency on orders and payments versus eventual consistency everywhere
Discovery, listings and tracking tolerate eventual consistency and stale caches without harm. The order state machine and payment capture do not, because eventual consistency there means double charges, lost orders, or an order stuck between states. So you split the system, with eventually consistent, cached, horizontally scaled read planes around a small strongly consistent transactional core that uses sharded SQL, atomic transitions, and idempotency keys. Do not pay for strong consistency where you do not need it, and never skip it on money and order state.
Surge to flatten peak demand versus fixed pricing
Fixed delivery fees are simpler and feel fairer, but during the dinner rush they leave demand unbounded while partner supply is fixed, which produces long delivery times and failed assignments. A smoothed, clamped surge multiplier trims demand at the edges of the peak and pulls more partners online. The cost is customer friction and the risk of a runaway feedback loop, which you reduce by smoothing over a window, capping the multiplier, and locking the price in at order time.
How Zomato actually does it
Several parts of this are documented directly by Zomato's engineering blog. The ETA system does predict food preparation time per order in real time with a bidirectional LSTM, predicts the delivery partner leg separately, and applies real time dynamic buffers that react to traffic, road closures, partner supply, system stress, and local weather, with specialized rain and quantile sub models. Weather Union is a real Zomato initiative, a crowd supported network of roughly 650 on ground weather stations across about 45 cities, built because public weather data was too coarse for hyperlocal ETA. Active Dispatch is Zomato's published deep Q network multi agent reinforcement learning model that repositions idle delivery partners to close demand and supply gaps, running on an in house machine learning runtime made of a feature compute engine, a feature store, a model store, and a model serving API gateway. The scale figures come from Zomato and Eternal's own annual reports and investor overviews: 753 million food delivery orders in FY24, rising to 853 million in FY25, 18.4 million average monthly transacting customers, rising to 20.6 million in FY25, more than 800 cities, about 247,000 monthly active restaurant partners, and about 400,000 monthly active delivery partners, with FY24 food delivery gross order value of 32,224 crore rupees and an average order value near 428 rupees. The New Year's Eve peak of 8,422 orders in the peak minute, about 140 orders per second at 8:06 pm on 31 December 2023, was stated publicly by the CEO Deepinder Goyal. Two honesty notes for the interview. First, the figure of about two million orders per day is derived from the annual total, not an official daily statistic. Second, the serviceability geo indexing, the event backbone, and the specific datastore choices described above are the standard hyperlocal delivery architecture, not details Zomato has published, so present them as the reasonable design and reserve the phrase Zomato does this for the ETA, Active Dispatch, and Weather Union work that they have actually written about.
Sources
- Zomato Engineering, The accurate ETA to customer satisfaction (Part One): food preparation time via a bidirectional LSTM, delivery partner ETA, dynamic buffers, and rain and quantile models
- Zomato Engineering, The elements of scalable machine learning: the machine learning runtime and the Active Dispatch deep Q network reinforcement learning model
- Zomato Engineering, How we increased our Restaurant Partner App speed by over 90 percent
- Weather Union, Zomato's crowd supported hyperlocal weather network of about 650 stations across roughly 45 cities
- Zomato investor overview (May 2024): FY24 scale figures for orders, monthly transacting customers, cities, and gross order value
- Eternal Ltd company overview (April 2025): FY25 figures and business segments
- The Week: Zomato received about 140 orders per second, 8,422 in the peak minute, on New Year's Eve 2023
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
WebSockets
intermediate / messaging event systems
Idempotency
foundation / core fundamentals
Cache-Aside Pattern
foundation / caching strategies
Load Balancing
foundation / core fundamentals
Rate Limiting for Resilience
advanced / reliability resilience
Design a Notification System
capstone / capstone