Risk of Ruin

Overview #

Risk of ruin is the probability that your account hits a predefined loss threshold before reaching your target. Not "the chance you lose money" — every trader loses money. Risk of ruin answers a harder question: given your win rate, your payoff ratio, and your bet size, what's the probability that a string of losses wipes you out before your edge compounds?

This is the number that separates traders who survive from traders who don't. You can have a genuine edge — a 55% win rate with 1.5:1 reward-to-risk — and still blow up if you size too aggressively. The math doesn't care about your edge if your sizing creates a path to ruin faster than the edge can compound. This article covers the formulas, the Monte Carlo approach, and the practical application for futures traders. It's a component of the broader Risk Management for Futures Trading framework.

Defining Ruin #

"Ruin" doesn't mean zero. It means the drawdown threshold where you can't trade anymore — or shouldn't. That threshold is personal and depends on your account structure.

As @Fat Tails explained on NexusFi ^[1]: "Ruin is achieved when you cannot trade anymore. Ruin so depends on the initial account size and the maximum acceptable drawdown."

For most futures traders, "ruin" falls in one of these ranges:

• Conservative: 25-30% drawdown (you stop trading and re-evaluate)
• Standard: 50% drawdown (you've lost half your stake — recovery requires a 100% gain)
• Prop firm: Often 5-10% drawdown (evaluation rules force the definition)

The definition matters because it directly changes the math. At the same bet size, a trader who defines ruin as 25% drawdown has a higher risk of ruin than one who can tolerate 50%. More room to absorb losses means lower probability of hitting the threshold.

The Core Formula #

The simplest risk of ruin formula comes from Perry Kaufman's Trading Systems and Methods ^[8], which @Big Mike introduced in the original NexusFi Risk of Ruin thread ^[2]:

risk_of_ruin = ((1 - Edge) / (1 + Edge)) ^ Capital_Units

Where Edge is the probability of winning a single bet and Capital_Units is how many bet-sized units your account holds.

Worked example:

• Win rate: 55% (Edge = 0.55)
• Account: $50,000
• Risking $500 per trade (Capital_Units = 100)
• risk_of_ruin = ((1 - 0.55) / (1 + 0.55))^100 = (0.45/1.55)^100 = (0.2903)^100
• Result: basically zero

But change that to $2,500 per trade (Capital_Units = 20):

• risk_of_ruin = (0.2903)^20 = 0.0000004 — still negligible

Now remove the edge entirely — 50% win rate:

• risk_of_ruin = ((0.50) / (1.50))^20 = (0.333)^20 = 0.00000026

And at 45% win rate with 20 units:

• risk_of_ruin = ((0.55) / (1.45))^20 = (0.379)^20 = 0.0000089

This formula, presented in Chapter 23 ("Risk Control") of Kaufman's reference work ^[8], is clean but limited. It assumes equal-sized wins and losses (1:1 payoff), fixed bet sizes, and independent outcomes. Real trading breaks all three assumptions.

The Kelly-Based Risk of Ruin Formula #

A more powerful approach ties risk of ruin to the Kelly criterion. @Fat Tails derived this framework on NexusFi ^[1], expressing bet size as a fraction of Kelly optimal:

P(a, b, k) = probability of reaching target b before hitting ruin a

Where:

• a = fraction of account defined as ruin (e.g., 0.25 means ruin at 25% of starting capital)
• b = multiple of account defined as target (e.g., 4.0 means quadrupling)
• k = Kelly factor (1.0 = full Kelly, 0.5 = half Kelly, 0.25 = quarter Kelly)

The risk of ruin is then 1 - P(a, b, k).

That's the key insight. Once you express sizing in Kelly terms, the math collapses to three variables. Ralph Vince's The Mathematics of Money Management ^[9] provides the rigorous derivation of optimal f — the mathematically optimal fixed fraction to bet — and its direct relationship to risk of ruin, validating this Kelly-based framework with deeper mathematical proofs. Here's how they interact for a trader starting with $50,000 targeting $200,000 (b=4) with ruin at $25,000 (a=0.5):

Full Kelly at 20% risk of ruin is reckless for most traders. Half Kelly drops it to 1.5%. Quarter Kelly makes it near-zero. @Fat Tails worked through a complete example on NexusFi ^[3] trading YM with a 45% win rate and 2:1 payoff: "With k = 0.25 I will be within the limits of my risk tolerance with a risk of ruin slightly inferior to 1%. I will so be betting quarter Kelly. This allows me to risk 2.3% of my account with every bet."

Monte Carlo Simulation -- The Practical Approach #

Formulas work for simple models. Real trading produces messy, non-normal distributions with streaks, regime shifts, and correlated outcomes. That's where Monte Carlo comes in.

The concept is straightforward: take your actual trade results, shuffle them into thousands of random sequences, and see how often the equity curve hits your ruin threshold.

As @Fat Tails explained on NexusFi ^[4]:

"A Monte Carlo Simulation allows me to obtain 100 different series of trade data by taking a backtest and create 100 series of trades by rearranging the order of the trades with a random generator, or picking a large number of trades allowing for double picks in a random fashion."

10-Step Monte Carlo Walkthrough #

Here's a concrete implementation. Say you have 150 backtest trades from an ES system:

1. Export your trade log — every trade with entry price, exit price, direction, and actual dollar P&L. You need at least 100 trades for meaningful results, 200+ is better.

1. Calculate net P&L per trade after costs — subtract commissions ($4.50 RT per contract is typical for ES) and estimated slippage ($12.50 per side for 1 tick on ES = $25 RT). A trade that made $200 gross becomes $200 - $4.50 - $25 = $170.50 net. Slippage matters — ignoring it inflates your edge and underestimates risk of ruin.

1. Store the 150 net P&L values in an array. This is your "trade pool."

1. Set simulation parameters — number of simulations (use 10,000 minimum), starting equity ($50,000), ruin threshold ($37,500 for 25% drawdown), and trade count per simulation (use your expected trades per year, say 200).

1. Run one simulation — randomly draw 200 trades from your pool with replacement (bootstrapping). This means the same trade can appear multiple times, which is correct because you're sampling from your system's distribution, not replaying history.

1. Apply position sizing — for each randomly drawn trade, scale the P&L by current equity. If using 2% risk: position_size = (current_equity * 0.02) / initial_risk_per_contract. Track the equity curve trade by trade.

1. Check for ruin — after each trade, check if equity dropped below $37,500. If yes, mark this simulation as "ruined" and stop. Record the trade number where ruin occurred.

1. Repeat 10,000 times — each simulation gets a fresh random sequence.

1. Count ruined simulations — if 312 out of 10,000 simulations hit ruin, your risk of ruin estimate is 3.12%.

1. Analyze the distribution — look beyond the binary ruin/survive count. What was the median max drawdown across all 10,000 sims? The 95th percentile max drawdown? The 99th? These distribution tails tell you what your worst realistic quarter looks like.

Slippage sensitivity check: Run the entire simulation twice — once with your baseline slippage estimate ($25/RT) and once with 2x slippage ($50/RT). If risk of ruin doubles or triples, your edge is too thin to absorb execution variance. That's a red flag about the system's robustness, not just its sizing.

As @Fat Tails described ^[5]: "I take the backtest of my trading system based on a single contract and do a Monte Carlo Analysis with 1,000 different equity graphs. Then I look at the drawdown distribution."

If you accept a 5% risk of ruin, you look at the worst 50 out of 1,000 simulations. If those 50 all stay above your ruin threshold at your current position size — you're within tolerance. If they breach it — reduce size.

@kevinkdog built a Monte Carlo simulator ^[6] available on NexusFi that handles this process: "For a given trading system, I use the Monte Carlo simulator to determine the position sizing scheme that is right for me."

Monte Carlo Limitations #

The simulation assumes trade independence — that one trade's outcome doesn't affect the next.

In practice, futures trades cluster. Trend days produce streaks of winners or losers. News events create correlated outcomes across instruments. Monte Carlo understates risk during these regimes because shuffling destroys the clustering. Use it as a baseline, not a guarantee.

Sequential Dependence and Regime Risk #

Standard risk of ruin formulas assume each trade is independent — a coin flip that doesn't know about the last flip. Real trading doesn't work that way. Trades cluster. Trend days produce five winners in a row. Choppy regimes produce five losers in a row. And the formulas can't see the difference because they've already averaged it out.

Why Correlated Streaks Inflate True Risk of Ruin #

Consider two systems with identical stats: 55% win rate, 1.5:1 R:R, 2% risk per trade. Over 1,000 trades, both produce the same expectancy. But one system generates those wins and losses randomly, while the other has strong serial correlation — winners cluster in trending markets, losers cluster in choppy markets.

The independent system's risk of ruin is exactly what the formula predicts. The correlated system's actual risk of ruin is higher — sometimes dramatically so. Here's why: when losses cluster, the drawdown from consecutive losers compounds before the edge shows up. A string of 8 losses at 2% risk per trade creates a ~15% drawdown. In the independent model, that string is rare. In a correlated system during a choppy regime, it's normal.

Research on serial correlation in trading systems shows that even modest positive autocorrelation in losses (correlation coefficient of 0.15-0.25) can increase effective risk of ruin by 40-80% versus the formula's prediction. The formulas don't capture this because they assume the loss sequence is random — but during adverse regimes, it isn't.

Moving-Window Ruin Calculation #

One practical response is to calculate risk of ruin not on your entire track record, but on rolling windows — typically 50-100 trades. This captures how your system's risk profile shifts across market regimes:

1. Take your last 100 trades (or 50 if your system trades less frequently)
2. Calculate risk of ruin using the core formula or Monte Carlo on just those trades
3. Slide the window forward by 10 trades and recalculate
4. Track the ruin estimate over time — plot it. You'll see it spike during unfavorable regimes and drop during favorable ones

When your rolling risk of ruin estimate exceeds your tolerance — say it crosses 5% when you normally accept 1% — that's a signal to reduce position size. You don't need to stop trading entirely. Just cut size until the rolling estimate returns to acceptable levels.

Regime-Based Size Adjustment #

A more systematic approach uses regime detection to pre-adjust:

• Identify your system's weak regime — for trend-followers, it's choppy, range-bound markets. For mean-reversion systems, it's strong trending markets.
• Measure a regime indicator — ADX below 20 for choppiness, VIX term structure for volatility regime, or simply your system's recent rolling win rate over the last 20 trades.
• Reduce size during unfavorable regimes — cut to 50-75% of normal position size when your regime indicator signals the adverse environment.
• Restore size when the regime shifts back — don't try to catch the exact transition. Wait for 3-5 winning trades at reduced size before scaling back up.

This approach won't eliminate regime risk, but it addresses the key flaw in static risk of ruin: the assumption that your future trade distribution looks like your historical average. During adverse regimes, it doesn't — and adjusting for that is the difference between a formula-compliant position size and a survivable one.

Why a Single Backtest Isn't Enough #

A single backtest shows you ONE possible ordering of trades. The actual sequence you'll experience in live trading will be different. Maybe your biggest winners come early, building a cushion. Or maybe your biggest losers cluster at the start, putting you in a hole before the edge shows up.

As @Fat Tails put it ^[4]: "A single backtest will usually not give you any useful information on the likelihood of a large drawdown. To get that information, several thousand trades would be required, and unless you are a HFT maniac trading for years, this will not be available."

Monte Carlo fills that gap. It can't predict exactly what will happen, but it shows you the range of what COULD happen. And the tails of that range — the worst 1% or 5% of simulations — are what risk of ruin analysis is about.

Risk Per Trade and Risk of Ruin #

The single biggest lever is bet size. Here's how risk per trade maps to risk of ruin for a system with 55% win rate and 1.5:1 R:R over 200 trades:

The jump from 2% to 3% risk per trade is where the math turns ugly. At 2%, risk of ruin is manageable. At 3%, it becomes a real threat. At 5%, you're gambling on sequence — your edge has to show up early or you're done.

This is why most professional futures traders land in the 0.5-2% range. Not because they're timid — because they've done the math.

The Input Problem #

Every risk of ruin calculation requires inputs you don't actually know with precision:

• Win rate: Estimated from backtests or track records, but subject to regime change
• Payoff ratio: Historical average, but future distributions may differ
• Trade independence: Assumed but rarely true in practice

As @Fat Tails noted ^[4]: "The edge or winning probability are never known in trading and you can only make a best guess, based on some statistical data. So the outcome of our model is of limited value."

The practical response: use conservative estimates. If your backtest shows 55% win rate, run the risk of ruin calculation at 50% and 45%. If the sizing still works at degraded inputs, it's strong. If it only works at the optimistic estimate, you're curve-fitting your risk management — and that defeats the entire purpose.

Estimating Inputs Without a Long Track Record #

Not everyone has 500+ trades to feed into a risk of ruin model. If you're launching a new system or switching timeframes, here's how to build defensible estimates from limited data.

Bootstrapping from Small Samples #

If you have 50-100 trades — enough to see the system's general behavior but not enough for reliable statistics — bootstrapping gives you a distribution where raw averages would give you a single (potentially misleading) number:

1. Take your 50-trade sample and calculate raw win rate and payoff ratio
2. Resample with replacement — randomly draw 50 trades from your pool, allowing repeats, and calculate win rate/payoff for that resample
3. Repeat 5,000 times — you now have a distribution of possible win rates, not one estimate
4. Use the 25th percentile of that distribution as your input — not the median. This gives you a conservatively biased estimate that accounts for sampling uncertainty

With only 50 trades, your 95% confidence interval for a 55% win rate is roughly 41% to 69%. That's a massive range. The bootstrap 25th percentile will land around 50-51%, which is a much more honest input for risk of ruin than the raw 55%.

Conservative Degradation Protocol #

A simpler approach that doesn't require statistical software: systematically degrade your inputs before running the risk of ruin calculation.

• Win rate: Subtract 10% from your observed win rate. If your backtest shows 58%, use 48%.
• Payoff ratio: Reduce by 15%. If your average winner is 1.8x your average loser, use 1.53x.
• Slippage: Double your estimated execution costs. If you're assuming $25 per round trip, model $50.

Run the risk of ruin calculation with these degraded inputs. If the position size still works at degraded assumptions — you have a strong setup. If degraded inputs push risk of ruin above your tolerance, the system's edge isn't strong enough for that position size, regardless of what the optimistic backtest says.

Kaufman makes this point explicitly in Trading Systems and Methods ^[8]: risk control must account for the reality that backtest performance almost always overstates live performance. The degradation protocol builds that reality into the calculation upfront rather than discovering it with real money.

Updating Estimates as Your Track Record Builds #

Risk of ruin isn't a once-and-done calculation. Your inputs improve as you accumulate live trades, and your sizing should evolve with them:

• At 30 trades: Use maximum degradation (subtract 10% from win rate, 15% from payoff). Your estimates are rough and the confidence interval is wide. Size conservatively.
• At 100 trades: Reduce degradation to 7% win rate, 10% payoff. You're starting to see real patterns in your live results.
• At 250 trades: Reduce to 5% win rate, 7% payoff. Confidence intervals are tightening. Your live track record carries meaningful statistical weight.
• At 500+ trades: Reduce to 3% win rate, 5% payoff. Your observed stats are approaching reliability and you can size closer to what the raw numbers suggest.

At each checkpoint, recalculate risk of ruin and adjust position size so. Most traders find they can gradually increase size as their track record validates the edge — but only if the live performance actually matches or exceeds the degraded estimates they started with. If it doesn't, that's information too — and it might mean the system's edge was overstated in backtesting, which is the most common outcome.

Position Sizing Depends on Acceptable Risk #

Risk of ruin isn't a number you calculate once and forget. It's a framework that connects two personal decisions to a mathematical output:

1. What drawdown would make you stop trading? (Your ruin threshold)
2. What probability of hitting that drawdown can you tolerate? (Your risk of ruin tolerance)

As @Fat Tails stated ^[4]: "There is no way around the point that these two parameters need to be individually chosen. Nobody can tell you whether 0.1% or 10% is an acceptable risk of ruin, and whether you stop trading after a 30% or 75% drawdown."

Once you've answered those two questions, the math tells you your maximum position size. Everything else — entry signals, trade management, targets — operates within that constraint.

For a deeper treatment of how to calculate position size from these inputs, see Position Sizing Methods for Futures Trading.

Practical Checklist #

1. Define your ruin threshold — the drawdown where you stop. Be honest.
2. Set your risk tolerance — 1% risk of ruin is standard, 5% is aggressive.
3. Estimate your edge — win rate and payoff ratio from 100+ trades minimum.
4. Degrade your inputs — subtract 10% from win rate, 15% from payoff ratio, double slippage costs. Use these degraded inputs for sizing.
5. Run the math at degraded inputs — if risk of ruin exceeds your tolerance at degraded inputs, reduce position size until it doesn't.
6. Size so — if the math says 2% risk per trade, don't trade 3% because "this setup looks great."
7. Monitor with rolling windows — recalculate risk of ruin every 50-100 trades using your most recent data, not your full history.
8. Adjust for regime — reduce size by 25-50% during your system's unfavorable market conditions.
9. Re-run quarterly — as your track record grows, tighten the degradation factors and refine position size.

Risk of ruin is the reality check that keeps your edge alive long enough to compound. The edge means nothing if you don't survive to see it work.

Sources & Citations #

This article draws on extensive research and community discussion from NexusFi's trading forums, including contributions from @Fat Tails (Kelly-based risk of ruin formulas, Monte Carlo methodology, position sizing frameworks), @Big Mike (Kaufman's risk of ruin formula, Monte Carlo simulator references), @JonnyBoy ^[7] (probability of ruin matrices), and @kevinkdog (Monte Carlo simulation tools for position sizing). The Kaufman risk of ruin formula is presented in Perry J. Kaufman, Trading Systems and Methods, 6th Edition, Chapter 23: Risk Control (Wiley, 2019, ISBN 978-1-119-60535-5) ^[8]. The Kelly-optimal sizing framework and its mathematical relationship to risk of ruin draws on Ralph Vince, The Mathematics of Money Management (Wiley, 1992, ISBN 978-0471547389) ^[9], the definitive treatment of optimal f and fixed-fractional position sizing.