Groww Placement Papers 2026 — Complete Preparation Guide

Last Updated: March 2026

Meta Description: Prepare for Groww 2026 campus placements with our comprehensive guide featuring the hiring process, 20+ solved technical questions on DSA, system design, trading systems, and backend engineering for India's leading investment platform.

---

Company Overview

Groww is India's leading investment and trading platform, enabling over 30 million users to invest in stocks, mutual funds, fixed deposits, gold, and IPOs. Founded by four ex-Flipkart engineers, Groww has become the go-to platform for first-time investors in India, processing millions of transactions daily.

Attribute	Details
Founded	2016 by Lalit Keshre, Harsh Jain, Neeraj Singh, and Ishan Bansal
Headquarters	Bangalore, India
Employees	1,800+
Valuation	$3+ billion
Users	30+ million (registered), 10M+ active
Products	Stocks, Mutual Funds, IPOs, F&O, Fixed Deposits, Gold, US Stocks
Key Investors	Tiger Global, Sequoia, Ribbit Capital, YC Continuity, Propel Venture Partners
Tech Stack	Java, Go, Kotlin, React, React Native, Kafka, Redis, PostgreSQL, Elasticsearch, AWS
SEBI Registration	Registered stockbroker (member of NSE, BSE)

Why Work at Groww?

• Massive scale — Millions of trades daily, real-time market data processing
• Competitive packages — SDE-1 starts at ₹25-45 LPA (base + ESOPs)
• Democratizing investing — real mission-driven work (financial inclusion)
• Hard engineering problems — sub-millisecond trading, real-time feeds, high availability
• Strong engineering culture — ex-Flipkart DNA, focus on quality and scale
• Rapid growth — fast promotions, high ownership

---

Eligibility Criteria

Parameter	Requirement
Degree	B.E./B.Tech (CS/IT preferred), M.Tech
CGPA	7.0+
Backlogs	No active backlogs
Skills	Strong DSA, System Design, Backend Engineering

---

Hiring Process

Round 1: Online Assessment (90-120 minutes)

• 3-4 coding problems (Medium to Hard)
• Platform: HackerRank or Codility
• Topics: Arrays, Strings, Trees, Graphs, DP, Greedy, Sliding Window
• Clean, optimal code expected

Round 2: Technical Interview 1 — DSA (60 minutes)

• 2-3 coding problems, live IDE
• Approach discussion before coding
• Edge cases, complexity analysis
• Follow-up optimizations

Round 3: Technical Interview 2 — System Design (60 minutes)

• Design a real-world system (order matching engine, real-time feed, portfolio tracker)
• Scalability, availability, latency focus
• Database design, caching, message queues
• API design, microservices

Round 4: Technical Interview 3 — LLD / Backend (45-60 minutes)

• Low-Level Design (Design Patterns, SOLID principles)
• OR Backend Deep Dive (databases, concurrency, distributed systems)
• Past project discussion

Round 5: Hiring Manager / Culture Fit (30-45 minutes)

• Behavioral questions (STAR format)
• Interest in finance/investing
• Why Groww? Career aspirations
• Problem-solving approach and learning mindset

---

Groww Technical Interview Questions with Solutions

Data Structures & Algorithms

Question 1

Given a stream of stock prices, find the maximum profit from at most K transactions (buy and sell).

def maxProfit(k, prices):
    if not prices:
        return 0
    
    n = len(prices)
    
    # If k >= n//2, unlimited transactions
    if k >= n // 2:
        return sum(max(prices[i+1] - prices[i], 0) for i in range(n-1))
    
    # DP: dp[i][j] = max profit using at most i transactions on first j days
    dp = [[0] * n for _ in range(k + 1)]
    
    for i in range(1, k + 1):
        max_diff = -prices[0]
        for j in range(1, n):
            dp[i][j] = max(dp[i][j-1], prices[j] + max_diff)
            max_diff = max(max_diff, dp[i-1][j] - prices[j])
    
    return dp[k][n-1]

# Time: O(k*n), Space: O(k*n) — can be optimized to O(n)

---

Question 2

Design a data structure for a stock ticker that supports: addPrice(timestamp, price), getMax(start, end), getMin(start, end) — efficiently for range queries.

Answer (Segment Tree):

