System design interview guide
Robinhood System Design Interview: How a Stock Trading App Places, Routes and Shards Orders
Short answer
A strong scenario to practise for a Robinhood system design interview is a broker's order system. It sends each order on to be filled. We have no public source that Robinhood asks it. The key idea is shards by customer: full copies of the stack that each serve some customers. So one order stays inside one shard. In 2021 Robinhood wrote that a routing layer finds each customer's shard. Each shard has its own servers and PostgreSQL database. Peak load rose from 100,000 requests per second in December 2019 to 750,000 in June 2020. It went from one shard in early 2020 to ten in 2021. Robinhood says its routing system sends stock orders to market makers chosen by past execution quality. In this design the app also sends a client order ID, so a retry never buys twice.
Designing the exchange itself, with an order book and a matching engine? Read the stock exchange guide
Two courses by the author of this page:
770 lessons · 18 free to read
₹1,111 in India · $35 elsewhere, once
Get System DesignYou own this course
219 lessons · 10 free to read
₹1,333 in India · $35 elsewhere, once
Get Generative AI and Agentic AIYou own this course
Save your progress and get the interview checklist PDF
Robinhood had 28.7 million funded customers at the end of September 2026. In that quarter they traded 905 million options contracts and $992 billion of equities by value. Back in June 2020, its brokerage system took 750,000 requests per second at peak. That was seven times the load of six months before.
Designing Robinhood means designing a broker, not an exchange. A broker takes the customer's order, checks it and stores it. Then it sends the order to someone who can fill it. Robinhood sends most stock orders to market makers, firms that buy and sell all day. The hard parts are the spikes. Orders queued overnight arrive together at the market open, and a volatile day can multiply traffic. Robinhood's answer, which it wrote about in 2021, was to split the whole brokerage into shards by customer. A shard is a full copy of the system that serves only some customers. Each shard has its own servers and its own PostgreSQL database.
Where it shows up
A common type of question for backend and infrastructure roles at brokers, trading apps and other fintech companies. We have no public source that Robinhood uses this exact question. This guide is built from Robinhood's own engineering writing and SEC filings so you can reason with real numbers.
Spec sheetRobinhood
- 01Customers
- 28.7M
- 02Options contracts per trading day, estimated
- ~14M
- 03Equities traded per trading day, estimated
- ~$15.5B
- 04Peak request rate
- 750k/s
worked through below, with the maths
Robinhood in its own numbers
Every figure below is quoted from Robinhood's own engineering writing. Tap a source to check it.
28.7M
funded customers, end of Q3 2026
Robinhood Q3 2026 results, SEC filing905M
options contracts traded in Q3 2026, a record
Robinhood Q3 2026 results, SEC filing$992B
equity trading volume by value in Q3 2026, a record
Robinhood Q3 2026 results, SEC filing750k
requests per second to the brokerage at peak, June 2020 (100k in Dec 2019)
Robinhood engineering, 202110
brokerage shards in mid-2021 (one at the start of 2020)
Robinhood engineering, 202175%
fewer load-related customer incidents, Q1 to Q2 2021
Robinhood engineering, 2021
Why this question is asked
A trading app looks like a simple form with a Buy button. Behind it sit three hard problems. Money must never be counted twice, so every step must be safe to retry. Load is very uneven, with sharp peaks at the market open and on news days. And the system depends on outside firms it does not control: market makers, exchanges and the clearinghouse. A strong answer splits the work by customer and plans for the peak. It also keeps one bad part from taking everyone down. Robinhood has written in public about several of these, which makes it a good case to reason about.
What the interviewer asks
“Design the order system for a stock trading app like Robinhood. A customer opens the app, sees prices and places an order to buy or sell a stock. Focus on what happens between pressing Buy and getting a fill. A fill is the report that the order was carried out at a price. Also focus on surviving the market-open spike.”
Ask these back before you draw
- 1.Are we the broker or the exchange? (The broker. The order is filled by a market maker or a trading venue, not by us.)
- 2.Which assets? (Stocks first. Options, ETFs (funds that trade like a single stock) and crypto change the details, not the shape.)
- 3.Which order types? (Market orders and limit orders. A market order buys or sells at the best price available now. A limit order sets the worst price you accept.)
- 4.Trading hours? (Regular hours are 9:30 AM to 4 PM ET. Robinhood also offers extended hours and a 24 Hour Market.)
- 5.How many customers and how much peak load? (Use Robinhood's public numbers below.)
This page is the free part.
The course goes deeper on the Robinhood design
₹1,111 in India$35 everywhere elseonce, for the whole course
The System Design course covers the Robinhood design across a run of lessons, not one page. These 4 alone are about 95 minutes of step-by-step reading, every one with a quiz.
- Database Sharding
Splitting a database across multiple servers, the nuclear option for scaling writes, and the architecture behind Instagram, Uber, and YouTube.
- Read Replicas
Scaling reads by replicating data to follower databases, primary-replica architecture and replication lag.
- Idempotency Keys
Safely retry failed API requests without causing duplicate side effects.
- Idempotent Consumer
Design consumers that produce the same result whether a message is processed once or ten times.
all part of
System Design Masterclass
770 lessons · about 290 hours · 18 free to read
₹1,111in India, by UPI
$35everywhere else, by card or PayPal
It is really nice and good Please join the course
You own this course
Continue with Database Shardingpay once,
yours for life
Live from the course bench
Before you design Robinhood, try the questions it rests on.
Real interview questions, live diagrams and measured lab results, pulled at random from the lessons. A new set every time you come back.
01Requirements
Requirements
Always clarify these in the first 5 minutes of the interview. Do not start drawing boxes until both lists are agreed.
Functional requirements
- A customer places a market or limit order to buy or sell a stock
- The app checks the order before it leaves: the stock is tradable and the customer has the money or the shares
- The order goes to a venue that can fill it, and the customer sees the fill quickly
- Orders placed when the market is closed wait and go out at the next open
- The customer can cancel an open order
- The customer sees positions, balances and order history across everything they own
Non-functional requirements
- Never lose an order and never place one twice, even when the phone retries
- Survive the market open: Robinhood saw a 7x rise in peak load in six months
- A failure should hurt as few customers as possible, not all of them
- Strong consistency for money and positions; prices on the screen may be a second old
- Every order and fill is kept for audit and regulators
- Room to grow by adding hardware, not by rewriting the system
02Scale estimates
Back-of-envelope scale estimates
Show your math. Pulling numbers from thin air signals you have not thought about the load.
Customers
28.7M
Robinhood's funded customers at the end of September 2026, from its Q3 2026 results filed with the SEC. A funded customer is a person with a balance above zero, or a transaction, in the last 45 days.
Options contracts per trading day, estimated
~14M
905 million contracts in Q3 2026. We count about 64 trading days in that quarter. 905 million / 64 is about 14 million a day. These are contracts, not orders; one order can carry many contracts.
Equities traded per trading day, estimated
~$15.5B
$992 billion of equities by value in Q3 2026, over our count of about 64 trading days. Divide and you get about $15.5 billion a day.
Peak request rate
750k/s
Robinhood's figure for June 2020, up from 100,000 per second in December 2019. These are all requests to the brokerage system, such as reading balances, quotes and history, not orders alone. Size for the peak, not the average. A quiet afternoon tells you nothing about 9:30 AM on a news day.
Customers per shard, estimated
~2.9M
Robinhood had 10 shards in mid-2021. It has not published today's count. If you kept 10 shards, 28.7 million / 10 is about 2.9 million customers on each. Use this to explain why the shard count must keep growing.
Shards for another 7x, estimated
~18
Assume another 7x jump, like December 2019 to June 2020: 750,000 x 7 = 5.25 million requests per second. In 2021 Robinhood wrote that each shard could handle many hundreds of thousands of requests per second. It gave no exact number. Take a cautious 300,000 per shard, which is our assumption. 5.25 million / 300,000 = 17.5, so plan for 18 shards plus spare. A higher limit per shard means fewer shards.
03Architecture
High-level architecture
Draw the stack in four layers. Robinhood described the middle two in 2021; the rest is this design. At the top is the customer's app. Below it is a routing layer. It reads each request, finds the customer, and looks up which shard that customer lives on. A shard is a full copy of the brokerage stack that serves only some customers. Each shard has its own application servers, its own PostgreSQL database and its own deployment pipeline. In this design the order is checked and saved inside that one shard. Kafka, a log of events that many services can read, carries events between services. It sits outside the shards. In 2021 Robinhood wrote that every shard read all messages and kept only those for its own customers. Next to the shards sits an aggregation layer. It is a stateless service, which means it keeps no data of its own between requests. Internal services call it when they need data from many shards at once. At the bottom, an order router sends the order out to the market. In regular hours Robinhood sends stock orders to market makers, chosen by an algorithm based on past execution quality. Overnight orders in its 24 Hour Market go to an alternative trading system, or ATS. That is a private trading venue, not a public exchange. In this design fills come back and are saved in the customer's shard. The trade later settles through Robinhood Securities and a clearinghouse. A clearinghouse is a central firm that stands between buyer and seller. It makes sure the stock and cash change hands.
In a real interview, sketch this on the whiteboard before diving into any single box.

04One request
What happens when you press Buy, step by step
Steps 2, 4, 5 and 7 follow Robinhood's 2021 post on sharding, its support articles and its January 2021 note. Robinhood has not published its order service. So steps 1, 3 and 6 are this design's assumptions: the client order ID, the checks and the fill handling.
- 1
The app sends the order
The customer presses Buy. In this design the app sends the order with a client order ID. That is a unique ID the app makes for this one order. If the network drops and the app sends it again, the ID stays the same.
- 2
The routing layer finds the shard
The routing layer maps the request to a customer, and the customer to a shard. Robinhood's first version made a synchronous call to a shard mapping service on every request. The mapping records are durable and can be cached.
- 3
The shard checks and saves the order
In this design, the order service inside the customer's shard checks the order. The stock must be tradable, and the money or shares must be there. It saves the order and reserves the money or shares in the shard's Postgres, in one transaction. A repeated client order ID returns the order already saved.
- 4
If the market is closed, the order waits
Robinhood queues orders placed outside market and extended hours for the next regular session. Regular hours are 9:30 AM to 4 PM ET. Extended hours are 7 to 9:30 AM and 4 to 8 PM ET.
- 5
The order router sends it to a venue
Robinhood sends stock orders to market makers, picked by an algorithm based on past performance. Overnight orders in the 24 Hour Market go to an ATS. In this design the router is a separate service that every shard calls. Robinhood has not published where its router sits.
- 6
The fill comes back
The venue reports a fill: how many shares and at what price. In this design the order ID carries the shard ID. Then each fill can be sent straight back to the right shard. Robinhood's crypto team made IDs unique across all shards when it sharded. The shard saves the fill, updates the position and releases any unused reservation. An event goes on Kafka so notifications and history can update.
- 7
Clearing and settlement
In January 2021 Robinhood explained this step. The market maker sends a record of the trade to Robinhood Securities, Robinhood's clearing broker. A clearing broker is the firm that handles settlement for the broker's trades. It works with a clearinghouse to settle the trade. Settlement moved from two business days to one in the US on May 28, 2024.
05Components
Core components
Walk through each service. The interviewer wants to hear what each one owns, not just the names.
Routing layer
The switchboard for external traffic. It reads a request, finds the customer and sends the request to that customer's shard. In 2021 it used a shard mapping service, whose records are durable and cacheable. It holds no business logic, so it stays simple and fast.
Shards
Each shard is a full copy of the brokerage stack: application servers, a PostgreSQL database and its own deployment pipeline. A customer lives on exactly one shard. Robinhood had one shard at the start of 2020. It had three at the end of 2020 and ten by mid-2021.
Order service (inside each shard)
Validates the order, reserves the money or shares, and saves the order with its client order ID. It owns the order's state: new, sent, partly filled, pending cancel, filled, cancelled or rejected. Robinhood has not published this service's design; this is the design we assume.
Aggregation layer
A stateless service for internal traffic that needs data from many shards, such as a report across all customers. It fans the request out to the shards and merges the results. Robinhood built a custom cursor, a bookmark of where the last page stopped. It lets callers page through merged results in order.
Kafka
Carries events between services. In 2021 Robinhood had every shard consume all messages and process only those for its own customers. For very busy streams it created topics per shard. A topic is a named stream of messages. Then no shard wastes time filtering.
Order router
Chooses where the order is filled. Robinhood's routing system sends stock orders to the market makers likely to give the best execution, based on historical performance. Best execution is a broker's legal duty to get customers the best terms reasonably available. For the 24 Hour Market it uses an ATS, which may reject prices outside set bands.
Clearing (Robinhood Securities)
Records trades with the clearinghouse and moves stock and cash at settlement. Each trading day by 10 AM ET it must meet the clearinghouse's deposit requirement. In 2021 Robinhood wrote that the requirement grows when customers buy more than they sell. It also grows when what they buy is volatile.
Load protection
Load testing replays real production read traffic. Load shedding turns off less important features when the system is overloaded. Robinhood wrote about both in 2021 and 2022. Its crypto team also put order flows on their own servers and connection pools.
06Data model
Data model
Pick the right store per table. Justify each choice with the access pattern, not by reflex.
shard_map (routing layer)customer_id (key)shard_idassigned_atOne row per customer. Durable, because a lost row means a customer cannot trade. Cached at the routing layer, because it is read on every request and changes very rarely. In 2022 Robinhood's crypto team sent most new customers to a new shard to fill it.
orders (in the customer's shard)order_idcustomer_idclient_order_id (unique per customer)symbolsidetype (market / limit)quantitylimit_pricestatuscreated_atPostgres, in the customer's own shard. The unique key on (customer_id, client_order_id) turns a retried request into a read of the saved order. Status changes are written in the same transaction as any money movement.
fills (in the customer's shard)fill_idorder_idvenuevenue_fill_id (unique per venue)quantitypriceexecuted_atOne order can have many fills, because a large order can be filled in parts. Insert only. The venue's own fill ID is stored too, so a fill reported twice is saved once.
positions (in the customer's shard)customer_idsymbolquantityreserved_quantityOne row per stock the customer holds. Updated with the order and the fill, in the same database. This is the reason to shard by customer. Everything one order touches lives on one shard, so no transaction crosses shards.
cash_balances (in the customer's shard)customer_idsettled_cashunsettled_cashreserved_cashOne row per customer. Cash from a sale that has not settled yet is tracked apart until settlement. A buy order reserves cash here in the same transaction that saves the order.
07Deep dives
Deep dives
These are the conversations the interviewer is steering you toward. Practice each one until you can talk through it without notes.
Placing an order safely: the client order ID
Phones lose signal. When that happens, the app does not know if the order arrived, so it sends it again. Without care, the customer buys twice. The fix is an idempotency key. Idempotency means doing a request twice has the same effect as doing it once. The key is the value that makes this possible. In this design the app creates a client order ID once, when the customer presses Buy. Every retry carries the same ID. The shard stores the ID with a unique constraint. That is a database rule that refuses a second row with the same value. A retry then finds the saved order and returns it. The order of steps matters. Insert the order first. If the insert returns a row, run the checks and reserve the money in the same transaction. If it returns nothing, this is a retry, so skip the reservation and return the saved order. Then an order either exists with its money reserved, or does not exist at all. Robinhood has not published how its order service does this; the sketch below is our design.
-- in the customer's shard, one transaction
INSERT INTO orders (customer_id, client_order_id, symbol, side,
type, quantity, limit_price, status)
VALUES ($1, $2, $3, $4, $5, $6, $7, 'new')
ON CONFLICT (customer_id, client_order_id) DO NOTHING
RETURNING order_id;
-- no row returned: this is a retry, so read and return the saved orderSharding the brokerage: what Robinhood did in 2020 and 2021
Robinhood wrote in 2021 that its brokerage first ran on a single database server. The application servers could scale, but the database could not. Peak load went from 100,000 requests per second in December 2019 to 750,000 in June 2020. Bigger databases, caching and query tuning gave less each time. Robinhood looked at Cloud Spanner, DynamoDB, CitusDB and CockroachDB. It decided they would need too large a rewrite of its business logic. So it kept PostgreSQL and built sharding on top of it. The key choice was where to cut. Robinhood could split only the database, or the whole system. It chose the whole system, at the application level. Each shard got its own servers, database and deployment pipeline. Robinhood gave two reasons. A failure stays inside one shard, which it calls a smaller blast radius. And a new feature can go to one shard first. It had one shard at the start of 2020, three at the end of 2020 and ten in 2021.
Reading across shards: the aggregation layer and its cursor
Sharding by customer makes one customer's work easy. It makes questions across customers hard. A support tool or a report may need rows from every shard, in order. In 2021 Robinhood wrote that it built an aggregation layer for this. It is a stateless service that fans a request out to all shards and merges the answers. Paging is the subtle part. Each shard returns its next page in order, and the service merges them. The next request must say where each shard stopped. So Robinhood built a custom cursor, a bookmark that holds one position per shard. The sketch below shows the idea with a simple merge. In an interview, say clearly that cross-shard reads are slower and rarer by design.
import heapq, itertools
def next_page(shards, cursor, size):
# cursor: {shard_id: last_key_seen}, one entry per shard
pages = {s.id: s.page_after(cursor.get(s.id), size) for s in shards}
merged = heapq.merge(*[[(r.key, sid, r) for r in rows]
for sid, rows in pages.items()])
taken = list(itertools.islice(merged, size))
for key, sid, _ in taken:
cursor[sid] = key # move only the shards we used
return [r for _, _, r in taken], cursorKafka in a sharded system
Kafka is a durable log of events that many services can read at their own pace. Events still flow between services after sharding: order updates, fills, notices to send. Robinhood had to make sure each event was handled by the right shard. Its 2021 answer was simple. Every shard consumed every message and processed only the messages for its own customers. Robinhood said this might not be the most efficient way. But it avoided building another proxy layer in an already complex system. For very busy streams, it made separate topics per shard. A topic is a named stream of messages. Then a shard reads only its own messages and skips the filtering. In 2022 Robinhood's crypto team made the same change when it sharded, and also made IDs globally unique across shards. Robinhood also built and open-sourced Faust, a Python library for stream processing on Kafka. Its README said Robinhood used it for pipelines that process billions of events every day. Robinhood has since deprecated it, and a community fork carries it on.
The market-open spike and the March 2020 outage
Load on a trading app is not smooth. Robinhood queues orders placed while the market is closed. It sends them at the next regular session, which opens at 9:30 AM ET. So the open starts with a burst, on top of everyone opening the app. A queued market order also carries a price risk. It fills at whatever price the stock opens at, which can be far from last night's close. A limit order caps that risk. On news days it gets much worse. On March 3, 2020, Robinhood's co-CEOs wrote that two days of outages were not acceptable. They said stress from unprecedented load led to a thundering herd effect that made its DNS system fail. DNS is the system that turns names like robinhood.com into server addresses. A thundering herd is many clients hitting the same thing at the same moment. Often they all retry at once. Robinhood did not publish which clients or retries were involved. The causes they named were historic market conditions, record volume and record sign-ups. They promised fewer dependencies between systems and more redundancy. In an interview, plan for this directly. In this design, clients retry with backoff and jitter, which means waiting longer each time plus a random amount. Servers should shed less important work first, and the open should be load-tested in advance.
Testing for the peak: Robinhood's Load and Fault team
Robinhood wrote in 2021 about a team built to find limits before customers do. It captures real traffic. Its nginx load balancers log a sample of requests: the user ID, the URL and the time. The logs flow through Kafka into S3. Only GET requests are kept, and each gets a read-only token, so a replay can never change customer data. Load generator pods running k6, an open source load testing tool, replay that traffic, in production whenever possible. A control loop raises the rate step by step. It stops the test the moment the target reports unhealthy. Robinhood reported a 75% drop in load-related customer incidents between Q1 and Q2 of 2021. It went through its IPO with no major load-induced incident. In 2022 its crypto team wrote that it built load shedding too. Less important features could be switched off to keep orders working. It never had to use it.
Routing the order: market makers, best execution and the overnight market
A broker does not match orders itself. Robinhood says it generally sends stock, ETF and options orders to market makers. An ETF is a fund that trades like a single stock. A market maker is a firm that is always ready to buy or sell. Robinhood's routing algorithm picks the market maker likely to give the best execution, based on historical performance. Best execution is a broker's legal duty to get customers the best terms reasonably available. Robinhood says most of its orders fill at the National Best Bid and Offer or better. That is the best public buy and sell price across US exchanges, called the NBBO. Market makers pay Robinhood for sending them orders. This is called payment for order flow, or PFOF. Robinhood says every market maker it works with pays the same rate. Overnight is different. In Robinhood's 24 Hour Market, orders go to an ATS, an alternative trading system. An ATS is a private trading venue that is not a public exchange. Only whole-share limit orders are allowed there. The ATS may reject limit prices outside price bands set from the price before 8 PM ET. In this design, the router needs live quality scores per venue and a fallback when a venue stops answering.
Clearing, deposits and the January 2021 restrictions
The trade is not over when it fills. Robinhood explained in January 2021 how the plumbing works. The market maker sends a record of the trade to Robinhood Securities, its clearing broker. That is the firm that handles settlement. Robinhood Securities works with a clearinghouse to record and settle it. Settlement then took two business days, called T+2. By 10 AM ET each trading day, the clearing broker must post a deposit. It covers trades that have not settled. Robinhood wrote that the deposit grows when customers buy more than they sell, and when what they buy is volatile. That week Robinhood's equity deposit requirement rose ten-fold. So it limited buying in a few volatile stocks. In a February 2021 post Robinhood said its systems stayed up through those volumes. The limit was money at the clearinghouse. The design lesson is that a broker needs a risk service. That is our view, not something Robinhood has described. It should estimate the next deposit through the day, by stock, so the firm sees the bill coming. US settlement moved to one business day, T+1, on May 28, 2024.
Common mistakes candidates make
The first mistake is designing an exchange. Candidates draw an order book and a matching engine. Robinhood is a broker: it sends orders to market makers and venues. Say that early, and spend your time on routing, safety and load. The second mistake is sharding only the database and leaving one shared application tier. Then one bad deploy or one slow query still hits every customer. Robinhood cut the whole stack into shards so a failure stays in one shard. The third mistake is choosing a shard key that splits one order's data. Shard by customer, so the order, the money and the position live together and one transaction is enough. The fourth mistake is ignoring retries. Without a client order ID, a dropped connection becomes a double purchase. Plain retries without backoff can turn a slow minute into an outage. Robinhood's March 2020 outage involved a thundering herd, though it did not say retries were the trigger. The fifth mistake is caching balances. In 2022 Robinhood's crypto team cached slow reads but never used caching on the write paths. Money values should come from the database. The sixth mistake is treating a cancel as instant. A cancel is only a request to the venue, and a fill can arrive first. The seventh is adding a shared service, like an order router, without saying how it fails. If it has no saved state and runs as several copies, losing one only slows things down. How to spend 45 minutes: about 5 on questions and numbers and 10 on the high-level design. Spend 20 on two or three deep dives and 10 on failures and follow-ups. Pick the deep dives the interviewer cares about, usually safe retries, sharding and the market open.
08Trade-offs
Trade-offs to discuss
Every senior interviewer expects you to surface at least 3 of these. Pick the decisions, state the alternatives, and justify your choice.
Shard the whole stack vs shard only the database
Sharding only the database keeps one shared application tier, which is simpler to deploy. Robinhood chose the whole stack. A failure or a bad release then stays in one shard. Features can go out one shard at a time. The cost is more moving parts: routing, aggregation and many deployment pipelines.
Postgres with sharding vs a distributed database
Spanner, DynamoDB, CitusDB or CockroachDB would scale out on their own. Robinhood judged they needed a deep rewrite of its business logic and data access. Keeping Postgres kept the code and the team's knowledge. The cost is that Robinhood must build and run the sharding itself.
Every shard reads every Kafka message vs a proxy that routes messages
A routing proxy reads each message once and sends it to one shard. It is efficient, but it is one more service to build and run. In 2021 Robinhood let every shard read everything and drop what was not its own. It wastes some work but adds nothing new to break. Busy streams got their own topic per shard.
Synchronous shard lookup vs a cached mapping
Robinhood's first routing layer called the shard mapping service on every request. That is simple and always current, but it adds a call to every request. Robinhood wrote that the mapping records are cacheable, and a customer rarely moves. In this design, a cache in the routing layer removes most of those calls.
Market makers vs sending every order to an exchange
Robinhood says market makers typically offer better prices than public exchanges. It also says their rebates are one of the revenue streams that keep its costs low. The cost is a dependency on a few outside firms and a duty to prove best execution. So the router needs quality data per venue and a fallback path.
Strong consistency for money vs caching for speed
Balances, reservations and positions must be exact, so they are read and written in the shard's database. Charts, news and prices can be a little stale and are cached. Robinhood's crypto team followed this split: it cached expensive reads that could tolerate staleness, and never cached on write paths.
Free PDF · 18 pages
Get the free System Design Interview Cheat Sheet
The interview in seven stages, the numbers worth knowing by heart, and twelve classic systems on one page each, every line linked to the lesson it comes from.
09Follow-ups
Follow-up questions to expect
After the main design, the interviewer usually picks one part and asks more. Here is what to say.
One shard's database fails during trading hours. What happens?
Only the customers on that shard are affected. Robinhood wrote in 2021 that failures are now limited to one shard. The routing layer keeps sending other customers to healthy shards. In this design the shard fails over to its own Postgres replica, a live copy of the database. Orders and money need synchronous replication to at least one replica. That means a write is confirmed only after the copy has it. Otherwise a confirmed order can vanish in the failover. That costs a little write latency, which is the right trade for money. Its customers see errors until it is back, and safe retries with client order IDs prevent double orders.
A meme stock is trending and everyone wants to buy it at the open. What breaks first?
Retries and the most popular endpoints. Prepare by load-testing the open in advance, shedding less important features first and making clients back off with jitter. Also watch the money side. In January 2021 Robinhood's systems stayed up, but its clearinghouse deposit requirement rose ten-fold. It had to limit buying in a few volatile stocks.
Your order router is shared by every shard. Doesn't that undo the blast-radius benefit?
Partly, yes. In this design, run several router copies, each with no saved state, so losing one only slows things down. Keep the order's state in the shard, so a router restart loses nothing. Robinhood's crypto team made a similar trade in 2022. It ran one settlement component shared across shards to avoid copying it for every shard. Robinhood has not published where its stock order router sits.
The customer presses Cancel, but the order fills a moment later. What does the system show?
A cancel is a request to the venue, not a promise. In this design the order moves to pending cancel. If the venue confirms the cancel, it becomes cancelled. If a fill arrives first, the fill wins. The shares are bought, and the customer sees a filled order and a rejected cancel. The app must never show cancelled before the venue confirms it.
How do millions of open apps get live prices?
Keep prices off the order path. In this design a market-data service takes the price feed once. It pushes updates over long-lived connections, such as WebSockets, through a fan-out tier. It sends only the stocks each screen is showing. Prices can be a moment old; orders cannot be wrong. Robinhood has not published how it does this.
10In production
How Robinhood actually does it
Every fact about Robinhood on this page comes from Robinhood's own writing and filings. The estimates and anything marked 'in this design' or 'assume' are ours. The shard design, the request numbers and the shard counts are from the 2021 post on scaling the brokerage system. The March 2020 outage cause is from the co-CEOs' note of March 3, 2020. Read replicas, caching only on read paths, and load shedding are from the 2022 post on scaling Robinhood Crypto. Traffic replay and the 75% drop in incidents are from the 2021 post on the Load and Fault team. Order routing, trading hours and the 24 Hour Market are from Robinhood's support articles, read in November 2026. Clearing and the January 2021 deposit rise are from Robinhood's note of January 29, 2021. That its systems stayed up is from its February 4, 2021 post on growth. The term payment for order flow is from Robinhood's Singapore support page. Customer and volume figures are from the Q3 2026 results filed with the SEC. Robinhood has not published its order service or where its order router sits. Those parts are marked as our design. Older posts describe the system at that date, so say the year when you quote a number.
Sources
- Robinhood engineering: How we scaled Robinhood's brokerage system for greater reliability (2021)
- Robinhood newsroom: the co-CEOs' update on the March 2020 outages (2020)
- Robinhood engineering: Scaling Robinhood Crypto systems (2022)
- Robinhood engineering: Scaling Confidently with the Load and Fault Team (2021)
- Robinhood support: Stock, ETF, and options order routing
- Robinhood support (Singapore): Stock and options order routing, on payment for order flow
- Robinhood support: Extended-hours trading
- Robinhood support: Robinhood 24 Hour Market
- Robinhood newsroom: What happened this week, on clearing and settlement (January 2021)
- Robinhood newsroom: Reflections on Robinhood's Growth (February 2021)
- Robinhood Q3 2026 results, Form 8-K/A exhibit 99.1, SEC (October 2026)
- SEC: statement on the move to T+1 settlement on May 28, 2024
- Robinhood on GitHub: Faust, stream processing for Python
Lessons to study before this interview
If any of these topics are fuzzy, the interviewer will catch it. Each lesson is 15 to 60 minutes with diagrams, code, and a quiz.
Database Sharding
foundation / database fundamentals
Read Replicas
foundation / database fundamentals
Idempotency Keys
intermediate / api design protocols
Idempotent Consumer
intermediate / messaging event systems
Transactional Outbox Pattern
intermediate / messaging event systems
Load Testing
intermediate / devops cicd
Load Shedding
advanced / reliability resilience
Bulkhead Pattern
advanced / reliability resilience
Retry Patterns
advanced / reliability resilience
Capstone: Design a Payment System
capstone / capstone
System design interviews at companies in the US, UK, Canada and Singapore
41 walkthroughs of real systems at well-known companies, each built from that company's own engineering blog, talks or filings, with the numbers cited.
Banking, payments and trading
- Monzo system design (UK)
- Wise system design (UK)
- Stripe system design
- PayPal system design
- Robinhood system design (this page)
- Coinbase system design
Commerce and delivery
Rides and maps
- Grab system design (Singapore)
- Uber system design
Feeds, social and messaging
Streaming and media
AI labs and big tech
Developer and collaboration tools
11FAQ
Frequently asked questions
Go deeper
This guide is built on these 6 lessons. Each one teaches one piece of the Robinhood design above, step by step.
- Database ShardingSystem Design · database fundamentals · 35 min
- Read ReplicasSystem Design · database fundamentals · 22 min
- Idempotency KeysSystem Design · api design protocols · 18 min
- Idempotent ConsumerSystem Design · messaging event systems · 20 min
- Transactional Outbox PatternSystem Design · messaging event systems · 22 min
- Load TestingSystem Design · devops cicd · 11 min
Practice with 770 system design lessons
Lifetime access for ₹1,111 in India or $35 elsewhere. Interactive diagrams, quizzes, and 20 capstone projects to practise on.
This one question is not enough for the interview.
Get all 200 questions in the System Design and Distributed Systems pack
Each question has why it is asked, a full answer, what the interviewer listens for, the follow-ups, the common mistakes and a diagram (268 diagrams in all). A PDF you keep, junior to staff level.
Pay by UPI, cards or netbanking through Razorpay. Pay by card or PayPal, in US dollars. Download at once from My packs.
NEWSystem Design Hands-On
Included in the System Design course: real systems, built live
Postgres Sharding: Complete Hands-On (PgBouncer + Citus). 2 h 36 min and 20 chapters: one PostgreSQL loaded until it breaks, then four shards behind a router you write, PgBouncer and Citus, with the 139-page slide deck. The first 15 minutes are free to watch.


