How Optiver's process runs, as candidates and the firm describe it, and the questions candidates report, each with a worked solution. Free, no sign-up.
Online assessment reported to include the 80-in-8 mental maths test, a "Beat the Odds" probability section, Zap-N reaction/neuro games and number-sequence puzzles.
Later rounds reported to include probability questions, estimation, and trading/betting games with dice, coins and cards where you look for arbitrage and size bets.
Software engineering applicants (including interns) take a different online assessment: one or two long class-design coding problems on HackerRank, a 20-minute computer-science quiz and Zap-N games. Then a recruiter call, technical interviews (data structures, networking and operating systems, debugging a trading program) and a final round with system design. Practise them in Coding (SWE).
Trader · Interview · Optimal stopping · reported by a candidate
Three face-down cards show n, n + 1 and n + 2, in random order, and you don't know n. Turn one over: keep it, or turn another. Keep that, or take the last card. You win the value of the card you keep.
Under the best strategy, how much more than n do you win on average?
Answer and worked solution
Answer: 4/3 ≈ 1.3333
Key idea. The first card tells you nothing, since n is unknown, but the second can be compared with it.
Always look at a second card.
If it's higher than the first, it's the middle or top card, equally likely: keep it (worth n + 1.5 on average, versus n + 1 for the last card).
If it's lower, the last card is better on average: take it.
Over the 6 equally likely orders this strategy wins 1, 2, 2, 2, 1 and 0 above n: 8/6, so 4/3 ≈ 1.33 above n on average.
Check. Doing nothing clever gives n + 1 on average; the comparison adds a third.
Interviewers may push further: With four cards n … n + 3? Now you are told n is 0, 10 or 20, equally likely. Does the strategy change?
Software Engineer Intern · Final round · System design · reported by a candidate
Design a low-latency trading system, from the exchange's market data arriving to your order reaching the exchange. Describe the components, what hardware they run on, and where the time goes. Go as deep as you can.
Model answer
Market data in. Exchanges publish over UDP multicast, often on two redundant feeds (A and B). A feed handler decodes the exchange's binary protocol, checks sequence numbers, takes the first copy of each packet from either feed, and recovers gaps from a snapshot or retransmission service. Kernel-bypass networking (the NIC delivers packets straight to user space) avoids system calls and copies; some firms decode on FPGAs.
Order book. Build the book per instrument from the updates: price levels in arrays indexed by tick for speed, best bid and offer kept current.
Strategy. Compute fair values and decide quotes. The hot path is single-threaded and pinned to an isolated core: no locks, no memory allocation, no logging, data laid out for the cache. Other threads talk to it through lock-free single-producer single-consumer ring buffers.
Risk checks before every order. Position and exposure limits, price bands (no order far from the market), order-rate throttles, and a kill switch. They must be in the path and fast.
Order gateway. A TCP session per exchange using its binary order protocol or FIX: logon, heartbeats, sequence numbers, handling acknowledgements, fills and rejects, and resynchronising after a disconnect.
Off the hot path. Asynchronous logging, monitoring and alerting, a drop copy of fills to reconcile positions, and recording of all data for replay and testing.
Hardware and placement. Servers colocated in the exchange's data centre, fast NICs with hardware timestamps, clocks synchronised by PTP, and tuned machines (isolated cores, no CPU frequency scaling, huge pages).
Where the time goes. Wire to decoded update, to decision, to risk check, to order on the wire: measure each stage with hardware timestamps and watch the tail (the 99.9th percentile), not just the average. A cache miss is about 100 ns and a system call around a microsecond, so they show up.
Say what you would build first, and what happens on failure: a gap on the feed, a disconnect from the exchange, a strategy behaving badly (the kill switch). Ask what latency matters for this business before optimising.
Software Engineer Intern · Final round · System design · reported by a candidate
Design a system for selling concert tickets. A popular show sells out in minutes, and no seat may ever be sold twice.
Model answer
Requirements first. No double-selling (correctness over speed), fair access when demand spikes, people pick seats, payment can fail. Ask about scale: seats per show, buyers at the start of a sale.
Hold, then pay. Selecting a seat places a hold for a few minutes. The hold must be atomic: one conditional update such as "set status to held where id = ? and status = free", or a transaction with a row lock. Exactly one buyer's update succeeds. Holds that expire release the seat.
Payment. Charge with an idempotency key so a retry never charges twice; on success mark the seats sold and the hold finished, in one transaction.
The spike. A virtual waiting room lets buyers in at the rate the system can take. Seat maps are read far more than written, so cache them and accept being a second stale; the hold itself always goes to the database.
Scaling. Shard by event, since one event's seats are only contended among its own buyers. Keep services stateless behind a load balancer.
Then talk about failure: what happens if a server dies after the payment succeeds but before the seats are marked sold? (Reconcile from the payment provider's records and the order log.)
Software Engineer Intern · Technical · Data structures · reported by a candidate
Talk me through how you would implement a queue. Now build it on an array. What does each operation cost? What changes if it has to grow, or if one thread pushes while another pops?
Model answer
Linked list: keep head and tail pointers; push at the tail, pop at the head, both O(1). Each node is a separate allocation, which is slow and scatters memory.
Array (ring buffer): keep the array, the index of the front and the count. Push writes at (head + count) mod capacity; pop reads at head and moves it on. Both O(1), nothing shifts. Store the count (or leave one slot empty), or you can't tell full from empty.
Growing: when full, allocate double the size and copy the items in order to the start. Pushes stay O(1) amortised, because the copies add up to less than 2n.
Two threads: the simple answer is a mutex (plus a condition variable to wait on). With exactly one producer and one consumer you can avoid locks: only the producer writes the tail index and only the consumer writes the head, both atomics with release and acquire ordering, and each index on its own cache line so the cores don't fight over it (false sharing). Trading systems pass messages between threads this way.
Software Engineer Intern · Technical · CS fundamentals · reported by a candidate
What is the difference between TCP and UDP? Which would you use to receive market data, and which to send orders, and why?
Model answer
TCP: a connection (three-way handshake: SYN, SYN-ACK, ACK) carrying a reliable, ordered byte stream. Lost segments are retransmitted, and flow and congestion control slow the sender down. A lost segment holds up everything behind it (head-of-line blocking). Nagle's algorithm can delay small writes; low-latency code sets TCP_NODELAY.
UDP: independent datagrams with no connection, no retransmission and no ordering. Less overhead and no waiting for lost data, and it supports multicast.
Market data: UDP multicast. The exchange sends each update once to every subscriber. Stale prices are useless, so don't wait for a retransmission: detect the gap from sequence numbers, mark the book as unreliable, and recover from a snapshot or a separate retransmission channel (often TCP).
Orders: TCP. Every order, cancel and fill must arrive exactly once and in order, and the exchange needs a session for each firm. Exchange order protocols run over TCP.
Software Engineer Intern · Technical · CS fundamentals · reported by a candidate
Compare Python, C++ and Java. Why might a trading firm write its fastest systems in C++ and its tools in Python?
Model answer
How they run: C++ compiles ahead of time to machine code. Java compiles to bytecode that a JIT compiles while the program runs, so it needs warming up. CPython interprets bytecode, roughly 10 to 100 times slower for plain loops.
Memory: C++ is managed by hand, made safe with RAII (destructors free resources at the end of a scope) and smart pointers, and you control the layout of data in memory. Java and Python use garbage collection (Python mainly reference counting), so there are pauses or overhead you don't control directly.
Types: C++ and Java are statically typed; Python is dynamic, which makes it fast to write and easier to get wrong at run time.
Concurrency: C++ and Java threads run in parallel; CPython's global interpreter lock stops threads running Python code at the same time (processes or native libraries such as NumPy get round it).
The trade-off: on the latency-critical path, predictability matters most: no garbage collection pauses, no JIT warm-up, control of the cache. That favours C++. For research, analysis, tooling and glue code, speed of writing matters more, and Python's libraries win. Java sits between, with careful tuning to avoid garbage collection on the hot path.
Software Engineer Intern · Interview · Behavioural · reported by a candidate
Behavioural questions candidates report from Optiver's software engineering interviews:
Why Optiver, and not a software company?
What does a market maker do?
Describe a project on your CV. What was the hardest technical decision?
Tell me about a time you failed or didn't meet expectations.
What would people who have worked with you say is your weakness?
Answer one out loud, as you would in the interview.
Model answer
Why Optiver rather than a tech company: the software is the business. Its performance and correctness show up straight away in profit and loss, engineers sit with traders, and problems such as low latency and risk are unusual. Name something concrete you learned from Optiver's own material or from someone there.
What a market maker does: it quotes both a price to buy (bid) and a price to sell (ask) in many products, all the time, so others can trade when they want. It earns the spread between them and manages the risk of the positions it ends up with, hedging quickly. The skill is pricing accurately and reacting fast, which is why the technology matters.
Projects: be ready to go deep: why you chose that design, what you would change, what broke and how you found it. Only claim what you can defend line by line.
Failure and weakness: Use a short story: the situation in one sentence, what you did (not the team), the result with a number if you have one, and what you'd do differently. Aim for about two minutes. Pick a real weakness with a cost, and what you now do about it.
Trader · Interview · Behavioural · reported by a candidate
Behavioural questions candidates report:
Tell me about an accomplishment you are particularly proud of.
How have you worked in a team, and how did you handle conflict?
Why Optiver, and why do you want to be a trader?
Answer one out loud, as you would in the interview.
Model answer
Three parts, about a minute each. Why trading: a specific moment you got hooked (a game, a market you followed, a decision under uncertainty), not "I like maths". Why this firm: something concrete about how it trades or trains people, ideally from talking to someone there or from its own material. Why you: evidence you already think in probabilities and react well to being wrong. Avoid anything about money or prestige.
For the others: Use a short story: the situation in one sentence, what you did (not the team), the result with a number if you have one, and what you'd do differently. Aim for about two minutes.