What Is Quant Trading? A Worked Example, Costs & Beginner Path

Quant trading is the use of numerical models and testable rules to decide what to trade, how much to hold and which risks to accept. The model could rank investment opportunities, estimate a tradable price or decide when a position should change. Quantitative trading is the full name; a quant trader is a person doing some of this work.

A signal is a measured input to a decision. A strategy combines the signal with position sizing, entry and exit rules, execution assumptions and risk limits. An edge is an expected benefit that survives costs and uncertainty. A rule can be quantitative without having an edge.

Consider a rule that buys after a price rises. It is easy to implement and test. Whether it makes money depends on what happens after the buy, what price is available and what the trade costs. Adding machine learning changes the model; it does not remove those questions.

Quant, algorithmic, systematic and high-frequency trading

“Quant decides what; algorithms decide how” is a useful starting distinction, but an incomplete definition. Algorithms can also choose instruments, prices, sizes and risk. The SEC staff report treats algorithmic activity broadly rather than restricting it to execution. SEC staff report, pages 5–7.

Quantitative finance is broader still. It includes valuation and risk modelling that may never generate a trading order. Humans also choose datasets, objectives and model changes. Writing rules makes these choices inspectable; it does not eliminate bias.

A useful research process produces evidence someone else can challenge. At each stage, ask what the next person would need to reproduce or reject your conclusion.

Suppose the idea is that recent gains tend to continue. Define “recent,” the instruments, the observation frequency and the target holding interval before running experiments. An economic explanation helps choose a useful question, but is not proof that the relationship exists.

For every input, distinguish when an event happened from when its information became available. The evaluation checklist below turns that distinction into a test; it is not enough to place a timestamp column beside the data.

The simulation then separates signal, requested position, order and fill. A buy instruction might remain unfilled; a partial fill creates a different exposure. Risk controls belong around the entire process, including limits on order size, inventory and stale inputs.

Paper trading is a subsequent observation exercise, not a certificate of readiness. It can reveal discrepancies between intended and recorded behaviour, but simulated fills still depend on assumptions. A research decision can be “reject this idea,” “collect better data” or “investigate further.” Deploying capital is a separate decision.

The following prices are invented for this lesson. They have no ticker, calendar or claim to represent market behaviour. We deliberately include a favourable pattern and a reversal pattern so the calculation can fail visibly.

Start with 10,000 units of equity, no position and no leverage. Cash earns zero; there are no dividends, taxes or borrowing. At each mark after the first observed change, hold 100% long for the next interval if the latest change was positive; otherwise hold cash. A flat change also means cash. The first interval is cash because no prior change exists.

This is a one-interval directional rule. It illustrates momentum mechanics; it is not a reproduction of published momentum research or a suggested trading strategy.

Timing comes before the return calculation

At mark 1 on the trend path, the observed move from 100 to 102 is +2%. That signal requests a long position for the interval 102 to 104. It cannot earn the earlier 100-to-102 move. At mark 3, the latest change is negative, so the next interval, 103 to 105, is held in cash even though its price rises.

For interval i, the asset return is price[i] / price[i−1] − 1. The position is determined using only price[i−1] and price[i−2]. One-way turnover is the absolute change in exposure: cash to fully long counts as 1; fully long to cash counts as another 1; staying long counts as 0.

Fill assumption: the requested position is established at the preceding mark's price after its signal is known. This is an idealised boundary fill. In actual close-based research, a final closing price may be known too late to trade at that close. Using the next open or a later actionable quote changes the return intervals and must be simulated separately. Lagging the signal is necessary here, but does not validate that fill.

Charge both sides of a trade

Use a cost of 10 basis points one way: 0.10%, or 0.001. Our return-space convention subtracts cost rate × turnover from each interval's portfolio return. It charges against equity at the start of that interval. This is a teaching approximation, not a share-and-cash broker ledger.

gross interval return = position × asset return
net interval return   = position × asset return − 0.001 × turnover
next equity           = previous equity × (1 + net interval return)

