---
title: Zomato Frontend Interview Questions (2026 Guide)
description: Real Zomato frontend engineer interview questions — search and autocomplete UI, infinite feeds, virtualization and JavaScript depth, with worked answers.
url: https://usegreenroom.app/blog/zomato-frontend-engineer-interview-questions
last_updated: 2026-07-29
---

← Back to blog

India · Zomato

# Zomato frontend interview questions and process

July 29, 2026 · 12 min read

![Zomato frontend interview questions guide — cover from Greenroom, the AI mock interviewer](/assets/blog/zomato-frontend-engineer-interview-questions-hero.webp)

"Build the restaurant feed," said the interviewer, and the candidate did — cards, images, infinite scroll, the lot. It looked great for about forty cards. By two hundred, scrolling on the throttled profile had turned to soup. The interviewer asked what was slow. The candidate said, "probably the images." It was not the images. It was two hundred cards in the DOM, each re-rendering on every scroll event, and he had never had to notice before.

That noticing is what **Zomato frontend interview questions** are built to test. The rounds are standard on paper — JavaScript, machine coding, design, hiring manager — but the JavaScript bar runs deeper than at most consumer-internet companies, and the design prompts keep pulling until something in your answer gives. I built Greenroom after freezing in an interview I had prepared hard for, so this guide covers what Zomato asks frontend engineers and how to hold the thread out loud.

## The Zomato frontend engineer interview process in 2026

Zomato's frontend loop is compact and sharp. What candidates report as the **Zomato frontend interview process**:

- **Online assessment** — DSA problems, and as on the backend track the difficulty skews harder than peer companies, closer to medium-hard.
- **JavaScript and DOM round** — deep fundamentals: the event loop, closures, prototypes, `this`, plus implement-it questions.
- **Machine coding round** — build a working UI feature in roughly 90 minutes, then walk through it.
- **Frontend system design round** — search and autocomplete, the restaurant feed, the menu page, or an image-heavy listing.
- **Hiring manager round** — pace, ownership, a corner you knowingly cut, and why Zomato.

The differentiator: Zomato interviewers keep asking "can you do better?" after you have produced a working answer. Treat your first solution as the opening of a conversation. Our [Zomato interview questions guide](/blog/zomato-interview-questions) covers the company-wide loop, and the [Zomato backend engineer guide](/blog/zomato-backend-engineer-interview-questions) covers the same products from the other side.

![Zomato frontend engineer interview process diagram — online assessment, JavaScript and DOM round, machine coding round, frontend system design round, hiring manager round](/assets/blog/zomato-frontend-engineer-interview-questions-diagram.webp)

The Zomato frontend loop: five rounds, with a JavaScript bar noticeably deeper than most consumer-internet companies.

## The JavaScript round: mechanisms, not rules

This is the round that surprises people. The **Zomato JavaScript round** goes past "what is a closure" into "what does this snippet print and why," and then into "now implement it." Recurring ground:

- **Event loop ordering** — a snippet mixing `setTimeout`, promise callbacks, `queueMicrotask` and synchronous logs, and "what prints, in what order?" Know that microtasks drain completely before the next macrotask.
- **Closures in loops** — the `var` versus `let` classic, and three fixes: `let`, an IIFE, or passing the value as a `setTimeout` argument.
- **`this` binding across all four forms**, then implement `call`, `apply` and `bind` yourself.
- **Prototypal inheritance** — the prototype chain, `Object.create`, and how `class` desugars.
- **Implement-it set** — `debounce`, `throttle`, deep clone, `flatten`, `Promise.all`, and a promise-based retry with backoff.
- **Event delegation and propagation** — capture versus bubble, `target` versus `currentTarget`, and why delegation matters for a list of two hundred cards.
- **`==` coercion, hoisting and the temporal dead zone** — usually quick-fire follow-ups.

Answer with the mechanism. "`setTimeout` schedules a macrotask, and the microtask queue is fully drained between macrotasks, so both `.then` callbacks print before the timeout" is exactly the register this round wants. Our [JavaScript interview questions guide](/blog/javascript-interview-questions) covers the full set and the [TypeScript interview questions guide](/blog/typescript-interview-questions) covers the typing follow-ups.

## Search and autocomplete: the signature frontend problem

Zomato is a search product, so **autocomplete** shows up in the machine coding round, the design round, or both. The naive version is a `keyup` handler that fetches on every keystroke. Every follow-up from there is predictable, so pre-empt them:

