Groww SDE On-Campus 4-Round Breakdown for 2026 Prep

The 4-Round Groww SDE Process: What One Candidate Reported

The on-campus SDE hiring experience shared on GeeksforGeeks describes a structured 4-stage process from Groww's August 2020 drive. While this is a single candidate's account from a specific cycle, the round structure and question types are useful signal for anyone preparing for Groww in 2026.

Stage 1 was an online screening test. The test had 10 questions total: 9 MCQs and 1 programming problem. The MCQs covered time-complexity analysis, operating-systems fundamentals, threading concepts, and C++ basics. The source describes the coding task as a minimum-cost-for-tickets variant. It does not provide the full prompt, constraints, or input format, so this guide does not claim an exact match to a public problem.

About a week after the online test, 6 candidates were shortlisted for the next stage. That is a raw count from this candidate's 2020 campus account, not a fixed conversion rate. The source does not explain the shortlist decision or establish how another cycle works.

Technical Round 1 covered two DSA problems plus two logic puzzles. The DSA problems were detecting a loop in a linked list, which can be solved with two moving pointers, and finding the next greater element for each array value, which can be solved with a monotonic stack. The reported puzzles involved identifying one poisoned bottle with a limited number of rats and reasoning about newspaper page numbering.

Technical Round 2 was narrower and more focused. It centred on finding the minimum number of moves for a knight to reach a target square on a chessboard. Model the board positions as graph nodes and legal knight moves as edges, then use breadth-first search for an unweighted shortest path. The source does not publish the full constraints or an evaluation rubric.

The process closed with a 15-minute Managerial Round. The candidate described this round as primarily a conversation about company culture, role expectations, and general fit, rather than a technical evaluation. No coding or system design was asked in this round according to the account.

The original GeeksforGeeks post does not mention the CTC offered, eligibility cutoffs, or whether the candidate received a final offer. Treat the round structure as a historical prep map, not a guaranteed 2026 template. Follow the role notice, recruiter message, or campus instructions you receive for current details.

Round-by-Round Breakdown and 2026 Prep Map

Here is a consolidated table of the 4 rounds, what was asked, and how to prepare for each if you are targeting Groww in 2026.

Within this 2020 account, the question mix covered fundamental DSA, DP problem solving, operating systems, threading, complexity analysis, and logic puzzles. Those are useful preparation signals, but the source does not establish the breadth of a current Groww loop.

Question mix in this account:

• DP and graph traversal: 2 of the 4 reported programming problems (minimum cost for tickets, knight moves)
• Linked-list and stack reasoning: 2 of the 4 reported programming problems (linked-list cycle, next greater element)
• CS fundamentals: 9 MCQs covering OS, threading, complexity, C++
• Analytical puzzles: 2 logic riddles in Technical Round 1

For preparation based on this account, prioritise the reported gaps in your own skill set. The minimum-cost-for-tickets and knight-moves problems exercise DP and graph traversal, while the technical round also requires linked-list and stack fluency. The source supports this question mix only for its reported cohort.

A claim-safe prep map from the reported questions

If you are targeting a Groww SDE role, use the reported questions to find gaps in your preparation. Do not infer current eligibility, timing, or round structure from this account.

CS fundamentals and MCQ preparation

The reported online test had nine MCQs focused on time complexity, operating systems, threading, and C++. Review these areas before attempting a timed mixed set:

• Time complexity analysis: Practice deriving Big-O for recursive functions, nested loops, and divide-and-conquer algorithms. Know common complexity classes (O(n log n), O(n^2), O(2^n)) and identify them from code snippets.
• Operating systems: Focus on process scheduling, thread-versus-process differences, semaphores, mutexes, deadlocks, and memory-management basics. Use a current operating-systems text or course and verify each concept with worked examples.
• Threading: Understand race conditions, critical sections, thread synchronisation, and common concurrency pitfalls.
• C++ fundamentals: Know pointers, references, virtual functions, constructors, destructors, STL containers, and their time complexities.

DSA problem solving

Solve the specific problem types reported in this account, then expand only where a current role or a demonstrated gap justifies it:

• DP: Define the travel-day state, compare every allowed pass from that state, and explain the recurrence and base case.
• Linked lists: Derive why slow and fast pointers detect a cycle, including empty, single-node, and self-loop cases.
• Stacks: Trace how a decreasing stack finds the next greater value and decide how absent answers are represented.
• BFS on grids: Define legal knight moves, visited-state handling, unreachable cases, and the shortest-path argument.

Puzzles and logic

Logic puzzles showed up in Technical Round 1. For the reported bottle puzzle, define what one test outcome can encode and how the available tests constrain the search. For the newspaper puzzle, draw a physical sheet, pair page numbers, and state the invariant before calculating. These methods add substance without claiming that unrelated puzzles are part of Groww's current process.

Mock interviews and managerial preparation

• Run timed mock interviews with a peer or senior, focusing on explaining your approach before coding.
• Prepare honest behavioural examples about a technical challenge, teamwork, learning from failure, and your reason for applying to the specific role.
• Read the current role description and Groww's own product pages. Use only details you can point to when explaining why the role interests you.

Common Mistakes and Red Flags

• Ignoring the reported MCQ areas: The historical assessment included nine MCQs across time complexity, operating systems, threading, and C++. Review definitions and work through code-based examples instead of relying on recognition alone.
• Skipping puzzles: The reported first technical round included logic puzzles. Practice explaining a puzzle solution step by step, while remembering that a current loop may use different material.
• Not practising BFS with custom moves: The knight-moves task requires defining eight legal transitions, preventing revisits, and stating why the first reached distance is minimal.
• Neglecting the managerial discussion: The account reports a conversation of about fifteen minutes. Prepare truthful examples and use the current role description for motivation without guessing how answers are scored.
• Over-relying on this 2020 account: The source does not verify a current process. Use it as a question bank, then follow the role notice, recruiter guidance, and campus instructions for your own application.

Real-world data points

• 4 rounds in the Groww SDE on-campus process (candidate-reported, August 2020 drive, posted on GeeksforGeeks)
• 10 questions in the online screening test: 9 MCQs plus 1 coding problem
• 6 candidates shortlisted for technical rounds after the online test
• 2 DSA problems in Technical Round 1: linked list loop detection and next greater element
• 2 logic puzzles in Technical Round 1: poisoned bottle riddle and newspaper page numbering
• 1 DP/graph problem in Technical Round 2: knight minimum moves on a board
• 15 minutes approximate duration of the managerial round
• ~1 week gap between the online test and technical round shortlisting
• No CTC, cutoff, or final verdict disclosed in the source account

Sources & credits

• https://www.geeksforgeeks.org/interview-experiences/groww-software-development-engineer-interview-experience/