Indian Unicorn

SDE-1, Product Analyst, Operations

Online assessment (DSA / SQL + aptitude / case) + technical, LLD, business and HR rounds

Zomato & Blinkit Interview Questions & Placement Prep (2026)

Zomato and Blinkit hire across three very different tracks. SDE-1 is a product-company process dominated by DSA, debugging, low-level design and project depth. Product Analyst focuses on SQL, analytics, product cases and estimation. Operations roles test execution, marketplace metrics, communication and business problem solving. Prepare for your track using the structures and question banks below.

SDE-1: 2–3 DSA/debugging problems in 75–90 min · Product Analyst: aptitude + SQL (query writing) + case · Ops: aptitude/case + managerial rounds

Last updated: 12 August 2026

Exam Pattern

SDE-1: 2–3 DSA/debugging problems in 75–90 min · Product Analyst: aptitude + SQL (query writing) + case · Ops: aptitude/case + managerial rounds

Section	Questions	Time	Type	Difficulty
SDE-1 · Online assessment	2–3 problems	75–90 min	DSA / debugging	Medium–Hard
SDE-1 · Recruiter screen	Varies	20–30 min	Background & role fit	Easy
SDE-1 · Technical round 1	1–2 problems	45–60 min	Live coding, complexity	Medium
SDE-1 · Technical round 2	Varies	60 min	DSA + LLD + project deep dive	Hard
SDE-1 · Hiring manager / bar raiser	Varies	30–45 min	Ownership & product thinking	Medium
Product Analyst · Online assessment	~25 aptitude + ~9 SQL	Timed	Aptitude, SQL MCQ + query writing	Medium
Product Analyst · Case & business round	1–2 cases	45–60 min	Funnels, retention, estimation	Medium–Hard
Operations · Aptitude / case assessment	Varies	Timed	Numerical reasoning + operational judgement	Medium

Section-Wise Syllabus

Everything that appears in the assessment, grouped by section.

1. SDE-1 — DSA core

Arrays & strings

• Prefix sums
• Difference arrays
• Two pointers
• Sliding window
• Hashing
• Sorting-based optimisation
• Subarrays & subsequences
• Palindromes
• Anagrams
• String frequency
• Pattern matching
• Minimum window problems

Linked lists

• Reverse a list
• Reverse in groups of k
• Detect a cycle
• Cycle-entry node
• Middle node
• Merge two sorted lists
• Merge k sorted lists
• Palindrome linked list
• Clone list with random pointers

Stacks & queues

• Balanced parentheses
• Min stack
• Next greater element
• Largest rectangle in histogram
• Sliding-window maximum
• Queue using stacks
• Stack using queues
• Monotonic stack

Trees & BSTs

• Recursive & iterative traversals
• Level-order traversal
• Height & diameter
• Lowest common ancestor
• Validate BST
• Serialize & deserialize
• Build tree from traversals
• Root-to-leaf path problems
• Maximum path sum
• Vertical & boundary traversal
• Tree views

Graphs

• BFS & DFS
• Connected components
• Cycle detection
• Bipartite graph
• Topological sort
• Shortest path
• Dijkstra
• Minimum spanning tree
• DSU
• Number of islands
• Word ladder
• Strongly connected components

Dynamic programming

• House robber
• Coin change
• 0/1 knapsack
• Subset sum
• Grid DP
• Longest increasing subsequence
• Longest common subsequence
• Edit distance
• Stock buy–sell
• Partition DP
• Interval DP basics
• Tree DP basics

2. SDE-1 — low-level & product design

LLD fundamentals

• Class identification
• Interfaces
• Composition vs inheritance
• SOLID principles
• Design patterns
• Thread safety
• Validation
• Error handling
• Extensibility
• Unit-testable design

Likely LLD questions

• Design a restaurant menu system (size, crust, toppings, configuration)
• Design a food-ordering system
• Design a parking lot
• Design a coupon engine
• Design a delivery-partner assignment module
• Design a notification service
• Design a rate limiter
• Design an inventory-reservation service
• Design an order state machine