Liquidate any remaining long position at the final mark, charging another 10 basis points against the final marked equity. No signal at mark 7 opens a new position because there is no subsequent interval. The trend case therefore has four one-way exposure changes, including liquidation. The reversal case has six and already finishes in cash.

Inspect the trend path interval by interval

Multiply the growth factors using full precision. Do not add the rounded percentages. The zero-cost strategy ends at 10,675.07; after costs and liquidation it ends at 10,632.84. The difference of 42.23 reflects costs and their compounding, rather than a single charge of 40 deducted at the end.

Now change only the price path

On the reversal path, every rise is followed by a fall. The lagged rule repeatedly buys before the fall and holds cash through the recovery. Its position sequence is 0, 1, 0, 1, 0, 1, 0; the trend sequence is 0, 1, 1, 0, 1, 1, 1.

The comparator enters for the first interval, remains fully long and liquidates at the last mark, using the identical cost formula. Cash would end at 10,000. The momentum winner still underperforms buy-and-hold. Positive P&L alone does not show that the signal adds value.

Maximum drawdown is the largest percentage decline from a previous equity peak. These figures include final liquidation and only observe our marks; they cannot reveal losses between marks. Eight invented prices cannot establish statistical significance, realistic capacity or a dependable Sharpe ratio.

Save the following as momentum_example.py and run python momentum_example.py with Python 3. No data subscription, external package or account is required. The downloadable Python file contains this complete program; the eight-mark CSV provides both synthetic paths separately.

from math import isfinite

PATHS = {
    "trend": [100, 102, 104, 103, 105, 107, 109, 111],
    "reversal": [100, 102, 100, 102, 100, 102, 100, 102],
}

def backtest(prices, cost_bps=10, mode="momentum"):
    if len(prices) < 3 or any(not isfinite(p) or p <= 0 for p in prices):
        raise ValueError("Need at least three finite, positive prices")
    if not isfinite(cost_bps) or not 0 <= cost_bps <= 1000:
        raise ValueError("One-way cost must be between 0 and 1000 bps")
    if mode not in ("momentum", "buy-and-hold"):
        raise ValueError("Unknown strategy mode")
    cost = cost_bps / 10000
    equity = gross = 10000.0
    previous_position = changes = 0
    curve = [equity]
    rows = []
    for i in range(1, len(prices)):
        position = int(mode == "buy-and-hold" or
                       (i > 1 and prices[i - 1] > prices[i - 2]))
        asset_return = prices[i] / prices[i - 1] - 1
        turnover = abs(position - previous_position)
        growth = 1 + position * asset_return - cost * turnover
        if not isfinite(growth) or growth <= 0:
            raise ValueError("Outside this simplified model; use a share/cash ledger")
        gross *= 1 + position * asset_return
        equity *= growth
        rows.append((i, position, asset_return, turnover, equity))
        curve.append(equity)
        changes += turnover
        previous_position = position
    equity *= 1 - cost * previous_position  # sell at the last mark
    changes += previous_position
    curve.append(equity)
    peak = curve[0]
    drawdown = 0.0
    for value in curve:
        peak = max(peak, value)
        drawdown = max(drawdown, 1 - value / peak)
    return dict(equity=equity, gross=gross, changes=changes,
                drawdown=drawdown, rows=rows)

if __name__ == "__main__":
    for name, prices in PATHS.items():
        for mode in ("momentum", "buy-and-hold"):
            result = backtest(prices, mode=mode)
            net_return = result["equity"] / 10000 - 1
            print(f"{name:8} {mode:12} equity={result['equity']:.2f} "
                  f"return={net_return:.4%} dd={result['drawdown']:.4%} "
                  f"changes={result['changes']}")

Expected output, verified using the downloadable program:

trend    momentum     equity=10632.84 return=6.3284% dd=1.0606% changes=4
trend    buy-and-hold equity=11078.03 return=10.7803% dd=0.9615% changes=2
reversal momentum     equity=9366.26 return=-6.3374% dd=6.3374% changes=6
reversal buy-and-hold equity=10179.81 return=1.7981% dd=1.9608% changes=2

