Practice for quant developer interviews

Almost every firm opens with a HackerRank, Codility or CodeSignal test of two to four problems in one to two hours, proctored and AI-detected. What follows depends on the firm: language-agnostic algorithm rounds at some, and at the C++-first firms the order book, the memory model and the lock-free queue. On the track below, each group of problems comes right after the lessons that teach it.

Sign up freeAlready have an account? Log in

The track

140

items in 12 sections

Starts with
How a market works
Time to complete
40.5 h
6 to 8 weeks · 1 to 2 h a day

The approach

How to prepare for a quant developer interview

  1. Step 1

    Know which of the three interviews you face

    Three developer interviews exist: the language-agnostic algorithm process, the C++-first low-latency one, and the data-leaning platform seat; the job description usually says which. All three open with a proctored online test of two to four problems in one to two hours on HackerRank, Codility or CodeSignal, so the fundamentals come first either way.

  2. Step 2

    Read the lessons, then solve the problems beside them

    Read the programming lessons, then solve the problems beside them in order: warm-up, data structures, algorithms and intervals, then parsing and order books. Every problem runs against hidden tests in the workspace, in Python or C++, and a passing submission marks it done. Practise reading the constraints before you type.

  3. Step 3

    Go deep on C++ if the firm is C++-first

    If the firm is C++-first, the systems course covers what these firms ask beyond the generic band: move semantics, RAII, what virtual dispatch costs, the memory model and atomics, lock-free queues and allocators. The C++ internals, concurrency and systems sections rehearse those rounds.

The rules

  • Work from the top

    How a market works and how developers are tested come first, then data structures and algorithms, order books and trading systems, C++ internals, concurrency, systems and system design. The C++ containers and the Python and data sections are optional and do not count toward the track.

  • Pass the tests

    A lesson ticks when you complete it. A coding problem ticks when a submission passes every hidden test, in Python or C++. The course questions have a bar, shown as the goal, and a guide ticks when you open it.

  • Practise from anywhere

    A run, a lesson or a problem counts wherever you start it on Tradermath, not only from this page. Opening an item from the track gives you its place on the track, with the way back.

  • Free to follow

    Some lessons and problems and every guide are free. The rest need Tradermath Premium. Each item shows its own access.

Sections [12]

  1. 01

    How a market works

    3 items · 21 min

    The venue around the code, before any of it: the order book, spread and depth, and price-time priority. Three short reads; every developer interview asks about these in passing.

    Prepares forLive coding

  2. 02

    How developers are tested

    3 items · 29 min

    The shape of the developer funnel before any code: the online assessment every major firm uses as its first filter, what the graders check once the tests pass, and the interview guide for the whole process.

    Prepares forOnline assessmentLive coding

    • 1 Article
    • 2 Lessons
  3. 03

    Data structures and algorithms

    29 items · 8.5 h

    The structures and algorithms the online tests and live rounds are built on: arrays and pointers, hash maps, heaps, caches, windows, intervals, graphs and dynamic programming, and how to talk through complexity out loud. Each is followed by the problems that test it.

    Prepares forOnline assessmentLive coding

    • 10 Lessons
    • 18 Coding problems
    • 1 Course questions
  4. 04

    Order books and trading systems

    22 items · 8 h

    The signature domain problems: parsing a message stream and a log, a price-time priority book under cancels and amends, an order management system and an auction, and the object design around them.

    Prepares forOnline assessmentLive coding

    • 7 Lessons
    • 15 Coding problems
  5. 05

    C++ internals

    28 items · 7.5 h

    C++ internals as the low-latency firms test them: what the machine does with an object, ownership and move semantics, what virtual dispatch costs, allocators, container costs, floating point and undefined behaviour, what each standard added, and compile-time programming. For Python candidates, what CPython does with your objects. The C++-first firms ask this far deeper than a generic tech interview.

    Prepares forOnline assessmentLive codingOnsite

    • 14 Lessons
    • 13 Coding problems
    • 1 Course questions
  6. 06

    C++ containers by hand

    Optional9 items · 5 h

    For C++ candidates: the standard containers rebuilt by hand, from a small vector to an open-addressing map and a skip list. The low-latency firms ask for this kind of code. This section is optional and does not count toward the track.

    • 9 Coding problems
  7. 07

    Concurrency

    21 items · 6.5 h

    Threads and races, mutexes and the lost wakeup, atomics and the memory model, lock-free queues, thread pools and false sharing, then the problems: a producer-consumer queue, a lock-free ring, a thread pool and a data race to fix. For Python candidates, the GIL, threads against processes and asyncio, with a deadlock problem in Python.

    Prepares forLive codingOnsite

    • 9 Lessons
    • 11 Coding problems
    • 1 Course questions
  8. 08

    Systems and performance

    17 items · 5.5 h

    The systems round: the cache hierarchy, the network path to a feed handler and how to measure latency, then the problems: virtual memory and the TLB, copy-on-write, an allocator, and the feed side of networking, from framing and gap detection to arbitrating two feeds and a latency histogram.

    Prepares forLive codingOnsite

    • 3 Lessons
    • 12 Coding problems
    • 2 Articles
  9. 09

    System design

    3 items · 19 min

    The design round in both of its forms: a low-latency system on one machine, with a thread, a queue and a latency budget for every stage, and the distributed design platform teams ask, with replication, idempotent retries and quorums. Six design trade-off questions sit with the two lessons.

    Prepares forOnsite

    • 2 Lessons
    • 1 Article
  10. 10

    Python and data

    Optional12 items · 3 h

    For the data-leaning developer seats: vectorised pandas and numpy, time-series alignment, a trade blotter end to end and numbers that survive review, then the problems, ending with a SQL query over a table of trades. This section is optional and does not count toward the track.

    • 6 Lessons
    • 6 Coding problems
  11. 11

    Reading and fixing code

    11 items · 3.5 h

    Code you did not write: how to read it, how the fix-the-bug round runs, and code written to be read. Then broken code to fix, three programs in C++ and two in Python, and two probability problems in code.

    • 4 Lessons
    • 7 Coding problems
  12. 12

    Interview craft

    3 items · 21 min

    The rounds that are not a problem to solve: the take-home and the review that follows it, defending a project you built, and the extension round, where one problem grows for an hour. Three reads.

    Prepares forOnline assessmentLive codingOnsite

    • 3 Lessons

