# Position Sizing for Systematic Traders: How Much to Risk Per Trade

AI agents: this is one page from QuantIDE's site, in Markdown.
Canonical HTML: https://www.quantide.io/guides/position-sizing-systematic-traders-how-much-risk-per-trade
Full index of Markdown pages: https://www.quantide.io/llms.txt
Full text of recent articles: https://www.quantide.io/llms-full.txt

---
*2026-11-15 · QuantIDE Team · 7 min read*

Position sizing, not entry timing, decides whether a systematic strategy survives its losing streaks. Fixed-fractional rules, the Kelly criterion, and volatility targeting, compared on the same 100-trade simulation — with the real numbers.

## In brief

- Risk a fixed fraction of capital per trade — 1% is the default that survives, 2% is the aggressive end of sensible.
- Full Kelly maximises growth in theory but produced a median 82% drawdown and left 14% of simulated paths below their starting capital.
- Volatility targeting scales positions by target over realised volatility — Moreira and Muir show it raised the market portfolio's Sharpe ratio by 25%.
- Recompute size after every trade, from current equity; a sizing rule you override after three losses is not a sizing rule.

## The short answer

Risk a fixed fraction of your capital on every trade — 1% is the default that survives, 2% is the aggressive end of sensible — and resize after every trade as your equity moves. The Kelly criterion gives the growth-maximising fraction, but on a realistic edge it demands risking 17.5% per trade, and a simulation of that rule shows a median 82% drawdown and 14% of paths ending below their starting capital. Size from realised volatility, not from confidence: when volatility doubles, halve the position.

## Why sizing matters more than entries

A systematic strategy is a machine that takes the same bet hundreds of times. The entry rule decides whether each bet has an edge; the sizing rule decides what a losing streak does to you. Ten losses in a row at 1% risk per trade costs roughly 10% of capital. Ten losses in a row at 10% risk per trade costs roughly 65%. Same strategy, same edge, completely different outcome — and losing streaks of ten happen to every strategy eventually, because they are a property of the win rate, not a sign the strategy broke.

That is why sizing is the first decision in the risk-and-sizing cluster, and why it sits downstream of everything in the [backtesting guide](/guides/how-to-backtest-a-trading-strategy-in-python): a backtest tells you the edge; sizing decides whether you live long enough to collect it. Costs belong in the same calculation — [fees and slippage](/guides/transaction-costs-backtesting-fees-slippage) shrink the edge that sizing is built on — and [how much history your test needs](/guides/how-much-history-does-a-backtest-need) decides how much you should trust the win rate and payoff numbers you size from.

## The fixed-fractional rule: 1% and 2%

Fixed-fractional sizing means every trade risks the same percentage of current equity. If your account is $50,000 and you risk 1%, you risk $500 on the next trade. If the account grows to $60,000, you risk $600. If it falls to $40,000, you risk $400. The rule automatically shrinks your bets during drawdowns and grows them during winning runs, which is exactly the behaviour you want and exactly the behaviour most traders override by hand.

The position size follows from the risk, not the other way round. Decide the dollars at risk, divide by the distance to your stop, and that is the size. A $500 risk with a 50-pip stop at $10 per pip per lot is 0.10 lots. There is no discretion in the arithmetic, which is the point: discretion is where sizing rules go to die.

Why 1%? It is not a law of nature. It is a convention that survives contact with reality: it keeps drawdowns in the range a human can keep trading through, and it leaves enough room that a strategy with a genuine edge still compounds. 2% doubles the growth and roughly doubles the drawdown. Above that, you are no longer trading the strategy — you are trading your tolerance for drawdowns, and you will find out where that tolerance ends at the worst possible moment.

## The Kelly criterion: the growth-maximising answer you probably should not use

The Kelly criterion comes from information theory, not trading. John L. Kelly Jr. published it in 1956 in the Bell System Technical Journal, in a paper titled "A New Interpretation of Information Rate", asking how a gambler with a noisy private tip should size bets to grow capital fastest. The answer: maximise the expected logarithm of wealth. For a bet with win probability p, loss probability q = 1 - p, and payoff b (profit per unit risked), the Kelly fraction is f* = (b * p - q) / b. Edward Thorp later carried the idea from blackjack into markets.

Take a strategy that wins 45% of trades, with an average win twice the average loss (b = 2). The Kelly fraction is (2 * 0.45 - 0.55) / 2 = 0.175 — risk 17.5% of capital on every trade. That is the growth-maximising answer, and it is also an answer no working desk would run at full size, because Kelly assumes you know your edge exactly. You do not. Your win rate and payoff come from a backtest with estimation error, and Kelly is brutally sensitive to that error: overstate your edge slightly and the same formula sizes you into ruin.

Here is what the trade-off actually looks like. I simulated the strategy above — 45% win rate, +2R wins, -1R losses — over 100 trades, 2,000 paths per sizing rule, in Python:

```python
import random, statistics
random.seed(42)
P_WIN, WIN_R, LOSS_R = 0.45, 2.0, 1.0
N_TRADES, N_PATHS = 100, 2000
kelly = (WIN_R * P_WIN - (1 - P_WIN)) / WIN_R  # 0.175

def simulate(risk_frac):
    finals, max_dds, ruined = [], [], 0
    for _ in range(N_PATHS):
        equity, peak, max_dd = 1.0, 1.0, 0.0
        for _ in range(N_TRADES):
            stake = equity * risk_frac
            if random.random() < P_WIN:
                equity += stake * WIN_R
            else:
                equity -= stake * LOSS_R
            if equity <= 0:
                equity = 0.0
                break
            peak = max(peak, equity)
            max_dd = max(max_dd, (peak - equity) / peak)
        finals.append(equity)
        max_dds.append(max_dd)
        if equity < 1.0:
            ruined += 1
    finals.sort(); max_dds.sort()
    return statistics.median(finals), statistics.median(max_dds), 100.0 * ruined / N_PATHS

for name, frac in [("Fixed 1%", 0.01), ("Fixed 2%", 0.02),
                    ("Quarter Kelly", kelly / 4), ("Half Kelly", kelly / 2),
                    ("Full Kelly", kelly)]:
    med, dd, below = simulate(frac)
    print(f"{name}: median final {med:.2f}x, median max drawdown {dd:.1%}, paths below start {below:.1f}%")
```

Real output:

| Rule | Risk per trade | Median final equity | Median max drawdown | Paths ending below start |
| --- | --- | --- | --- | --- |
| Fixed 1% | 1.00% | 1.40x | 7.7% | 0.8% |
| Fixed 2% | 2.00% | 1.92x | 15.0% | 0.8% |
| Quarter Kelly | 4.38% | 3.72x | 30.1% | 1.9% |
| Half Kelly | 8.75% | 9.22x | 53.0% | 3.6% |
| Full Kelly | 17.50% | 18.62x | 82.3% | 14.2% |

Read the table by the drawdown column, not the growth column. Full Kelly wins on median growth and still loses the argument: the median path suffers an 82% drawdown, and more than one path in seven ends below where it started despite a genuine edge. Half Kelly keeps about half the growth at a 53% median drawdown — still a drawdown most traders do not survive psychologically. Quarter Kelly is the first row where the drawdown looks like something a person can keep trading through. This is a hypothetical edge with no costs, no regime change, and no estimation error — the real world is harsher on every row, which is why practitioners who use Kelly at all use a fraction of it.

## Volatility targeting: size from the market, not from your confidence

Fixed-fractional sizing holds the risk per trade constant in percentage terms. Volatility targeting holds the portfolio's risk constant as market volatility moves. When realised volatility doubles, you halve the position; when it halves, you double it. The scaling is mechanical: position scale = target volatility / realised volatility. Target 10% annualised volatility against 20% realised volatility and you run at half size.

The academic case is Moreira and Muir's "Volatility-Managed Portfolios" (Journal of Finance, 2017): portfolios that scale exposure by the inverse of the previous month's realised variance produced large alphas across equity factors and the currency carry trade, and for the market portfolio the strategy produced an alpha of 4.9% and a 25% increase in the buy-and-hold Sharpe ratio. Their explanation is simple and checkable: variance is highly forecastable at short horizons, and it is only weakly related to future returns — so cutting exposure when volatility is high removes risk without removing proportionate return.

In practice, volatility targeting is the sizing rule that pairs best with a systematic strategy, because it needs no opinion about the future. You measure realised volatility over a trailing window, you scale, you move on. Its failure mode is whipsaw: volatility spikes after the damage is done, so you cut size into the recovery. That is a cost worth paying if the alternative is holding full size through the spike.

## A rule you can actually run

Put the three ideas together and the working rule is short:

1. Size every trade as a fixed fraction of current equity — start at 1% risk per trade.
2. Never size from the Kelly fraction at full strength. If you use Kelly at all, use a quarter of it, and only once the edge is estimated on out-of-sample data — [walk-forward validation](/guides/walk-forward-validation-systematic-strategies) exists for exactly this reason.
3. Scale positions by target volatility over realised volatility, and recompute the scale on a schedule, not on a feeling.
4. Recompute after every trade. The rule only works if the arithmetic runs when you least feel like running it.

The common failure is not picking the wrong percentage. It is picking a percentage and then overriding it after three losses, or doubling down after three wins. A sizing rule you override is not a sizing rule; it is a mood. Write the rule down, automate it, and judge it over hundreds of trades, not over the last week.

## What to do next

Backtest your strategy with costs included, then read off its win rate and average win and loss from the out-of-sample segment — not the segment you tuned on. Plug those numbers into the Kelly formula to see what full Kelly would demand, then size at a quarter of it or at a fixed 1–2%, whichever is smaller. If your platform can scale positions by realised volatility, turn that on as a second layer. And if the whole pipeline — backtest, validation, sizing, execution — is more plumbing than you want to maintain by hand, that is the job an embedded engineer does: describe the rules, and the strategy comes back built, sized, and running. QuantIDE is built for that workflow — systematic strategies, tested and sized properly, on your own machine.

*This article is education, not investment advice. Every number in the simulation is hypothetical, from a stated edge and a fixed seed; no real strategy is promised to behave this way.*

## Sources

- [Kelly, J. L. (1956). A New Interpretation of Information Rate. Bell System Technical Journal, 35(4), 917-926.](https://en.wikipedia.org/wiki/Kelly_criterion)
- [Moreira, A. and Muir, T. (2017). Volatility-Managed Portfolios. Journal of Finance.](https://amoreira2.github.io/alan-moreira.github.io/VolPortfolios_published.pdf)
- [Moreira, A. and Muir, T. Volatility-Managed Portfolios (SSRN working paper).](https://papers.ssrn.com/sol3/papers.cfm?abstract_id=2659431)

*Educational content, not investment advice. Trading involves risk of loss.*