For a timing check, inspect result["rows"]. Each row holds the interval number, position, asset return, turnover and equity before terminal liquidation. Changing a later price should not alter earlier requested positions. Inspect the first long interval by hand: 10,000 × (1 + 104 / 102 − 1 − 0.001) = 10,186.08.

For a cost check, rerun backtest(PATHS["trend"], cost_bps=50). Then use the same rate on the reversal path. Change one input at a time and record every result, including failures.

These rates are sensitivity inputs, not estimates of a particular broker or market. If an extreme move plus the assumed fee would exhaust equity, the program rejects that interval: the approximation needs replacement with a share-and-cash ledger. It does not allow negative equity to produce an artificial liquidation credit. The program has no order routing or live-trading capability.

The reversal example fails before sophisticated statistics enter the picture: the rule's underlying expectation is wrong on that path. Real research adds several independent ways to obtain misleading results.

A stop-loss is an instruction, not a guaranteed fill at its trigger. Costs can also expand precisely when liquidity is weakest. A rule that looks acceptable with a fixed fee might be impractical under variable spreads or market impact.

Backtest overfitting is more than using too many model features. Selecting the best lookback, market, entry threshold or start date also selects on noise. Bailey and co-authors explain why a holdout alone does not account for the number of configurations tried. The Probability of Backtest Overfitting.

Machine learning cannot repair a contaminated target or an impossible fill. A high historical win rate also says little without payoff sizes: frequent small gains can coexist with rare large losses. Examine the return distribution, exposures and path of equity rather than optimising one headline number.

The synthetic exercise checks accounting. Before testing a market hypothesis, write down these five decisions.

1. Freeze the question. Specify the universe, signal, position limits, evaluation horizon and a result that would make you reject the idea. Preserve data provenance, publication times, revisions and cleaning rules.
2. Separate development from evaluation. Fit preprocessing and models using the earlier period, then apply the frozen process to later observations. If outcomes span several intervals, separate overlapping labels near the boundary. A random shuffle or arbitrary gap does not establish independence.
3. Keep the complete trial log. Record unsuccessful variants as well as winners. Once a held-out result influences another adjustment, that period is development data. Time order and selection bias require separate checks.
4. Use achievable fills and consistent costs. Trace decisions to later actionable prices and filled positions. Include fees, spreads, slippage and impact; add borrow costs for shorts and contract-roll treatment for futures. Challenge the result with delayed fills and higher costs.
5. Choose a fair comparator. Use the same universe, intervals and cost convention. Report gross/net results, drawdown, turnover and exposure. Our winning momentum path still trails buy-and-hold.

TimeSeriesSplit's official documentation illustrates chronological training and evaluation; directly comparable fold durations require equally spaced observations. A library split does not audit data availability or account for every attempted configuration.

The conclusion here remains reproducible arithmetic, path-dependent results and untested market profitability. For a full experiment specification, continue to the strategy research checklist.

A strategy family names an idea about markets. A tool such as machine learning or a frequency such as HFT tells you something different. Keep the three separate when comparing descriptions.

Momentum can mean an instrument's own past return or its performance relative to other instruments. The 2012 time-series momentum study examines the former across futures and forwards over much longer horizons than our exercise. Its historical findings do not validate a one-interval rule on eight prices. Moskowitz, Ooi and Pedersen: Time Series Momentum.

Market making also involves more than collecting a quoted spread. Both sides may not fill, and a price can move against accumulated inventory. SEC staff discuss adverse selection faced by passive market makers. SEC staff report, pages 38–39.

Use this map to identify the assumption you would test. Choosing a family because its name sounds professional adds no evidence. For more detailed signal, data and failure comparisons, continue to the nine-family strategy guide. For queue position and partial fills in market making, read the worked order-book example.

The same mathematical idea can serve different businesses. The objective determines what the team measures, which risks it accepts and how its software must behave.

