Interview experience
Flipkart Interview Questions and Answers (2026)
Overview
Section titled “Overview”Flipkart’s SDE loop is DSA-heavy at the screening stage but is best known for its machine coding round - building a small working application under time pressure - which most other product companies don’t run at all.
Flipkart interview process at a glance
Section titled “Flipkart interview process at a glance”| Round | Duration | What they test |
|---|---|---|
| Online Coding Assessment | 60-90 min | DSA + CS fundamentals on HackerRank |
| Technical/DSA Interview | 45-60 min | Live problem solving, optimizations |
| Machine Coding Round | 90-120 min | Building a working, extensible application |
| Low-Level Design (SDE-2+) | 45-60 min | OOP-based class design, edge cases |
| Hiring Manager/HR | 30 min | Ownership, culture fit, motivation |
Online Coding Assessment
Section titled “Online Coding Assessment”A 60-120 minute HackerRank (or Flipkart-platform) test with 2-4 DSA problems, medium-to-hard difficulty, often leaning on graphs and dynamic programming rather than easy array/string questions.
Common questions
- Number of Islands - count connected components in a grid (BFS)
- Longest Consecutive Sequence - O(n) approach using a hash set
- Word Ladder - shortest transformation sequence via BFS
- Design an LRU Cache with O(1) operations
Technical/DSA Interview
Section titled “Technical/DSA Interview”A 45-60 minute live coding round that mixes 1-2 DSA problems with a deep dive into your resume project - database design decisions, API design patterns, and performance optimizations you actually made.
Common questions
- Merge overlapping intervals, then discuss edge cases
- Course Schedule II - return a valid build order via topological sort, with a follow-up on detecting impossibility
- Walk through the architecture and your specific contribution on your flagship project
- Find the median in a data stream (two-heap approach)
Machine Coding Round
Section titled “Machine Coding Round”Flipkart’s defining stage: instead of one algorithm problem, you design and build a small working application in 90-120 minutes - for example a shopping-cart system with add/remove items, discount codes, and inventory checks. Interviewers grade the working solution, code quality, class design, and whether you wrote any tests.
Common questions
- Design a shopping cart / order system with a clean class hierarchy (Item, Cart, Discount)
- Design a parking-lot or rate-limiter style system with extensible rules
- Explain how you’d add a new feature to your solution without breaking existing code
- Handle edge cases: empty cart, invalid discount code, out-of-stock item
Round-by-round breakdowns are on the Flipkart interview experience page.
Low-Level Design (SDE-2+)
Section titled “Low-Level Design (SDE-2+)”For senior SDE roles, an additional 45-60 minute round on OOP-based system design - translating a real-world scenario into classes, interfaces, and relationships before any code is written.
Common questions
- Design the class structure for a flash-sale or inventory-management system
- Where would you use interfaces vs abstract classes in this design?
- How would you extend this design if a new requirement showed up tomorrow?
Hiring Manager/HR
Section titled “Hiring Manager/HR”A closing 30-45 minute round mixing a light technical-depth check with culture fit, ownership, and motivation questions. Senior candidates sometimes also field a system-design question here.
Common questions
- Why Flipkart?
- Tell me about your most challenging project
- How do you handle conflicting or ambiguous requirements when a spec isn’t fully defined?
- Where do you see yourself in three years?
Sample answer frameworks for each of these are on the Flipkart HR interview questions page.
Why the machine coding round matters
Section titled “Why the machine coding round matters”Most product companies test DSA and system design but skip a build-a-working-app stage entirely - Flipkart doesn’t. It’s graded less on cleverness and more on whether the code actually runs, handles edge cases, and could be extended later, which means practicing LeetCode alone under-prepares you for this specific round. Treat it as its own prep track: pick a small domain (cart, booking system, rate limiter), and practice building it end-to-end with basic tests in under 90 minutes.
Common technical interview questions and answers
Section titled “Common technical interview questions and answers”Q: How do you solve Number of Islands?
Treat the grid as a graph where every land cell is connected to its four orthogonal neighbours. Iterate over every cell; when you hit an unvisited land cell, increment the island count and run a BFS or DFS from it that marks every reachable land cell as visited - the common shortcut is to overwrite each visited cell with “0” so it is never revisited. Because each cell is processed a constant number of times, the complexity is O(rows times cols) time, with O(rows times cols) worst-case space for the queue or recursion stack when the entire grid is one island. Flipkart interviewers usually follow up with a variant: counting distinct island shapes, finding the largest island, or handling 8-directional connectivity, all of which only change the neighbour generation, not the overall approach.
Q: How do you find the Longest Consecutive Sequence in O(n)?
Put every number into a hash set so membership checks are O(1). Then iterate over the numbers, and for each value n check whether n - 1 is in the set: if it is, n is not the start of a run, so skip it. If it is not, n starts a sequence, so walk upward through n + 1, n + 2, and so on while each is present, counting the length, and keep the maximum. The skip check is what makes this O(n) overall rather than O(n squared) - every element is walked over at most once as part of exactly one sequence. Sorting first would also work but costs O(n log n), and the interviewer is explicitly asking for linear time. For the input 100, 4, 200, 1, 3, 2 the answer is 4, from the run 1, 2, 3, 4.
Q: How do you merge overlapping intervals?
Sort the intervals by start time, then sweep through them keeping a current merged interval. For each next interval, if its start is less than or equal to the current interval’s end, they overlap, so extend the current end to the maximum of the two ends; otherwise push the current interval to the result and start a new one from the next interval. Do not forget to push the final interval after the loop ends. Sorting dominates the cost at O(n log n) time, with O(n) space for the output. The edge cases worth naming out loud are touching intervals like (1,4) and (4,5) - whether they merge depends on whether the interviewer treats the endpoints as inclusive - fully nested intervals such as (1,10) and (2,3), and an empty input.
Q: How do you solve Course Schedule II with topological sort?
Model courses as nodes and each prerequisite pair as a directed edge from the prerequisite to the course. Use Kahn’s algorithm: compute the in-degree of every node, push all nodes with in-degree 0 into a queue, then repeatedly pop a node, append it to the ordering, and decrement the in-degree of each of its neighbours, enqueuing any that drop to 0. This runs in O(V + E) time and O(V + E) space. The impossibility follow-up falls straight out of the algorithm: if the final ordering contains fewer than the total number of courses, some nodes never reached in-degree 0, which means the graph has a cycle and no valid order exists - so return an empty array. A DFS-based topological sort with a recursion-stack cycle check is an equally valid answer.
Q: How do you find the median in a data stream?
Keep two heaps: a max-heap for the smaller half of the values and a min-heap for the larger half. On each insertion, push into the max-heap, move its top to the min-heap, and if the min-heap is now bigger than the max-heap move its top back - that rebalancing keeps the two halves sorted relative to each other and their sizes within one. The median is the max-heap’s top when the total count is odd, or the average of the two tops when it is even. Insertion is O(log n) and querying the median is O(1), using O(n) space. Naively sorting the collected values on every query would be O(n log n) per query, which is why maintaining the heap invariant is the expected answer.
Q: How would you structure the classes for a shopping cart in the machine coding round?
Start from the entities and their responsibilities, not the code. A Product holds id, name, and price; a CartItem pairs a Product with a quantity and can compute its own line total; a Cart owns a collection of CartItem objects and exposes add, remove, updateQuantity, and getTotal; an Inventory tracks available stock and is consulted before any add succeeds. Model discounts as a DiscountStrategy interface with an apply(total) method and concrete PercentageDiscount and FlatDiscount implementations, so adding a buy-one-get-one rule later means writing a new class rather than editing a switch statement. Keep the pricing calculation in one place, throw or return meaningful errors for out-of-stock and invalid-coupon cases, and write a handful of tests. Given the reported grading weights, a small design that runs and handles edge cases scores better than an elaborate one that does not compile.
Q: When do you use an interface versus an abstract class in a low-level design?
Use an interface to declare a capability that unrelated classes can share - Discountable, Serializable, PaymentMethod - since a class can implement many interfaces and this keeps the design open to extension. Use an abstract class when several classes are genuinely the same kind of thing and need to share state or a partial implementation: an abstract Order can hold orderId and createdAt fields and implement common logic while leaving calculateShipping() abstract for each subclass. The practical rule is that interfaces express “can do” relationships and abstract classes express “is a” relationships. Since Java allows only one superclass but many interfaces, prefer interfaces when in doubt - programming to an interface also makes the design easier to test with fakes, which matters when the round is graded partly on testability.
Q: How do you make a machine-coding design extensible for a new requirement?
Aim for the open/closed principle: the code should be open to extension but closed to modification, so a new requirement means adding a class rather than editing an existing one. Concretely, replace conditional chains over types with polymorphism - if adding a new discount type means adding a case to an if-else chain that computes prices, extract a strategy interface instead. Depend on abstractions rather than concrete classes, so the Cart takes a PricingEngine interface rather than instantiating a specific one, which also lets tests inject a stub. Keep each class to a single responsibility so a change in discount rules never forces you to touch inventory code. When you finish, interviewers commonly ask you to add a feature live, and a design built this way lets you answer by naming the one new class you would write.
Frequently asked questions about Flipkart interviews
Section titled “Frequently asked questions about Flipkart interviews”What is the Flipkart interview process for freshers?
Flipkart’s SDE process for freshers typically runs 4-5 rounds over 2-4 weeks: 1. Online Coding Assessment (60-90 minutes, sometimes up to 120) on HackerRank or Flipkart’s own platform, covering DSA and CS fundamentals. 2. Technical/DSA Interview (45-60 minutes), live problem solving with follow-up optimizations. 3. Machine Coding Round (90-120 minutes), building a working, testable console application rather than just an algorithm. 4. Low-Level Design round (45-60 minutes) for senior SDE roles, covering OOP-based system design. 5. Hiring Manager/HR round (30-45 minutes), mixing technical depth checks with culture fit.
What is Flipkart’s machine coding round?
The machine coding round is Flipkart’s signature interview stage: instead of solving a single algorithm problem, you design and build a small working application (like a shopping cart or parking lot system) within 90-120 minutes, with clean, extensible, testable code. Reported grading splits roughly as working solution 40%, code quality 30%, design 20%, testing 10% - it rewards a simple version that actually runs over an ambitious one that doesn’t.
What questions are asked in Flipkart interviews?
Flipkart interviews commonly cover DSA problems (arrays, graphs, dynamic programming - Number of Islands, Longest Consecutive Sequence, Word Ladder, Merge Intervals, Course Schedule II have all been reported), object-oriented low-level design, one machine coding exercise, and behavioural questions on ownership and handling ambiguity. Senior roles add system design questions around Flipkart-scale traffic, like a flash-sale or Big Billion Days-style order system.
How many rounds are there in the Flipkart interview?
Flipkart’s SDE interview process typically has 4-5 rounds: Online Assessment, Technical/DSA Interview, Machine Coding Round, Low-Level Design (for SDE-2+), and a Hiring Manager/HR round. The full process usually takes 2-4 weeks from application to offer.
How should I prepare for Flipkart interviews?
Practice 200+ medium-hard DSA problems with a strong focus on graphs and dynamic programming, since Flipkart’s OA and technical rounds skew harder than average. Separately, practice building a small working application end-to-end (classes, edge cases, basic tests) in 90 minutes for the machine coding round, and read up on e-commerce-flavoured system design - flash sales, inventory, order processing - for senior loops.
Is Flipkart’s process different for interns vs SDE-1 hires?
The core structure (OA, DSA interview, machine coding, HR) is largely shared, but internship-to-PPO conversions typically skip or shorten the Low-Level Design round, since that’s mainly used to bar-raise SDE-2 and above. Direct SDE-1 hires from campus go through the full loop including at least one system-design-flavoured technical round.