Zerodha Software Engineer — Hiring Process, Syllabus & 8-Week Prep Roadmap 2026
Zerodha is a product-first engineering team. Their process is highly selective, focusing on clean code, system design for high-concurrency trading, and deep curiosity about financial markets. This guide covers the DSA core, machine coding patterns, trading-domain mechanics, and a structured 8-week roadmap to crack the role.
Medium-hard DSA (1–2 problems in 60–90 min) + Machine coding (live or take-home) + Trading-domain system design & culture fit.
Last updated:
Exam Pattern
Medium-hard DSA (1–2 problems in 60–90 min) + Machine coding (live or take-home) + Trading-domain system design & culture fit.
| Section | Questions | Time | Type | Difficulty |
|---|---|---|---|---|
| Technical Screen | 1 problem / task | 20–30 min | DSA / Project walkthrough | Medium |
| Online Assessment | 1–2 problems | 60–90 min | Coding (Algorithms & Debugging) | Medium–Hard |
| Machine Coding | 1 task | 90–120 min | Live / Take-home (Clean Code) | Hard |
| DSA Round | 1–2 problems | 45–60 min | Live coding & Complexity | Medium–Hard |
| Domain & System Design | Case study | 45–60 min | Trading systems, Latency, Reliability | Hard |
| Culture / Leadership | Varies | 30–45 min | Ownership & Communication | Medium |
Section-Wise Syllabus
Everything that appears in the assessment, grouped by section.
1. DSA Core
Arrays & Strings
- • Prefix sums
- • Difference arrays
- • Two pointers
- • Sliding window
- • Hashing
- • Sorting-based optimization
- • Subarrays & subsequences
- • Frequency counting
- • Palindromes
- • Anagrams
- • String matching
- • Minimum window
- • Coordinate compression
Linked Lists & Stacks
- • Reverse in groups of k
- • Detect cycle entry node
- • Merge sorted lists
- • Clone random-pointer list
- • Balanced parentheses
- • Min stack
- • Next greater element
- • Largest rectangle in histogram
- • Sliding-window maximum
Trees & Graphs
- • Traversals (Iterative)
- • Level-order
- • Lowest Common Ancestor
- • Validate BST
- • Serialize/Deserialize
- • BFS & DFS
- • Cycle detection
- • Topological sort
- • Dijkstra
- • DSU
- • Strongly Connected Components
Dynamic Programming
- • House robber
- • Coin change
- • 0/1 Knapsack
- • LIS & LCS
- • Edit distance
- • Stock buy-sell
- • Partition DP
- • Tree DP
2. Trading-Domain & System Design
Market Mechanics
- • Market vs Limit vs Stop-loss orders
- • Bid-Ask spread
- • Liquidity & Slippage
- • Market Depth
- • Margin & Leverage
- • Order Lifecycle (Validated -> Open -> Filled)
Kite-like Architecture
- • User Auth & KYC
- • Instrument Catalogue
- • Market-data feed (Streaming)
- • Order Management Service (OMS)
- • Risk & Margin service
- • Exchange adapter
- • Portfolio & Ledger
Low-Latency Systems
- • In-memory data structures
- • Efficient serialization (Protobuf/gRPC)
- • Non-blocking I/O
- • Event-driven architecture
- • Lock contention & Backpressure
- • p99 Latency optimization
- • Batching & Connection pooling
3. CS Fundamentals
Operating Systems
- • Process vs Thread
- • Thread safety & Race conditions
- • Mutex vs Semaphore
- • Concurrency basics
- • Garbage collection impact
Networking & DBMS
- • TCP vs UDP (High-speed feeds)
- • Database indexing
- • ACID properties
- • Isolation levels
- • Eventual consistency
- • Pub/Sub streaming
Most Asked Topics
Highest-frequency areas across recent test papers.
Order Idempotency
Preventing duplicate orders using unique request keys and atomic persistence.
Matching Engine Logic
Simulating high-speed bid/ask matching using priority queues and order-state management.
Real-time Margin Calculation
Calculating risk and available funds during high market volatility.
Market-data Fan-out
Distributing price updates to millions of clients with minimal latency.
LRU Cache / Rate Limiter
Standard machine coding tasks focused on efficiency and thread safety.
Free Resources
Curated practice links per section.
System Design & Trading
50+ DSA Practice Problems
Solve in order — arrays and strings first, then sorting and recursion.
Arrays & Strings
- Longest substring without repetition
- Maximum subarray sum
- Smallest missing positive integer
- Product of array except self
- Minimum swaps to sort
- Merge intervals
- Group anagrams
- Subarray sum equals K
- Longest consecutive sequence
Advanced DSA
- LRU Cache implementation
- Kth-smallest element in BST
- Detect cycle in directed graph
- Shortest path in weighted graph
- Maximum product subarray
- Trie for auto-complete
- Segment tree for range queries
Previous Year Questions & Patterns
Repeat coding questions with the expected approach.
System Design Scenarios
- Design an Order Management System (OMS) that handles 1M+ orders per minute.
- How would you distribute market prices to 10M concurrent users in real-time?
- Design a portfolio tracker that calculates realized/unrealized P&L in real-time.
- How do you handle exchange-side connection failure and state reconciliation?
Technical Questions
- What is the difference between TCP and UDP? When would you use UDP in trading?
- Explain the CAP theorem in the context of a ledger system.
- How do you ensure idempotency in a payment or order API?
- Describe a situation where you had to debug a low-level memory or concurrency issue.
20+ SQL Query Bank
Write these out by hand — joins and subqueries are asked in both the test and the interview.
Ledger & Orders
User P&L summary
SELECT user_id, SUM(realized_pnl) FROM trades GROUP BY user_id;Unfilled orders count
SELECT instrument, COUNT(*) FROM orders WHERE status = 'OPEN' GROUP BY instrument;High-volume instruments
SELECT instrument_id, SUM(quantity) as vol FROM trades WHERE trade_time > NOW() - INTERVAL '1 hour' GROUP BY instrument_id ORDER BY vol DESC LIMIT 10;DBMS & Core Interview Q&A
Short answers you should be able to say out loud.
What is an Idempotency Key?
A unique identifier sent by the client to ensure that the same request processed twice results in only one action (e.g., placing one order instead of two).
Market Order vs Limit Order?
Market orders prioritize execution speed at the best current price; limit orders prioritize price, executing only at a specified price or better.
OOPs Concepts + 10 Code Snippets
Theory plus the exact snippets asked in the technical round.
State Machine
Modeling order lifecycles (Created -> Validated -> Open -> Filled) to ensure valid transitions.
Interface-based Design
Decoupling the trading engine from different exchange adapters using standard interfaces.
LRU Cache Skeleton (O(1))
class LRUCache {
int capacity;
list<pair<int, int>> cache; // {key, value}
unordered_map<int, list<pair<int, int>>::iterator> map;
public:
LRUCache(int cap) : capacity(cap) {}
int get(int key) {
if (map.find(key) == map.end()) return -1;
cache.splice(cache.begin(), cache, map[key]);
return map[key]->second;
}
void put(int key, int value) {
if (map.find(key) != map.end()) {
cache.splice(cache.begin(), cache, map[key]);
map[key]->second = value;
return;
}
if (cache.size() == capacity) {
map.erase(cache.back().first);
cache.pop_back();
}
cache.push_front({key, value});
map[key] = cache.begin();
}
};Order State Machine Enum
public enum OrderStatus {
CREATED, VALIDATED, SUBMITTED, OPEN, PARTIALLY_FILLED, FILLED, CANCELLED, REJECTED;
public boolean isTerminal() {
return this == FILLED || this == CANCELLED || this == REJECTED;
}
}Operating System Basics
Scheduling, deadlock and memory management essentials.
Concurrency & Performance
- • Thread pools vs Event loops
- • Mutex, Semaphores and Spinlocks
- • Garbage collection tuning for low latency
- • Backpressure handling in streaming data
- • Memory-mapped files for logging
4-Week Preparation Roadmap
From zero to test-ready in 28 days.
DSA Fundamentals
- Arrays, Strings, Two-pointers, Sliding Window
- Solve 5-6 problems/day focus on clean code
Goal: Master core logic and complexity analysis.
Advanced Structures
- Trees, Graphs, DSU, Dijkstra
- Solve hard problems on LeetCode/GFG
Goal: Confidence in complex algorithms.
CS Core & Domain
- OS, Networking (TCP/UDP), DBMS (ACID, Indexes)
- Study Trading concepts (Order types, Margin)
Goal: Build foundation for technical rounds.
Machine Coding & System Design
- Build LLD for OMS/Matching Engine
- Design Kite-like architecture
- Practice timed coding
Goal: Prepare for high-pressure design rounds.
Exam Day Strategy
Score targets and time allocation.
Section targets
- Machine Coding: Focus on readability, extensibility and 'Happy Path' first.
- System Design: Clarify non-functional requirements like latency and consistency early.
Coding time split (50 min)
- 90 min: DSA Core
- 45 min: Machine Coding practice
- 30 min: Trading Domain study
Interview Process
What follows the online test.
Stage 1: Technical Screen
- • Initial screening of resume and 1–2 medium DSA problems.
Stage 2: Machine Coding
- • Deep dive into code quality, entity design, and working implementation.
Stage 3: Technical / Domain Design
- • Discussion on high-scale systems, latency, and trading mechanics.
Mock Test Plan
Four simulations to run before the real test.
Machine Coding Mock
- • Build a thread-safe Rate Limiter in 90 minutes.
- • Build an Order Matching Engine with Price-Time priority.
System Design Mock
- • Design a system to stream live stock prices to 1M clients.
- • Design a trade reconciliation system for exchange mismatches.
Final Checklist
Tick all of these before test day.
Recent Interview Experiences
First-hand write-ups from students who actually sat the Zerodha process.
Be the first to share a Zerodha interview experience.
Frequently Asked Questions
Does Zerodha hire freshers?
Yes, but they are very selective. High-quality personal projects and open-source contributions are highly valued.
Which programming language is preferred?
Zerodha uses many languages (Go, Python, C++). Language choice in interviews usually depends on the candidate, but low-level understanding is expected.
Want the full structured prep for Zerodha?
The Premium Vault covers Aptitude, Core CS, DSA, SQL and HR rounds with module-wise courses and drill sheets.
Related Prep
Next steps chosen from the Zerodha pattern and other Finance & Quant recruiters.
Other Finance & Quant companies
Core CS subjects for this pattern
DBMS & SQL Essentials
Normalisation, keys, transactions and the SQL queries asked in written rounds.
Operating System Essentials
Processes, scheduling, deadlock and memory management in interview-ready form.
Computer Networks Essentials
OSI vs TCP/IP, HTTP, DNS and the networking questions freshers actually get.
Recommended practice path