Blinkit (Eternal) SDE-1 Interview Experience (June 2026) – Offer Received

Sanuj Tiwari

Published : 15 June 2026
Updated : 15 June 2026

708 Views

#sde-1

#interview-experience

#interview-preparation

#technical-interview

#blinkit

Company: Blinkit (Eternal)
Role: Software Development Engineer I (SDE-1)
Location: Gurgaon
Experience: 1 Year
Education: B.Tech from Tier-1 College
Interview Mode: Remote
Interview Rounds: 3
Result: Selected
Compensation Offered: 30 LPA (25 LPA Fixed + 5 LPA Joining Bonus)

At the time of applying, I had around one year of experience working at a large multinational company. Although the company offered stability, I felt that the learning opportunities and technical exposure were limited. Most of my time was spent on low-impact work and I wanted to move to a fast-paced product company where I could work on challenging engineering problems and grow significantly as a software engineer.

Interestingly, I decided to resign without having another offer in hand. While this was a risky decision, I was confident in my preparation and wanted to focus completely on interview preparation.

Recruiter Screening Call

The process started with a recruiter reaching out to schedule the first interview round. During the call, the recruiter explained the overall hiring process and the expectations from candidates. The interview process consisted of three rounds:

Problem Solving Round
System Design Round
Culture Fit Round

The recruiter also briefly discussed the role, team structure and work culture at Blinkit. The entire interaction was smooth and professional and interview slots were scheduled quickly.

Round 1 : Problem Solving

Interviewer: SDE-III (5 Years Experience)
Duration: 60 Minutes
Difficulty: Medium

The interviewer started with a casual introduction and asked about my background, current role and reasons for looking for a change. The atmosphere was very relaxed and he made it clear from the beginning that he was not interested in asking extremely difficult algorithmic questions.

According to him, the primary goal of the round was to evaluate how candidates think under pressure and approach problem-solving rather than test obscure algorithms.

DSA Questions Asked

1. House Robber (LeetCode Medium)

The problem involves maximizing the amount of money robbed from houses while ensuring that adjacent houses are not robbed.

I explained the recursive solution first and gradually optimized it using Dynamic Programming. The interviewer was particularly interested in understanding my thought process and how I arrived at the state transition.

1. Recursive Solution (Brute Force)


class Solution {
    public int rob(int[] nums) {
        return solve(0, nums);
    }
    private int solve(int index, int[] nums) {
        if (index >= nums.length) {
            return 0;
        }
         // Take and Non-Take type DP problem
        int rob = nums[index] + solve(index + 2, nums);
        int skip = solve(index + 1, nums);
        return Math.max(rob, skip);
    }
}

2. Memoization (Top-Down DP)


class Solution {
    public int rob(int[] nums) {
        Integer[] dp = new Integer[nums.length];
        return solve(0, nums, dp);
    }

    private int solve(int index, int[] nums, Integer[] dp) {
        if (index >= nums.length) {
            return 0;
        }
        if (dp[index] != null) {
            return dp[index];
        }
        int rob = nums[index] + solve(index + 2, nums, dp);
        int skip = solve(index + 1, nums, dp);
        return dp[index] = Math.max(rob, skip);
    }
}

3. Bottom-Up DP (Tabulation)


class Solution {
    public int rob(int[] nums) {
        int n = nums.length;
        if (n == 1) {
            return nums[0];
        }
        int[] dp = new int[n];
        dp[0] = nums[0];
        dp[1] = Math.max(nums[0], nums[1]);
        for (int i = 2; i < n; i++) {
            dp[i] = Math.max(
                    dp[i - 1],
                    dp[i - 2] + nums[i]
            );
        }
        return dp[n - 1];
    }
}

4. Space Optimized DP


class Solution {
    public int rob(int[] nums) {
        int prev2 = 0; // dp[i-2]
        int prev1 = 0; // dp[i-1]
        for (int money : nums) {
            int curr = Math.max(prev1, prev2 + money);
            prev2 = prev1;
            prev1 = curr;
        }
        return prev1;
    }
}

