Interview experience
Groww interview experiences covering Online assessment (campus), Take-home (off-campus intern), Technical 1, Technical 2 / EM, +1 more. Round-wise notes, common questions, and what candidates report clears each stage.
Groww Interview Questions and Answers (2026)
Groww is a Bengaluru-based investment platform that lets users trade stocks, mutual funds, F&O, and other financial products through a simple mobile app. Founded in 2016, it is known for a rigorous SDE hiring process that expects strong data structures and algorithms skills.
Explore: Interview experience · HR interview questions · Overview · Placement papers · Preparation guide
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.
HR interview questions
Groww HR interview questions with sample answer frameworks - motivation, relocation, STAR stories, and culture-fit prompts.
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 |
Groww online assessment: quick answers
These answers are compiled from public candidate reports and prep guides, not from an official notice, and drives differ. The instruction screen of your own test is the final word.
| Question | Answer |
|---|---|
| How many questions and how long? | Campus SDE OAs are usually 60-90 minutes with 1 medium and 1 hard DSA problem plus about 12 MCQs on computer networks, databases and OS. A campus SDET intern OA was 2 medium coding questions (DP on strings and bit manipulation) in 50 minutes, and a 2021-22 on-campus intern test had 10 easy MCQs plus 2 coding questions. |
| Does it have negative marking? | No public report mentions any, though one 2021-22 on-campus intern account says a single wrong MCQ led to rejection. The coding problems carry most of the marks (around 50 for the medium and 100 for the hard in candidate reports). |
| Is there a sectional cutoff? | Not published. With the hard problem worth about twice the medium, the coding section decides the shortlist. |
| How much is the cutoff? | Not published, and shortlists are tiny. In one SDET intern drive, only 5 students cleared the OA and 2 were finally selected. Candidate-reported eligibility is often 7.0+ CGPA with no active backlogs. |
| Is there an aptitude section? | Sometimes. A 2023 on-campus SWE drive combined aptitude (ratios, averages, mixtures, trains) with technical questions on bit manipulation, XOR/AND and stacks in round 1. |
| Is there an OA for every role? | No. Off-campus web and React Native intern tracks often get a take-home assignment (a working demo or APK) instead, and some off-campus SDE candidates go straight to a live DSA round. |
| Which languages can I use? | Any mainstream language for DSA; take-home and frontend tracks expect JavaScript/TypeScript or Kotlin depending on the role. |
Groww interview questions by role
These themes come from GfG candidate reports and the SDE-1/SDE-2 reports summarised in the rounds below. They show the level and style, not a fixed list.
| Role | Reported questions and topics |
|---|---|
| SDE intern / SDE (backend) | Best Time to Buy and Sell Stock II and Candy in a one-hour live DSA round. Your project’s DB schema, why NoSQL, how you prevented race conditions, an OTP lifecycle, and how to build a payment feature with coupons and card discounts. System design: an event management system with entities, APIs and transactions. |
| SDE intern (campus, 2021-22 report) | OA: a one-transaction stock buy-and-sell variant and a Minimum Cost for Tickets variant; interview: find the missing and duplicate elements in O(N) time and O(1) space, candidate key vs unique key, and minimum steps between two BST nodes using BFS. |
| React Native SDE intern (off-campus, November 2025 report) | A take-home to build a stock broker app in React Native, then React internals, React Native architecture and a live todo-list build, followed by a hiring manager round. |
| SDET intern | A recursive + DP subsequences problem, explaining your own OA solution with complexity, abstract classes and the static keyword, ACID properties, then a long project deep-dive and an easy string problem. |
| Frontend SDE / SDE-2 | Deep clone, URL parsing without built-ins, throttle vs debounce, a live order-book UI with WebSocket state, and rebuilding Redux from scratch. |
| SWE (campus, 2023) | Aptitude plus bit manipulation and stack questions, then arrays and permutations using recursion in the interview. |
Asked across every role: why Groww, whether you use the app and which feature you would add, your strongest tech domain rated out of 5, and how you would handle a dispute in your team.
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
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.
Recent SDE-1 and SDE-2 reports (LeetCode Discuss, LinkedIn, CodeKerdos) also mention scenario questions - optimizing an e-commerce or trading UI under load, explaining end-to-end flow of a real-time app, or a short high-level design on order placement with latency constraints - even when the job title looks “entry level.” Do not skip system-design fundamentals if your mail mentions backend or platform teams.
Common questions
- Additional DSA problems (interviewers often re-probe the same topics from the OA)
- Graph problems such as topological sort on job/task dependencies (including cycles/disconnected components)
- 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
- Frontend SDE-2 track: deep clone, URL parsing without built-ins, throttle vs debounce, live order-book UI with WebSocket state
- Machine coding: scalable cache with pluggable eviction, Splitwise-style ledgers, or group chat with admin limits
- 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
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.
Groww campus OA vs off-campus take-home track
Groww has two common entry paths for freshers, and the first round is different in each.
The campus SDE / SDET path starts with a timed DSA-first OA (1 medium and 1 hard problem plus CS MCQs, or 2 medium problems for SDET), then technical rounds on DSA, projects, OOP and SQL, and a managerial or HR close. The off-campus web and app intern path usually starts with a take-home assignment judged on a working demo and code quality, then a stack-heavy technical round (JavaScript/TypeScript, React or React Native) before culture fit.
Both paths end in the same culture round. This page covers both; prepare the take-home only if your mail asks for one.
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.
Q: What is the difference between throttle and debounce?
Throttle guarantees a function runs at most once per window (e.g. every 300ms) while events keep firing - useful for scroll handlers or live price ticks so you do not repaint faster than the screen can show. Debounce waits until events pause for a window, then runs once - useful for search-as-you-type so you do not hit the API on every keystroke. Groww frontend reports explicitly test both; mixing them up under pressure is a common SDE-2 rejection reason.
Q: How do you deep-clone a JavaScript object beyond JSON.parse/stringify?
JSON cloning drops undefined, functions, and Date fidelity, and throws on circular references. Interview-grade answers walk a recursive structure: handle arrays, plain objects, Date (new instance), Map/Set if required, and track a WeakMap of seen objects to break cycles. Mention that production code often uses a library (structuredClone in modern runtimes) but you should still explain the edge cases Groww interviewers follow up on.
Q: How would you topologically sort tasks with dependencies?
Model tasks as nodes and prerequisites as directed edges, then run Kahn’s algorithm (in-degree queue) or DFS with a post-order stack. If the number of processed nodes is less than V, a cycle exists - report that instead of a bogus order. For disconnected graphs, run from every unvisited node. Time is O(V + E). SDE-2 Groww reports used “jobs as strings” with cycles; stating how you detect and surface cycles matters as much as the happy path.
Q: Why does ACID matter for a Groww-style investing app?
When money or holdings change, partial updates corrupt trust: a debit without a credit, or a filled order without ledger entry. ACID transactions keep related rows consistent; idempotent APIs and reconciliation jobs handle retries from payment gateways. Interviewers use this to test whether you think about failure (timeouts, duplicate webhooks) not only happy-path DSA.
Q: What belongs in a minimal order-book or market-data UI design?
Separate transport (WebSocket or multiplexed stream), normalized state (bids/asks sorted, spread derived), and view throttling (batch ticks to animation frames). Explain how you would resubscribe after reconnect and how you avoid one socket per symbol. Machine-coding reports asked for live buy/sell feeds with aggregation - clarity of state management often beats extra features.
Q: How would you design a small in-memory cache with configurable eviction?
Start with a hash map for O(1) lookup plus a doubly linked list or queue for eviction order. Support get, put, invalidate, and setMaxSize; make eviction strategy pluggable (FIFO vs LRU) so the interviewer can ask you to swap behavior without rewriting the core. Groww SDE-2 machine-coding reports rejected FIFO-only answers when scalability follow-ups asked for LRU or custom policies.
Frequently asked questions about Groww interviews
Does the Groww online assessment have negative marking?
No public candidate report mentions negative marking, though one 2021-22 on-campus intern account says a single wrong MCQ led to rejection. The campus OA is usually 1 medium and 1 hard DSA problem (around 50 and 100 marks) plus about 12 MCQs on networks, databases and OS, so the coding problems decide the shortlist.
What is the Groww OA pattern for campus hiring?
Usually 60-90 minutes with 1 medium and 1 hard DSA problem plus about 12 CS MCQs. An SDET intern OA was 2 medium coding questions in 50 minutes. Off-campus web and app intern tracks often get a take-home assignment instead. Cutoffs are not published.
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?
Usually 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.
Does Groww ask machine coding or only DSA?
Often, at SDE-1 and SDE-2 - many reports include a machine-coding or LLD-style build (for example an extensible cache) in addition to DSA. Interviewers often probe whether eviction or scale assumptions can change without a rewrite - design for interfaces, not a single happy path.
What interviewers score
| Stage | Strong signal | Weak signal |
|---|---|---|
| OA | DSA + CS fundamentals MCQs finished | Skipping DBMS/OS MCQs |
| DSA | Arrays/strings/DP/graphs with complexity | Untimed Hard-only prep |
| Machine coding / LLD | Extensible cache or feature with tests | Hardcoded demo that cannot swap eviction |
| HM / culture | Fintech ownership + market-hours realism | Generic startup praise |
Groww loops lean into fintech reliability (orders, portfolios, real-time quotes). Machine-coding feedback often cites extensibility, not only a happy path.
Red flags that kill Groww offers
- Designing trading systems without latency, retries, or idempotency
- Machine coding that cannot change eviction or scale assumptions
- CAP/ACID answers that collapse on follow-up
- “Why Groww?” with no investing-product hook
- Ignoring Bengaluru hub / joining logistics
How to prepare for Groww interviews
- Loop map: Online assessment (campus); Take-home (off-campus intern); Technical 1; Technical 2 / EM. Confirm timings from the drive mail.
- Technical depth: Drill the Q&A section until answers are spoken, not read. Know every resume project cold.
- Experiences: Study round-wise notes on the interview experience page - real prompts beat generic lists.
- HR: Three STAR stories + a specific “Why Groww?” on the HR page.
Who usually fits and who struggles
Good fit: You like building consumer product, you can sit with a medium DSA pair under a clock, and you have opinions about app vs web (if you did both). Fintech curiosity helps - you do not need a CFA.
Harder path: You only solve Easy problems, you submit a half-broken assignment APK, or you refuse Bengaluru. Culture rounds are friendly and still drop people who cannot say why Groww specifically.
A practical Groww prep plan
Use this as a default four-week loop before a Groww drive. Adjust to your invite timeline.
- Week 1: Oa pattern first: sit one untimed paper, then redo it under the real clock. Open the Groww previous-year sets on this site and mark which sections ate your time. Write the timing on a sticky note. That number is more useful than a 200-problem LeetCode streak you never timed.
- Week 2: Most Groww drives fail people on the first timed paper or OA. Do three timed sits this week. After each one, log every miss in a two-column note: topic and why (slow, wrong formula, bad edge case, panic). The next sit should only add problems from that log.
- Week 3: Technical interviews at Groww usually want a clean project story, one or two CS fundamentals, and (if the process has it) a behavioral or values round. Write STAR stories on paper, not in your head. Practise “Why Groww?” with one concrete product, lab, or business line - not a slogan.
- Week 4: Star stories + one project walkthrough recorded on your phone. If you still have energy, redo only the questions you failed in week 2.
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.
Compensation notes
Candidate-reported fresher/early-career packages for Groww often cite SDE-1 ~₹15-28 LPA; intern stipends often ₹50-80k/month. Treat forum numbers as ranges, not guarantees - confirm the written offer letter for your team and location.
Sources
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 Groww interview experience page. For OA papers and coding drills, use Groww on placementpapers.app. OA quick answers and role-wise questions draw on GfG’s Groww interview experiences (SDE intern, 2021-22 on-campus internship, SDET intern, SWE on-campus 2023) and a LeetCode Discuss snippet of a November 2025 React Native SDE intern experience seen via search.