class StockTicker:
    def __init__(self, max_size):
        self.n = max_size
        self.max_tree = [float('-inf')] * (4 * max_size)
        self.min_tree = [float('inf')] * (4 * max_size)
        self.prices = [0] * max_size
        self.count = 0
    
    def _update(self, tree, node, start, end, idx, val, is_max):
        if start == end:
            tree[node] = val
            return
        mid = (start + end) // 2
        if idx <= mid:
            self._update(tree, 2*node, start, mid, idx, val, is_max)
        else:
            self._update(tree, 2*node+1, mid+1, end, idx, val, is_max)
        tree[node] = max(tree[2*node], tree[2*node+1]) if is_max else min(tree[2*node], tree[2*node+1])
    
    def _query(self, tree, node, start, end, l, r, is_max):
        if r < start or end < l:
            return float('-inf') if is_max else float('inf')
        if l <= start and end <= r:
            return tree[node]
        mid = (start + end) // 2
        left = self._query(tree, 2*node, start, mid, l, r, is_max)
        right = self._query(tree, 2*node+1, mid+1, end, l, r, is_max)
        return max(left, right) if is_max else min(left, right)
    
    def addPrice(self, price):
        idx = self.count
        self.prices[idx] = price
        self._update(self.max_tree, 1, 0, self.n-1, idx, price, True)
        self._update(self.min_tree, 1, 0, self.n-1, idx, price, False)
        self.count += 1
    
    def getMax(self, start, end):
        return self._query(self.max_tree, 1, 0, self.n-1, start, end, True)
    
    def getMin(self, start, end):
        return self._query(self.min_tree, 1, 0, self.n-1, start, end, False)

# addPrice: O(log n), getMax/getMin: O(log n)

---

Question 3

Find the top K most frequent elements in an array. (Like finding top K traded stocks)

import heapq
from collections import Counter

def topKFrequent(nums, k):
    count = Counter(nums)
    # Min-heap of size K
    return heapq.nlargest(k, count.keys(), key=count.get)

# Time: O(n log k), Space: O(n)

# Alternative: Bucket Sort — O(n) time
def topKFrequent_bucket(nums, k):
    count = Counter(nums)
    buckets = [[] for _ in range(len(nums) + 1)]
    
    for num, freq in count.items():
        buckets[freq].append(num)
    
    result = []
    for i in range(len(buckets) - 1, -1, -1):
        for num in buckets[i]:
            result.append(num)
            if len(result) == k:
                return result
    return result

---

Question 4

Implement a concurrent-safe bounded queue (producer-consumer) for order processing.

import java.util.LinkedList;
import java.util.concurrent.locks.*;

public class BoundedQueue<T> {
    private final LinkedList<T> queue = new LinkedList<>();
    private final int capacity;
    private final Lock lock = new ReentrantLock();
    private final Condition notFull = lock.newCondition();
    private final Condition notEmpty = lock.newCondition();
    
    public BoundedQueue(int capacity) {
        this.capacity = capacity;
    }
    
    public void put(T item) throws InterruptedException {
        lock.lock();
        try {
            while (queue.size() == capacity) {
                notFull.await();  // Wait until space available
            }
            queue.addLast(item);
            notEmpty.signal();  // Notify consumers
        } finally {
            lock.unlock();
        }
    }
    
    public T take() throws InterruptedException {
        lock.lock();
        try {
            while (queue.isEmpty()) {
                notEmpty.await();  // Wait until item available
            }
            T item = queue.removeFirst();
            notFull.signal();  // Notify producers
            return item;
        } finally {
            lock.unlock();
        }
    }
}

---

System Design

Question 5

Design a real-time stock market feed system for Groww (processing millions of price updates per second).

Requirements:

• Ingest real-time market data from NSE/BSE
• Process 5,000+ stocks × 10+ updates/second = 50K+ updates/second
• Deliver to 10M+ connected clients with <100ms latency
• Support market depth (order book), candlestick charts, ticker

Architecture:

NSE/BSE Feed → Feed Handler → Kafka (raw data) →
                                    ↓
                        Stream Processor (Flink)
                           ↙    ↓    ↘
                    Aggregation  Alerting  OHLC Computation
                         ↓                        ↓
                  Redis (latest prices)     TimescaleDB (history)
                         ↓
              WebSocket Gateway (Go) ← Client subscriptions
                         ↓
              Mobile/Web App (React Native / React)

Key Components:

1. Feed Handler:

   • Connects to exchange via FIX protocol
   • Parses binary market data (ITCH/OUCH protocol)
   • Publishes to Kafka partitioned by stock symbol
   • Handles reconnection, sequence gap detection

2. Stream Processor (Flink):

   • Computes OHLC candles (1m, 5m, 15m, 1h, 1d)
   • Detects price alerts (user-configured)
   • Calculates 52-week high/low, moving averages
   • Output to Redis (hot data) + TimescaleDB (historical)

