District by Zomato | SDE-1 Backend | Gurugram

Recently went through the hiring process for a Backend Engineer / SDE-1 position at District by Zomato.

I had around one year of internship experience at the time of the interview.

There were two technical discussions. Both were fairly interactive.

Round 1 - Problem Solving + Backend

The interview began with a DSA problem based on an integer array and a given value k.

The task was to determine the maximum-length contiguous segment in which the frequency of every number stays within k.

I approached it using a two-pointer/sliding-window technique combined with a hashmap. After explaining the idea, I walked through an example and discussed the complexity before implementing the solution in C++.

The conversation then shifted towards backend engineering. A lot of the questions were connected to technologies and concepts mentioned in my resume.

Discussed topics such as:

• How PostgreSQL indexes affect query performance

• Identifying slow queries using EXPLAIN ANALYZE

• Reducing database overhead through batching

• Differences between stateful and stateless services

• Designing REST endpoints that return large datasets

• Choosing between Kafka and SQS

• Partitioning and message ordering in Kafka

• Handling duplicate messages safely

• Monitoring services with Prometheus and Grafana

• Problems caused by high-cardinality metrics

The interesting part was the depth of the discussion. Whenever I mentioned an approach, the interviewer usually followed up with questions around the reasoning behind it, possible alternatives, and what could happen under higher load.

The conversation was comfortable overall, and I was given enough time to explain my thought process rather than having to rush through the answers.

Round 2 - API Design + Implementation

The second round focused heavily on backend design.

The initial requirement was to build an API that could return a user's District Money transaction history with pagination.

i used different ways of handling pagination and discussed the trade-offs between offset-based and cursor-based approaches.

For the cursor approach, we considered using createdAt together with transactionId so that the position within the result set could be tracked reliably. This also led to a discussion around suitable composite indexes, request/response structure, and the SQL required to retrieve the data efficiently.

Then the interviewer introduced another constraint: the transactions were distributed across three separate tables.

That changed the design discussion considerably, talked about:

• Whether JOIN or UNION ALL would be appropriate

• Fetching records independently from each table

• Combining the results within the application

• Maintaining ordering across multiple sources

• Continuing pagination correctly after merging the datasets

• The behavior of the solution as the volume increased

The round also required actual implementation. I had to write the backend logic as well as the SQL, rather than stopping at an architectural explanation.

At one point, the interviewer asked:

Apart from offset and cursor, what other way can you paginate?

I wasn't able to come up with another option immediately. The interviewer mentioned page-number pagination.

I explained that page-number pagination is generally implemented using an offset internally, where the offset can be calculated as:

(page - 1) × limit

I still wasn't completely sure what distinction the interviewer was looking for, but it was an interesting discussion.

The Part I Struggled With

The biggest challenge for me was the implementation itself.

The interviewer expected the code to be written cleanly and independently, without using an AI coding assistant. That's where I realized I had become somewhat dependent on AI-assisted development in my regular workflow.

Without those tools, my implementation wasn't as clean or structured as I wanted it to be.

That was probably the most useful takeaway from the process for me. AI can make development significantly faster, but it's still important to stay comfortable with writing, structuring, and debugging code independently when the situation demands it.

Result

I was not able to clear the process and was rejected after the second round.