Ordering-platform components

• User service
• Restaurant or dark-store service
• Product/menu catalogue
• Search
• Cart
• Pricing
• Coupon service
• Order service
• Payment
• Inventory
• Delivery allocation
• Notifications
• Tracking
• Refunds

Design questions to rehearse

• How do you prevent selling an out-of-stock item?
• How do you handle duplicate payment requests?
• How do you retry a failed delivery assignment?
• How do you maintain order-state consistency?
• How do you handle a store going offline?
• How do you update delivery status in near real time?
• How do you prevent coupon abuse?
• How do you handle festival traffic spikes?

Blinkit-specific emphasis

• Real-time inventory
• Search and availability
• Order allocation
• Warehousing
• Delivery tracking
• Low-latency APIs
• Consistency and failure handling

3. Product Analyst — SQL, Python, statistics & metrics

SQL

• SELECT, WHERE, ORDER BY
• GROUP BY & HAVING
• Inner, left & self joins
• Subqueries
• CTEs
• Window functions
• ROW_NUMBER, RANK, DENSE_RANK
• LAG & LEAD
• Date-time functions
• Conditional aggregation
• Null handling
• Duplicate detection
• Cohort analysis
• Funnel analysis
• Retention analysis

Python & pandas

• Lists, dictionaries, sets
• Functions & comprehensions
• NumPy
• pandas DataFrames
• groupby
• merge & join
• pivot_table
• Filtering & sorting
• Duplicate removal
• Missing-value treatment
• Date conversion
• Aggregation
• Basic visualisation

Statistics

• Mean, median, mode
• Variance & standard deviation
• Percentiles
• Probability
• Sampling
• Confidence intervals
• Hypothesis testing
• A/B testing
• Statistical significance
• Type I & Type II errors
• Correlation vs causation
• Regression basics
• Outlier analysis
• Skewed distributions

Customer funnel

• App open
• Search
• Restaurant/store view
• Product/menu view
• Add to cart
• Checkout
• Payment success
• Order placement
• Delivery completion
• Repeat order

Marketplace metrics

• Conversion rate
• Search-to-order conversion
• Add-to-cart rate
• Average order value
• CAC & LTV
• Repeat purchase rate
• Retention & churn
• Cancellation rate
• Refund rate
• Delivery time
• On-time delivery rate
• Restaurant acceptance rate
• Rider assignment time
• Order defect rate
• GMV
• Contribution margin

Blinkit dark-store metrics

• Fill rate
• Inventory accuracy
• Stockout rate
• Picking time
• Packing time
• Order-to-dispatch time
• Average delivery time
• Item substitution rate
• Basket size
• Repeat purchase rate
• Delivery-partner utilisation
• Store-level contribution margin
• Wastage/spoilage rate

4. Operations — execution & marketplace problem solving

Core topics

• Last-mile delivery
• Supply and demand
• Inventory availability
• Store or restaurant operations
• Delivery-partner utilisation
• Route and zone planning
• Peak-hour staffing
• SLA monitoring
• Incident management
• Escalation handling
• Merchant & delivery-partner coordination
• Customer complaint resolution
• Excel & basic data analysis
• Daily reporting
• Workforce planning
• Root-cause analysis

Formulas to memorise

• On-time delivery rate = orders delivered on time / total delivered orders × 100
• Fill rate = fulfilled item quantity / ordered item quantity × 100
• Cancellation rate = cancelled orders / total orders × 100
• Utilisation = productive time / available time × 100

Operations case framework

• Verify whether the metric definition changed
• Segment by zone, time, store, restaurant, rider and order type
• Separate preparation, assignment and travel time
• Check demand spikes, weather, traffic and staffing
• Identify the largest contributor
• Apply a short-term fix
• Propose a long-term process improvement
• Define monitoring metrics

Roles this covers