3. WebSocket Gateway:

   • Go service handling millions of concurrent WebSocket connections
   • Client subscribes to specific symbols
   • Fan-out: Redis Pub/Sub → Gateway → clients
   • Batching: aggregate updates in 100ms windows to reduce messages

4. Data Storage:

   • Redis: Latest tick data, order book (sorted sets)
   • TimescaleDB: Historical OHLC data (time-series optimized PostgreSQL)
   • S3: End-of-day data archive, compliance

Scale Calculations:

• 10M connected users × avg 5 subscriptions = 50M subscription entries
• Each WebSocket gateway handles ~100K connections
• Need ~100 gateway instances
• Redis cluster: 6 nodes for replication and partitioning

---

Question 6

Design an order matching engine for stock trading.

An order matching engine is the core of any trading platform. It matches buy and sell orders based on price-time priority.

Order Book Structure:

Sell Orders (Asks) — sorted ascending by price, then by time
  ₹105.50 × 200 shares (oldest first)
  ₹105.00 × 500 shares
  ₹104.75 × 100 shares  ← Best Ask

  --- Spread: ₹0.25 ---

  ₹104.50 × 300 shares  ← Best Bid
  ₹104.25 × 150 shares
  ₹104.00 × 400 shares
Buy Orders (Bids) — sorted descending by price, then by time

Matching Logic:

from sortedcontainers import SortedList
from collections import deque
from dataclasses import dataclass
from enum import Enum

class Side(Enum):
    BUY = "BUY"
    SELL = "SELL"

@dataclass
class Order:
    id: str
    side: Side
    price: float
    quantity: int
    timestamp: float

class OrderBook:
    def __init__(self):
        self.bids = {}  # price -> deque of orders (FIFO)
        self.asks = {}
        self.bid_prices = SortedList()   # Descending
        self.ask_prices = SortedList()   # Ascending
    
    def add_order(self, order):
        trades = self._match(order)
        
        if order.quantity > 0:  # Remaining quantity
            book = self.bids if order.side == Side.BUY else self.asks
            prices = self.bid_prices if order.side == Side.BUY else self.ask_prices
            
            if order.price not in book:
                book[order.price] = deque()
                if order.side == Side.BUY:
                    prices.add(-order.price)  # Negative for descending
                else:
                    prices.add(order.price)
            
            book[order.price].append(order)
        
        return trades
    
    def _match(self, order):
        trades = []
        
        if order.side == Side.BUY:
            opposite_book = self.asks
            opposite_prices = self.ask_prices
            can_match = lambda ask_price: order.price >= ask_price
        else:
            opposite_book = self.bids
            opposite_prices = self.bid_prices
            can_match = lambda bid_price: order.price <= bid_price
        
        while order.quantity > 0 and opposite_prices:
            best_price = opposite_prices[0]
            if order.side == Side.BUY:
                actual_price = best_price
            else:
                actual_price = -best_price
            
            if not can_match(actual_price):
                break
            
            queue = opposite_book[actual_price]
            while queue and order.quantity > 0:
                resting = queue[0]
                fill_qty = min(order.quantity, resting.quantity)
                
                trades.append({
                    "buyer": order.id if order.side == Side.BUY else resting.id,
                    "seller": resting.id if order.side == Side.BUY else order.id,
                    "price": actual_price,
                    "quantity": fill_qty
                })
                
                order.quantity -= fill_qty
                resting.quantity -= fill_qty
                
                if resting.quantity == 0:
                    queue.popleft()
            
            if not queue:
                del opposite_book[actual_price]
                opposite_prices.remove(best_price)
        
        return trades

---

Backend Engineering & Fintech

Question 7

Explain the difference between optimistic and pessimistic locking. When to use each in a trading system?

Feature	Optimistic Locking	Pessimistic Locking
Approach	Check for conflicts at commit time	Lock resource before access
Conflict Handling	Retry on conflict	Wait for lock
Performance	Better for low-contention	Better for high-contention
Implementation	Version column check	SELECT ... FOR UPDATE
Throughput	Higher (no lock waiting)	Lower (lock waiting)

In Trading:

• Portfolio balance updates: Pessimistic locking — high contention (many trades from same user)
• Order placement: Optimistic locking — lower contention (unique per order)
• Price cache updates: Neither — use atomic operations (Redis INCR/SET)

-- Pessimistic: Balance deduction (high contention)
BEGIN;
SELECT balance FROM accounts WHERE user_id = 123 FOR UPDATE;
-- Check balance >= order_amount
UPDATE accounts SET balance = balance - 1000 WHERE user_id = 123;
COMMIT;

