Interview experience
Groww Interview Questions and Answers (2026)
Overview
Section titled “Overview”Groww’s interview loop splits by entry path - a DSA-heavy Online Assessment for campus SDE hires versus a take-home assignment for off-campus/intern roles - before converging on two technical rounds and a Culture/HR close.
Groww interview process at a glance
Section titled “Groww interview process at a glance”| Round | Duration | What they test |
|---|---|---|
| Online assessment (campus) | 60-90 min | 1 medium + 1 hard DSA problem, ~12 MCQs on CN/DB/OS |
| Take-home (off-campus intern) | 24-72 hrs | Working demo, edge cases, stack fit |
| Technical 1 | ~60 min | More DSA + CS fundamentals / projects |
| Technical 2 / EM | ~60 min | Projects, light design, more DSA or stack depth |
| Culture / HR | 20-30 min | Why Groww, Bengaluru, how you get unstuck |
Online assessment / take-home
Section titled “Online assessment / take-home”Campus hires get a DSA-first OA - 1 medium (typically worth around 50 marks) and 1 hard problem (around 100 marks) plus roughly a dozen MCQs on computer networks, databases, and OS. Off-campus web/app intern tracks often swap this for a take-home assignment - a working demo or APK judged on completeness, not just DSA.
Common questions
- One medium and one hard DSA problem (arrays, trees, graphs, hash maps)
- MCQs on computer networks, databases, and operating systems
- Take-home track: build a small feature or app with a working demo, README, and edge-case handling
Technical interviews
Section titled “Technical interviews”Both tracks converge here: more DSA under time pressure, CS fundamentals, and a real deep-dive into your internship or project work. Off-campus candidates on web/React Native tracks get stack-specific machine-coding questions layered in.
Common questions
- Additional DSA problems (interviewers often re-probe the same topics from the OA)
- Backend/SQL/OS/OOP deep-dive tied to an internship project
- Rebuild Redux (or a similar state-management pattern) from scratch
- Design handling for multiple concurrent WebSocket connections
- Light system/feature design - trade-offs and why you chose them
Round-by-round breakdowns are on the Groww interview experience page.
Culture / HR round
Section titled “Culture / HR round”A closing 20-30 minute conversation on motivation and fit - candidate write-ups consistently flag “why Groww” (naming a real product surface, not “fintech unicorn”), willingness to join in Bengaluru, and a genuine story about debugging without help.
Common questions
- Tell me about yourself?
- Why Groww?
- Describe a feature or issue you owned end-to-end, from the first line of code to it running in production.
- Tell me about a time you chose a simpler design over a fancier one - what trade-off did you accept, and why?
- How do you get unstuck on a problem when there’s no senior engineer around to ask?
Sample answer frameworks for each of these are on the Groww HR interview questions page.
Common technical interview questions and answers
Section titled “Common technical interview questions and answers”Q: How would you rebuild Redux from scratch?
A minimal createStore holds a state variable and a listener array. dispatch(action) sets state = reducer(state, action) and then calls every listener; getState returns the current state; subscribe(fn) pushes the listener and returns an unsubscribe closure that splices it back out. Reducers must be pure functions that return a new object rather than mutating, because change detection relies on reference equality. Middleware is layered by wrapping dispatch in a chain of functions shaped store => next => action => result, which is exactly how redux-thunk intercepts a function-typed action and calls it with dispatch instead of forwarding it to the reducer.
Q: How would you handle multiple concurrent WebSocket connections in a trading app?
Prefer one multiplexed connection with a subscribe/unsubscribe protocol over a socket per symbol, because browsers cap connection counts and each socket costs a handshake and its own heartbeat. Wrap it in a singleton connection manager holding a topic-to-callback map so many components share one socket and unsubscribe on unmount. Add reconnection with exponential backoff plus jitter, a heartbeat ping to detect half-open connections, and a resubscribe step after every reconnect. On the render side, throttle or batch incoming ticks - a live price feed can emit far faster than the screen refreshes, so coalesce updates in a buffer and flush on an animation frame to keep the UI responsive.
Q: How do you detect a cycle in a directed graph?
Run DFS with three colours: white for unvisited, grey for nodes on the current recursion stack, and black for fully processed. If DFS ever reaches a grey node, that back edge closes a cycle. Complexity is O(V + E) time and O(V) space for the colour array and recursion stack. The iterative alternative is Kahn’s topological sort - if the produced order holds fewer than V nodes, the remainder forms a cycle. For undirected graphs the colour trick does not apply: use union-find, or DFS while ignoring the edge back to the immediate parent.
Q: How do you find the longest substring without repeating characters?
Use a sliding window with a map from character to its last seen index. Advance the right pointer one character at a time; when the current character was already seen at an index at or after the window’s left edge, jump the left edge to one past that index. Track the maximum window width as you go. This is O(n) time in a single pass and O(min(n, alphabet size)) space. The subtle bug interviewers watch for is letting the left pointer move backwards on a stale index - always take the maximum of the current left and the stored index plus one.
Q: What is the difference between var, let, and const in JavaScript?
var is function-scoped and hoisted with an initial value of undefined, so reading it before assignment yields undefined rather than an error. let and const are block-scoped and also hoisted but sit in the temporal dead zone, so reading them before the declaration throws a ReferenceError. const forbids reassigning the binding, not mutating the referenced object - you can still push into a const array. The classic trap is a loop declaring the counter with var and calling setTimeout inside: every callback logs the final value because all iterations share one binding, whereas let creates a fresh binding per iteration.
Q: What is the event loop, and how do microtasks differ from macrotasks?
JavaScript runs on a single thread with one call stack; asynchronous work is handed to the host environment and its callbacks are queued for later. The event loop takes one macrotask - a timer callback, an I/O callback, a UI event - runs it to completion, then drains the entire microtask queue before rendering or picking up the next macrotask. Promise continuations and queueMicrotask land in the microtask queue; setTimeout and setInterval land in the macrotask queue. That is why a promise resolved inside a timer logs before a second zero-delay timer, and why an unbounded chain of microtasks can starve rendering completely.
Q: How do TypeScript’s interface and type alias differ?
Both describe object shapes and both are erased at runtime, but interfaces support declaration merging - declaring the same interface twice merges its members, which is how library augmentation works - whereas a type alias cannot be redeclared. Type aliases are more expressive: they can name unions, intersections, tuples, primitives, mapped types, and conditional types, none of which an interface can express. Interfaces compose with extends; aliases compose with intersections. The practical convention is interface for public object contracts a consumer might augment, and type for unions and computed types.
Q: How should you approach a Groww take-home assignment?
Read the brief for the graded axes first - usually a working demo, edge-case handling, and code quality - and optimise for those rather than for feature count. Structure the project with clear separation between data fetching, state, and presentation, keep components small and typed, and handle the three states every async view needs: loading, empty, and error. Cover the edge cases explicitly - empty result sets, network failure with retry, debounced search input, pagination - because that is where most submissions lose marks. Ship a README stating how to run it, what you deliberately left out, and what you would do next; reviewers often weigh that note as heavily as the code.
Frequently asked questions about Groww interviews
Section titled “Frequently asked questions about Groww interviews”What is the Groww interview process for freshers?
Groww’s process depends on the track: campus hires usually start with an Online Assessment (60-90 minutes - 1 medium and 1 hard DSA problem plus around 12 MCQs on CN/DB/OS), while off-campus intern applicants often get a take-home assignment (24-72 hours) instead. From there it’s two technical rounds (around 60 minutes each) covering DSA, CS fundamentals, and project/stack depth, followed by a Culture/HR round (20-30 minutes).
What questions are asked in Groww interviews?
Groww interviews cover competitive-programming-adjacent DSA (arrays, trees, graphs, hash maps), take-home coding assignments testing a working demo and edge-case handling for off-campus roles, project deep-dives (especially internship work), and questions on ownership (features you drove end-to-end) and simplicity in design trade-offs, reflecting Groww’s product-simplicity culture.
How many rounds are there in the Groww interview?
Groww typically runs 4 rounds: an Online Assessment or take-home assignment, two technical/engineering-manager rounds, and a Culture/HR round. Exact structure varies by whether you’re a campus or off-campus/intern candidate - some off-campus loops report an extra machine-coding or low-level-design round.
Does Groww’s interview process differ for web/app intern roles?
Yes. Off-campus web and React Native intern tracks often start with a take-home assignment (a working demo or APK, sometimes graded on TypeScript code quality) instead of a DSA-only OA, then move into a stack-heavy technical round - JS/TypeScript output questions, Redux-from-scratch, or multi-WebSocket design - before culture fit. Campus SDE hiring is closer to a standard DSA-first loop.
How should I prepare for Groww interviews?
For Groww, practice medium-to-hard DSA (arrays, trees, graphs, hash maps) under time pressure, be ready to build and explain a small working project if you’re on the take-home track, prepare a clear story with a real metric about a feature you owned end-to-end, and think through why you’d choose a simpler design over a more complex one.