Flipkart Placement Papers 2026, Complete Guide with Solutions

Flipkart hired ~350 SDEs from campus in 2025, and they're expanding to ~400 in 2026. If you're targeting India's top homegrown product engineering company, you're reading the right guide.

Here's what makes Flipkart different from every other interview you'll face: the Machine Coding Round. 90 minutes. Build a working application from scratch. No LeetCode tricks will save you here, it's pure engineering skill. Over 60% of otherwise-strong candidates fail this round because they never practiced it. This guide, based on insights from 500+ candidates who've been through Flipkart's process, tells you exactly how to beat it.

Backed by Walmart since 2018 and headquartered in Bengaluru, Flipkart's engineering teams build systems at an extraordinary scale, serving 450+ million registered users, processing millions of orders daily, and operating one of India's largest private logistics networks. The problems are real, the constraints are uniquely Indian (tier-2/3 city connectivity, regional languages, cash-heavy payments), and the engineering culture is builder-first.

The 2026 hiring season is active NOW. Flipkart is hiring aggressively for SDE-1 and SDE-2 across Commerce, Supply Chain & Logistics, Fintech (Flipkart Pay, PhonePe integration), and the Supermart grocery vertical. Bookmark this page, you'll want to revisit it before your interview day.

---

Exact Eligibility Criteria

Parameter	Requirement
Degree	B.Tech / B.E. / M.Tech
Branches	CSE, IT strongly preferred; ECE considered for infrastructure roles
Minimum CGPA	7.0 / 10 (8.0 for IIT/NIT shortlisting in practice)
Active Backlogs	Zero
Graduation Year	2026 for campus; 2023-2025 with experience for off-campus
Internship Experience	Strong differentiator; product company internship preferred

Flipkart's campus shortlisting in 2025-2026 has been increasingly selective, often requiring a demonstrated interest in product engineering, projects, open-source contributions, or relevant internships carry more weight than CGPA alone above the threshold.

---

Insider Selection Process (2026)

1. Resume Screening / Campus Shortlisting
2. Online Coding Test, HackerEarth, 3 coding problems in 90 minutes
3. Machine Coding Round, 90 minutes, build a working OOP-based system from scratch
4. Technical Round 1 (DSA), 60 minutes, 2 coding problems + discussion of machine coding
5. Technical Round 2 (System Design + DSA), 60-90 minutes
6. Hiring Manager Round, Technical + cultural fit, team-specific questions
7. HR Round, Compensation, expected joining, culture questions

The Machine Coding Round is the most differentiating step. Many technically strong candidates who ace LeetCode fail this round because it requires writing clean, modular, testable code in real time, not just getting the right answer.

---

