Two traders take the same trades on a $50,000 evaluation with a $6,000 target and a $2,500 drawdown. One account ends the week down $400 and is still alive. Another is dead — while up $2,700.
Nobody made a different decision. The rulebooks were different shapes.
I keep seeing this described as "risk management," which is not quite it. Risk management is a discipline you apply to a position. This is arithmetic applied to an account, and it is fully modellable. So rather than argue about it, let's simulate it — and then run the simulation 200,000 times instead of trusting the one walk that happened to be in front of us.
Every number below is real output from the script in this post, with a fixed random seed so you get byte-identical results when you run it. All code is at the end of the relevant section.
The three drawdown modes firms actually use
Static drawdown. The floor is fixed below the starting balance. A $50k account with a $2.5k limit has a floor at $47,500 that never moves. Profit is pure gain, because the reference point is fixed.
Trailing drawdown, measured on closed equity. The floor rises with the high-water mark of the closed balance. Close at $55,000 and the floor becomes $52,500 permanently.
Trailing drawdown, measured on unrealised equity. The floor rises with the highest equity touched during a trade. A position that prints +$2,200 of open profit ratchets the floor immediately — even if it later closes flat. Or at a loss.
There's a fourth variant worth knowing: trailing until break-even, where the floor trails your peak but is never allowed above your starting balance. It sounds like a minor detail. It turns out to be the most interesting result in this post.
The simulator
The whole thing is about 45 lines. Two modelling choices matter and I'll flag both:
- Each trade visits its favourable extreme first, then its adverse extreme, then closes. That "gives back from the peak" shape is precisely what a trailing floor punishes, so this is the conservative assumption.
- The trade can die at any of those three moments — on the spike, on the give-back, or at the close — which is what makes the intraday rule formally distinct from the on-close rule.
const CFG = { start: 50000, target: 6000, dd: 2500, fee: 500 };
function floorFor(mode, peak, cfg, lockProfit) {
if (mode === 'static') return cfg.start - cfg.dd;
// trails the peak, but the floor never rises above break-even
if (mode === 'trailing_lock')
return Math.min(Math.max(peak - cfg.dd, cfg.start - cfg.dd), cfg.start);
// trails until the account reaches start + lockProfit, then locks
if (mode === 'trailing_lock3k')
return Math.max(Math.min(peak, cfg.start + lockProfit) - cfg.dd, cfg.start - cfg.dd);
return peak - cfg.dd; // trails indefinitely
}
function simulate(trades, mode, cfg = CFG, lockProfit = 3000) {
let eq = cfg.start, peak = cfg.start, worstRoom = Infinity;
for (let i = 0; i < trades.length; i++) {
const t = trades[i];
const upEq = eq + t.up, dnEq = eq + t.down;
// 1. favourable excursion — only the intraday rule sees this
if (mode === 'trailing_intraday') peak = Math.max(peak, upEq);
let f = floorFor(mode, peak, cfg, lockProfit);
worstRoom = Math.min(worstRoom, upEq - f);
if (upEq <= f)
return { out: 'BREACHED', at: 'intratrade-up', day: i + 1, eq: upEq, floor: f, pnl: upEq - cfg.start, worstRoom };
// 2. the give-back — can breach the intraday rule on its own
f = floorFor(mode, peak, cfg, lockProfit);
worstRoom = Math.min(worstRoom, dnEq - f);
if (dnEq <= f)
return { out: 'BREACHED', at: 'give-back', day: i + 1, eq: dnEq, floor: f, pnl: dnEq - cfg.start, worstRoom };
// 3. daily loss limit, measured from this day's starting equity
if (cfg.daily && dnEq <= eq - cfg.daily)
return { out: 'BREACHED', at: 'daily-limit', day: i + 1, eq: dnEq, floor: eq - cfg.daily, pnl: dnEq - cfg.start, worstRoom };
// 4. close
eq += t.close;
peak = Math.max(peak, eq);
f = floorFor(mode, peak, cfg, lockProfit);
worstRoom = Math.min(worstRoom, eq - f);
if (eq <= f)
return { out: 'BREACHED', at: 'close', day: i + 1, eq, floor: f, pnl: eq - cfg.start, worstRoom };
if (eq - cfg.start >= cfg.target)
return { out: 'PASSED', day: i + 1, eq, floor: f, pnl: eq - cfg.start, worstRoom };
}
return { out: 'ALIVE', eq, floor: floorFor(mode, peak, cfg, lockProfit), pnl: eq - cfg.start, peak, worstRoom };
}
Now feed one fixed trade sequence through all four rulebooks. up is the favourable excursion, down the adverse one, close the settled result:
const TRADES = [
{ up: +1000, down: -300, close: +900 },
{ up: +900, down: -400, close: +800 },
{ up: +1400, down: -400, close: +1300 },
{ up: +2200, down: -300, close: +1200 }, // spike, then give back 1000 of it
{ up: +1500, down: -300, close: +1400 },
{ up: +300, down: -600, close: -600 },
{ up: +100, down: -1000, close: -1000 },
{ up: +100, down: -1100, close: -1100 },
{ up: +100, down: -1200, close: -1200 },
{ up: +100, down: -1200, close: -1200 },
{ up: +100, down: -900, close: -900 },
];
const label = {
static: 'static',
trailing_lock: 'trailing→breakeven',
trailing_closed: 'trailing on close',
trailing_intraday: 'trailing intraday',
};
for (const m of Object.keys(label)) {
const r = simulate(TRADES, m);
const pnl = (r.pnl >= 0 ? '+' : '-') + '$' + Math.abs(r.pnl);
console.log(label[m].padEnd(20), r.out === 'BREACHED'
? `${r.out.padEnd(9)} day ${String(r.day).padStart(2)} (${r.at}) equity $${r.eq} vs floor $${r.floor} | P&L then: ${pnl}`
: `${r.out.padEnd(9)} equity $${r.eq} | P&L ${pnl} | peak $${r.peak} | thinnest room $${r.worstRoom}`);
}
The output
start $50000 | target +$6000 | drawdown $2500 | 11 trades | fee $500
static ALIVE equity $49600 | P&L -$400 | peak $55600 | thinnest room $2100
trailing→breakeven BREACHED day 11 (give-back) equity $49600 vs floor $50000 | P&L then: -$400
trailing on close BREACHED day 8 (give-back) equity $52900 vs floor $53100 | P&L then: +$2900
trailing intraday BREACHED day 4 (give-back) equity $52700 vs floor $52700 | P&L then: +$2700
Read the last two lines twice. Both full-trail accounts were up thousands of dollars when they died. The trader was not losing. The trader was winning, and still lost the account — while the static account, on identical trades, ended down $400 and perfectly alive.
And note the break-even row: it survived to day 11, dying at break-even rather than at +$2,900. It lagged the full trail. Why it never dies in profit is the most interesting finding below.
Why the intraday account died on day 4
The mechanism isn't obvious, so here it is at position level:
| Day | Entry equity | Peak touched | Floor after the peak | Result |
|---|---|---|---|---|
| 1 | $50,000 | $51,000 | $48,500 | closed +$900, alive |
| 2 | $50,900 | $51,800 | $49,300 | closed +$800, alive |
| 3 | $51,700 | $53,100 | $50,600 | closed +$1,300, alive |
| 4 | $53,000 | $55,200 | $52,700 | a pullback to $52,700 ended the account |
Trade four printed $55,200 of open profit. That alone dragged the failure floor to $52,700. The position then pulled back to that level and the account was gone — on a trade that, measured from its entry, was never close to being a loser.
Note what's absent: no bad market call, no revenge trade, no broken stop. The trade worked. The failure was administrative — the reference point moved while the trader was still measuring risk from the entry.
Now the part that matters: 200,000 accounts
One walk proves a mechanism exists. It says nothing about how often it fires. So I ran each rulebook over 200,000 independent accounts, using the same seeded trade generator for all four — only the rule changes:
rulebook passed breached still open breach-while-ahead
static 57.01% 20.40% 22.58% 0.0%
trailing→breakeven 47.77% 44.15% 8.08% 0.0%
trailing on close 38.34% 60.12% 1.54% 40.9%
trailing intraday 22.02% 77.93% 0.05% 46.2%
Four findings, in order of how much they should change your behaviour:
1. The spread is enormous. Same trades, same target — pass rates from 22% to 57%. If you believe you have "a 50% pass rate," you don't. You have a pass rate against one rulebook, and it can more than double without you changing anything about how you trade.
2. About 4 in 10 full-trail breaches happen while the account is in profit (40.9%, 46.2%). The day-4 story is not an unlucky anecdote — it is the largest failure mode of the trailing rule, at population scale.
3. The two rulebooks whose floor cannot rise above break-even both show 0.0%. Not just static — also trailing→breakeven, which genuinely does trail your peak and is measurably harder than static (47.77% vs 57.01%).
That's the finding I didn't expect, and it isolates the mechanism exactly:
"Died while winning" is not a property of trailing drawdown. It happens if and only if the floor is allowed to rise above your starting balance.
If a firm says the floor stops at break-even, that one sentence deletes the entire failure category responsible for ~4 in 10 trailing breaches. Worth more than any comparison-table column.
4. The 0.0% is by construction, not by discipline. No skill is being measured in that column. It's a property of the rule.
What that spread costs
Feed the measured pass rates into E[attempts] = 1/p with the same $500 fee:
rulebook pass rate p E[attempts] E[fee spend] vs advertised fee
static 0.5701 1.75 $877 1.75x
trailing→breakeven 0.4777 2.09 $1,047 2.09x
trailing on close 0.3834 2.61 $1,304 2.61x
trailing intraday 0.2202 4.54 $2,270 4.54x
Identical headline price. Expected bill differing by a factor of 2.5.
Choosing a static account over an intraday-trailing one is a bigger financial decision than choosing a $500 account over a $1,250 one — and nobody advertises it that way, because the fee is the number that fits on a button.
A pass rate isn't a number, it's a distribution
Twenty independent runs of the intraday rulebook, 5,000 accounts each:
min 20.82% median 22.04% max 23.32%
mean 22.05% SD 0.68pp
Two things here, pointing in opposite directions.
Reassuring: the run-to-run spread is under a percentage point, so the 22%-vs-57% gap above is real signal, not sampling noise. The ordering is robust.
Uncomfortable: a pass rate isn't a fact about a firm you can look up. It's the output of a distribution that shifts when you shift. The only pass rate worth planning around is one you've measured on your own record against the specific rulebook you're about to trade.
The daily loss limit, which dominates everything else
Real evaluations usually carry a daily loss limit as well as a maximum drawdown. I modelled it separately, because the interaction is not obvious. Same $50,000 account, same $2,500 maximum drawdown. The worst single loss in the generator is $600 and the worst adverse excursion is $1,000.
daily limit static trailing on close trailing intraday binding-limit share of breaches
none 57.01% 38.34% 22.02% 0.0% / 0.0% / 0.0%
$1250 57.01% 38.34% 22.02% 0.0% / 0.0% / 0.0%
$1000 57.01% 38.34% 22.02% 0.0% / 0.0% / 0.0%
$900 27.75% 21.60% 14.44% 83.4% / 55.4% / 36.4%
$800 5.60% 5.32% 4.60% 97.0% / 91.5% / 79.8%
$700 1.04% 1.04% 1.02% 99.7% / 99.3% / 96.8%
$600 0.24% 0.24% 0.24% 100.0% / 100.0% / 99.8%
There's a phase change here, and it happens inside a very narrow band.
At $1,000 and above the limit is completely inert — pass rates identical to the no-limit run, 0.0% of breaches. A limit that far from your normal loss size is decoration.
Between $900 and $800 it becomes the dominant failure mode. At $900 it explains 83% of static breaches and halving pass rates. By $800 it explains 79–97% of all breaches and the static pass rate collapses from 57% to 5.6%.
By $600 the drawdown rule stops mattering at all. All three rulebooks converge on 0.24% — within rounding error — and 100% of breaches are the daily limit. Static, trailing-on-close and intraday become the same product.
The reading is uncomfortable and useful in equal measure:
A daily loss limit set anywhere near the size of your worst single loss doesn't add a constraint to the drawdown rule; it replaces it.
Everything on the comparison table becomes irrelevant, and you've spent real effort choosing between rulebooks while the rule that actually ends your account sat underneath all of them.
Where the trail stops: the highest-value fact on your dashboard
I ran the two trailing rulebooks with the trail stopping at a +$3,000 profit lock, against trailing indefinitely:
trailing on close full trail 38.34% → locked at +$3,000 45.99% (+7.66pp)
E[fee spend] $1,304 → $1,087
trailing intraday full trail 22.02% → locked at +$3,000 45.99% (+23.97pp)
E[fee spend] $2,270 → $1,087
Locking at +$3,000 takes the intraday pass rate from 22% to 46% and cuts expected fee spend from $2,270 to $1,087 — more than halving the cost of the same account at the same price.
Note the two rows converge on exactly 45.99%. Once the floor is locked, the intraday/on-close distinction stops existing: a floor that can't move can't be breached by an intratrade excursion. Reaching the lock is not a milestone on the way to the target — it is the objective, and treating it that way is a different trading plan to "hit $6,000."
Does skill help equally under every rulebook?
This decides whether rulebook-shopping substitutes for getting better. Same rulebooks, five win rates, identical trade sizes so the only variable is decision quality:
win rate static trailing on close trailing intraday static minus intraday
40% 8.02% 4.98% 2.63% 5.4pp
45% 27.10% 16.94% 9.01% 18.1pp
50% 57.01% 38.34% 22.02% 35.0pp
55% 82.67% 62.51% 40.46% 42.2pp
60% 95.03% 81.01% 60.10% 34.9pp
Skill is worth more than the rulebook — on the easy rulebooks. Going 50% → 55% takes the static pass rate from 57% to 83%, a 26-point swing, larger than the entire 35-point static-vs-intraday gap at 50%. If you can improve, improving is the higher-return activity. Nothing here argues for settling for a bad rulebook instead of trading better.
But harder rulebooks convert skill into pass rate less efficiently. At 55% the gap is the widest in the table: 82.67% static versus 40.46% intraday. A trader at that skill level gets less than half the benefit from their own improvement on a trailing-intraday account, because a large share of their good outcomes is being consumed by a floor that rises while they win.
The 40% row is worth reading separately: all three rulebooks are in the single digits, because the model is running at slightly negative expectancy there. Rulebook choice is a second-order question for a trader whose edge isn't yet positive. Get the edge first.
The buffer result that surprises people
Trailing $2,500 on a $50,000 account:
peak equity floor room from peak room if 1,500 off the peak
+$0 $47500 $2500 $1000
+$1000 $48500 $2500 $1000
+$2000 $49500 $2500 $1000
+$2500 $50000 $2500 $1000
+$3000 $50500 $2500 $1000
+$5000 $52500 $2500 $1000
+$10000 $57500 $2500 $1000
Every row is identical. An account up $10,000 has exactly the same room as one at break-even, provided both sit $1,500 below their own peak.
That's the formal statement of the whole post. On a static account a buffer is defensive capital you can spend down. On a full trail it isn't, because the floor has already risen to match it. The only variable that helps is your distance from your own high-water mark — at every moment, including intratrade. Or, better, holding an account where the floor isn't allowed above break-even, which makes the whole category of failure arithmetically impossible.
Turning the threshold into a position size
The useful thing about a trailing threshold is that it converts into contract counts exactly, because futures ticks are fixed-dollar:
contracts = (risk fraction × threshold) ÷ (stop distance in ticks × value per tick)
On $50,000 with a $2,500 threshold, a 10% risk budget is $250. Ten-point stops:
contract stop (pts) $/contract contracts allowed verdict
MES 10 $50.00 5 ok
ES 10 $500.00 0 not tradeable at this risk
MNQ 10 $20.00 12 ok
NQ 10 $200.00 1 ok
This is why micros are not a beginner's concession on a trailing account — they're the only instruments where a $250 risk budget exists at all. On ES the permitted size is zero, and one contract is double your entire per-trade budget against a floor that's still moving.
The failure mode this model doesn't cover: the consistency rule
Everything above stops at the profit target, which is why it models the drawdown rules well and the consistency rule not at all. That's a real gap, because consistency is a separate failure mode with a different shape: it doesn't breach your account — it blocks your payout after the account is already passed.
The typical rule: no single day (or single trade, depending on the firm) may account for more than a set share of your total profit — commonly 30% to 50%. The arithmetic that follows is not obvious and it is brutal.
Take a $6,000 target with a 40% consistency cap:
target $6,000
consistency cap 40% of total profit
day one result +$6,000 (target hit — and the payout is blocked)
to satisfy the cap: best day ÷ total profit ≤ 0.40
6,000 ÷ total ≤ 0.40
total ≥ 15,000
profit still required:
$15,000 − $6,000 = $9,000 more, after already hitting the target
Hitting the target in one good day doesn't just fail to finish the job — it raises the finish line by 150%. You finish that account at $15,000 instead of $6,000, and every one of those extra dollars is traded on a floor that has been ratcheting up the whole time.
The practical consequence is that the target and the finish line are different numbers, and they diverge most for the traders who are best at the thing the challenge measures. Someone who can put together one exceptional day is penalised by exactly that skill. This is why "paced to a payout-ready distribution" and "hit the target" are two different plans, and why an account that shows a pass can still be weeks away from paying.
A five-minute check on your own account
Before you apply any of the above, pull your actual rulebook and answer five things. Write the numbers down — a rule you can't quote from memory is one you'll misread at the moment it matters.
- Daily loss limit — the figure, and whether it is measured from the day's starting equity or including open float. Compare it to your worst normal single loss. If it's within a stone's throw, it's your real failure line, and nothing else on this list matters as much.
- Drawdown type — static, trailing on close, or trailing intraday. Look for "trailing," "high-water," "follows your highest balance." The wording is often indirect.
- Where the trail stops — break-even, a stated lock level, or never. If the rulebook doesn't say it stops, assume it doesn't.
- The lock level — because reaching it changes which rulebook you're effectively trading. Getting there is the first objective, not a milestone.
- The consistency rule — the percentage and the measurement period. Multiply it out the way I did above to find your true finish line.
Five numbers, five minutes, and they determine your expected cost more than the account size or the fee ever will.
Where this model is wrong
A simulation you can't audit is just an opinion with numbers:
- Trades are independent and identically distributed. Real trading clusters, and a rule that punishes give-back punishes clustering harder than independence predicts. This makes the trailing figures conservative.
- The winner/loser mix is fixed at 50/50, winners $300–800, losers −$200 to −$600 — plausible but arbitrary. Low win rate with large winners will look worse on trailing rules, because big winners are exactly what ratchet the floor.
- Favourable-then-adverse is an assumption. Real trades sometimes reverse first, which would flatter the intraday rule.
- The lock is modelled at two specific values (break-even and +$3,000). Real firms pick their own; the measured gap between those two is large, which is the point.
- The daily limit is a fixed dollar figure from the day's starting equity. Some real rules include the day's open float, which is stricter.
Most assumptions push the same way: the true spread between rulebooks is wider than shown. The percentages are illustrative. The ordering isn't.
What I'd actually do with this
Before comparing any two firms on price, check two rules, in this order:
- The daily loss limit. If it's anywhere near your worst single loss, it is your failure line and everything else is colour. This is the highest-value line on the dashboard.
- Can the drawdown floor rise above your starting balance? If no, you cannot be killed while in profit. If yes, ask where it stops — break-even, a profit lock, or never.
Then, and only then, compare fees. Get either of the first two wrong and you'll size a position correctly for a different account than the one you're trading — which is the failure this post describes, expressed in dollars instead of trades.
Two things worth doing before you commit to a rulebook. Run your own numbers through the drawdown and challenge-cost calculator — it turns a measured pass rate into an expected fee across all four rulebooks above. And if you would rather not put your own evaluation through a rising floor at all, the done-for-you evaluation passing service trades the account for a flat $220.
Every figure in this post is the actual stdout of the simulator above, at a fixed seed. Paste the two code blocks into a file and run it: set CFG.dd to a static-account value and watch every trailing breach in the single walk vanish, or set CFG.daily = 600 and watch all three rulebooks collapse to the same number.
Top comments (0)