Zerodha Onsite Interview: Every Round, What It Tests, and How to Prepare

Zerodha moves roughly 15% of India's daily stock trading volume through a backend run by about 35 engineers. Over one four-year stretch, they hired five people for the tech team. Total. That number tells you everything about how seriously they take this process. This is not a pipeline. It's a deliberate, high-signal conversation with engineers who genuinely don't need to fill a quota.

Walk in expecting a FAANG-style loop of five identical LeetCode rounds and you'll be confused. Zerodha's onsite is smaller, more varied, and weighted heavily toward practical judgment and cultural alignment. Here's what actually happens.

What the Onsite Loop Looks Like

The Zerodha onsite typically runs three to four rounds, spread across sessions rather than packed into a single day.

Round	Focus	Who Runs It
Technical 1	DSA, problem-solving methodology	Senior engineer
Technical 2	System design or domain depth	Senior or staff engineer
Practical assignment (some roles)	Real-world building task	Reviewed async
Culture / leadership	Values, ownership, motivation	CTO or senior leadership

Not every candidate sees all four stages. Junior roles may skip system design. Infrastructure roles sometimes swap a coding round for a take-home involving Docker or infrastructure configuration. The process is informal enough that round count and ordering can shift.

Technical Round 1: Problem-Solving Under the Microscope

The first technical round covers core CS fundamentals: data structures, algorithms, and debugging. Problems come from the usual suspects: arrays, strings, linked lists, trees, graphs, dynamic programming. Difficulty is roughly LeetCode medium, occasionally hard. But the framing is less "solve this exactly" and more "show me how you think."

Common question types:

Subarray and sliding window problems
Linked list manipulations (cycle detection, merge sorted lists, remove nth node)
Tree traversals (in-order, LCA, path problems)
Graph traversal: BFS and DFS on real-world-ish inputs
SQL query writing and optimization
Debugging a slow query or a function with an off-by-one error

The SQL component is not a throwaway. Zerodha's backend touches financial data constantly, and engineers are expected to write clean queries. Candidates who treat SQL as something they'll look up when needed tend to discover window functions for the first time during the interview itself.

If you don't know something, say so. Faking confidence tends to backfire harder here than at most companies. Small team, senior interviewers. They notice.

Language preference: Go is the primary backend language. Python handles data-heavy work. Code in Go if you're comfortable with it. Python is a reasonable fallback. Java and C++ will raise an eyebrow.

Technical Round 2: System Design or Domain Depth

For mid-level and senior candidates, round two goes deeper. You'll see one of two flavors.

Fintech system design. Real-time market data pipelines, distributed order matching, high-frequency trading infrastructure, streaming financial events through Kafka or NATS. Zerodha runs its own matching engine and processes orders at sub-40ms latency. The design problems reflect things their team has actually built. You're expected to reason about trade-offs at real scale, not just draw boxes.

Common territory: real-time order book updates across distributed nodes, fault-tolerant message queues for trade confirmations, ClickHouse-based analytics over high-volume event streams, rate limiting and circuit breaking for broker API consumers.

Domain depth. Some rounds skip formal system design entirely and dig into a specific area instead: concurrency and threading, network fundamentals, database internals, performance optimization. If your resume claims expertise in something, expect them to find the edges of it.

Three things Zerodha cares about that FAANG doesn't emphasize:

They use Nomad, not Kubernetes. Defaulting to "and then we scale with Kubernetes" lands like showing up to a Go interview and asking if they'd consider rewriting in Java. Technically coherent. Not what anyone asked.
They care about simplicity. Reaching for a distributed system when a well-tuned Postgres instance would do is actively penalized.
Practical understanding beats theoretical breadth. One real system you know deeply is worth more than six you can name-drop.

The Culture Round: The One That Decides

This is the round people least expect to matter and most underestimate. It often involves Kailash Nadh or another member of senior leadership, and candidates consistently describe it as "surprisingly profound" after expecting a generic HR warmup.