-- Optimistic: Order status update (low contention)
UPDATE orders 
SET status = 'EXECUTED', version = version + 1 
WHERE id = 456 AND version = 3;
-- If affected_rows = 0 → conflict → retry

---

Question 8

What is event-driven architecture? How does Groww use it?

Event-Driven Architecture (EDA) = Services communicate through events (asynchronous messages) rather than direct API calls.

Groww's Event Flow (Order Execution):

User Places Order → Order Service (event: ORDER_PLACED)
                          ↓ Kafka
    ┌─────────────────────┼─────────────────────┐
    ↓                     ↓                     ↓
Risk Service      Exchange Gateway      Notification Service
(validate limits)   (send to NSE/BSE)    (push notification)
    ↓                     ↓
ORDER_VALIDATED     TRADE_EXECUTED
                          ↓ Kafka
    ┌─────────────────────┼─────────────────────┐
    ↓                     ↓                     ↓
Portfolio Service   Settlement Service   Analytics Service
(update holdings)   (T+1 settlement)    (trade metrics)

Benefits:

1. Loose coupling — services don't know about each other
2. Scalability — add consumers without changing producers
3. Resilience — if notification service is down, trades still work
4. Audit trail — every event is logged in Kafka (retention)
5. Replay — fix bugs and replay events to rebuild state

---

Question 9

How would you implement idempotency in a payment/trading system?

import redis
import json

class IdempotencyManager:
    def __init__(self, redis_client, ttl=86400):
        self.redis = redis_client
        self.ttl = ttl  # 24 hours
    
    def execute_idempotent(self, idempotency_key, operation, *args):
        cache_key = f"idempotent:{idempotency_key}"
        
        # Check if already processed
        cached = self.redis.get(cache_key)
        if cached:
            return json.loads(cached)  # Return cached result
        
        # Execute operation
        result = operation(*args)
        
        # Cache result with TTL
        self.redis.setex(cache_key, self.ttl, json.dumps(result))
        
        return result

# Usage
idempotency = IdempotencyManager(redis_client)

def place_order(order_details):
    return idempotency.execute_idempotent(
        idempotency_key=order_details["client_order_id"],
        operation=_actually_place_order,
        order_details
    )

Layers of idempotency:

1. Client-generated UUID — client sends unique ID with each request
2. Server-side deduplication — check Redis before processing
3. Database constraint — unique index on transaction_id
4. Kafka deduplication — idempotent producer (exactly-once semantics)

---

Preparation Strategy

45-Day Groww Prep Plan

Week 1-2: DSA Intensive

• LeetCode Medium-Hard: 5 problems/day
• Focus: Arrays, Trees, Graphs, DP, Heaps, Sliding Window
• Special focus: Stock buy/sell problems (LeetCode 121, 122, 123, 188)

Week 3: System Design

• Study: Load Balancing, Caching, Message Queues, Database Sharding
• Practice: Design stock feed, order matching, portfolio tracker
• Read: "Designing Data-Intensive Applications"

Week 4-5: Fintech + LLD

• Study: Trading systems, order books, settlement (T+1/T+2)
• SOLID principles, Design Patterns, concurrency
• Read Groww's engineering blog

Week 6: Mock Interviews

• 3-4 mock interviews covering DSA + System Design
• Prepare behavioral stories
• Research Groww's recent product launches, regulatory changes

---

Related Preparation Guides

• Slice Placement Papers 2026 — Fintech interview preparation
• Meesho Placement Papers 2026 — Startup engineering interviews
• Amazon Placement Papers 2026 — System design focus
• TCS Placement Papers 2026 — Campus hiring guide
• BrowserStack Placement Papers 2026 — SaaS engineering
• 30-Day Placement Preparation Plan — Structured approach

---

Frequently Asked Questions

Q: What is the salary at Groww for SDE-1? A: SDE-1 at Groww ranges from ₹25-45 LPA (CTC including ESOPs). Base salary is typically ₹20-30 LPA. Exact package varies by campus and performance.

Q: Does Groww hire from non-IIT colleges? A: Yes, Groww hires from NITs, IIITs, BITS, and top private colleges through campus drives. Off-campus hiring through referrals and applications is also common.

Q: Is finance/stock market knowledge needed? A: Not mandatory for freshers, but understanding basic concepts (stocks, mutual funds, order types, settlement) significantly helps in system design rounds. It shows genuine interest.

Q: What's the tech stack at Groww? A: Backend: Java (Spring Boot), Go, Kotlin. Frontend: React, React Native. Data: Kafka, Redis, PostgreSQL, Elasticsearch, TimescaleDB. Cloud: AWS.

---

Last Updated: March 2026