How a quant actually works

A beginner imagines a quant hunting for a magic formula. The reality is a disciplined, repetitive process that mostly produces rejections, and the discipline is the point. A researcher who follows the process stays honest; one who skips it fools themselves. This chapter is the workflow every good quant follows, and the funnel in which most ideas die on the way.

The funnel

A quant idea travels through stages, and at each one most ideas are thrown out. It starts as a hypothesis with a reason, not a random rule but a belief about why an edge might exist, because a rule with no reason is just a pattern waiting to fail. Then you gather and clean the data. Then you test the idea in-sample, on history you are allowed to look at, and most ideas die here, showing no edge. The survivors face validation on out-of-sample data they have never touched, and most of those die too. The few left must survive realistic costs and the limits of capacity. And only the rare idea that passes every stage is deployed, at small size, and monitored, ready to be retired when its edge fades. The shape is a funnel: many ideas in, almost none out.

# The research funnel: most ideas die, and that is the process working. We invent
# 200 random trading signals, test each on the first half of a random price series
# (in-sample), keep the ones that look good, then check those survivors on the
# second half they have never seen (out-of-sample). Watch how few make it through.
import numpy as np

rng = np.random.default_rng(0)
n_days = 500
price = 100 * np.exp(np.cumsum(rng.normal(0, 0.01, n_days)))    # a random walk
rets = np.diff(price) / price[:-1]
half = len(rets) // 2


def annual_sharpe(signal, r):
    strat = signal * r
    if strat.std() == 0:
        return 0.0
    return strat.mean() / strat.std() * np.sqrt(252)


candidates = 200
passed_in_sample = 0
survivors = 0
for _ in range(candidates):
    signal = rng.choice([1, -1], size=len(rets))               # a random rule's positions
    if annual_sharpe(signal[:half], rets[:half]) > 1.0:        # looked good in-sample
        passed_in_sample += 1
        if annual_sharpe(signal[half:], rets[half:]) > 1.0:    # still good out-of-sample
            survivors += 1

print(f"Ideas tested:                    {candidates}")
print(f"Passed in-sample (Sharpe > 1):   {passed_in_sample}")
print(f"Also passed out-of-sample:       {survivors}")
print("\nMany ideas look good in-sample by luck; almost none survive out-of-sample.")
print("Rejecting them is not failure. It is the research process doing its job.")

Ideas tested:                    200
Passed in-sample (Sharpe > 1):   44
Also passed out-of-sample:       9

Many ideas look good in-sample by luck; almost none survive out-of-sample.
Rejecting them is not failure. It is the research process doing its job.

Watch the attrition. Of 200 random ideas, 44 looked good on the in-sample half, a Sharpe above 1, purely by luck. But when those 44 were tested on the out-of-sample half they had never seen, only 9 still looked good, and since these signals were random, even those 9 are pure coincidence, not edge. That is the funnel in miniature: a rule that shines in-sample usually dims out-of-sample, and rejecting it is the process working, not failing.

Reject, and be glad

Here is the mindset shift that makes a quant. In most of life, effort that ends in rejection feels wasted. In quant research, rejection is the product. The purpose of the process is not to confirm your ideas but to kill the bad ones cheaply, on a computer, before they can lose real money in the market. A researcher who tests fifty ideas and rejects forty-nine has not failed forty-nine times; they have done their job forty-nine times and possibly found one real edge. The danger is never rejecting too much. It is rejecting too little, falling in love with an idea, and lowering the bar until it passes.

A reason, not just a rule

One rule separates research from mere data-mining: an idea should have a reason before it has a backtest. If you can say why an edge might exist, some persistent behaviour, structural feature, or risk that someone is paid to bear, then a good backtest is evidence for a real story. If you have only a rule that fit the past, with no reason behind it, then a good backtest is almost certainly a coincidence you found by looking. The reason does not guarantee the edge is real, but its absence almost guarantees the edge is not. Start from a why, then test it, never the other way around.

What to carry forward

A quant follows a funnel, hypothesis, data, in-sample test, out-of-sample validation, costs and capacity, and only then deployment, in which most ideas rightly die, as you saw random ideas pass in-sample by luck and almost all fail out-of-sample. Rejection is the product of the process, not its failure, and the real danger is rejecting too little. Above all, demand an economic reason before you run a backtest, because a rule without a story behind it is a coincidence waiting to be found. To run any of this you need the statistics to measure luck, which the next chapter provides: just enough to stop fooling yourself.