Summary
Job Role: Software Development Engineer 2
Number of Rounds: 4
Offer Status: Offer (not accepted due to compensation mismatch)
Location: –
Candidate Name: Not disclosing
Interview Process
The interview process at PhonePe consisted of four rounds in total. It started with a take-home machine coding challenge conducted on CodeSignal, followed by a short face-to-face discussion round to evaluate the submitted solution. After this, there was a Problem Solving Data Structures (PSDS) round, then a System Design round, and finally a Hiring Manager (HM) round.
After clearing all rounds successfully, I was asked about my expected compensation. Since PhonePe could not match the numbers I quoted, they did not proceed with extending the final offer letter despite confirming my selection.
Preparation Guide
For this particular interview, I relied on my prior experience and did not use any structured preparation sources. However, candidates preparing for a similar process should:
Practice machine coding style questions, especially those involving clean modular code and design patterns.
Strengthen problem-solving skills in data structures and algorithms, including both standard problems from platforms like LeetCode as well as custom variations.
Revisit system design concepts with a focus on trade-offs across databases, scalability, and authorization models.
Be well-prepared to discuss existing projects in detail, especially design decisions, scaling strategies, and technology trade-offs.
Interview Rounds
Round 1: Take-home Machine Coding Round
Duration: 90 minutes (plus 30-minute face-to-face discussion)
Difficulty Level: Medium
Experience:
The first round was a 90-minute CodeSignal machine coding challenge.
Problem Statement:
Design a TODO list with the following features:
Add Task
Update Task
Remove Task
Fetch analytics of spilled tasks, completed tasks, and so on
The solution could be built using in-memory data structures.
After submission, a 30-minute face-to-face discussion was scheduled on the same problem. The interviewer, who was very experienced and approachable, asked detailed questions about my implementation and how I would scale it further.
I had structured my code in a modular way. The interviewer appreciated that but suggested improvements:
Using the Command Pattern to design the analytics functions more cleanly.
Using Concurrent HashMaps instead of regular HashMaps as the data store to handle concurrent access better.
This round was focused not only on coding ability but also on code quality, scalability, and design choices.
Key Learnings:
Writing modular code is important, but complementing it with appropriate design patterns can make the solution much more extensible.
Always consider concurrency and thread safety when choosing data structures.
Round 2: PSDS Round
Duration: Around 60 minutes
Difficulty Level: Difficult
Experience:
In this round, I was asked two problems. I could fully implement the first one but, due to time constraints, could not code the second. However, I was able to provide a convincing algorithm for it.
Given an array A of N positive integers, count the number of subarrays where the number of odd integers is equal to the number of even integers.
Example:
For A = [1,2,1,2], the odd-even subarrays are:
[1,2]
[2,1]
[1,2]
[1,2,1,2]
Answer = 4
Although I couldn’t implement the second problem due to lack of time, my explanation and reasoning around prefix sums and balance tracking convinced the interviewer.
Key Learnings:
Time management is critical in coding interviews. Even if you cannot implement the complete solution, explaining a solid and optimal algorithm can still leave a positive impression.
For problems involving counts and subarrays, prefix sums and hash-based approaches are often useful.
Round 3: System Design Round
Duration: Around 60 minutes
Difficulty Level: Medium
Experience:
The design problem was to build a platform similar to Quora. The interviewer clarified that the system should first be designed for internal company use and later made extensible to other companies.
Key discussions included:
Whether it was feasible to store foreign keys if an RDBMS was chosen for storing questions.
How search results would be displayed efficiently.
Whether user information and Q&A data should be stored in separate databases or combined.
How authentication and authorization would be handled inside the API gateway.
How authorization tokens would be passed across microservices.
Trade-offs between Cassandra, other NoSQL databases, and RDBMS.
The round was not just about drawing an architecture but also defending choices with trade-offs.
Key Learnings:
For design problems, be ready to explain why a certain database or architecture is preferred over others.
Authentication and authorization are central topics in distributed architectures and are often probed in depth.
Round 4: Hiring Manager Round
Duration: Around 55 minutes
Difficulty Level: Medium
Experience:
This round started with a brief introduction by the HM about their team and work. The majority of the time, however, was spent discussing the architecture of my current project in detail.
Key questions included:
What improvements would I propose in the current architecture?
Why did I choose MongoDB in my project?
What was the replication and sharding strategy for databases, and how much load was being handled?
How was the API exposed to other teams?
How many people were involved in the project and what was the overall timeline?
Since I had prepared a high-level architecture diagram of my existing work beforehand and noted the points I wanted to highlight, I was able to explain my design clearly and confidently.
Key Learnings:
Preparing architecture diagrams and main discussion points ahead of the HM round helps significantly.
The Hiring Manager round often emphasizes clarity of thought, depth of technical ownership, and ability to reflect on design trade-offs.
Final Thoughts
The PhonePe interview process was well-structured and balanced across coding, problem solving, and design skills.
Some key takeaways:
For machine coding rounds, clean modular code and design patterns can set you apart.
Problem solving rounds are not only about coding but also about your ability to think through and articulate optimal approaches.
System design interviews test both your technical breadth (databases, scalability, microservices) and depth (trade-offs, reasoning, and real-world applicability).
Hiring Manager rounds can heavily focus on your past work. Preparing architecture notes beforehand can make the discussion more effective.
Although I cleared all rounds, PhonePe and I could not align on compensation, so the process ended without an offer letter.