Jane Street Quantitative Developer Interview Guide

The short answer: Jane Street has no Quantitative Developer title. Its developers are Software Engineers who work mostly in OCaml, and the Low-Latency Engineer role is the closest match to a low-latency quant developer. Engineers build everything from trading systems to accounting and infrastructure, so only the trading-facing seats are developer work in the quant sense. Jane Street describes an application review, a technical interview over Zoom and in-person final rounds, all built on collaborative coding in the language you choose. Its software engineering interviews have no math, probability or puzzles. Last reviewed October 2026.

Jane Street quantitative developer interview: quick answers

The Jane Street quantitative developer role

What Jane Street quantitative developers work on, the skills its job postings ask for, and what a week can look like. Jane Street posts the role as Software Engineer (Experienced, New Grad and Summer Internship), working mostly in OCaml, with Low-Latency Engineer as the closest match to a low-latency developer. Jane Street has no Quantitative Developer title, and only its trading-facing Software Engineer seats are quant developer work.

Jane Street quantitative developer levels and pay

Your level sets the bar you are interviewed against and the pay band of the offer.

Jane Street publishes no level ladder. Postings are split only into Experienced, New Grad and Summer Internship, and the New York base is the same $300,000 for experienced and new-grad Software Engineers, so the pay table uses posting titles.

Pay in Jane Street's US job postings

Jane Street's New York postings state a base salary and say total compensation also includes an annual discretionary bonus.

The New York Software Engineer internship posting states a base salary of $300,000 but does not say whether that figure is annualized or prorated, so it is left out of the table. London, Hong Kong and Singapore postings show no pay. Ranges seen October 29, 2026.

Jane Street quantitative developer interview process

The steps follow Jane Street's interviewing page, its software engineering prep page and its blog posts on the developer interview. Round counts come from the 2020 blog post and candidate reports, so treat them as approximate.

Based on Jane Street's own pages and candidate reports.

Jane Street replies about a week after each step and does not publish an overall timeline. It encourages reapplying, since it reconsiders candidates over time. Last reviewed October 2026.

What is different at Jane Street

• The title maps loosely. Jane Street has no Quantitative Developer title. Developers are Software Engineers in the Technology department, hired through one process and considered for all open roles. Engineers work in every part of the firm, from trading desks to accounting and network monitoring, so only the trading-facing seats match quant developer work. Low-Latency Engineer is the closest posting: it works with quantitative researchers and developers on fast-trading systems. Jane Street's trading interviews are a different process, covered in our separate Jane Street Quantitative Trader guide.
• There is no math round. Jane Street says software engineering interviews have no math or probability questions, and software engineers get no mental math, math olympiad or logic puzzles. The bank questions on this page are general quant practice for readers who also apply to trading roles. The developer loop does not ask them.
• OCaml runs almost everything. Jane Street writes everything it can in OCaml. Even the Low-Latency Engineer role builds fast-trading systems mainly in OCaml, with small amounts of C and C++. You need no OCaml to apply, and interns learn it on the job.
• The interview simulates working together. Interviewers want to know whether they would like to work with you, so they weigh clear discussion, tradeoffs and honest "I don't know" answers alongside correct code. In the published example question, every successful candidate finishes the first part bug-free fairly quickly, and strong candidates reach the third.
• Jane Street builds its own tools. It has released about a million lines of open-source code, including magic-trace, Hardcaml, Bonsai, Dune and OxCaml, and runs code review and releases through its own system, Iron.
• Jane Street does not publish a rule on AI use in interviews; ask your recruiter. Its interviewing pages, prep pages and software engineering postings say nothing about AI tools.

Jane Street quantitative developer interview questions

Questions from our bank, then practice prompts we wrote for this guide around Jane Street's work.

1from typing import List, Optional, Tuple
2
3def track_bbo(events: List[tuple]) -> List[Tuple[Optional[int], Optional[int]]]:
4    """Return (best_bid, best_ask) after each event."""
5    pass

1import heapq
2from typing import List, Optional, Tuple
3
4def track_bbo(events: List[tuple]) -> List[Tuple[Optional[int], Optional[int]]]:
5    orders = {}  # id -> [side, price, qty left]
6    levels = {"B": {}, "S": {}}  # side -> price -> total qty
7    heaps = {"B": [], "S": []}  # bids stored negated; stale prices removed lazily
8    out = []
9
10    def best(side):
11        h, lv = heaps[side], levels[side]
12        while h:
13            price = -h[0] if side == "B" else h[0]
14            if lv.get(price, 0) > 0:
15                return price
16            heapq.heappop(h)  # level is empty now
17        return None
18
19    def reduce(oid, qty):
20        side, price, left = orders[oid]
21        take = min(qty, left)
22        levels[side][price] -= take
23        if levels[side][price] == 0:
24            del levels[side][price]
25        if left == take:
26            del orders[oid]
27        else:
28            orders[oid][2] = left - take
29
30    for ev in events:
31        if ev[0] == "add":
32            _, oid, side, price, qty = ev
33            if oid not in orders and qty > 0:
34                orders[oid] = [side, price, qty]
35                if price not in levels[side]:
36                    heapq.heappush(heaps[side], -price if side == "B" else price)
37                levels[side][price] = levels[side].get(price, 0) + qty
38        elif ev[0] == "cancel":
39            if ev[1] in orders:
40                reduce(ev[1], orders[ev[1]][2])
41        elif ev[0] == "trade":
42            if ev[1] in orders:
43                reduce(ev[1], ev[2])
44        out.append((best("B"), best("S")))
45    return out
46
47# Complexity: O(log n) amortized per event, where n is the number of price levels seen;
48# each pushed price is popped at most once. O(n + m) space for levels and m live orders.

How to prepare

A plan for the Jane Street loop, most important first:

1. Pick the language you know best and practice writing real, bug-free code in it, including its standard data structures and APIs.
2. Practice open-ended problems that grow in stages, such as a cache that gains eviction, and finish the first stage cleanly before extending it.
3. Watch Jane Street's mock interview and work through its published example question, then rehearse thinking out loud.
4. Review CS fundamentals and real-machine costs: Big-O, caching and IO. For low-latency seats add x86 caches, profiling and kernel-bypass networking.
5. Build a small project from scratch, as Jane Street suggests, so you can talk through its design and tradeoffs.
6. Skip math and puzzle drills for this loop. The bank questions on this page are general quant practice and matter only if you also apply to trading roles.

Practice path

Courses that cover the rounds above:

• Data Structures and Algorithms
• System Design
• Trading Systems Design
• Modern C++