2. House Robber II (LeetCode Medium)

This problem extends the previous one by arranging houses in a circular manner.

The key observation was that the first and last houses cannot be robbed together. I discussed splitting the problem into two linear House Robber cases and taking the maximum result.

Recursive Solution


class Solution {

    public int rob(int[] nums) {
        int n = nums.length;

        if (n == 1) {
            return nums[0];
        }
        return Math.max(
                solve(nums, 0, n - 2),
                solve(nums, 1, n - 1)
        );
    }

    private int solve(int[] nums, int start, int end) {
        if (start > end) {
            return 0;
        }
        int rob = nums[start] + solve(nums, start + 2, end);
        int skip = solve(nums, start + 1, end);
        return Math.max(rob, skip);
    }
}

The interviewer seemed satisfied with both solutions and asked follow-up questions around optimization and edge cases.

Database Discussion

After the coding portion, the conversation shifted toward system fundamentals. Some questions included:

Difference between SQL and NoSQL databases
When would you choose NoSQL over SQL?
How Redis works internally
What happens if Redis is used as the only database?
Challenges with durability and persistence in Redis

The discussion became fairly conversational and we ended up discussing experiences from our respective companies as well.

Overall, this was one of the most comfortable DSA interviews I have attended. The interviewer focused heavily on fundamentals and problem-solving clarity rather than tricky questions.

Round 2 : System Design + Problem Solving

Interviewer: SDE-III (7 Years Experience) Duration: 75 Minutes Difficulty: Medium to Hard

This round was originally intended to be a System Design round, but surprisingly it started with a DSA problem. The interviewer was extremely supportive and frequently encouraged me to slow down and think carefully whenever I appeared rushed.

DSA Question

Given two arrays containing unique numbers:


arr1 = [2, 3, 5, 1]
arr2 = [4, 3, 5, 1, 9]

Determine whether there exists an array arr3 such that:

Both arr1 and arr2 are subsequences of arr3.
All elements in arr3 remain unique.

Example:

arr3 = [2, 4, 3, 5, 1, 9]

Answer = True

Second Example:


arr1 = [2, 3, 5, 1]
arr2 = [2, 3, 1, 5]

Answer = False

The underlying idea was to identify whether ordering constraints from both arrays create a cycle.

After discussing brute-force approaches, we modeled the ordering relationships as a directed graph and analyzed whether a valid topological ordering exists. The interviewer seemed more interested in how I modeled the problem than the final implementation itself.

My Algorithm

Build graph from both arrays.
Compute indegree of each node.
Run Kahn's Topological Sort.
If all nodes are processed → valid ordering exists.
Otherwise cycle exists → impossible.


import java.util.*;

class Solution {

    public boolean canConstruct(int[] arr1, int[] arr2) {
        Map<Integer, Set<Integer>> graph = new HashMap<>();
        Map<Integer, Integer> indegree = new HashMap<>();
        // Register all nodes
        for (int num : arr1) {
            graph.putIfAbsent(num, new HashSet<>());
            indegree.putIfAbsent(num, 0);
        }
        for (int num : arr2) {
            graph.putIfAbsent(num, new HashSet<>());
            indegree.putIfAbsent(num, 0);
        }
      
        buildEdges(arr1, graph, indegree);
        buildEdges(arr2, graph, indegree);
      
        Queue<Integer> queue = new LinkedList<>();

        for (int node : indegree.keySet()) {
            if (indegree.get(node) == 0) {
                queue.offer(node);
            }
        }

        int visited = 0;

        while (!queue.isEmpty()) {
            int curr = queue.poll();
            visited++;
            for (int next : graph.get(curr)) {
                indegree.put(next, indegree.get(next) - 1);
                if (indegree.get(next) == 0) {
                    queue.offer(next);
                }
            }
        }
        return visited == indegree.size();
    }