• Operations Associate
• City Operations Associate
• Field Operations
• Delivery Operations
• Restaurant / merchant operations
• Blinkit dark-store operations
• Supply or category operations

Most Asked Topics

Highest-frequency areas across recent test papers.

Minimum swaps to sort

Cycle decomposition after mapping values to sorted positions — reported in recent SDE discussions.

Restaurant menu LLD

Menu items with size, crust, topping and configuration variations — composition and pricing rules.

Banner scheduling with frequency caps

Priority queue plus frequency tracking inside a time window.

Root-to-leaf path sums

DFS carrying the current value — a repeated tree question.

Customer ordering streaks (SQL)

Row-number gap trick on distinct order dates — reported in Product Analyst interviews.

Window functions + date-time SQL

A Zomato Product Analyst assessment reportedly had 25 aptitude and 9 SQL questions including 4 query-writing problems.

Delivery-partner churn analysis

Active days, completed orders, earnings, wait time, incentives, zone difficulty, app issues and seasonality.

Ops root-cause decomposition

Split delays into preparation, assignment and travel time before proposing fixes.

Free Resources

Curated practice links per section.

DSA practice

Design

SQL & analytics

Operations & business

50+ DSA Practice Problems

Solve in order — arrays and strings first, then sorting and recursion.

Arrays & strings

Minimum swaps to sort an array
Longest substring without repetition
Maximum subarray sum
Product of array except self
Smallest missing positive integer
Group anagrams
Subarray sum equals K
Merge intervals
Minimum window substring

Linked lists & stacks

Reverse in groups of k
Detect cycle and entry node
Merge k sorted lists
Palindrome linked list
Min stack
Next greater element
Largest rectangle in histogram
Sliding-window maximum

Trees & graphs

Sum of root-to-leaf numbers
Lowest common ancestor
Serialize & deserialize
Maximum path sum
Number of islands
Dijkstra shortest path
Topological sort
DSU connectivity

DP & design

House robber
Coin change
Longest common subsequence
Edit distance
Banner scheduling with frequency limit
Inventory-reservation service
Rate limiter
LRU cache

Previous Year Questions & Patterns

Repeat coding questions with the expected approach.

SDE-1 previous-year-style

Find the minimum number of swaps needed to sort an array (cycle decomposition).
Design a restaurant menu system supporting size, crust, toppings and custom configurations.
Schedule promotional banners with a maximum display frequency (priority queue + frequency window).
Find the sum of all numbers formed from root-to-leaf paths in a binary tree.
Find the longest common subsequence of two strings.
Design an inventory-reservation service for Blinkit — temporary reservation, expiry, idempotency, concurrent updates and out-of-stock handling.
How would you prevent duplicate payment requests from creating two orders?
How would you keep order state consistent when a store goes offline mid-order?

Product Analyst questions

Orders are stable but completed deliveries are falling — how would you investigate? (cancellation, restaurant rejection, rider availability, payment failure, delivery delays, data-quality changes)
Blinkit's stockout rate increased in one city — what would you analyse? (forecast accuracy, supplier delays, store inventory, replenishment timing, high-demand SKUs, inventory accuracy)
How would you measure customer retention? Build first-order cohorts, track repeat ordering and segment by city, category and channel.
Why might average order value increase while conversion falls?
How would you detect delivery-partner churn?
Write a query for the longest customer ordering streak.
Estimate the number of daily food-delivery orders in a metro city (market sizing).

Operations questions

What would you do if delivery delays increased during dinner peak?
How would you handle a sudden shortage of delivery partners?
A dark store has frequent stockouts — how would you investigate?
How would you improve picker productivity?
How would you handle an angry restaurant partner?
A delivery partner refuses orders from a particular zone — what would you do?
How would you plan operations for a festival or rainy weekend?
How would you decide between adding more workers and improving the process?
What daily dashboard would you build for a city manager?
How would you balance cost and delivery speed?

20+ SQL Query Bank