Interview ready

How quant developer interviews run

The stages in the order firms run them. Select a stage for its rounds and the track sections that prepare them.

Stage 02 of 04

The online assessment

The first filter is a machine: a small number of problems, a hard clock, webcam proctoring and AI-use detection. Almost every major firm gates the developer funnel with one, in one of three shapes.

The roundsPrepared by

Full process The Quant Developer Interview Guide

Then zoom in on a firm

The track gets you to level in general. Each firm runs its own version of the process, and its page has the assessments, questions and guide for it.

Quant developer interview preparation: questions

Which language should I prepare in?
C++ for the low-latency firms, where it is often mandatory and the internals are tested in depth. Python is accepted at most algorithm-first firms and at the data-leaning developer seats. On this track, the warm-up, algorithms, parsing and Python and data problems run in Python, and so do the Python members of the data-structures and order-book groups. The C++ containers and C++ internals problems are C++ only, the concurrency problems are C++ apart from one deadlock problem in Python, and the systems section mixes the two.
Do quant developer interviews use LeetCode?
The online assessment and the algorithm rounds draw on the LeetCode band, medium to hard, and it is worth doing. LeetCode stops short of the firm-specific part: an order book under cancels and amends, feed and log parsing under a time limit, the C++ memory model, lock-free structures and custom allocators. The Quant Dev 50 is built for that part, with the two courses in front of it.
What is on the quant developer online assessment?
Usually two to four problems in 60 to 120 minutes on HackerRank, Codility or CodeSignal, proctored by webcam and checked for AI use. Some firms mix in multiple choice: one major assessment opens with ten C++ questions on language semantics before any code. Akuna Capital and XTX Markets set a take-home instead, graded on hidden tests and then read for design.
What C++ do quant developer interviews ask?
At the low-latency firms, the internals: move semantics, RAII and the rule of five, what virtual dispatch costs, the memory model and atomics, lock-free queues, custom allocators, and fixing a data race in code you are shown. Far deeper than a generic tech interview. The systems course on the track covers each of these, and the C++ internals and concurrency sections have a problem on most of them.
How long does the Quantitative Developer Role Track take?
Six to eight weeks at one to two hours a day, most of it on the problems. The track counts about 41 hours of sit-down time, and that figure is a floor: an order book or a lock-free queue in C++ usually takes more than one sitting to pass every hidden test. The lessons around the problems are short and worth reading before the problems they introduce.
How is progress tracked?
From what you have already done: a lesson counts when you complete it, and a coding problem when a submission passes every hidden test or you mark it complete from the problem page. A guide counts once you have opened it while signed in. The C++ containers and the Python and data sections are optional: their items tick as you go, but they do not count toward the track.