Interview
Zomato Interview Questions and Process: The Complete Guide (2026)
A full breakdown of Zomato's SDE interview process — the assessment with its debugging section, the graph problems that recur, and a 30-day preparation plan.
Zomato's interview loop is algorithm-first with a design requirement that switches on with seniority. The online assessment is coding-heavy and includes a debugging section that most candidates never practise. The technical rounds step up in algorithmic difficulty, and from SDE-2 upward system design and low-level design become mandatory rather than optional.
There is also a recognisable flavour to the problems. Zomato runs a delivery network, and graph problems — shortest paths, traversal, connectivity, assignment — recur often enough across reported accounts to be worth preparing specifically.
This guide walks each stage. To practise the design round, Zomato's interview kit holds two low-level design problems attributed to the company, each with a worked editorial and AI-evaluated practice.
The process at a glance
| # | Round | Format | What it screens |
|---|---|---|---|
| 1 | Online assessment | 2–3 coding problems plus a debugging section | Coding ability and code comprehension |
| 2 | Technical rounds (2–3) | Harder algorithms; design from SDE-2 upward | Algorithmic depth, design judgement |
| 3 | Managerial | Project depth, ownership | Judgement, level fit |
| 4 | HR | Fit and logistics | Communication, expectations |
Round counts vary by level and team. Confirm the sequence with your recruiter.
Round 1 — the assessment, including the part nobody practises
Two to three coding problems at standard interview difficulty, plus a debugging section — you are given code that does not work and asked to find and fix the fault.
The debugging component is worth preparing for deliberately, because it is a genuinely different skill from writing code. Reading unfamiliar code under time pressure and locating a fault requires you to build a mental model of intent quickly, then find where the implementation diverges from it. Most interview preparation builds none of this.
How to practise it cheaply: take problems you have already solved, deliberately introduce a subtle bug — an off-by-one, a wrong comparison operator, an inverted condition, a mutation inside a loop — and set them aside for a week. Then come back and find the fault. It feels artificial and it works.
For the coding half, the material is standard: arrays and strings, hash maps, sorting, two pointers, and — given the domain — a healthy share of graph problems. The DSA Patterns Sheet is free to browse and organises problems by pattern, and graph traversal patterns is the most directly relevant read for this loop.
💡 Pro Tip: Practise reading code you did not write. The debugging section rewards comprehension speed, and it is the one part of the assessment where extra preparation is unusually cheap because so few candidates do any.
Round 2 — the technical rounds
Two or three live rounds, and the difficulty steps up from the assessment. Expect harder algorithmic problems, and expect design content to appear — mandatory from SDE-2 upward, and increasingly common even below it.
The algorithmic half. Graph problems deserve specific attention here. A delivery network is a graph, so shortest path, traversal, connected components and assignment problems all map naturally onto the business and appear frequently in reported accounts. Beyond graphs, the usual suspects: dynamic programming, binary search, heaps, and interval problems.
As always in a live round, process is marked alongside output. Clarify before coding, state your approach and complexity before typing, narrate trade-offs, and find your own edge cases. What interviewers actually look for in live coding rounds covers the mechanics.
The design half. At the class level, expect to model entities and their relationships, and to say where behaviour varies and therefore where an interface belongs. At the architecture level — more prominent at senior grades — natural territory includes order and delivery state, notification fan-out at scale, real-time tracking, and systems where read and write patterns differ sharply.
The free Low Level Design Sheet and System Design Sheet cover both levels, and low-level design vs high-level design explains what each is asking for. How much system design is enough for SDE-1 vs SDE-2 will tell you how much applies at your level.
⚠️ Important: If you are interviewing at SDE-2 or above, treat design as a first-class part of your preparation rather than something to revise the night before. At that level it is a requirement, not a bonus round.
Round 3 — the managerial round
Project depth and ownership. Two or three projects you can discuss for ten minutes each without notes: what you personally decided, what went wrong, what you would change now.
Vague ownership is the failure mode. "We built the service" invites "what did you decide?", and being unable to answer that tends to result in being levelled down rather than rejected. Practising these aloud is worth more than rereading your résumé — a behavioural mock interview is a reasonable substitute if you have nobody to rehearse with.
Round 4 — HR
Fit, motivation and logistics. Be able to say why this company and this problem space specifically.
Is the Zomato interview hard?
Moderate, rising sharply with level.
At entry level the loop is fair: standard coding difficulty, a debugging section that is easy if you have practised and awkward if you have not, and design content that is present but not decisive.
At SDE-2 and above the loop is materially harder, because design becomes mandatory and the algorithmic bar rises at the same time. Candidates applying at senior level with purely algorithmic preparation are the ones who struggle.
How many rounds? Typically the assessment plus two or three technical rounds, then managerial and HR stages.
How long does it take? Commonly two to four weeks end to end.
A 30-day preparation plan
Week 1 — algorithmic foundations, with graphs weighted. Core patterns for recognition speed, then extra time on graph problems specifically: traversal, shortest paths, connectivity, topological ordering. Timed practice from the start with in-browser code practice.
Week 2 — debugging and harder problems. Spend two or three sessions purely on finding faults in code you did not write, or in your own code with deliberately introduced bugs. Then push algorithmic difficulty up a band.
Week 3 — design. Class-level design vocabulary and two design problems implemented end to end. The two low-level design problems evidenced at Zomato come with editorials worth reading against your own attempts. If you are interviewing at SDE-2 or above, add architecture reading on queues, caching, fan-out and consistency.
Week 4 — integration and rehearsal. Keep algorithms ticking over. Two or three mocks: one algorithmic, one design, one behavioural. Write out your project stories and say them aloud.
What changes between SDE-1 and SDE-2
Zomato's loop is one where the level you interview at changes the process substantially rather than marginally, so it is worth being clear about which one you are in.
At SDE-1 the loop is algorithm-led. The assessment and the first technical round carry most of the decision. Design content appears, but it tends to be exploratory — the interviewer wants to see whether you can reason about structure, not whether you already know how to build a distributed system. Strong algorithmic performance plus coherent thinking about classes is usually enough.
At SDE-2 and above two things happen at once. Design becomes a requirement rather than a bonus, spanning both class-level and architecture-level questions. And the algorithmic bar rises at the same time, so the design requirement is added rather than traded against. This combination is what catches candidates who have been preparing as though the loop were simply a harder version of the entry-level one.
The specific shift to prepare for is architectural: order and delivery state across services, notification fan-out to large audiences, real-time tracking, and systems where read and write patterns diverge sharply enough to need different treatment. Being able to name a trade-off — and say what you would give up — matters more than reciting a reference architecture.
There is also a subtler change in the managerial round. At entry level it examines potential; at SDE-2 it examines track record, and vague ownership becomes expensive. "We built it" invites a follow-up you need a real answer to.
Ask your recruiter which level you are being considered for. It is the single fact that most changes what you should do with your remaining weeks.
Frequently asked questions
How many rounds does Zomato have for SDE roles? Typically an online assessment, two to three technical rounds, a managerial round and an HR round. Counts vary by level.
What is in the online assessment? Reported accounts describe two to three coding problems plus a debugging section where you fix faulty code.
Is there a debugging round? Debugging appears as a section within the online assessment. It is the part of the loop candidates most commonly leave unprepared.
Does Zomato ask system design questions? Yes, and from SDE-2 upward design content — both low-level and architecture-level — is described as mandatory rather than optional.
What kind of algorithmic problems appear? Standard interview material with a notable share of graph problems, which map naturally onto a delivery network.
Do I need design preparation for an entry-level role? Class-level design is worth knowing, but it is not usually decisive below SDE-2. At SDE-2 and above it is required.
What language should I use? Whichever you are most fluent in. Fluency beats the choice, particularly in a timed assessment.
How long does the process take? Commonly two to four weeks, varying by team and hiring urgency.
How do I know which level I am interviewing at? Ask your recruiter. It is the single fact that most changes your preparation, because design moves from optional to required between SDE-1 and SDE-2 while the algorithmic bar rises at the same time.
How should I practise the debugging section? Take problems you have already solved, introduce a subtle fault — an off-by-one, an inverted condition, a mutation inside a loop — leave them a week, then come back and find it. It is artificial and it works.
Where to start
Two things distinguish preparation that works for Zomato specifically: put real time into graph problems, and actually practise debugging rather than assuming you will manage on the day. Then, if you are interviewing at SDE-2 or above, treat design as a requirement rather than an extra.
Open Zomato's interview kit for the two low-level design problems evidenced at Zomato, each with an editorial and AI-evaluated practice. Use the free DSA Patterns Sheet for the algorithmic rounds — graph traversal patterns is the most relevant single read — and rehearse with an AI mock interview.
Interview processes change. Confirm round structure and timings with your recruiter before your loop.