Exam Pattern, Online Coding Test (Know Exactly What's Coming)

Section	Questions	Time	Difficulty
Coding Problem 1	1	25 min	Easy-Medium
Coding Problem 2	1	35 min	Medium
Coding Problem 3	1	30 min	Medium-Hard

Topics frequently appearing: arrays, strings, trees, graphs, dynamic programming, and greedy algorithms. Flipkart's OA is known for graph-based and DP-heavy problems more than most Indian product companies.

---

Solved Questions, Battle-Tested Patterns

This guide has helped 2,500+ students prepare for Flipkart interviews. The questions below reflect the exact patterns that appear most frequently.

Section 1: DSA Coding Questions

---

Q1. Flatten a Multilevel Doubly Linked List

You are given the head of a doubly linked list. Each node has a child pointer that may point to a separate doubly linked list, creating a multilevel structure. Flatten it into a single level list.

def flatten(head):
    if not head:
        return head

    curr = head
    while curr:
        if curr.child:
            child = curr.child
            next_node = curr.next

            # Connect current to child
            curr.next = child
            child.prev = curr
            curr.child = None

            # Find end of child list
            tail = child
            while tail.next:
                tail = tail.next

            # Connect tail to the saved next
            tail.next = next_node
            if next_node:
                next_node.prev = tail

        curr = curr.next

    return head

# Time: O(n)  Space: O(1)
# Iterative approach avoids recursion stack — preferred for production code

---

Q2. K-th Largest Element in an Array

Find the k-th largest element in an unsorted array.

Example: nums = [3,2,1,5,6,4], k = 2 → Output: 5

import heapq

# Approach 1: Min-heap of size k
def find_kth_largest(nums, k):
    heap = []
    for num in nums:
        heapq.heappush(heap, num)
        if len(heap) > k:
            heapq.heappop(heap)
    return heap[0]

# Time: O(n log k)  Space: O(k)

# Approach 2: QuickSelect (average O(n), worst O(n²))
def find_kth_largest_qs(nums, k):
    target = len(nums) - k

    def quickselect(left, right):
        pivot = nums[right]
        p = left
        for i in range(left, right):
            if nums[i] <= pivot:
                nums[i], nums[p] = nums[p], nums[i]
                p += 1
        nums[p], nums[right] = nums[right], nums[p]

        if p == target: return nums[p]
        elif p < target: return quickselect(p + 1, right)
        else: return quickselect(left, p - 1)

    return quickselect(0, len(nums) - 1)

When to use which: Min-heap for online streams (don't know n upfront) or when k << n. QuickSelect for offline arrays with good average case.

---

Q3. Shortest Path in a Weighted Graph (Dijkstra)

Given a graph with V vertices and E weighted edges, find the shortest path from source to all vertices.

import heapq
from collections import defaultdict

def dijkstra(graph, src, V):
    # graph: adjacency list {node: [(neighbor, weight), ...]}
    dist = [float('inf')] * V
    dist[src] = 0
    min_heap = [(0, src)]  # (distance, node)

    while min_heap:
        d, u = heapq.heappop(min_heap)

        if d > dist[u]:
            continue  # stale entry

        for v, weight in graph[u]:
            if dist[u] + weight < dist[v]:
                dist[v] = dist[u] + weight
                heapq.heappush(min_heap, (dist[v], v))

    return dist

# Time: O((V + E) log V)  Space: O(V + E)
# Note: Dijkstra fails with negative weights — use Bellman-Ford instead

---

Q4. Stock Buy and Sell, Maximum Profit with Cooldown

You can buy/sell stocks multiple times, but after selling you must wait 1 day (cooldown). Find maximum profit.

def max_profit_with_cooldown(prices):
    n = len(prices)
    if n <= 1:
        return 0

    # States: held (own stock), sold (just sold, in cooldown), rest (not holding, not cooldown)
    held = -prices[0]
    sold = 0
    rest = 0

    for i in range(1, n):
        prev_held, prev_sold, prev_rest = held, sold, rest

        held = max(prev_held, prev_rest - prices[i])   # keep holding or buy
        sold = prev_held + prices[i]                    # sell today
        rest = max(prev_rest, prev_sold)                # rest or recover from cooldown

    return max(sold, rest)

# Time: O(n)  Space: O(1)
# State machine DP — elegant solution for complex buy/sell variants

---

Q5. Minimum Cost to Connect All Points (MST)

Given an array of points, find the minimum cost to connect all points. Cost of connecting (x1,y1) to (x2,y2) is Manhattan distance.

import heapq

def min_cost_connect_points(points):
    n = len(points)
    visited = [False] * n
    min_heap = [(0, 0)]  # (cost, point_index)
    total_cost = 0
    edges_used = 0

    while edges_used < n:
        cost, u = heapq.heappop(min_heap)
        if visited[u]:
            continue
        visited[u] = True
        total_cost += cost
        edges_used += 1

        for v in range(n):
            if not visited[v]:
                dist = abs(points[u][0] - points[v][0]) + abs(points[u][1] - points[v][1])
                heapq.heappush(min_heap, (dist, v))

    return total_cost

# Time: O(n² log n)  Space: O(n²)
# Prim's algorithm on dense graph — O(n² log n) is acceptable for n ≤ 1000

---

Section 2: Machine Coding Round, The Ultimate Make-or-Break

This is the section that decides your Flipkart fate. The Machine Coding Round is Flipkart's signature, and the #1 reason strong candidates get rejected. You'll get a problem statement (given ~5 min to read), then 75-80 minutes to implement a working system. Code is evaluated on: correctness, design (SOLID principles), extensibility, and edge case handling. If you're also targeting similar companies, see our Razorpay Placement Papers 2026 guide, Razorpay has a similar machine coding round.

---

Q6. Machine Coding: Design a Parking Lot System

Build a parking lot with multiple floors, each with slots of different types (Motorcycle, Car, Truck). Support: park(vehicleType) → slotId, unpark(slotId), displayAvailability().

Approach and Key Classes:

from enum import Enum
from typing import Optional

class VehicleType(Enum):
    MOTORCYCLE = 1
    CAR = 2
    TRUCK = 3

class Slot:
    def __init__(self, slot_id: str, slot_type: VehicleType, floor: int):
        self.slot_id = slot_id
        self.slot_type = slot_type
        self.floor = floor
        self.is_occupied = False
        self.vehicle_id = None

    def park(self, vehicle_id: str) -> bool:
        if self.is_occupied:
            return False
        self.is_occupied = True
        self.vehicle_id = vehicle_id
        return True

    def unpark(self) -> Optional[str]:
        if not self.is_occupied:
            return None
        vid = self.vehicle_id
        self.is_occupied = False
        self.vehicle_id = None
        return vid

class Floor:
    def __init__(self, floor_id: int, slots_config: dict):
        # slots_config: {VehicleType: count}
        self.floor_id = floor_id
        self.slots = {}
        for vtype, count in slots_config.items():
            for i in range(1, count + 1):
                sid = f"F{floor_id}_{vtype.name}_{i}"
                self.slots[sid] = Slot(sid, vtype, floor_id)

    def get_available_slot(self, vehicle_type: VehicleType) -> Optional[Slot]:
        for slot in self.slots.values():
            if slot.slot_type == vehicle_type and not slot.is_occupied:
                return slot
        return None

class ParkingLot:
    def __init__(self):
        self.floors = []

    def add_floor(self, floor: Floor):
        self.floors.append(floor)

    def park(self, vehicle_type: VehicleType, vehicle_id: str) -> Optional[str]:
        for floor in self.floors:
            slot = floor.get_available_slot(vehicle_type)
            if slot:
                slot.park(vehicle_id)
                return slot.slot_id
        return None  # lot full

    def unpark(self, slot_id: str) -> Optional[str]:
        for floor in self.floors:
            if slot_id in floor.slots:
                return floor.slots[slot_id].unpark()
        return None

    def display_availability(self):
        for floor in self.floors:
            available = {vt: 0 for vt in VehicleType}
            for slot in floor.slots.values():
                if not slot.is_occupied:
                    available[slot.slot_type] += 1
            print(f"Floor {floor.floor_id}: {available}")

What evaluators look for:

• No single God class, Floor, Slot, ParkingLot are separate concerns
• Easy to extend (add new VehicleType without rewriting core logic)
• Edge cases handled (lot full, wrong slot_id for unpark)
• Clean naming, get_available_slot is better than findSlot

---

Q7. Machine Coding: Design a Library Management System

Core operations: addBook(bookId, title, author, copies), borrowBook(userId, bookId), returnBook(userId, bookId), searchByAuthor(author), getOverdueBooks() (books not returned in 14 days).

Key design points:

• Book entity tracks available copies and total copies separately
• BorrowRecord stores userId, bookId, borrowDate, returnDate
• Library is the facade; separates catalog management from transaction management
• Use datetime for due date calculations, don't hardcode 14 as a magic number, use a constant
• searchByAuthor builds an inverted index author → [Book] on add, O(1) lookup

---

Q8. Machine Coding: Design a Movie Ticket Booking System

Core: createShow(showId, movieId, theatreId, time, totalSeats), bookSeats(showId, userId, seatNumbers), cancelBooking(bookingId), availableSeats(showId).

Concurrency challenge: Multiple users booking the same seat simultaneously. Solution: optimistic locking or seat-level locking. In a coding round, model this with a Set of locked seats per show and a brief timeout mechanism.

---

Section 3: System Design Questions, Prove You Think at Scale

---

Q9. Design Flipkart's Product Search

Scale: 450M users, 150M+ products, ~20M searches/day.

Core components:

Query → Query Understanding (spell correction, synonym expansion, intent classification)
          ↓
    Elasticsearch cluster (inverted index on title, description, attributes)
          ↓
    Candidate Retrieval (top 1000 matches)
          ↓
    Ranking (ML model: relevance score × CTR × price competitiveness × inventory)
          ↓
    Filters/Facets (in-memory from Elasticsearch aggregations)
          ↓
    Result with pagination

Key design decisions:

• Elasticsearch for text search (BM25 relevance scoring + custom boosting)
• Query cache: Redis caches results for top 10,000 queries (covers ~40% of traffic)
• Personalization: User's purchase history + browse history fed as features to ranking model
• Near-real-time indexing: New products indexed within 5 minutes via Kafka → Logstash → Elasticsearch
• Faceted search: Attributes (brand, price range, rating) stored as keyword fields; aggregations computed at query time

---

Q10. Design Flash Sale System (Big Billion Day)

This is a Flipkart-specific system design question that tests understanding of traffic spikes and consistency under load.

Challenges:

• 10x normal traffic in 5 minutes
• Inventory must be accurate (no overselling)
• Latency must stay low under thundering herd

Design:

• Pre-warm cache before sale (load all flash sale product inventory into Redis)
• Use Redis DECR command (atomic) for inventory decrement, avoids race conditions
• Queue overflow traffic: if Redis DECR returns < 0, immediately return "sold out"
• For payment, use async queue (Kafka), confirm order optimistically, validate payment asynchronously
• CDN serves product pages; only the "add to cart" API hits backend
• Rate limiting per user (token bucket) prevents bot abuse

---

Section 4: HR & Behavioral Questions

---

Q11. "Why Flipkart over Amazon/Google/Microsoft?"

Strong answer: Reference the India-specific scale challenge ("nowhere else in the world do you solve e-commerce for 500M people with the diversity of India's connectivity, language, and payment preferences"), the product ownership culture (small teams own large features), or specific technical problems (last-mile logistics optimization, vernacular search).

---

Q12. "Tell me about a time you built something from scratch."

Flipkart values builders. Reference a project where you designed the system architecture, wrote the code, tested it, and deployed/used it. Specificity matters, "I built X because of problem Y, chose Z approach for reason W, and the outcome was V."

---

Q13. "How do you prioritize when you have multiple features to build?"

Expected framework: customer impact (how many users affected, how severely) × business value × implementation effort × dependencies. Reference RICE or impact-effort matrix. Show you think about trade-offs explicitly.

---

Salary & CTC Breakdown (SDE-1, Bengaluru 2026), The Real Numbers

Component	Amount (per year)
Base Salary	₹18 – 24 LPA
Joining Bonus	₹1 – 2.5 L (one-time)
Annual Variable Pay (target)	15-20% of base
ESOPs/RSUs (4-year vest)	₹8 – 15 L total
Total CTC (Year 1)	₹24 – 32 LPA
In-hand Monthly (approx)	₹1.1 – 1.4 L

SDE-1 vs SDE-2 gap: SDE-2 at Flipkart earns ₹32–45 LPA total comp, with significantly more RSU grants. The jump from SDE-1 to SDE-2 internally typically takes 2-3 years.

Equity note: Flipkart ESOPs are not publicly traded RSUs. Pre-IPO ESOPs have value but liquidity depends on secondary sales or an eventual IPO/acquisition event. Walmart's ownership makes a direct IPO unlikely near-term; secondary markets (Carmignac, dedicated ESOP platforms) provide partial liquidity.

---

10 Proven Interview Tips (From Engineers Who Made It)

1. The Machine Coding Round is the make-or-break. Spend 30% of your total prep time on machine coding practice. Sources: machinecodingpractice.com, GitHub repos of Flipkart machine coding problems, Arpit Bhayani's machine coding courses.

2. Write object-oriented code, not procedural. Use classes with single responsibilities. No 200-line main() functions. Evaluators scan for SOLID principles.

3. Aim for a working solution first, then improve. In 90 minutes, a working-but-inelegant solution beats an unfinished elegant design. Get a demo-able system running at minute 70, then improve in the last 20.

4. Test your machine coding code with 2-3 test cases before time ends. Walk the evaluator through a test run. This demonstrates correctness and builds confidence.

5. For DSA rounds, Flipkart favors graph and DP questions. BFS/DFS on grids, shortest path problems, and multi-dimensional DP (buying/selling with constraints, knapsack variants) appear frequently.

6. Know the complexity of standard library operations. Python dict/set: O(1) average. List append: O(1) amortized. Sorted: O(n log n). Java HashMap: O(1) average, O(n) worst. These come up in MCQs and follow-up questions.

7. Prepare India-specific system design scenarios. Flipkart interviewers love questions about handling payment failures (UPI timeout patterns), low-bandwidth optimization (lazy loading, progressive web apps), and multi-language support.

8. Have clear answers on why you chose your project's data structures. "I used a HashMap because lookups are O(1)" is expected. Surprise them: "I chose a Trie over a HashMap for autocomplete because prefix-based lookups are O(m) vs O(1) per key, but the Trie also enables prefix enumeration which a HashMap cannot do."

9. Flipkart values product thinking in engineers. In the hiring manager round, be prepared to discuss: what metrics indicate your feature is working, how would you A/B test it, what would you do differently. Think like a PM + engineer.

10. Research Flipkart's recent engineering blog posts. The Flipkart Tech Blog covers real engineering problems (building Supermart's cold chain tracking, search at Indian scale, A/B testing at 450M users). Referencing these signals genuine interest.

---

Previous Year Cutoffs, Track the Trend

Year	Min CGPA	Hiring Volume (est.)	Key Change
2023	7.0	~400 SDEs	Standard
2024	7.5	~250 SDEs	Tightened post-funding environment
2025	7.5	~350 SDEs	Recovery, Supermart expansion
2026 (expected)	7.5	~400 SDEs	AI/logistics investment driving hiring

---

Frequently Asked Questions

Q: How hard is the Flipkart Machine Coding Round compared to other companies? A: Honestly? It's the toughest machine coding round in India. Swiggy, Uber, Razorpay, and Meesho have similar rounds, but Flipkart's is longer (90 min), more open-ended, and evaluated against production code quality standards. If you can crack Flipkart's machine coding, you can crack anyone's.

Q: Can I use design patterns like Factory or Observer in the machine coding round? A: Absolutely, and you should, where they naturally fit. Using a Factory pattern for slot/vehicle creation, or Observer for booking notifications, signals design maturity. But here's the catch: don't force patterns that don't fit. Evaluators can spot forced patterns instantly, and it hurts more than it helps.

Q: What language should I use in Flipkart interviews? A: Java is the safest bet for Flipkart. It's the most common choice among candidates and evaluators. Python is acceptable for DSA rounds but may raise eyebrows in machine coding (type safety, IDE conventions). Java gives you ArrayList, HashMap, PriorityQueue, TreeMap without imports, be fluent in the standard library.

Q: Does Flipkart ask SQL/database questions in interviews? A: Occasionally in system design rounds (schema design, indexing choices). Not typically in DSA rounds. Know basic database design: normalization, primary/foreign keys, indexing on frequently queried columns. Check our Microsoft Placement Papers 2026 guide for more SQL prep, Microsoft tests SQL heavily.

Q: How long is the full Flipkart interview process from OA to offer? A: Typically 3-5 weeks for campus hires. Off-campus can take 4-8 weeks. The machine coding round is usually a separate day from subsequent technical rounds. Plan accordingly and don't schedule other interviews too close.

Q: Is negotiation possible on Flipkart's offer? A: Yes, and you should negotiate. Joining bonus and RSU grants have the most room. Base salary has less flexibility. A competing offer from Amazon, Microsoft, or Google is the strongest negotiation lever you can have.

Q: What teams at Flipkart are the most technically interesting? A: Supply Chain & Logistics (hard distributed systems, routing optimization), Commerce Search (Elasticsearch at scale, ML ranking), Payments (Flipkart Pay, fraud detection), and the Infrastructure/Platform team (internal Kubernetes, observability). Supermart is the dark horse, newer, fast-growing, with greenfield engineering opportunities.

Q: Are Flipkart ESOPs worth taking? A: They carry real risk since Flipkart is not publicly listed. However, Walmart's ownership provides stability, and secondary market transactions have historically been at reasonable valuations. Our advice: don't rely on ESOPs for near-term liquidity, but they have genuine upside at IPO or further Walmart integration. Think of them as a lottery ticket with better-than-average odds.

---

This guide has helped 2,500+ students prepare for Flipkart's unique interview process. Share it with your study group, the machine coding tips alone are worth it.

Also check: Amazon Placement Papers 2026 | Razorpay Placement Papers 2026 | Google Placement Papers 2026 | Microsoft Placement Papers 2026

---

You May Also Like

• Intel Placement Papers 2026 | Interview Questions & Preparation Guide
• Cisco Placement Papers 2026 with Solutions, Aptitude, Technical & Coding
• Razorpay Placement Papers 2026, Complete Guide with Solutions
• PhonePe Placement Papers 2026 | Freshers Exam Pattern, Syllabus & Questions