Write these out by hand — joins and subqueries are asked in both the test and the interview.

Customer behaviour

Customers with multiple orders

SELECT user_id
FROM orders
GROUP BY user_id
HAVING COUNT(DISTINCT order_id) > 1;

Longest customer ordering streak

WITH ordered_days AS (
    SELECT DISTINCT
           user_id,
           DATE(order_time) AS order_day
    FROM orders
),
numbered AS (
    SELECT user_id,
           order_day,
           order_day
           - INTERVAL '1 day' *
             ROW_NUMBER() OVER (
                 PARTITION BY user_id
                 ORDER BY order_day
             ) AS grp
    FROM ordered_days
)
SELECT user_id,
       COUNT(*) AS streak_length
FROM numbered
GROUP BY user_id, grp
ORDER BY streak_length DESC;

Store & city performance

Top stores by city

SELECT city,
       store_id,
       revenue,
       RANK() OVER (
           PARTITION BY city
           ORDER BY revenue DESC
       ) AS city_rank
FROM store_revenue;

City order & AOV summary

SELECT city,
       COUNT(DISTINCT order_id) AS orders,
       SUM(revenue) AS revenue,
       AVG(revenue) AS avg_order_value
FROM orders
GROUP BY city
ORDER BY revenue DESC;

DBMS & Core Interview Q&A

Short answers you should be able to say out loud.

How do you find consecutive-day streaks in SQL?

Subtract ROW_NUMBER() (per user, ordered by date) as days from the date; equal results form one streak group.

What is DATE_TRUNC used for in analytics?

Bucketing timestamps into day/week/month for cohort, funnel and trend analysis.

Difference between HAVING and WHERE?

WHERE filters rows before aggregation; HAVING filters aggregated groups.

Why use a window function instead of a self join?

Window functions compute per-partition ranks and lags in one pass without duplicating rows.

How do you handle duplicate order rows?

Deduplicate on the natural key with ROW_NUMBER() and keep the latest record.

How do you compute fill rate in SQL?

SUM(fulfilled_qty) / SUM(ordered_qty) × 100, grouped by store or city.

OOPs Concepts + 10 Code Snippets

Theory plus the exact snippets asked in the technical round.

Composition for menu configuration

A menu item composes size, crust and topping options plus pricing rules instead of subclassing every combination.

State machine for orders

Placed → confirmed → picked → dispatched → delivered / cancelled, with legal transitions enforced in one place.

Idempotency keys

Duplicate payment or reservation requests with the same key must not create two effects.

Reservation with expiry

Inventory is held temporarily and released on timeout to avoid overselling in dark stores.

SOLID

Single responsibility and open/closed keep the coupon engine and pricing rules extensible.

Minimum swaps to sort — cycle decomposition

cpp

int minSwaps(vector<int> a) {
    int n = a.size(), swaps = 0;
    vector<pair<int,int>> v(n);
    for (int i = 0; i < n; ++i) v[i] = {a[i], i};
    sort(v.begin(), v.end());
    vector<bool> vis(n, false);
    for (int i = 0; i < n; ++i) {
        if (vis[i] || v[i].second == i) continue;
        int cycle = 0, j = i;
        while (!vis[j]) { vis[j] = true; j = v[j].second; ++cycle; }
        swaps += cycle - 1;
    }
    return swaps;
}

Inventory reservation service (interface sketch)

java

interface InventoryService {
    // idempotent: same reservationId returns the same result
    Reservation reserve(String reservationId, String storeId, Map<String,Integer> items, Duration ttl);
    void commit(String reservationId);   // on payment success
    void release(String reservationId);  // on failure or TTL expiry
    int available(String storeId, String sku);
}

// Concurrency: use per-(store, sku) row locks or atomic decrements,
// reject when available < requested, and expire stale reservations via a sweeper.

Fill rate & on-time delivery by city

sql