    private void buildEdges(int[] arr,
                            Map<Integer, Set<Integer>> graph,
                            Map<Integer, Integer> indegree) {

        for (int i = 0; i < arr.length - 1; i++) {
            int u = arr[i];
            int v = arr[i + 1];
            if (graph.get(u).add(v)) {
                indegree.put(v, indegree.get(v) + 1);
            }
        }
    }
}

System Design Discussion

The design question was Design a Ticket Booking System Similar to BookMyShow

Instead of asking for a complete design, the interviewer focused on specific engineering decisions and tradeoffs. This made the discussion much more practical and closer to real-world backend engineering.

Scenario 1: Handling High-Traffic Events

The interviewer asked: How would you improve user experience when millions of users try to book tickets for a popular event simultaneously? Some points discussed:

Virtual waiting rooms
Rate limiting
Queue-based admission
CDN caching
Read replicas
Event partitioning

We discussed how systems can prioritize fairness while maintaining availability under sudden traffic spikes.

Scenario 2: Seat Locking Problem

The next question was: Two users attempt to book the same seat at exactly the same time. How would the system handle this? This led to a detailed discussion around:

Seat reservation workflows
Temporary seat locking
Lock expiration
Distributed systems challenges
Race conditions

Optimistic vs Pessimistic Locking

The interviewer then explored database consistency approaches. Topics included:

Pessimistic Locking

Lock the seat immediately
Prevent concurrent modifications
Strong consistency
Reduced concurrency

Optimistic Locking

Version-based conflict detection
Better scalability
Retry mechanisms
Improved throughput

We also discussed where Redis could be used in the seat reservation workflow.

This was my favorite round of the process. The interviewer was extremely collaborative and treated the session more like a design discussion than an interrogation. I felt that the round focused on engineering judgment and real-world tradeoffs rather than textbook answers.

Round 3 : Culture Fit

Interviewer: Tech Lead (13 Years Experience) Duration: 30 Minutes Difficulty: Moderate

The final round was significantly different from the previous two. The interviewer joined slightly late and quickly started discussing business-oriented problem-solving scenarios.

Instead of asking technical implementation questions, he focused on understanding how I think about product and business challenges.

Discussion Topics

The conversation revolved around:

Product thinking
Business tradeoffs
Problem-solving approach
Working in high-growth environments
Team collaboration

Rather than completing one problem fully, the interviewer frequently switched contexts and introduced new scenarios. This made the round feel more like a rapid brainstorming session than a structured interview.

Relocation Discussion

Toward the end of the interview, we discussed:

Relocation to Gurgaon
Team preferences
Interest in different engineering domains
Long-term career goals

The round ended fairly abruptly because of time constraints.

Final Result

To be honest, I was somewhat concerned after the final round because it was difficult to gauge my performance. However, the recruiter called me the very next day and informed me that I had successfully cleared all rounds. Shortly afterward, I received the official offer letter.

Compensation Breakdown

Component	Amount
Fixed Salary	₹25 LPA
Joining Bonus (One-Time)	₹5 LPA
Total CTC (Year 1)	₹30 LPA

Overall Interview Experience

The entire hiring process was completed in approximately 10 days, which was one of the fastest recruitment experiences I have had.

What I Liked

Friendly interviewers
Focus on fundamentals rather than puzzle-style questions
Real-world system design discussions
Quick communication from recruiters
Fast turnaround on interview feedback

Preparation Areas That Helped

Dynamic Programming fundamentals
Database concepts (SQL, NoSQL, Redis)
Concurrency and locking mechanisms
Basic system design principles
Product and business-oriented thinking

Difficulty Rating

Round	Difficulty
Problem Solving	Medium
System Design	Medium-Hard
Culture Fit	Medium

Key Takeaways

If you are preparing for a Blinkit SDE-1 interview, focus less on solving extremely hard competitive programming problems and more on building strong fundamentals. Be comfortable with medium-level Dynamic Programming, database concepts, concurrency control mechanisms and practical system design discussions. Most importantly, be prepared to explain your thought process clearly, because the interviewers seem to value reasoning and engineering judgment more than memorized solutions.

Overall, I had a very positive experience throughout the process and am excited about the opportunity to work at Blinkit.