Asset managers and quantitative hedge funds can use models to select instruments and construct portfolios for investors. Their research may address diversification, exposures and implementation across a portfolio. AQR describes both traditional long-only and alternative approaches; a quantitative investment organisation need not specialise in short-horizon trading. AQR's official firm description.

Market makers and proprietary trading firms may focus on prices, liquidity and inventory. Old Mission identifies its business as quantitative market making and describes proprietary valuation and trading systems. Its work connects models with the risk of holding instruments between transactions. Old Mission's official overview. Our Old Mission company and careers guide separates official employer facts, dated roles and independent preparation.

Bank and institutional execution desks can use algorithms to implement an existing investment decision. Here, a useful model may improve execution rather than predict the asset's direction. The BIS Markets Committee's FX report examines execution algorithms and the risks their users must manage. This is another reason to ask what an algorithm does before calling it a trading strategy. BIS: FX execution algorithms.

Turn a skill into an inspectable output

This is a practical skill map, not a universal employer checklist. O*NET's quantitative-analyst tasks include portfolio analysis, software verification and written research outputs, showing why a model alone is an incomplete deliverable. O*NET occupational profile.

Use Python and plain files for this exercise. Add numerical libraries, databases or performance tooling when the problem requires them. A low-latency quoting system and a daily research report have different engineering needs; learning every technology at once is unnecessary.

Trading organisations divide the work differently. Job titles are useful clues; responsibilities and deliverables are the better guide. Some researchers implement strategies, some traders conduct research, and some developers build both research and trading software.

Jane Street's official research description includes models, datasets, trading strategies and implementation. Its trader description includes pricing opportunities and managing risk. These are employer examples, not universal boundaries. Jane Street quantitative research, quantitative trader.

Learning this exercise does not require a doctorate. Hiring requirements are specific to the job: Jane Street's trader example does not require prior finance knowledge or a particular programming language. Avoid treating a generic skills list as an employer's eligibility rule.

The stack also varies. Python is convenient for this lesson, while Jane Street describes both OCaml and Python in its engineering work. Learn the software needs of the role rather than assuming every quant uses an identical stack. Jane Street software engineer. For valuation and risk roles beyond trading, see the five-role quant comparison.

Build enough skill to explain one result correctly before expanding the model. This four-stage sequence is a learning plan with concrete outputs, not a promise of job readiness or trading profits.

Stage 1: calculate a return and a loss. Work through prices 100, 110, 99. The interval returns are +10% and −10%, while the compounded result is −1%. Learn percentages, multiplication of growth factors and decline from a prior peak. Finish when you can explain why adding returns gives the wrong answer.

Stage 2: write and inspect a small program. Learn lists, loops, functions and input validation. Run the program above, then print each row. Identify exactly which two prices set the next position. Finish when the code agrees with your hand calculation and rejects invalid prices.

Stage 3: challenge the result. Use the reversal path, cost sensitivity and buy-and-hold comparator. Write a short report containing the question, assumptions, numerical results and limits. Finish when you can explain both a losing strategy and a profitable strategy that still trails its comparator.

Stage 4: design a separate investigation. Choose a data source and check its documentation, timestamps and permissions before importing observations. Define your hypothesis and evaluation periods before tuning. Extend the execution model and preserve every experiment. The first deliverable is a research protocol, not a live bot.

For a structured start, the free QR starter course teaches percentages, Python, returns and drawdown. Once you can calculate a return, the standalone free returns and risk lab lets you compare synthetic price paths and write an independent research brief. The trading cost sensitivity tool is another arithmetic exercise, not an execution simulator.

The momentum research project extends into signal timing, costs and a held-out period using synthetic teaching data; it requires Pro access. Signing in supports saved progress and project work. The QT and QD specialist pages currently describe planned curricula with shared foundations available. They do not offer a completed specialist course.

All calculations on this page are independent educational exercises. They do not represent employer interview questions, investment advice or evidence of future returns. The next useful action is to reproduce the losing case and write down why it loses.