SELECT city,
       ROUND(100.0 * SUM(fulfilled_qty) / NULLIF(SUM(ordered_qty), 0), 2) AS fill_rate,
       ROUND(100.0 * SUM(CASE WHEN delivered_at <= promised_at THEN 1 ELSE 0 END)
             / NULLIF(COUNT(*), 0), 2) AS on_time_pct
FROM order_items
GROUP BY city
ORDER BY fill_rate;

Operating System Basics

Scheduling, deadlock and memory management essentials.

Systems topics for SDE rounds

• Process vs thread
• Locks and thread safety
• Deadlock conditions
• Caching and eviction
• Rate limiting
• Retry with backoff and idempotency

Data & reliability

• Indexing basics
• Transactions and isolation levels
• Eventual consistency in order tracking
• Queue-based decoupling
• Handling festival traffic spikes

4-Week Preparation Roadmap

From zero to test-ready in 28 days.

Week 1

SDE: arrays, strings, hashing · PA: SQL basics · Ops: operations metrics

6 problems / 10 queries / metric definitions

Goal: Lock in fundamentals for your track.

Week 2

SDE: sliding window, prefix sums, binary search · PA: joins & aggregation · Ops: delivery funnel

6 problems / 10 queries / 1 funnel breakdown

Goal: Pattern recognition and funnel thinking.

Week 3

SDE: linked lists, stacks, queues · PA: window functions · Ops: inventory & staffing

5 problems / 8 window queries / 1 staffing plan

Goal: Handle pointer code and analytic SQL.

Week 4

SDE: trees, heaps, recursion · PA: Python/pandas · Ops: SLA & incident handling

5 problems / 2 notebooks / 1 incident write-up

Goal: Cover tree questions and data cleaning.

Week 5

SDE: graphs, DSU, shortest paths · PA: statistics & A/B tests · Ops: root-cause analysis

5 graph problems / stats revision / 1 RCA

Goal: Model problems and reason with data.

Week 6

SDE: DP & greedy · PA: product cases · Ops: city/store cases

5 DP problems / 2 cases / 2 ops cases

Goal: Complete the hardest block for each track.

Week 7

SDE: LLD & product system design · PA: mock SQL & estimation · Ops: mock interviews

1 LLD write-up / 1 mock test / 1 mock interview

Goal: Practise structured, spoken answers.

Week 8

Timed coding, interviews, resume & business cases

1 timed assessment
1 mock interview
Resume and project polish

Goal: Be interview-ready end-to-end.

Exam Day Strategy

Score targets and time allocation.

Section targets

SDE assessment (75–90 min): Bank the easiest problem fully, then split the rest; debugging problems reward careful reading over speed.
Product Analyst assessment: Clear the 25 aptitude questions fast, then spend the bulk of the time on the 4 query-writing problems.
SQL query writing: Write the CTE skeleton first, then add window functions; state assumptions about date grain.
Ops case: Verify the metric definition, segment, decompose the timeline, name the biggest contributor, propose a fix and a monitor.
LLD round: Entities → interfaces → state transitions → extensibility → failure handling → tests.

Coding time split (50 min)

SDE-1: 2 hours DSA + 45 min timed coding + 30 min CS fundamentals + 30 min LLD/project
Product Analyst: 60 min SQL + 45 min pandas + 30 min statistics + 45 min cases and estimation
Operations: 45 min aptitude + 45 min metrics & Excel + 30 min case practice + 30 min communication drills

Interview Process

What follows the online test.

SDE-1

• Online assessment — 2–3 DSA/debugging problems (75–90 min)
• Recruiter or phone screen
• Technical round 1 — live coding and complexity
• Technical round 2 — DSA, LLD and project deep dive
• Hiring manager / bar raiser — ownership, product thinking, culture
• HR / final round

Product Analyst

• Online assessment — aptitude, SQL and case study
• Technical/data interview — SQL, Python, statistics, resume
• Product case round — funnels, retention, growth, marketplace metrics
• Business or hiring manager round — estimation, prioritisation, communication
• Culture / HR round