- **Debounce the input**, and be precise that this reduces request volume — it does not fix ordering.
- **Cancel or version the requests.** An `AbortController` in the effect cleanup, or a request id compared on arrival. Without this, a slow early response can overwrite a newer one.
- **Cache by query string**, so backspacing to a previous prefix is instant and free.
- **Keyboard navigation and ARIA.** Arrow keys, Enter, Escape, `aria-activedescendant`, and a live region announcing result counts. Zomato ships to a very large audience; accessibility questions are fair.
- **Empty, loading and error states** — including the awkward one where the user typed something and there are genuinely no results.
- **Highlight the match** without breaking on user-supplied characters that look like markup.
- **Minimum query length and trimming**, so a single space does not fire a request.

Here is the ordering guard, which is the part most candidates skip:

```
const latest = useRef(0);

async function search(q) {
  const id = ++latest.current;          // tag this request
  setStatus('loading');
  try {
    const items = await fetchSuggestions(q);
    if (id !== latest.current) return;  // a newer query already fired — drop this
    setItems(items);
    setStatus(items.length ? 'success' : 'empty');
  } catch (e) {
    if (id === latest.current) setStatus('error');
  }
}
```

Our [machine coding round guide](/blog/machine-coding-round) covers the wider 90-minute budget, and the [HTML and CSS interview questions guide](/blog/html-css-interview-questions) covers the semantics and ARIA layer this leans on.

## Infinite feeds, virtualization and image-heavy pages

The other signature Zomato prompt is the **restaurant feed**: an infinitely scrolling, image-dense list. It has a clear depth ladder, and knowing the rungs is the whole game.

- **Pagination strategy.** Cursor-based beats offset-based for a feed, because new entries shifting the offset produce duplicates and gaps. Say this explicitly.
- **`IntersectionObserver`, not scroll listeners.** A sentinel element at the bottom of the list, observed. Scroll handlers fire constantly and cost frames.
- **Virtualization once the list is long.** Only render the visible window plus a small buffer. This is the answer to "why did it get slow at two hundred cards."
- **Images are the payload.** Responsive `srcset`, modern formats, explicit width and height to prevent layout shift, lazy loading below the fold, and a low-quality placeholder so the card does not pop.
- **Memoize the card** and keep its props referentially stable, otherwise every parent render re-renders every card.
- **Preserve scroll position** when the user navigates into a restaurant and comes back. This is a real product problem and a great thing to raise unprompted.
- **Skeletons that match the final layout**, so nothing shifts when data lands. Cumulative Layout Shift is a metric you should name.

The [Zomato frontend engineer prep page](/prep/zomato-frontend-engineer-interview) has a round-by-round checklist, and the [React interview questions guide](/blog/react-interview-questions) covers the memoization semantics.

## Frontend system design at Zomato

Design prompts stay in the browser: design the search experience, the restaurant feed, the menu page, or a shared component library. Structure the answer this way:

- **Constraints first.** Device profile, network, how many items, how fresh the data must be. Menu availability changes during service; restaurant metadata does not.
- **Server state versus client state.** Cache the first with clear keys and a revalidation policy; own the second. Do not put fetched data in a global store by reflex — our [Redux interview questions guide](/blog/redux-interview-questions) covers when a store genuinely earns its place.
- **Rendering strategy.** Server rendering or static generation for a listing page that needs to be indexable and fast on a slow device, with hydration cost named as the tradeoff. The [Next.js interview questions guide](/blog/nextjs-interview-questions) covers this ground.
- **Performance budget.** Bundle size, image weight, and Core Web Vitals by name with one concrete fix each.
- **Degradation.** Slow API, partial data, a failed image. What renders, and does the page stay usable?
- **Instrumentation.** How you would know the feed regressed after a release, using real-user data rather than a lab score on a fast laptop.

## Behavioral rounds: pace, ownership and why Zomato

Zomato's culture question is about speed. The hiring manager round reliably probes a time you shipped fast and what you knowingly traded, a bug that reached users, and a disagreement with design or product. They are not looking for someone who never cut a corner — they want someone who knew it was a corner, said so, and came back for it.

First person, two minutes, numbers. "We optimised the feed" is invisible. "The feed dropped to about 25 frames per second past 200 cards, I added windowing and memoized the card component, and we held 60 with about a third of the memory" is a hire signal. Our [tell me about a time you failed](/blog/tell-me-about-a-time-you-failed) and [behavioral interview questions guide](/blog/behavioral-interview-questions-answers-software-engineer) cover the structures.

## LeetCode, GreatFrontEnd, ChatGPT — where each fits

An honest map of the prep stack for this loop:

