---
title: "Quant Developer"
book: "The Industry: Firms, Roles and Careers"
subject: quant
language: en
chapter: 19
exercises: 8
source: https://one-course.com/books/quant/17/en/chapter/19-quant-developer
---

# Chapter 19 — Quant Developer

In fiscal 2025 the sourced finance employers filed 169 labour condition applications for jobs whose titles named a quantitative developer or engineer. They filed 122 of them under the occupation code of financial quantitative analysts, 25 under software developers, and 22 under at least three other codes, none of which reached ten. The code is the employer’s choice, and it follows the job more than the title does: behind “quant developer” stand three different jobs, the researcher’s engineer, the desk’s [library developer](#def-in-quant-developer-library) and the [trading-system developer](#def-in-quant-developer-trading). This chapter separates them, shows what each ships and how it is judged, and measures what the choice of code says about pay.

| **Role cards: the three quant developers** |
| --- |
|  | [research engineer](#def-in-quant-developer-research) | [library developer](#def-in-quant-developer-library) | [trading-system developer](#def-in-quant-developer-trading) |
| works with | researchers | [desk strategists](https://one-course.com/books/quant/17/en/chapter/18-bank-quant#def-in-bank-quant-strat) and [library quants](https://one-course.com/books/quant/17/en/chapter/18-bank-quant#def-in-bank-quant-library) | traders and engineers |
| ships | research infrastructure and production versions of signals | the pricing library’s code | the trading system |
| horizon | days to weeks | releases | microseconds to days |
| reports to | head of research | head of quantitative analytics | head of trading technology |
| codes in filings | 13-2099.01, 15-1252 | 13-2099.01, 15-1252 | 15-1252 |
| taught in | Book 7, ch. 1; Book 15, ch. 1 | Book 5, ch. 28; Book 6, ch. 29 | Book 13, ch. 1; Book 16, ch. 21 |

Book 16, chapter 21, defines the quant developer as an engineer who turns a researcher’s prototype into production code, owns its performance and correctness, and knows enough of the model to change it safely, and places the role in embedded or central teams. This chapter takes that definition as given and asks which of three products the engineer is building.

## 19.1 The researcher’s engineer

**Definition 19.1 (Research engineer).**

A *research engineer* is a quant developer who works inside a research group and builds what researchers work with and what their results become: data pipelines, backtesters and simulation tools, the computing that runs experiments, and the production versions of signals the group has decided to trade.

The [research engineer](#def-in-quant-developer-research)’s customers are researchers, and the product is their speed. Book 7 (chapter 1) describes the research process the engineer serves, and Book 15 the platforms (research, data and risk) that a firm builds for it: the point-in-time data store, the backtester that reproduces a result a year later, the experiment tracker, the job scheduler on the cluster. At a systematic fund or a platform, where many researchers share one infrastructure, the [research engineer](#def-in-quant-developer-research)’s work is multiplied by every researcher who uses it; at a market maker, where research sits close to trading, the engineer also carries a signal from the research code into the trading system and checks that the two agree.

The job is judged on two things. The first is correctness under reproduction: a backtest that cannot be rerun, or a production signal that differs from its research version, destroys the evidence research exists to produce. The second is time: the hours between an idea and its first honest test. A researcher’s [feedback speed](https://one-course.com/books/quant/17/en/chapter/17-quantitative-researcher#def-in-quant-researcher-feedback) (chapter 17) is limited by the market; the [research engineer](#def-in-quant-developer-research) sets the other limit.

## 19.2 The desk’s library developer

**Definition 19.2 (Library developer).**

A *library developer* is a quant developer who writes and maintains the code of a pricing and risk library for the quants who design its models: the interfaces, data structures, performance and numerical plumbing that turn a [library quant](https://one-course.com/books/quant/17/en/chapter/18-bank-quant#def-in-bank-quant-library)’s methods into a product every desk and risk system can call.

The [library developer](#def-in-quant-developer-library) works beside the [library quant](https://one-course.com/books/quant/17/en/chapter/18-bank-quant#def-in-bank-quant-library) of chapter 18, and the line between them is a matter of emphasis: the quant owns the mathematics of a model, the developer the code that makes it fast, stable and callable from elsewhere. Book 5, chapter 28, builds a pricing library with a core in C++20 and Rust behind a Python interface, and the split of work there is the split of the two jobs: the numerical method on one side; memory layout, threading, the interface, the build and the regression suite on the other. Where one library serves every desk of a bank, the job sits with the group that owns it; where pricing is part of the trading system, as for an options market maker (Book 11), it merges into the [trading-system developer](#def-in-quant-developer-trading)’s.

The [library developer](#def-in-quant-developer-library) is judged like the library itself: no desk’s numbers change unless someone meant them to, every release reproduces the last one’s results to a stated tolerance, and the library is fast enough for the risk runs that call it millions of times a night.

## 19.3 The trading-system developer

**Definition 19.3 (Trading-system developer).**

A *trading-system developer* is a quant developer who builds and runs the systems that trade: market-data handlers, the strategy engine, order entry, risk checks and the monitoring around them, measured in microseconds and in what they do when something fails.

The [trading-system developer](#def-in-quant-developer-trading) works closest to money. The tick-to-trade latency and the latency budget of Book 13, chapter 1, are this developer’s units; the exchange protocols of Book 10 and the network and hardware of Book 14 are the developer’s environment. The quantitative part of the job is not the model but its implementation under constraints: a signal that must be computed in two microseconds, an inventory skew that must be applied on every quote, a risk check that must reject an order before it leaves. At market makers and high-frequency firms these developers are often filed as software engineers, and chapter 20 covers the engineering that surrounds them.

**As of September 2025 — Quant developers in the filings and the survey.**

Fiscal 2025 labour condition applications at the sourced finance employers: 169 in the quant-developer title family (122 coded 13-2099.01, 25 coded 15-1252, 22 under codes with fewer than ten each); the systematic funds’ cell, 12 applications from 3 employers, median offered base $235 000 (10th–90th percentile $195 500–272 500); every other employer kind’s cell comes from one or two employers and is suppressed. Across all titles: software developers (15-1252) 5 531 applications, median $155 000; financial quantitative analysts (13-2099.01) 1 294, median $150 000. Occupational survey, May 2025, software developers: securities industry median $163 290 (10th–90th $104 600–245 380; 34 940 employed); banks $136 620; software publishers $164 550 (173 080 employed).

## 19.4 What each ships and how it is judged

The three jobs share a title and much of a toolkit (a systems language, Python, version control, testing, some statistics), but not a product or a clock.

|  | [research engineer](#def-in-quant-developer-research) | [library developer](#def-in-quant-developer-library) | [trading-system developer](#def-in-quant-developer-trading) |
| --- | --- | --- | --- |
| ships | pipelines, tools, production signals | library releases | system releases, configurations |
| judged on | reproducibility; researchers’ time | stability; speed; coverage | latency; uptime; correct behaviour |
| failure looks like | a result no one can rerun | all desks’ numbers move | a loss in seconds |
| on call | rarely | at release | while markets are open |

The occupation codes follow the same line. The financial quantitative analysts’ definition, “Develop mathematical or statistical models for risk management, asset optimization, pricing, or relative value analysis”, fits the [research engineer](#def-in-quant-developer-research) and the [library developer](#def-in-quant-developer-library); the software developers’, “Research, design, and develop computer and network software”, fits the [trading-system developer](#def-in-quant-developer-trading). O*NET places the first in its highest preparation band (most need graduate school) and the second in the band below (most need a bachelor’s degree). The code also moves: in 2018 the classification merged the two software-developer codes of 2010 (15-1132 and 15-1133) into 15-1252, so fiscal 2021 filings need a crosswalk before they can be compared with fiscal 2025’s.

![Occupation codes within four title families, fiscal 2025 filings at the sourced finance employers. Codes with fewer than ten filings in a family are counted as “other”. The quant-developer titles are filed mostly as quantitative analysts, the software-engineer titles almost only as software developers. Data: data/industry/lca_titles.csv and lca_ranges.csv, through in_quantdev.soc_mix.](https://one-course.com/images/onecourse/chapters/quant-17/in-quant-developer/fig-38de63995e5e.svg)

***Figure 19.1.** Occupation codes within four title families, fiscal 2025 filings at the sourced finance employers. Codes with fewer than ten filings in a family are counted as “other”. The quant-developer titles are filed mostly as quantitative analysts, the software-engineer titles almost only as software developers. Data: `data/industry/lca_titles.csv` and `lca_ranges.csv`, through `in_quantdev.soc_mix`.*

Does the code matter for pay? Across all titles at the sourced employers in fiscal 2025, filings coded as software developers have a median offered base $5 000 above those coded as quantitative analysts, with a bootstrap interval from $-\$372$ to $5 688 that just includes zero. Within each [wage level](https://one-course.com/books/quant/17/en/chapter/14-pay-levels-by-role-firm-type-and-seniority#def-in-pay-levels-by-role-firm-type-and-seniority-soc) the sign reverses: the analysts’ median is higher at levels III and IV, by $11 000 and $27 092 (Figures [19.2](#fig-in-quant-developer-levels) and [19.3](#fig-in-quant-developer-gap)). The two statements are consistent because the codes are used at different levels: half the software-developer filings are at level IV, against one in seven of the analysts’ ([Figure 19.4](#fig-in-quant-developer-levelmix)).

![Median offered base by wage level for the two codes a quant developer is filed under, all titles at the sourced finance employers, fiscal 2025, with 95% bootstrap intervals for the median. Data: data/industry/lca_soc.csv, through in_quantdev.soc_cells.](https://one-course.com/images/onecourse/chapters/quant-17/in-quant-developer/fig-25194a077523.svg)

***Figure 19.2.** Median offered base by [wage level](https://one-course.com/books/quant/17/en/chapter/14-pay-levels-by-role-firm-type-and-seniority#def-in-pay-levels-by-role-firm-type-and-seniority-soc) for the two codes a quant developer is filed under, all titles at the sourced finance employers, fiscal 2025, with 95% bootstrap intervals for the median. Data: `data/industry/lca_soc.csv`, through `in_quantdev.soc_cells`.*

![Median offered base of software-developer filings minus that of quantitative-analyst filings, overall and by wage level, with 95% bootstrap intervals (fiscal 2021 codes merged by the 2018 crosswalk). At or above zero overall, negative or indistinguishable from zero within each level. Data: data/industry/lca_soc_gap.csv, through in_quantdev.gaps.](https://one-course.com/images/onecourse/chapters/quant-17/in-quant-developer/fig-7447ea1252d6.svg)

***Figure 19.3.** Median offered base of software-developer filings minus that of quantitative-analyst filings, overall and by [wage level](https://one-course.com/books/quant/17/en/chapter/14-pay-levels-by-role-firm-type-and-seniority#def-in-pay-levels-by-role-firm-type-and-seniority-soc), with 95% bootstrap intervals (fiscal 2021 codes merged by the 2018 crosswalk). At or above zero overall, negative or indistinguishable from zero within each level. Data: `data/industry/lca_soc_gap.csv`, through `in_quantdev.gaps`.*

![How the two codes’ fiscal 2025 filings spread over the four wage levels (filings with a stated level). Half the software-developer filings are at level IV, which lifts their overall median. Data: in_quantdev.level_mix.](https://one-course.com/images/onecourse/chapters/quant-17/in-quant-developer/fig-8379d64b966f.svg)

***Figure 19.4.** How the two codes’ fiscal 2025 filings spread over the four [wage levels](https://one-course.com/books/quant/17/en/chapter/14-pay-levels-by-role-firm-type-and-seniority#def-in-pay-levels-by-role-firm-type-and-seniority-soc) (filings with a stated level). Half the software-developer filings are at level IV, which lifts their overall median. Data: `in_quantdev.level_mix`.*

The comparison says what the codes do not: that a developer is paid more for being called a software developer. At the same stated level, the analysts’ code carries the higher offer; overall, the software code carries more senior filings, and most of them come from the banks’ engineering workforces (4 790 of the 5 531, from eight banks). A quant developer’s pay depends on the employer and the level, as chapter 14 showed; the code is a description, and the two gaps are a warning about comparing medians over populations with different mixes.

## 19.5 Moving between the three

The three jobs are close enough for people to move between them, and far enough for the move to cost something.

- **Trading-system to research engineering** brings a developer nearer to research: the systems skills carry over, and a developer who has run the production version of a signal knows where research code breaks.
- **Research engineering to research** is a change of product, from tools to results. A [research engineer](#def-in-quant-developer-research) who already writes signals’ production code can take a research problem of their own; firms differ in whether they allow it (chapter 28).
- **Library development to the desk** follows the bank’s path of chapter 18: a [library developer](#def-in-quant-developer-library) who knows the models becomes a [desk strategist](https://one-course.com/books/quant/17/en/chapter/18-bank-quant#def-in-bank-quant-strat) ; one who prefers systems moves to trading technology.
- **Between employers** the code and the title travel badly: a “quant developer” at a bank and at a market maker may do the library and the trading-system job respectively. A candidate should ask which of the three products the job ships and what the on-call duty is.

## 19.6 Tutorial: one title, several codes

**Goal.** Separate the title from the job and from the code, and measure what the code says about pay. **End state:** Figures [19.1](#fig-in-quant-developer-mix), [19.2](#fig-in-quant-developer-levels), [19.3](#fig-in-quant-developer-gap) and [19.4](#fig-in-quant-developer-levelmix).

1. **Normalise titles.** `firm.roles.normalise_title` strips teams and locations, takes out seniority words, expands abbreviations and drops grade numerals ([Listing 19.1](#lst-in-quant-developer-normalise)); on the chapter’s illustrative list, “Sr. Quant Developer - Equities”, “VP, Quant Dev” and “Quant Dev L3” all become `QUANTITATIVE DEVELOPER`. `def normalise_title (title): """Upper case; split at a comma, slash, bar, parenthesis or spaced dash and keep the first part that names a job (the others are team, desk or location); take seniority words out of every part; expand abbreviations; drop grade numerals (I, II, 2, L3). Returns (clean title, seniority or '').""" import re seniority, found = " " , " " raw = str (title or " " ).upper().replace(" C++ " , " CPP " ).replace(" C# " , " CSHARP " ) for part in re.split(r " \ s[- \ u2013] \ s|[,/|()] " , raw): words = [w for w in re.sub(r " [^A-Z0-9 ] " , " " , part).split() if not re.fullmatch(r " (I { 1,3}|IV|V|L? \ d+) " , w)] t = " " + " " .join(words) + " " for key, level in SENIORITY: if f " { key} " in t: seniority = seniority or level t = t.replace(f " { key} " , " " ) for key, full in ABBREVIATIONS: t = t.replace(f " { key} " , f " { full} " ) if not found and t.strip(): found = " " .join(t.split()) return found, seniority` **Listing 19.1.** The job-title normaliser. code/firm/roles/firm_roles.py
2. **Cross-tabulate.** `crosstab(pairs)` counts title families by occupation code and suppresses cells under ten; chapter 14’s `lca_titles.csv` is that table for the filings.
3. **Cells by code and level.** `in_lca_soc_derive.py` rebuilds the code tables from chapter 14’s cached records (no second pass over the raw files), with the three-employer rule.
4. **The gap.** `median_gap(x, y, rng)` gives the difference and ratio of medians with independent bootstrap intervals ([Listing 19.2](#lst-in-quant-developer-gap)). `def median_gap (x, y, rng, n_boot=2000 , min_cell=10 ): """Median of x minus median of y and their ratio, with 95% percentile-bootstrap intervals (independent resamples of each population); None if either has fewer than min_cell values.""" x, y = np.asarray(x, float ), np.asarray(y, float ) if len (x) < min_cell or len (y) < min_cell: return None mx = np.median(x[rng.integers(0 , len (x), (n_boot, len (x)))], axis=1 ) my = np.median(y[rng.integers(0 , len (y), (n_boot, len (y)))], axis=1 ) d, r = mx - my, mx / my return {" diff " : float (np.median(x) - np.median(y)), " diff_lo " : float (np.percentile(d, 2.5 )), " diff_hi " : float (np.percentile(d, 97.5 )), " ratio " : float (np.median(x) / np.median(y)), " ratio_lo " : float (np.percentile(r, 2.5 )), " ratio_hi " : float (np.percentile(r, 97.5 ))}` **Listing 19.2.** The gap between two medians with bootstrap intervals. code/firm/roles/firm_roles.py

For fiscal 2025: overall gap $5 000 ($-\$372$ to $5 688); level III $-\$11\,000$ ($-\$19\,038$ to $-\$6\,600$); level IV $-\$27\,092$ ($-\$37\,500$ to $-\$19\,900$). Holding the level mix at the analysts’, the software developers’ median by level averages $7 789 below the analysts’.

**What to change next.** Take the employer into account (a gap within each employer, then averaged); separate full-time new hires from transfers; match the normaliser’s cleaned titles to the codes directly, which needs the titles that this chapter’s single pass over the files did not keep.

## 19.7 Build: title normaliser and code comparison

**Purpose.** Add the three quant developers to the role registry, and the tools to study titles and codes.

**Interface.** `firm.roles`: the cards `research engineer`, `library developer`, `trading-system developer`; `normalise_title(title) -> (clean, seniority)`; `crosstab(pairs, min_cell)`; `median_gap(x, y, rng, n_boot, min_cell)`.

**Rules.** Seniority is recorded, not kept in the title; the first part of a title that names a job wins; cells under ten are suppressed; a gap is not computed from fewer than ten values on either side.

**Acceptance tests.** `code/firm/roles/tests/`: six titles normalised to their expected forms; a cross-tab suppresses a cell of three; a planted gap of 50 lies inside its interval; a population of nine gives no gap.

**Stretch.** Learn the normaliser’s abbreviation table from data; stratify the gap by employer; a permutation test of the gap.

Sources and further reading

- O*NET OnLine, occupations 15-1252, 13-2099.01, 15-2041 and 15-2051 (CC BY 4.0).
- Bureau of Labor Statistics, SOC 2010 to 2018 crosswalk; occupational survey, May 2025.
- Chapter 14’s tables from the Department of Labor’s LCA files.
- Book 16, chapter 21, for the quant developer and embedded and central teams.

## 19.8 Exercises

**Exercise 19.1 ★.**

What share of the fiscal 2025 quant-developer filings were coded as financial quantitative analysts, and what share as software developers?

**Solution of Exercise 19.1.**

122 of 169, 72.2%, as financial quantitative analysts; 25 of 169, 14.8%, as software developers; the other 13.0% under codes with fewer than ten filings each.

**Exercise 19.2 ★.**

What does `normalise_title` return for “Sr. Quant Dev (Rates), NY”?

**Solution of Exercise 19.2.**

(`QUANTITATIVE DEVELOPER`, `senior`): the parenthesis and what follows are dropped, “Sr” is recorded as seniority and “Quant Dev” is expanded.

**Exercise 19.3 ★.**

From the dated box, how much higher is the survey’s median for software developers in the securities industry than in banks, as a ratio?

**Solution of Exercise 19.3.**

$163\,290/136\,620=1.195$: about a fifth higher.

**Exercise 19.4 ★★.**

Explain in three sentences how the software developers’ median can exceed the analysts’ overall while falling below it at levels III and IV.

**Solution of Exercise 19.4.**

The overall median of each code mixes its levels. Half the software-developer filings are at level IV, against one in seven of the analysts’. So the software code’s overall median is pulled up by its senior filings even though, level by level, the analysts’ filings carry the higher offer.

**Exercise 19.5 ★★.**

Weight each code’s median by level with the analysts’ level shares (7.8%, 51.1%, 26.7%, 14.4%). What is the difference?

**Solution of Exercise 19.5.**

With the analysts’ shares, the software developers’ medians by level average $7 789 less than the analysts’: the sign of the overall gap is a matter of mix.

**Exercise 19.6 ★★.**

A graduate wants to become a researcher within three years. Which of the three quant-developer jobs gives the best start, and what should she ask at interview?

**Solution of Exercise 19.6.**

The [research engineer](#def-in-quant-developer-research)’s job, which works inside a research group and often carries signals into production. She should ask whether engineers there take research problems of their own, how many have moved to research, and who owns the signals she would implement.

**Exercise 19.7 ★★★.**

*Coding.* Write a function that calls a gap distinguishable from zero when its interval excludes zero, and apply it to the ten gaps of `lca_soc_gap.csv`. How many are distinguishable?

**Solution of Exercise 19.7.**

Five of the ten: in fiscal 2021 the overall gap and levels III and IV; in fiscal 2025 levels III and IV. The fiscal 2025 overall gap ($-\$372$ to $5 688) and every level I and II gap include zero.

**Exercise 19.8 ★★★.**

*Find the flaw.* “Software developers at finance employers earn more than quantitative analysts: their median is $5 000 higher. A quant developer should ask to be filed as a software developer.”

**Solution of Exercise 19.8.**

Three flaws. The $5 000 gap’s interval includes zero. It compares populations with different level mixes; within each level the analysts’ median is at least as high. And the code describes the job the employer files for; it does not set the offer, which follows the employer and the level.

## 19.9 Problem: One Title, Three Jobs

**Problem 19.1.**

Weekend problem — one title, three jobs

A developer has three offers, each titled “quantitative developer”: at a bank’s analytics group, at a systematic fund’s research group and at a market maker’s trading-technology group. He wants to know what the title hides.

**Part I — The jobs.**

1. Define the quant developer (Book 16) and the three jobs.
2. What does each ship?
3. What is each judged on, and what does failure look like?
4. Which job carries on-call duty while markets are open?
5. Where does each sit in the organisation?

**Part II — The codes.**

6. What are occupation codes 15-1252 and 13-2099.01, and which jobs fit each?
7. What preparation does O*NET attach to each?
8. What changed in the software-developer codes in 2018?
9. State the SOC mix of the fiscal 2025 quant-developer filings.
10. Why are most employer kinds’ pay cells for the family suppressed?

**Part III — The gap.**

11. State the method of `median_gap` .
12. Give the overall fiscal 2025 gap and its interval.
13. Give the gaps at levels III and IV.
14. Explain the reversal.
15. What happens to the gap when the level mix is held at the analysts’?

**Part IV — The verdict.**

16. State the *named result* : the SOC mix of quant-developer filings and the difference in median offered base between the software-developer and quantitative-analyst codes, with its interval.
17. Does the code he is filed under matter for his pay?
18. What does the systematic funds’ cell show, and why is it the only one?
19. Which question separates the three offers best?
20. In two sentences, answer him.

**Solution of Problem 19.1.**

1. An engineer who turns research prototypes into production code and owns its performance and correctness; the [research engineer](#def-in-quant-developer-research) , the [library developer](#def-in-quant-developer-library) and the [trading-system developer](#def-in-quant-developer-trading) .
2. Research infrastructure and production signals; library releases; the trading system.
3. Reproducibility and researchers’ time; stability, speed and coverage; latency, uptime and correct behaviour. A result nobody can rerun; every desk’s numbers moving; a loss in seconds.
4. The [trading-system developer](#def-in-quant-developer-trading) .
5. In a research group; in a central analytics group (or the trading technology of an options market maker); in trading technology.
6. Software developers and financial quantitative analysts; the first fits the [trading-system developer](#def-in-quant-developer-trading) , the second the [research engineer](#def-in-quant-developer-research) and the [library developer](#def-in-quant-developer-library) .
7. The analysts’ code is in the highest preparation band (graduate school), the software developers’ in the band below (a bachelor’s degree).
8. The 2010 codes 15-1132 and 15-1133 were merged into 15-1252.
9. 72.2% 13-2099.01, 14.8% 15-1252, 13.0% other codes.
10. Almost all the filings come from one or two employers per kind, and cells from fewer than three employers are suppressed.
11. Independent bootstrap resamples of each population; the difference and ratio of the resampled medians give 95% percentile intervals.
12. $5 000, from $-\$372$ to $5 688.
13. $-\$11\,000$ ( $-\$19\,038$ to $-\$6\,600$ ) and $-\$27\,092$ ( $-\$37\,500$ to $-\$19\,900$ ).
14. The software code’s filings are concentrated at level IV.
15. It becomes $-\$7\,789$ .
16. 72.2% analysts, 14.8% software developers, 13.0% other; software minus analysts $5 000 overall ( $-\$372$ to $5 688), $-\$27\,092$ at level IV.
17. No: the employer and the level decide the offer; the code only describes it.
18. A median of $235 000 over 12 filings from 3 employers; the other kinds’ filings come from one or two employers.
19. What the job ships: research tools, a library or a trading system, and the on-call duty that goes with it.
20. The three offers are three different jobs (research tools, a pricing library, a trading system) whatever their title and code. Choose by the product and the clock you want to work to, and compare pay within the employer kind and level.

## 19.10 Interview questions

**Interview question 19.1 ★ developer.**

A researcher’s Python signal and your C++ version disagree in the fourth decimal on 0.1% of days. What do you do?

**Solution of Interview question 19.1.**

Find whether it is arithmetic (order of operations, floating-point summation, a different library function) or data (a different input on those days): log both versions’ intermediate values on a failing day and compare step by step; then decide the tolerance with the researcher and put the case in the regression tests.

*What the interviewer is looking for: bisecting the computation, and a tolerance agreed and tested.*

**Interview question 19.2 ★ developer.**

How would you make a backtest reproducible a year later?

**Solution of Interview question 19.2.**

Version the code, the data (point-in-time snapshots or a data version), the configuration and the environment (dependency pins, random seeds), record them with the result, and rerun from the record as a test.

*What the interviewer is looking for: code, data, configuration and environment all versioned.*

**Interview question 19.3 ★★ developer, bank.**

A pricing function is called ten million times in the nightly risk run and takes 40 microseconds. Where do you look first?

**Solution of Interview question 19.3.**

Profile before changing anything: allocation and copying per call, repeated work (curves rebuilt each call), cache misses, then the numerical method; batch calls across trades; parallelise across cores last.

*What the interviewer is looking for: measurement first; repeated work and memory before arithmetic.*

**Interview question 19.4 ★★ developer, trader.**

The trading system’s median tick-to-trade is fine but the 99.9th percentile doubled after a release. How do you find out why?

**Solution of Interview question 19.4.**

Compare latency histograms of the two releases on the same replayed data; bisect the release’s changes; look for new allocations, locks, logging or branches on a rare path, and for changes in thread placement or garbage collection.

*What the interviewer is looking for: tail latency needs replay and bisection, not averages.*

**Interview question 19.5 ★★ developer, researcher.**

What would you put in a signal’s interface so that research and production cannot silently diverge?

**Solution of Interview question 19.5.**

A typed specification of inputs with their timestamps, the output’s units and range, reference cases with expected outputs that both versions run in CI, and a live check that compares the two on shadow data.

*What the interviewer is looking for: shared reference cases and a live comparison.*

**Interview question 19.6 ★★★ developer.**

Design the regression test suite for a pricing library that many desks use.

**Solution of Interview question 19.6.**

Golden values for a fixed portfolio against the previous release and an independent benchmark, with tolerances by product; identities (parity, limits) and Greeks against finite differences; performance tests; every past bug as a test; and a report of every changed number for the desks before release.

*What the interviewer is looking for: golden-value regression with tolerances, independent benchmarks and a change report.*