Explore: Interview experience · HR interview questions · Overview · Placement papers · Preparation guide
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.
Interview experience
Flipkart interview experiences covering Online Coding Assessment, Technical/DSA Interview, Machine Coding Round, Low-Level Design (SDE-2+), +1 more. Round-wise notes, common questions, and what candidates report clears each stage.
HR interview questions
Flipkart HR interview questions with sample answer frameworks - motivation, relocation, STAR stories, and culture-fit prompts.
| 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 |
These answers are compiled from public candidate reports and prep guides, not from an official Flipkart notice, and drives differ. The instruction screen of your own test is the final word.
| Question | Answer |
|---|---|
| How many questions and how long? | Usually 3 DSA coding problems in 90 minutes. Most 2024-2025 reports describe a mix such as 1 easy, 1 medium, 1 hard or 2 medium and 1 hard. Some campus drives run longer papers with a debugging section. |
| Does it have negative marking? | No public report mentions any. It is a coding test scored on hidden test cases, and candidates report partial credit for partially passing solutions. |
| Is there a sectional cutoff? | No. With only coding problems there are no sections to clear separately. |
| How much is the cutoff? | Not published; shortlists are relative to the batch. A 2025 Glassdoor report says solving about 2.5 to 3 problems gets you through. Eligibility is not officially fixed either: PrepInsta says about 7.0 CGPA is often preferred, other reports cite 6.5+, with no current backlogs. |
| Which platform is it on? | HackerRank, in most reports. Some 2025 candidates say the later live interviews were held on HirePro. |
| Which languages can I use? | The usual HackerRank set, so Java, C++ and Python are all safe. Pick the one you can write fastest without an IDE. |
| Are the questions hard? | Medium to hard. Graphs, DP and BFS-style problems appear more often than easy array questions, and one 2024 candidate noted the problem statements were worded confusingly, so read each one twice. |
| Is GRiD the same as the campus OA? | No. Flipkart GRiD is a separate national contest with its own screening, coding and case-study stages; see the comparison further down this page. |
These are topics candidates report on Glassdoor, LeetCode Discuss and GfG for Flipkart’s campus and early-career roles. They show the level and style, not a fixed list.
| Role | Reported questions and topics |
|---|---|
| SDE-1 (campus and off-campus) | 3-problem OA, then a problem-solving round of 1-2 DSA questions (graphs, DP, intervals, heaps) with complexity follow-ups, and a hiring-manager round on projects. Some 2024 off-campus loops had no separate machine coding round. |
| SDE-1 / SDE-2 machine coding | About 2 hours to build a console app with clean classes and edge cases: conference-room booking across buildings and floors, a Facebook-style feed with upvotes and ranking, a Kindle-style book reader with a 2-book borrowing limit, library management, or a food-ordering system. |
| SDE intern | OA, then 1-2 DSA interviews; strong interns convert through a pre-placement offer rather than a full SDE loop. |
| Business / data analyst | An aptitude test covering SQL, logical reasoning and statistics; a SQL-heavy technical round (joins, UNION vs UNION ALL, window functions, top-N queries); a problem-solving round with guesstimates such as estimating the sweet shops in your hometown, puzzles and a short case. |
Asked across every role: a detailed walk through your strongest project, why Flipkart specifically, and how you handled an ambiguous requirement.
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
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
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.
Public 2025-2026 reports add in-memory console apps with a driver and test cases, often no HTTP or real database - quick-commerce delivery (customers, partners, orders), flight or appointment booking with slot rules, wallets, or a distributed task scheduler with concurrency follow-ups. A separate evaluation round walks your zip submission and asks about patterns, production gaps, and race conditions.
Common questions
Round-by-round breakdowns are on the Flipkart interview experience page.
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
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
Sample answer frameworks for each of these are on the Flipkart HR interview questions page.
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.
Flipkart GRiD is a national engineering contest for students, not a normal recruitment drive. Recent editions run in stages - a profile screening on academics and achievements, a coding assessment, a case study with code, and national finals - and strong performers can be considered for internships and pre-placement interviews.
Regular campus and off-campus SDE-1 hiring is a standard recruitment loop: one 90-minute coding OA, then live DSA, machine coding or design, and a hiring-manager round. This page covers that regular hiring loop. If you entered through GRiD, check the GRiD stage notice for your edition, because the round format there is different and changes every year.
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.
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.
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.
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.
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.
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.
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.
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.
Model words as nodes and connect two words with an edge if they differ by exactly one letter. BFS from beginWord to endWord finds the shortest transformation sequence because BFS explores level by level. Use a queue of (word, path length) pairs and a visited set so you never reprocess a word. For each dequeued word, generate neighbours by changing each character to every letter a-z and enqueue unvisited matches that appear in the word list. If endWord is never reached, return 0 or an empty path per the prompt. Time is roughly O(N times L times 26) for N words of length L in the dictionary, with space O(N) for visited. Flipkart OAs and technicals use this as a graph problem cousin to grid BFS.
Combine a hash map from key to list node with a doubly linked list ordered by recency. The map gives O(1) lookup; the list lets you move a node to the most-recent side or evict the tail in O(1) because unlinking a known node does not require scanning. On get, return -1 if missing; otherwise move the node to the head and return its value. On put, update an existing node and move it to the head, or insert a new head node and, if size exceeds capacity, remove the tail node and delete its key from the map. Singly linked lists fail because removing an arbitrary node needs the predecessor pointer. This pattern appears in Flipkart technical rounds when interviewers want design trade-offs, not only LeetCode acceptance.
No public report mentions negative marking. The Flipkart SDE online test is a coding test - usually 3 DSA problems in 90 minutes on HackerRank - scored on hidden test cases, and candidates report partial credit for partially passing solutions.
Not published; shortlists are relative to the batch. Candidate reports say solving about 2.5 of the 3 problems is usually enough to move on. For eligibility, PrepInsta says no official CGPA minimum is stated but around 7.0 is often preferred, other reports cite 6.5+, and there should be no current backlogs.
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.
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.
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.
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.
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.
Only slightly. 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.
| Stage | Strong signal | Weak signal |
|---|---|---|
| OA | 2-3 DSA + debugging finished cleanly | Partial submissions with no tests |
| DSA rounds | Medium-hard trees/graphs/DP with complexity | Silent coding; no edge cases |
| Machine coding / design | Working OOP app + extensibility talk | Spaghetti that cannot add a filter |
| Team Fit / HM | Ownership under sale-event load + customer impact | Generic e-commerce praise |
Flipkart’s machine-coding evaluation often asks what you would change for production and peak events (Big Billion Days style load). Build for clarity first, then extensions.
Use this as a default four-week loop before a Flipkart drive. Adjust to your invite timeline.
10-day crash version: Days 1-4 timed DSA, days 5-7 resume projects + CS fundamentals, days 8-9 mock interviews out loud, day 10 HR STAR stories on the HR page.
Candidate-reported fresher/early-career packages for Flipkart often cite ₹22-28 LPA SDE-1. Treat forum numbers as ranges, not guarantees - confirm the written offer letter for your team and location.
Interview process details and sample questions on this site are editorially organized from public candidate reports and hiring write-ups, with round structure, prep notes, and company-specific framing added by our team. For round-by-round stories, see the Flipkart interview experience page. For OA papers and coding drills, use Flipkart on placementpapers.app. OA quick answers and role-wise questions draw on PrepInsta’s Flipkart eligibility and test-pattern page, Glassdoor candidate reviews for Flipkart SDE and analyst roles, LeetCode Discuss and GfG Flipkart SDE-1 interview experiences, and public Flipkart GRiD round guides.
