Zomato / Feeding India SDE-1 Interview Experience (0-1 YOE) — DSA + LLD + System Design

I recently interviewed for an SDE-1 role at Feeding India (Zomato) and wanted to share my experience because the interview was much broader than just DSA.

Sharing this mainly to help other candidates understand the interview pattern and topics worth preparing.

Round 1 - Technical Interview

1. Resume Deep Dive

The interview started with my resume.

The interviewer went fairly deep into my projects and experience, so I would strongly recommend being prepared to explain every technology and project mentioned on your resume.

Be ready for questions like:

Why did you choose this technology? What was your contribution? What challenges did you face? How did you scale/improve it? Why did you choose one approach over another? What would you change if you built it again?

Don't put anything on your resume that you cannot explain technically.

1. Zomato-style LLD / System Design

This was discussed quite deeply.

The discussion revolved around designing a food‑delivery type system and understanding how different entities interact.

Important areas to prepare:

User Restaurant Menu MenuItem Cart Order OrderItem Payment Delivery Delivery Partner Order Status Relationships between entities APIs Database design State transitions Concurrency

You should also be comfortable with:

SOLID principles Interfaces vs abstract classes Composition vs inheritance Strategy Pattern websocket vs webhook and sse and why and when you will choose what Factory Pattern Observer Pattern (do this thing very carefully they will cross question and create many scenario ) State Pattern Exception handling Thread safety Idempotency

A very important thing is to understand the reasoning behind your design, not just draw classes.

1. Bloom Filters (i mentioned this thing during the system design i know the working of this and why it is used but they got more curious about how it works inside the hood apart from this they also asked about elastic searching)

Bloom Filter was discussed.

Things I would recommend preparing:

What is a Bloom Filter? Why do we use it? Bit array Multiple hash functions False positive Why false negatives generally don't occur Memory advantage When it is useful When it should NOT be used How it can reduce unnecessary database/cache lookups

The key idea:

If the Bloom Filter says "NO", the item definitely isn't present. If it says "YES", the item is probably present and should be verified from the actual data store.

1. WebRTC (+ point if you know about exotal)

WebRTC was also discussed.

Important topics:

WebRTC architecture Signaling SDP ICE candidates STUN TURN NAT P2P communication Why UDP is commonly preferred for real-time communication When a TURN server is required WebSocket vs WebRTC

One important distinction:

Signaling is not WebRTC itself. Signaling is used to exchange information required to establish the WebRTC connection. STUN helps discover the public network address, while TURN can relay traffic when a direct peer‑to‑peer connection cannot be established.

1. SQL vs NoSQL

Another important discussion was:

When would you choose SQL and when would you choose NoSQL?

I would recommend NOT answering this only with:

SQL = structured data NoSQL = unstructured data

Instead, think about:

Access patterns Consistency requirements Transactions Relationships Scalability Read/write throughput Data model Availability Latency Horizontal scaling

For example:

SQL Useful when you need: Strong consistency ACID transactions Complex relationships Joins Constraints Structured schema Examples: PostgreSQL MySQL

NoSQL Can be useful when the workload requires: Massive horizontal scaling High throughput Flexible schema Specific key‑value/document/wide‑column access patterns Examples: MongoDB Cassandra DynamoDB

The important part is:

Don't choose a database because it is "popular". Choose it based on the system's access patterns and requirements.

1. DSA - Two Unique Numbers

The DSA question was based on finding two numbers that appear only once while the other numbers appear twice.

Example: [1, 2, 3, 2, 1, 5]

Answer: 3, 5

The expected optimal approach is using XOR.

Important XOR properties:

x ^ x = 0 x ^ 0 = x

XORing the entire array leaves: 3 ^ 5

Then use the rightmost set bit to divide the numbers into two groups and recover the two unique numbers.

Complexity: Time: O(n) Space: O(1)

Round 2 - Manager Round (more into dsa and they will try to break your confidence with DSA)

The manager round focused more on problem solving and reasoning.

Two interesting problems were asked.

Problem 1 - Array / Same Value Jump

You are given an array containing integers in arbitrary order. From index i, you can move to:

i + 1

i - 1 Any index j where: arr[i] == arr[j] Find the minimum number of moves required to reach the last index.

Example: [100, -23, -23, 404, 100, 23, 23, 23, 3, 404]

The important observation is: This is not really an array problem. It is a shortest‑path problem on a graph. Think of: index = node movement = edge From each index, we can go to: i - 1 i + 1 same‑value indexes Since every move has equal cost: Shortest path -> BFS

The challenge is efficiently finding all indexes containing the same value. Use: HashMap<Integer, List> For example: 100 -> [0, 4] 404 -> [3, 9] 23 -> [5, 6, 7]

A crucial optimization is to process each same‑value group only once. Otherwise, if the same value appears many times, we can end up repeatedly traversing the same list and approach O(n²).

The optimized solution is: Time: O(n) Space: O(n)

Pattern to remember: Minimum moves ↓ Shortest path ↓ Unweighted graph ↓ BFS

Problem 2 - Matrix Row/Column Reversal

The second problem was a matrix problem. You are given a square matrix and can reverse rows and columns any number of times. The goal is to maximize the sum of the top‑left quadrant.

This is very similar to HackerRank's Flipping the Matrix problem.

The key insight is: Don't simulate all the row/column flips. Instead, use symmetry. For every position (i, j) in the top‑left quadrant, only four values can eventually occupy that position: matrix[i][j] matrix[i][n-1-j] matrix[n-1-i][j] matrix[n-1-i][n-1-j]

Therefore, for every cell in the target quadrant: Take the maximum of those 4 values and add it to the answer.

For example:

a b | c d

e f | g h ----+----

i j | k l

m n | o p

For a, the possible values are: a, c, m, o For b: b, d, n, p

So: answer = max(a,c,m,o) + max(b,d,n,p) + ...

The important pattern is: Operations look complicated ↓ Find invariant / symmetry ↓ Avoid simulation ↓ Greedy selection

Overall Interview Pattern

Based on my experience, I would recommend preparing these areas for an SDE-1 interview:

DSA Arrays HashMap XOR BFS DFS Graphs Binary Search Sliding Window Two Pointers Stack / Queue Heap LLD SOLID Design Patterns State Pattern Strategy Pattern Factory Pattern Observer Pattern Interfaces Composition vs Inheritance Concurrency Thread Safety Idempotency System Design Caching Redis Load Balancing Database Indexing SQL vs NoSQL Replication Sharding Partitioning Message Queues Kafka basics Consistency Rate Limiting Bloom Filters Networking HTTP/HTTPS TCP vs UDP WebSockets WebRTC STUN TURN NAT Real‑time communication Databases ACID Transactions Isolation Levels Locks Optimistic vs Pessimistic Locking Deadlocks Indexing Normalization Replication Sharding CAP Theorem Eventual Consistency

My biggest takeaway

The interviews were not purely about memorizing LeetCode problems. The interviewers were interested in whether I could recognize the underlying concept.

For example: Array + minimum moves ↓ BFS / shortest path

and: Repeated row/column operations ↓ Don't simulate ↓ Find symmetry

and: Huge membership checks ↓ Bloom Filter

and: Database choice ↓ Access pattern + consistency + scale

So if you're preparing for a similar SDE-1 interview, I would recommend focusing on patterns, trade‑offs, and explaining your reasoning, rather than only memorizing solutions, and the interview went for 4 hours with 10min break so be prepared for this as well in my case it is like this.

Hope this helps someone preparing for their interview. Good luck!