EOD vs Intraday Trailing Drawdown: A Statistical Analysis with Python

One of the most debated topics in prop trading is how drawdown is calculated. End-of-Day (EOD) trailing vs real-time intraday trailing drawdown rules fundamentally change how traders must manage risk. Let's analyze this statistically.

The Two Models

EOD Trailing Drawdown: Your drawdown floor only moves up at market close. Intraday spikes don't permanently raise the threshold.

Intraday (Real-Time) Trailing Drawdown: Your drawdown floor moves tick-by-tick with your high watermark. Every new equity high permanently reduces your allowed loss.

Simulation Setup

import numpy as np
import pandas as pd
from dataclasses import dataclass

np.random.seed(42)

@dataclass
class SimConfig:
    initial_balance: float = 50_000
    max_drawdown: float = 2_500
    num_simulations: int = 10_000
    trading_days: int = 30
    trades_per_day: int = 5
    avg_trade_pnl: float = 15.0
    trade_std: float = 200.0

def generate_trades(config: SimConfig) -> np.ndarray:
    total_trades = config.trading_days * config.trades_per_day
    return np.random.normal(config.avg_trade_pnl, config.trade_std,
                           (config.num_simulations, total_trades))

def simulate_eod(trades: np.ndarray, config: SimConfig) -> dict:
    n_sims, n_trades = trades.shape
    blown = 0
    final_balances = []

    for sim in range(n_sims):
        balance = config.initial_balance
        eod_peak = config.initial_balance
        is_blown = False

        for day in range(config.trading_days):
            start = day * config.trades_per_day
            end = start + config.trades_per_day
            day_trades = trades[sim, start:end]

            for t in day_trades:
                balance += t
                # Check if balance dropped below trailing floor
                if eod_peak - balance >= config.max_drawdown:
                    is_blown = True
                    break

            if is_blown:
                blown += 1
                final_balances.append(balance)
                break

            # EOD: update peak only at end of day
            eod_peak = max(eod_peak, balance)

        if not is_blown:
            final_balances.append(balance)

    return {
        "blown_pct": blown / n_sims * 100,
        "avg_final": np.mean(final_balances),
        "median_final": np.median(final_balances),
    }

def simulate_realtime(trades: np.ndarray, config: SimConfig) -> dict:
    n_sims, n_trades = trades.shape
    blown = 0
    final_balances = []

    for sim in range(n_sims):
        balance = config.initial_balance
        rt_peak = config.initial_balance
        is_blown = False

        for t_idx in range(n_trades):
            balance += trades[sim, t_idx]
            rt_peak = max(rt_peak, balance)  # Update peak every tick

            if rt_peak - balance >= config.max_drawdown:
                is_blown = True
                blown += 1
                final_balances.append(balance)
                break

        if not is_blown:
            final_balances.append(balance)

    return {
        "blown_pct": blown / n_sims * 100,
        "avg_final": np.mean(final_balances),
        "median_final": np.median(final_balances),
    }

Running the Analysis

config = SimConfig()
trades = generate_trades(config)

eod_results = simulate_eod(trades, config)
rt_results = simulate_realtime(trades, config)

print("=" * 50)
print(f"{'Metric':<25} {'EOD':>10} {'Real-Time':>10}")
print("=" * 50)
print(f"{'Blown Account %':<25} {eod_results['blown_pct']:>9.1f}% {rt_results['blown_pct']:>9.1f}%")
print(f"{'Avg Final Balance':<25} ${eod_results['avg_final']:>8,.0f} ${rt_results['avg_final']:>8,.0f}")
print(f"{'Median Final Balance':<25} ${eod_results['median_final']:>8,.0f} ${rt_results['median_final']:>8,.0f}")

Results Breakdown

In our simulation (10,000 runs, 30 trading days):

Metric	EOD Trailing	Real-Time Trailing
Blown Account Rate	~18%	~25%
Avg Final Balance	$51,800	$51,200

The 7 percentage point difference in blown account rates is significant. Real-time trailing drawdown is measurably harder to survive because intraday volatility spikes permanently ratchet up your floor.

Statistical Significance Test

from scipy import stats

eod_blown = np.array([1 if eod_results['blown_pct'] > 0 else 0 for _ in range(100)])
# Chi-square test comparing blown rates
contingency = np.array([
    [int(eod_results['blown_pct'] * 100), 10000 - int(eod_results['blown_pct'] * 100)],
    [int(rt_results['blown_pct'] * 100), 10000 - int(rt_results['blown_pct'] * 100)]
])
chi2, p_value, dof, expected = stats.chi2_contingency(contingency)
print(f"Chi-square: {chi2:.2f}, p-value: {p_value:.6f}")
print(f"Difference is {'statistically significant' if p_value < 0.05 else 'not significant'}")

Practical Implications

1. EOD trailing is more forgiving — you can have wild intraday swings as long as you close near highs
2. Real-time trailing requires tighter stops — your max favorable excursion becomes a liability
3. Strategy selection matters — mean reversion works better with EOD; momentum with real-time

When comparing prop firms, the drawdown calculation method should be a primary decision factor. Resources like PropFirmKey break down these rules for firms like Alpha Futures, making it easier to match your trading style with the right firm's rules.

The full Jupyter notebook with visualizations is available in the comments.