LogIn
I don't have account.

Flipkart SDE-1 Interview Experience | System Design + DSA

Ajeet Pawar
11 Views

Getting an interview opportunity at Flipkart Internet Private Limited always feels exciting, especially because their process is not limited to just coding. It blends real-world system thinking with strong DSA fundamentals.

I recently went through a 2-round interview process for the SDE-1 role. Although I was rejected after the second round, the experience was genuinely valuable because it made one thing very clear: Flipkart is not looking for perfect answers. They are looking for practical thinking and clear execution under pressure.

The entire process was remote and completed within one to two weeks. On paper, the difficulty level of the questions was mostly medium, but what made the interviews challenging was the expectation of writing optimized solutions while explaining your approach clearly at every step.

If you are preparing for Flipkart SDE-1 interviews, DSA questions or system design rounds, this experience will give you a realistic picture of what actually matters.

Interview Process Overview

The process had two rounds:

  • Round 1 – System Design (Parcel Delivery Application)
  • Round 2 – DSA Round (2 Problems)

Unlike many interview processes where rounds are isolated, here both rounds felt connected through one common expectation, balance below things

  • Not just solving the problem.
  • Not just optimizing the solution.
  • Not just explaining the logic.

But balancing all three at the same time. That was the real challenge.

Round 1 – System Design (Parcel Delivery Application)

The first round at Flipkart Internet Private Limited was purely focused on system thinking. There was no heavy coding involved, which made the conversation feel closer to a real backend design discussion rather than a typical interview question.

The interviewer asked me to design a Parcel Delivery Application and the problem was framed in a very practical way. Instead of building a complex logistics system from scratch, the focus was on designing a platform where users could play dual roles, some users act as couriers offering pickup slots, while others act as senders who want to deliver parcels.

The system needed to allow senders to search for suitable pickup slots based on location, time and parcel constraints. At the same time, it had to manage real-time availability, booking and basic logistics information like source, destination and parcel size.

At first glance, it felt like a simple marketplace problem, but the depth came from how cleanly the system was broken down.

I started by identifying the core entities involved in the system. I defined users, parcels, pickup slots, bookings and locations as the primary building blocks. Then I explained how these entities interact with each other. For example, a courier (user) can create multiple pickup slots and a sender (another user) can book one of those slots. Each slot carries important attributes like source, destination, time window and capacity constraints.

The interviewer was not interested in complex diagrams. What mattered more was whether the relationships between these entities were logically consistent and easy to extend in the future.

Once the basic structure was clear, the discussion moved into real-world considerations. One of the key parts was the matching logic. I explained that senders should be able to search for available slots based on source and destination, filter them using time windows and ensure that the parcel size fits within the slot’s capacity. This required thinking in terms of efficient querying and filtering rather than just storing data.

Then came the challenge of real-time availability. The interviewer wanted to understand what happens when multiple users try to book the same slot. I explained that the system needs to update slot availability instantly when a booking is made or canceled. To handle this, approaches like caching frequently accessed slot data and using optimistic locking for concurrent updates can help maintain consistency without slowing down the system. This naturally led to scalability discussions.

As the number of users grows, searching for slots becomes a heavy operation. I mentioned that indexing based on location and time would be critical to keep queries fast. For larger scale, geo-based indexing or location-aware search strategies could further improve performance, especially when users are searching within specific regions.

Throughout the discussion, the interviewer kept the focus on practicality. There was no expectation of designing a distributed system with dozens of services. Instead, they were evaluating whether I could take a real-world problem, break it into logical components and think about constraints like concurrency, search efficiency and data relationships. By the end of the round, it was clear what was being tested.

This was not about knowing advanced system design patterns. It was about demonstrating real-world thinking, the ability to decompose a problem and explaining decisions in a structured and simple way. And honestly, that is what made this round both challenging and interesting.

Round 2 – DSA Round

The second round at Flipkart Internet Private Limited was purely focused on problem-solving and this is where the pressure really kicked in. I was given two medium-level problems, but what made them challenging was not just the logic. it was the expectation to balance correctness, optimization and speed while explaining everything clearly.

Problem 1 – Minimum Path Sum (Grid DP)

The first problem was based on a grid and required finding the minimum path sum from the top-left corner to the bottom-right corner, with movement restricted to only right and down.

At first, it’s tempting to think in terms of exploring all possible paths, but that quickly leads to exponential complexity. I explained that brute force is not feasible and shifted to a Dynamic Programming approach.

The key idea is simple but powerful: instead of recomputing paths, we store the minimum cost to reach each cell. For every position in the grid, the cost depends on the minimum of the top cell and the left cell. By building this step by step, we avoid redundant work and arrive at the optimal answer efficiently.

The interviewer was particularly interested in how clearly I could derive this transition and whether I could explain why overlapping subproblems exist in this scenario.


public class MinPathSum {

    public int minPathSum(int[][] grid) {
        int m = grid.length;
        int n = grid[0].length;

        int[][] dp = new int[m][n];
        dp[0][0] = grid[0][0];
        for (int i = 1; i < m; i++)
            dp[i][0] = dp[i - 1][0] + grid[i][0];

        for (int j = 1; j < n; j++)
            dp[0][j] = dp[0][j - 1] + grid[0][j];

        for (int i = 1; i < m; i++) {
            for (int j = 1; j < n; j++) {
                dp[i][j] = grid[i][j] +
                        Math.min(dp[i - 1][j], dp[i][j - 1]);
            }
        }
        return dp[m - 1][n - 1];
    }
}

The time complexity is O(m × n) and space can be optimized further, but the interviewer cared more about clarity than micro-optimizations at that moment.

Problem 2 – Contain Virus (Graph + BFS/DFS)

The second problem was significantly more complex and felt closer to a real-world simulation than a typical DSA question.

The grid represented infected and healthy cells and the goal was to contain the virus by strategically building walls while minimizing its spread. This required identifying infected regions, evaluating which region posed the highest risk, isolating it and then allowing the rest of the grid to evolve.

The interviewer was not expecting me to jump straight into coding. They wanted to see whether I could structure the problem correctly before touching the keyboard.

I approached it by first explaining how to identify connected infected regions using DFS. Then, for each region, I discussed how to calculate its potential spread and track the number of walls required to isolate it. The next step was selecting the most dangerous region, building walls around it and then letting the remaining regions spread.

The interviewer was not expecting a perfect implementation because the problem is quite heavy for a limited interview time. Instead, the focus was on how clearly I could structure the solution and reason about each step.

Read Contain Virus

Final Result – Rejected

Unfortunately, I was rejected after this round. But the reason became clear when I reflected on the interview.

I had focused heavily on getting the logic correct, but my optimization discussion could have been sharper, especially in the second problem. I also realized that time management played a big role. I spent too much time ensuring correctness, which affected how confidently I could present the optimized view.

Responses (0)

Write a response

CommentHide Comments

No Comments yet.