Operations

• Application screening — education, communication, location flexibility
• Aptitude or case assessment — numerical reasoning and operational judgement
• Managerial interview — execution, prioritisation, problem solving
• Business/operations round — city, store, delivery or merchant scenarios
• HR — shifts, relocation, targets and expectations

Mock Test Plan

Four simulations to run before the real test.

Mock 1 — SDE assessment

• 3 problems in 90 minutes
• Include one debugging problem
• Review complexity after each

Mock 2 — LLD discussion

• Design the restaurant menu or inventory-reservation service
• 45 minutes, spoken aloud
• Cover states, concurrency and extensibility

Mock 3 — Product Analyst assessment

• 25 aptitude questions + 5 SQL MCQs + 4 query-writing problems
• Timed, no reference material
• Include a streak and a cohort query

Mock 4 — Ops case

• Delivery delays up 20% in one city
• Segment, decompose, recommend
• Present a one-page daily dashboard

Final Checklist

Tick all of these before test day.

Can write minimum swaps, LCS, edit distance and root-to-leaf sums from memory

Prepared one LLD design end-to-end with classes, states and trade-offs

Know how to prevent overselling, duplicate payments and coupon abuse

Product Analyst: streak, cohort, funnel and retention queries written from scratch

Know Zomato marketplace and Blinkit dark-store metric lists

Ops: four core formulas and the case framework memorised

Two projects ready with architecture, decisions and hardest bug

Practised communicating conclusions in business language

Recent Interview Experiences

First-hand write-ups from students who actually sat the Zomato & Blinkit process.

Be the first to share a Zomato & Blinkit interview experience.

Frequently Asked Questions

Do Zomato and Blinkit share one hiring process?

Preparation overlaps heavily, but roles differ: SDE-1 is DSA plus design, Product Analyst is SQL and cases, Operations is execution and marketplace problem solving. Blinkit engineering additionally emphasises real-time inventory, allocation and low-latency APIs.

What does the SDE-1 online assessment look like?

Reports describe two to three DSA or debugging problems in roughly 75–90 minutes, followed by multiple technical rounds, a managerial/culture-fit round and HR.

What was in the Product Analyst assessment?

One reported assessment had 25 aptitude questions and 9 SQL questions — five MCQs and four query-writing problems — with interviews covering window functions, date-time operations and a detailed resume discussion.

Which LLD questions are most likely?

Restaurant menu system with size/crust/topping variations, coupon engine, delivery-partner assignment, notification service, rate limiter and inventory reservation.

How should Operations candidates prepare?

Focus on delivery and dark-store metrics, the four core formulas, root-cause decomposition, Excel/basic analysis and clear communication under pressure.

Want the full structured prep for Zomato & Blinkit?

The Premium Vault covers Aptitude, Core CS, DSA, SQL and HR rounds with module-wise courses and drill sheets.

Explore Premium Vault Zomato & Blinkit Company Sheet

Next steps chosen from the Zomato & Blinkit pattern and other Indian Unicorn recruiters.

Other Indian Unicorn companies

Flipkart Interview Prep Guide

Flipkart exam pattern, syllabus and previous year questions · ₹18–32 LPA · intern ₹80k–1.2L/mo.

Swiggy Interview Prep Guide

Swiggy exam pattern, syllabus and previous year questions · ₹16–30 LPA.

Myntra Interview Prep Guide

Myntra exam pattern, syllabus and previous year questions · ₹16–28 LPA.

Core CS subjects for this pattern

DBMS & SQL Essentials

Normalisation, keys, transactions and the SQL queries asked in written rounds.

OOPs Essentials for Interviews

The four pillars with the exact code snippets interviewers ask you to explain.

Operating System Essentials

Processes, scheduling, deadlock and memory management in interview-ready form.

Recommended practice path

Most Asked DSA Questions Sheet

High-frequency problems for candidates targeting Zomato & Blinkit.