Interview experience at Zepto for 48 LPA

Round 1

DSA + Problem Solving

Round 2

Low-Level Design + DB Schema + APIs

Both rounds were conducted on BarRaiser. Even though there were only two rounds, the discussions were intense and heavily technical.

Round 1 : DSA & Problem Solving Round

This round was entirely focused on coding. The interviewer clearly mentioned at the beginning that the expectation was: Solve 2 DSA questions within roughly 25 minutes each That immediately created pressure because both correctness and speed mattered heavily. The interviewer was collaborative but also closely evaluated: coding speed, optimization, communication, naming conventions and thought process.

One thing I noticed was that they were not interested in brute-force thinking. They expected optimized solutions almost immediately.

Problem 1 : Minimum Cost For Tickets (Leetcode)

The first problem asked was: Minimum Cost For Tickets This is actually considered a fairly difficult dynamic programming problem, especially under interview pressure.

The problem gives:

a list of travel days ticket costs for:1-day pass 7-day pass 30-day pass

Example :

Input: days = [1,4,6,7,8,20], costs = [2,7,15] Output: 11

The goal is: Find the minimum total cost required to cover all travel days. At first glance, the problem can feel confusing because there are multiple overlapping choices at every step. The interviewer mainly wanted to evaluate: recursive thinking

dynamic programming optimization state transition understanding

Problem 2 – Daily Temperatures (Leetcode)

The second question was Daily Temperatures. This problem is a classic stack-based problem and comparatively easier once you identify the pattern.

Given an array of temperatures, for every day we need to determine: How many days must pass before a warmer temperature appears If no warmer day exists, return 0 for that position.

Example:

Input: [73,74,75,71,69,72,76,73]

Output: [1,1,4,2,1,1,0,0] The interviewer specifically mentioned that this was a variation of a standard monotonic stack problem.

The brute-force approach would compare every future temperature for every index, leading to O(N²) complexity. Instead, I used a monotonic decreasing stack.

The idea is: maintain indices in decreasing order of temperatures whenever a warmer temperature appears, resolve pending indices This reduces complexity to O(N). I solved this problem in around 10 minutes because I had practiced similar stack problems before.

Round 2 : Low-Level Design + Database Schema + APIs This round was much more backend engineering focused. The interviewer asked me to: Design a Chess Game

Initially, it sounded simple, but the discussion quickly became deep. The interviewer expected:

class structures design patterns APIs database schema move validation logic extensibility discussions This was not just a UML exercise. The interviewer wanted to understand how I think while designing real systems.

Chess Game LLD Discussion I started by identifying the major entities: Player, Board, Piece, Move, Game and Position. Then I discussed how inheritance can be used for chess pieces. For example: King, Queen, Bishop, Knight, Rook and Pawn. Can inherit from a base Piece class.

I also discussed: encapsulation, abstraction and polymorphism. during the design.

Design Patterns Discussion The interviewer specifically asked where design patterns could be useful.

I discussed:

Factory Pattern for piece creation Strategy Pattern for move validation Singleton Pattern for game manager (optional discussion) The interviewer seemed more interested in my reasoning than memorized definitions.

Database Schema Design The next discussion focused on schema design.

I designed tables for players, games, moves and match history. I also explained relationships between entities and why indexing would matter for querying ongoing games efficiently.

The interviewer asked follow-up questions around:

scalability storing board state move history optimization which made the discussion feel very practical.

API Design The interviewer then asked me to define APIs.

I designed APIs such as:

Start New Game POST /games/start Make Move POST /games/{id}/move Fetch Game State GET /games/{id} I also explained request payloads, responses, status codes and validation handling.

This part of the interview honestly felt very similar to real backend development discussions.

Overall Experience at Zepto Technically, the interview process at Zepto was genuinely good. The interviewers were technically strong and the rounds tested:

DSA fundamentals optimization skills object-oriented design backend engineering thinking API design capability The main challenge was speed, time pressure and implementation clarity.