You walked in ready for "where do you see yourself in five years." You got a conversation about engineering philosophy with the CTO.

Zerodha's core values, from public statements and candidate reports:

Transparency: Communicate problems openly, including bad news
Simplicity: The best solution uses the least complexity that works. "Heavy on common sense and light on coolness."
Ownership: You care about the outcome, not just the task
Passion for building: Do you write code outside of work? This is taken seriously.

What they're actually testing is whether you've internalized these as genuine beliefs or are parroting them. Questions probe specific situations: times you simplified something complex, pushed back on a feature because it would hurt users, or cared enough to figure something out on your own.

The hobby projects signal is real. Kailash Nadh has said publicly that institutional pedigree doesn't move him much, but what you've built on your own does. A GitHub with actual projects matters. An empty portfolio is noticed.

What Actively Hurts You Here

LeetCode Hard grinding. The algorithmic ceiling is lower than FAANG. Solid medium-difficulty problem-solving is what you need. Nobody's asking you to implement a red-black tree. Save the Hard grind for companies that reward it.

STAR behavioral frameworks. Zerodha doesn't run Amazon-LP-style rounds where you recite structured stories on demand. The culture round is a conversation. You still need real stories, but a scripted "Situation-Task-Action-Result" cadence will feel rehearsed rather than genuine.

Obscure framework knowledge. They run a Go/Python/Postgres stack. Deep knowledge of Spring Boot or Azure Service Fabric isn't what they're looking for.

Yes, They'll Test Your Finance Basics

Some candidates report a brief stock market quiz during the online assessment or first technical stage. Questions are genuinely basic: what is a share, what is a mutual fund, what's the difference between a market order and a limit order. Zerodha wants evidence you understand the domain you'd be building for. This is not the CFA Level 1. It's 45 minutes of reading. Do it.

How to Prepare for the Zerodha Onsite Interview

For the coding rounds: Focus on LeetCode mediums across arrays, strings, trees, graphs (BFS/DFS), sliding window, prefix sums, and linked lists. Add SQL practice, specifically query optimization and window functions. LeetCode's SQL 50 problem set covers the right territory. Practice in Go if you're not already comfortable with it. Basic familiarity with maps, slices, and goroutines signals alignment with how the team actually works. A Tour of Go covers the language in a few hours.

For system design: Read about how financial exchanges work at the infrastructure level. Study Kafka or NATS-style message queues in detail. Be ready to discuss PostgreSQL vs. ClickHouse trade-offs. Practice designing for latency, not just scale. The Zerodha tech blog is the best prep resource available. It's written by the engineers who'll interview you.

For the culture round: Have specific answers ready: what you've built outside of work, one thing you simplified at a previous job, a time you pushed back on something because it was wrong for the user. Be honest about what you don't know. Overselling yourself has a short shelf life at a 35-person company.

Voice-practice the culture round with a mock session on SpaceComplexity. The behavioral rounds force you to articulate reasoning out loud, which is much closer to how Zerodha's conversation-heavy rounds feel than writing STAR stories in a doc.

What Gets Good Candidates Cut

Overcomplicating system design. A microservices mesh with 15 components for a problem a well-indexed Postgres table would solve is a yellow flag, not a green one.

Treating the culture round as a formality. Multiple candidates who passed the technical rounds got cut here. Prepare for it with the same seriousness as coding.

Not knowing Go exists. You don't have to code in it. But walking in without knowing it's their primary language suggests you didn't spend five minutes on their website.

Defaulting to Kubernetes. They use Nomad. It won't disqualify you, but casually assuming Kubernetes in a system design will earn a puzzled look and a follow-up question you'd rather not have to answer.

Trying to bluff. Small team, senior interviewers. They notice quickly. "I'm not sure, but here's how I'd approach figuring it out" is a better answer than a confident-sounding wrong one.

The full process, from application to offer, typically takes two to four weeks. Decision speed is often fast once the final round is done. Given how infrequently Zerodha opens roles, the wait to get your application reviewed is usually the longest part.