Interview experience
Zomato Interview Questions and Answers (2026)
Overview
Section titled “Overview”Zomato’s fresher hiring is a coding-heavy, 4-5 stage loop where even entry-level technical rounds lean on system-design questions mapped to Zomato’s actual product surface rather than generic prompts.
Zomato interview process at a glance
Section titled “Zomato interview process at a glance”| Round | Duration | What they test |
|---|---|---|
| Online Coding Assessment (OA) | 90-120 min | 2-3 DSA problems, debugging questions |
| Technical Interviews (2-3 rounds) | 45-60 min each | DSA plus system design scoped to Zomato’s product (order tracking, ranking, delivery) |
| Managerial/Team Fit Interview | 45 min | Zomato values, cultural fit |
| HR/Offer Discussion | 20-30 min | Compensation, relocation, company fit |
Online Coding Assessment
Section titled “Online Coding Assessment”A 90-120 minute test with 2-3 DSA problems ranging medium to hard, sometimes paired with short debugging questions. Solving all problems with an optimal (not just working) solution is usually the bar to advance.
Common questions
- Maximum-sum subarray (Kadane’s algorithm)
- Design an LRU cache
- Merge K sorted lists
- Top-K elements from a stream or array (heap-based)
Technical Interview(s)
Section titled “Technical Interview(s)”2-3 rounds of 45-60 minutes each, mixing a live-coded DSA problem with a system-design discussion. Design prompts are usually framed around Zomato’s own product rather than generic systems, and scale up with seniority - SDE-1 gets a single-feature design, SDE-2+ gets a fuller distributed-systems prompt.
Common questions
- Given restaurant ratings, efficiently find the top-K restaurants
- Design a data structure for real-time order-status tracking
- Design a rate limiter or a restaurant recommendation engine (senior roles)
- Graph and dynamic-programming problems (shortest path, coin change variants)
Round-by-round narratives are on the Zomato interview experience page.
Managerial/Team Fit Interview
Section titled “Managerial/Team Fit Interview”A values-alignment round built around Zomato’s stated principles - customer focus, ownership, and comfort with ambiguity. Expect STAR-format behavioural questions rather than technical ones.
Common questions
- Describe a time you showed customer focus even when it was inconvenient
- Give an example of taking ownership of a problem beyond your assigned scope
- How do you handle ambiguity when requirements are unclear?
- Tell me about a time you had to make a fast decision with incomplete information
HR/Offer Discussion
Section titled “HR/Offer Discussion”A short closing conversation on motivation, logistics, and compensation once the technical and managerial rounds are cleared.
Common questions
- Why Zomato, and what interests you about food-tech specifically?
- Are you willing to relocate to Gurugram or Bengaluru?
- What are your salary expectations?
- Do you have any questions about the team or role?
Sample answer frameworks for each of these are on the Zomato HR interview questions page.
Common technical interview questions and answers
Section titled “Common technical interview questions and answers”Q: How does Kadane’s algorithm find the maximum-sum subarray?
Walk the array keeping two values: currentSum, the best sum of a subarray ending at this index, and maxSum, the best seen anywhere. At each element, currentSum becomes the maximum of the element alone and currentSum plus the element - that choice is whether to extend the previous subarray or restart here - and maxSum takes the maximum of itself and currentSum. It is O(n) time and O(1) space. The classic trap is an all-negative array: initialising maxSum to 0 wrongly returns 0, so initialise it to the first element instead. To return the indices, record a start whenever you restart and commit start and end whenever maxSum updates.
Q: How do you merge K sorted linked lists efficiently?
Push the head of each list into a min-heap keyed by node value, then repeatedly pop the smallest node, append it to the output, and push that node’s successor if it exists. With N total nodes across K lists, this is O(N log K) time and O(K) space for the heap. The alternative is divide and conquer: pair up the lists and merge them two at a time over log K rounds, which is also O(N log K) but O(1) extra space when merging linked lists in place. Merging them sequentially one by one is the naive answer at O(N times K), which interviewers expect you to reject out loud.
Q: Given millions of restaurants with ratings, how do you find the top K efficiently?
Do not sort everything at O(n log n) if K is small. Maintain a min-heap of size K: push each restaurant, and whenever the heap exceeds K, pop the smallest, so the heap always holds the current best K and its root is the cutoff. That is O(n log K) time and O(K) space, and it works on a stream where the full dataset never fits in memory. Quickselect gives O(n) average time when the data is already in memory and you can reorder it, but degrades to O(n squared) in the worst case. In production you would precompute this per city or per cuisine and cache it, since the ranking changes far more slowly than it is read.
Q: How would you solve the coin change problem with dynamic programming?
For minimum coins, define dp[i] as the fewest coins summing to amount i, initialise dp[0] to 0 and everything else to infinity, then for each amount i and each coin c where c is at most i, set dp[i] to the minimum of dp[i] and dp[i - c] + 1. The answer is dp[amount], or -1 if it is still infinity. That is O(amount times number of coins) time and O(amount) space. The counting-ways variant needs the loops in the other order - coins on the outside, amounts on the inside - otherwise you count permutations rather than combinations. A greedy largest-coin-first approach is wrong for arbitrary denominations, for example coins of 1, 3, and 4 making 6.
Q: How would you design a data structure for real-time order-status tracking?
Model the order as a finite state machine - placed, accepted, preparing, picked up, out for delivery, delivered - with an explicit table of allowed transitions, so an invalid jump is rejected rather than silently written. Keep the current state in a fast key-value store keyed by order ID for O(1) reads, and append every transition with a timestamp to an immutable event log, which gives you the full history for support and analytics. Push updates to the customer’s app over WebSocket or server-sent events with a polling fallback, and publish each transition to a queue so the delivery, notification, and analytics services react independently. Include the transition version in each write so a delayed out-of-order update cannot move the order backwards.
Q: How would you find restaurants near a user’s location at scale?
Scanning every restaurant and computing haversine distance is O(n) per query and will not hold up. Instead index locations by a spatial key: geohash encodes latitude and longitude into a string where a shared prefix means spatial proximity, so a lookup becomes a prefix range scan; Uber’s H3 hexagonal grid is the same idea with uniform cell adjacency. Query the user’s cell plus its neighbouring cells - necessary because a restaurant just across a cell boundary is still close - then compute exact distances only on that small candidate set and sort. Quadtrees are the alternative when density varies wildly, since they subdivide only where points are dense. Cache results per cell, as many users in one area issue nearly the same query.
Q: How would you design a restaurant recommendation engine?
Start with candidate generation, which narrows millions of restaurants to a few hundred using cheap signals: deliverable in the user’s area, currently open, and matching broad taste from collaborative filtering over past orders. Then a ranking model scores those candidates on richer features - the user’s cuisine and price history, restaurant rating and recent order volume, distance and predicted delivery time, and time of day, since breakfast and dinner intent differ sharply. Finally apply business rules: suppress restaurants that are out of stock or heavily delayed, and inject some exploration so new restaurants can accumulate signal. Serve precomputed embeddings from a vector store to keep latency low, and evaluate online with A/B tests on conversion, not just offline accuracy.
Q: How does Dijkstra’s algorithm compute a shortest route, and why is it not enough for delivery ETAs?
Dijkstra keeps a min-heap of nodes keyed by tentative distance from the source. It pops the closest unvisited node, finalises its distance, and relaxes each outgoing edge by checking whether going through this node improves a neighbour’s distance. With a binary heap that is O((V + E) log V), and it is correct only when all edge weights are non-negative. For real delivery ETAs it is a starting point, not the answer: edge weights change with live traffic, the estimate must also include restaurant preparation time, order queueing, and rider pickup, and A star with a geographic heuristic explores far fewer nodes than plain Dijkstra on a road network. Production systems typically feed these signals into a learned model rather than reporting raw path time.
Frequently asked questions about Zomato interviews
Section titled “Frequently asked questions about Zomato interviews”What is Zomato placement interview experience like?
Zomato’s fresher SDE loop typically runs 4-5 stages: 1. Online Coding Assessment (90-120 min) - 2-3 DSA problems plus debugging questions. 2. Technical Interview(s) - 2-3 rounds of 45-60 minutes each mixing DSA with system-design questions framed around Zomato’s actual domain (restaurant ranking, order tracking, delivery ETAs). 3. Managerial/team-fit round on Zomato’s stated values (customer focus, ownership, innovation). 4. HR/offer discussion on relocation and compensation. Total timeline is roughly 2-4 weeks for campus drives.
What questions are asked in Zomato interviews?
DSA problems span arrays, trees, graphs, dynamic programming, and heaps (classic examples: maximum-sum subarray, LRU cache design, merge k sorted lists, top-K elements). System-design questions are usually reframed around Zomato’s own problems - designing an order-tracking system, a restaurant recommendation/ranking engine, or a rate limiter - rather than generic textbook prompts. Behavioural rounds use Zomato’s stated values (customer focus, ownership, bias for action) and expect STAR-format answers.
How many rounds are there in the Zomato interview?
Most fresher SDE drives run 4-5 stages: an online coding assessment, 2-3 technical interviews (DSA plus system design), a managerial/team-fit round, and a closing HR/offer discussion. Some drives compress the managerial round into the final technical interview instead of running it separately - confirm the exact structure from your placement cell or recruiter email.
What is the Zomato technical interview like?
Each technical round (45-60 minutes) mixes a DSA problem solved live on a shared screen with a system-design discussion scaled to the role level - SDE-1 candidates get lighter-weight design questions (e.g. a single feature like order-status updates), while SDE-2+ candidates get fuller system-design prompts (recommendation engines, distributed caching, scaling to millions of users). Interviewers weigh code quality, edge-case handling, and how clearly you explain trade-offs, not just whether the code runs.
How should I prepare for Zomato interviews?
Practice medium-to-hard DSA (arrays, graphs, DP, heaps) on a platform where you can talk through your approach out loud, since Zomato interviews are explicitly evaluated on communication as well as correctness. For system design, practice mapping generic patterns (rate limiters, recommendation systems, real-time tracking) onto food-delivery-shaped problems specifically. Prepare 2-3 STAR stories that map cleanly onto ownership, customer focus, and handling ambiguity - Zomato’s HR/managerial rounds ask for these by name.
Does Zomato ask domain-specific system design questions for freshers?
Yes, more than most product companies at the same level. Even SDE-1 candidates are commonly asked to design or extend a slice of Zomato’s actual product - order tracking, restaurant search/ranking, delivery-partner allocation - rather than a generic “design X” prompt. You don’t need production-scale answers, but you should be able to reason about the specific constraints of a real-time, location-based marketplace.