From zero to systematic trader

A quantitative trader uses rules, data, and code — not gut feel — to decide when to buy and sell. You do not need a finance degree to start. You need curiosity, basic Python literacy, and patience to treat every backtest as research, not a profit promise.

What makes trading "quant"?

Real example: turning a hunch into a rule

Suppose you notice that markets seem to fall hardest *after* they have already started declining. A discretionary trader acts on that feeling. A quant writes it down precisely: hold SPY only while its price is above its own 200-day average; otherwise hold Treasury bills. That single sentence is now testable, and every ambiguity has to be resolved — which price (adjusted close), which average (simple, 200 trading days), checked how often (every day), and what "otherwise" means (100% BIL).

ASSETS = ["SPY", "BIL"]

def make_on_day(prices):
    close = prices[ASSETS]
    sma200 = close["SPY"].rolling(200, min_periods=200).mean()
    ready = sma200.first_valid_index()   # no signal before 200 days exist

    def on_day(engine, dt):
        in_trend = close["SPY"].loc[dt] > sma200.loc[dt]
        engine.set_target_weights(dt, {"SPY": 1.0} if in_trend else {"BIL": 1.0})

    return on_day, ready

This is roughly the rule Mebane Faber published in 2007, and its historical behaviour is instructive rather than magical. Trend rules like this one exited equities in late 2007 / early 2008 and so sidestepped much of the ≈-57% peak-to-trough fall in the S&P 500 through March 2009. The same rule then lagged badly during 2009–2019, when the market rose steadily and every brief dip triggered a whipsaw: sell low, buy back higher. Both outcomes come from one unchanged rule — which is exactly the point of systematic trading.

Who actually trades this way

How Quant Buffet helps beginners

• Strategy Library — peer-reviewed ideas with economic rationale and Python.
• Backtest IDE on every strategy page — edit the code, run it in-browser, watch the equity curve redraw.
• API docs — reference for ASSETS, make_on_day, engine, and metrics.
• AI debugger — when a run fails you get the line number, the cause, and paste-ready fixes.
• This course — concepts before code, mapped to what the platform actually runs.

What one research session actually looks like

1. Read a strategy page: economic rationale first, code second (5–10 min).
2. Run the unmodified code to reproduce the published metrics (about a minute).
3. Change exactly one thing — a lookback, a ticker, a rebalance rule (2 min).
4. Re-run and compare Sharpe *and* max drawdown, not just CAGR (1 min).
5. Write down what you changed and what happened, before you touch anything else.

The failure mode nobody warns beginners about

The IDE lets you re-run a strategy in seconds. That speed is a trap. If you try 300 lookback windows and keep the best one, you have not found a signal — you have found the number that best fits this particular history. Researchers call this backtest overfitting, and with enough attempts a purely random strategy can produce a Sharpe ratio above 2. A practical defence: decide your parameter *before* you look at the result, prefer round numbers other people also use (50, 100, 200 days), and check that neighbouring values behave similarly. A signal that only works at exactly 187 days is noise wearing a costume.