- **LeetCode** — more relevant here than at most Indian consumer companies because of the harder assessment. Medium is the floor.
- **JavaScript.info and GreatFrontEnd** — the right depth for this specific JavaScript round. JavaScript.info's event loop and prototype chapters map almost one-to-one onto what gets asked.
- **MDN** — the source of truth for `IntersectionObserver`, `AbortController`, ARIA attributes and event propagation.
- **web.dev on Core Web Vitals and image optimisation** — read before the feed design conversation; naming metrics precisely is most of the credit.
- **Timed self-builds** — an autocomplete with cancellation and a virtualized feed, on a 90-minute clock. Then profile them and find your own bottleneck.
- **ChatGPT** — good for generating snippets to reason about and reviewing pasted code. It will not ask "can you do better?" three times while you sit with it.
- **Greenroom** — the spoken layer. [Ari, the AI interviewer](/), runs the round out loud, pushes the optimisation follow-up when you stop at your first working answer, and scores structure and clarity. Fair tradeoff: Ari will not review your JSX line by line, so pair it with real builds.

**The core truth:** Zomato hires frontend engineers who treat a working screen as the start of the conversation. Question banks prepare your first solution; only spoken practice prepares you for "good — now make it smooth at two hundred cards."

## How to prepare for the Zomato frontend interview

- **Week 1:** DSA at medium climbing to medium-hard, plus the implement-it set — `debounce`, `throttle`, `call`/`apply`/`bind`, deep clone, `Promise.all`, retry with backoff — written from memory.
- **Week 2:** event loop and prototype drills. Take snippets, predict the output aloud, then run them and reconcile the difference. This is the highest-yield hour for this specific company.
- **Week 3:** two timed builds — autocomplete with cancellation and keyboard support, and a virtualized image feed. Profile both and be able to say what your bottleneck was.
- **Final week:** five behavioral stories in first person with numbers, two full spoken mocks with optimisation pushback, and the [role-specific prep page](/prep/zomato-frontend-engineer-interview) the night before — not new material.

Interviewing across comparable loops? The [Swiggy frontend engineer guide](/blog/swiggy-frontend-engineer-interview-questions) covers the nearest equivalent bar with more real-time UI, the [Flipkart frontend engineer guide](/blog/flipkart-frontend-engineer-interview-questions) goes deeper on machine coding and performance budgets, the [Uber frontend engineer guide](/blog/uber-frontend-engineer-interview-questions) covers map-heavy interfaces, and the [Atlassian frontend engineer guide](/blog/atlassian-frontend-engineer-interview-questions) covers accessibility and design systems at enterprise scale.

## Frequently asked questions

### What is the Zomato frontend engineer interview process?

Candidates report an online assessment with DSA problems skewing medium-hard, a deep JavaScript and DOM round covering the event loop, closures, prototypes and implement-it questions, a machine coding round of about 90 minutes building a UI feature, a frontend system design round on search or the restaurant feed, and a hiring-manager round on pace and ownership. The JavaScript bar runs deeper than at most consumer-internet companies.

### What JavaScript questions does Zomato ask frontend engineers?

Expect snippet-and-explain rather than definitions: event loop ordering across setTimeout, promises and queueMicrotask, closures in loops with var versus let and three fixes, this binding across all four forms plus implementing call, apply and bind, the prototype chain and how class desugars, event capture versus bubbling, and implementing debounce, throttle, deep clone, flatten, Promise.all and a retry with backoff.

### How do you build an autocomplete in a frontend interview?

Debounce the input to cut request volume, then handle ordering separately with an AbortController in the effect cleanup or a request id compared on arrival, because a slow earlier response can otherwise overwrite newer results. Add a cache keyed by query so backspacing is instant, keyboard navigation with arrow keys, Enter and Escape plus ARIA attributes, and explicit loading, empty and error states including the genuinely-no-results case.

### Why does an infinite scrolling feed get slow, and how do you fix it?

It gets slow because every item stays in the DOM and re-renders as the parent updates, so hundreds of cards compete for each frame. The fixes, in order: virtualization so only the visible window plus a small buffer renders, an IntersectionObserver sentinel instead of a scroll listener, memoizing the card with referentially stable props, cursor-based pagination to avoid duplicates, and responsive lazy-loaded images with explicit dimensions to prevent layout shift.

### Is the Zomato frontend interview hard?

Harder than most Indian consumer-internet companies on fundamentals. The assessment skews medium-hard, and the JavaScript round expects mechanism-level explanations rather than definitions. The live rounds are optimisation-focused: a working solution is the entry fee, and the remaining time is spent on whether you can improve it and name your own bottleneck.

### How many rounds is the Zomato frontend interview and how long does it take?

Most reported loops run four to six rounds — online assessment, a JavaScript and DOM round, machine coding, frontend system design and a hiring-manager round — over roughly two to four weeks. Gaps between rounds are usually scheduling rather than deliberation, so use them to practise optimising and explaining under spoken pushback.

Zomato keeps asking "can you do better?" — that is a spoken skill. [Greenroom](https://usegreenroom.app/) runs mock frontend interviews out loud with Ari, pushes the optimisation follow-up, and scores structure, clarity and depth. Free to start. Curious how it works? See [how AI mock interviews work](/blog/ai-mock-interview).