Bollinger Bands Backtest: Compare Mean-Reversion and Breakout Rules

The Dual Personality of Bollinger Bands: Boundary of Value vs. Volatility DetonationCopy Anchor Link

In algorithmic trading research, few technical indicators are as widely referenced—and as fundamentally misunderstood—as Bollinger Bands. Developed by John Bollinger in the early 1980s, the indicator wraps a central moving average with dynamic volatility envelopes scaled by the rolling sample standard deviation of price.

Because the envelopes expand during volatile expansions and contract during quiet consolidations, algorithmic researchers routinely construct a bollinger bands strategy around one of two diametrically opposed market philosophies:

1. The Mean-Reversion Hypothesis (Rubber Band Model): Asset prices are locally stationary. When price stretches to the outer standard deviation envelope, it represents an extreme distributional displacement. The statistical expectation favors an immediate rubber-band snapback toward the central rolling mean.
2. The Volatility Breakout Hypothesis (Dynamite Squeeze Model): Volatility is cyclical and clusters over time. When price breaks beyond the outer envelope following a period of extreme compression (a BandWidth squeeze), the breach signifies a structural regime shift. The statistical expectation favors explosive momentum continuation rather than mean reversion.

               TWO COMPETING HYPOTHESES ON BOLLINGER BANDS

   MEAN REVERSION (Range Regime)            BREAKOUT SQUEEZE (Trend Regime)
   
Price                                    Price
  ▲                                        ▲
  │        * * * Upper Band                │                 * * * Upper Band
  │       /       \                        │                /     / (Band Walking)
  │      /  Exit   \                       │               /  *  /
  │  ---/----x------\--- Middle            │       Squeeze/  /  /
  │    /      ▲      \                     │      * * *  /  /  /
  │   /  Buy  │       \                    │     /     \/  /  /
  │  *────x───┘        * Lower Band        │ ---/-------x--/--- Middle
  │                                        │   /   Entry│ /
  └────────────────────────► Time          └──*─────────┴*──────► Time
     Oscillation within Envelope              Volatility Expansion / Detonation

Amateur discretionary traders frequently treat outer band touches as mechanical overbought or oversold buy/sell triggers. Yet John Bollinger explicitly cautioned against this naive interpretation, noting that "tags of the bands are just that, tags, not signals." During sustained momentum trends, an asset can continuously "walk the bands" for dozens of consecutive bars, systematically wiping out counter-trend mean-reversion traders. Conversely, in range-bound chop, breakout strategies suffer death by a thousand cuts as repeated false breakouts whipsaw into immediate losses.

To establish quantitative clarity, this research article conducts a rigorous, controlled bollinger bands backtest. We formalize the underlying mathematics of adaptive volatility channels and the normalized band width metric, outline strict causal execution mechanics to avoid lookahead bias, and test both trading hypotheses head-to-head on the identical historical market series under realistic transaction frictions.

Mathematical Formulation: Adaptive Volatility Bands, Degrees of Freedom, and Band WidthCopy Anchor Link

Unlike static price channels such as Keltner Channels (which traditionally rely on Average True Range) or Donchian Channels (which track rolling absolute extrema), Bollinger Bands adapt dynamically to changes in the second central moment of the price distribution.

For an asset close price series Close_t and an evaluation lookback window of N bars (typically N = 20) with a multiplier k (typically k = 2.0), the system is formulated mathematically as:

1. The Central Moving Average (Middle Band)Copy Anchor Link

The middle band represents the intermediate baseline trend, computed as an unweighted simple moving average:

Middle_t = SMA_N(Close_t) = (1 / N) * sum_{i=0}^{N-1} Close_{t-i}

2. Rolling Standard Deviation and Degrees of FreedomCopy Anchor Link

The channel width scales according to the rolling standard deviation sigma_N. In computational statistics, researchers must distinguish between population standard deviation (ddof = 0) and sample standard deviation (ddof = 1, applying Bessel's correction):

Sample Std (ddof=1):     sigma_N = sqrt( (1 / (N - 1)) * sum_{i=0}^{N-1} (Close_{t-i} - Middle_t)^2 )
Population Std (ddof=0): sigma_N = sqrt( (1 / N) * sum_{i=0}^{N-1} (Close_{t-i} - Middle_t)^2 )

While John Bollinger originally specified the population standard deviation (ddof = 0) in early desktop computing software, standard Python libraries like pandas.Series.rolling.std() default to sample standard deviation (ddof = 1). For N = 20, the sample standard deviation produces envelopes that are approximately sqrt(20 / 19) = 1.026 (2.6%) wider than population envelopes. While modest, this discrepancy alters edge-case trigger frequencies and must remain strictly consistent across trials.

3. Upper and Lower Envelope EnvelopesCopy Anchor Link

The dynamic boundary lines are placed at symmetric k-sigma distances from the baseline:

Upper_t = Middle_t + k * sigma_N
Lower_t = Middle_t - k * sigma_N

Under a theoretical Gaussian normal distribution of returns, approximately 95.4% of observations would reside within +/- 2 standard deviations of the mean. However, financial asset returns exhibit pronounced leptokurtosis (fat tails) and conditional heteroskedasticity. Consequently, band breaches occur far more frequently in real markets than Gaussian theory predicts.

4. Normalized Band Width (BandWidth)Copy Anchor Link

To compare envelope volatility across different price levels or assets, John Bollinger formulated the normalized BandWidth metric:

BandWidth_t = (Upper_t - Lower_t) / Middle_t = (2 * k * sigma_N) / Middle_t

BandWidth measures the percentage dispersion between the outer envelopes relative to the central trend line. Because volatility clusters—a phenomenon established by Benoit Mandelbrot and formalized in Robert Engle's ARCH models—prolonged periods of low BandWidth historically precede massive directional expansions.

                   THE ANATOMY OF A BOLLINGER SQUEEZE
   
BandWidth
   ▲
   │  Wide Dispersion (Exhaustion)
   │     \                                           Expansion Detonation
   │      \                                                 /
   │       \     The Squeeze (Volatility Compression)      /
   │        \               ┌─────────────┐               /
   │         \              │             │              /
   │          * * * * * * * *             * * * * * * * *
Threshold ── ─ ─ ─ ─ ─ ─ ─ ─ ┼ ─ ─ ─ ─ ─ ─ ─ ┼ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ (20th Percentile)
   │                         └─────────────┘
   └─────────────────────────────────────────────────────────────► Time

5. The Relative Position Oscillator (%b)Copy Anchor Link

A companion metric, %b, quantifies where current price sits relative to the bands:

%b_t = (Close_t - Lower_t) / (Upper_t - Lower_t)

• %b = 1.0: Price is exactly at the Upper Band.
• %b = 0.5: Price is exactly at the Middle Band.
• %b = 0.0: Price is exactly at the Lower Band.
• %b > 1.0: Price has broken above the Upper Band (potential breakout).
• %b < 0.0: Price has punctured below the Lower Band (potential oversold bounce).

Controlled Experiment Architecture: Mean Reversion vs. BreakoutCopy Anchor Link

To scientifically contrast the two philosophies without data-snooping distortions, we establish an isolated, controlled experiment. Both strategies are executed across the exact same price history, with identical initial capital, position sizing parameters, and transaction cost modeling.

The Underlying Market Data GeneratorCopy Anchor Link

Financial backtesting frequently falls victim to parameter p-hacking when tuned on a single cherry-picked historical ticker. To rigorously expose how each rule behaves across structural environments, we synthesize a multi-regime OHLCV dataset of 750 daily trading bars (approximately 3 calendar years) containing three distinct macro phases:

1. Regime 1: Mean-Reverting Stationary Range (Bars 0 to 250): An Ornstein-Uhlenbeck stochastic process oscillating around an equilibrium price of $100 with stationary variance.
2. Regime 2: Low-Volatility Squeeze & Explosive Trend (Bars 250 to 500): A severe volatility compression (the Squeeze) around $100 with variance collapsing by 70%, followed by an unyielding directional drift that powers prices from $100 up to $170.
3. Regime 3: High-Volatility Broad Range (Bars 500 to 750): A choppy, high-variance consolidation zone oscillating between $150 and $180.

The Two Mutually Exclusive HypothesesCopy Anchor Link

Both systems trade long-only with all-in cash allocations (100% equity allocated per position) and adhere to strict causal execution: signals evaluate on completed bar t-1 Close, and market orders execute on bar t Open.

Hypothesis 1: Mean-Reversion SystemCopy Anchor Link

• Entry Trigger: Buy when price closes below the lower envelope: Close[t-1] <= Lower[t-1] (or %b[t-1] <= 0.0).
• Exit Trigger: Sell to cash when price recovers to or exceeds the central baseline: Close[t-1] >= Middle[t-1].
• Underlying Premise: Oversold extremes represent temporary liquidity imbalances destined to revert to the rolling mean.

Hypothesis 2: Volatility Breakout (The Squeeze) SystemCopy Anchor Link

• Squeeze Condition: Band compression is active when BandWidth[t-1] drops into the lowest 20th percentile of its trailing 60-bar distribution (BandWidth[t-1] <= Quantile_60(BandWidth, 0.20)). This compression state remains valid for 3 bars.
• Entry Trigger: Buy when price closes above the upper envelope following a recent squeeze: Close[t-1] > Upper[t-1] AND Recent_Squeeze[t-1] == True.
• Exit Trigger: Sell to cash when price falls back below the central baseline: Close[t-1] <= Middle[t-1] (trailing trend exit).
• Underlying Premise: A breakout from low volatility heralds persistent directional momentum.

Frictional ModelingCopy Anchor Link

To avoid the common trap of friction-free simulations, every trade incorporates:

• Brokerage Commission: 5 basis points (0.05%) per trade leg.
• Execution Slippage: 5 basis points (0.05%) adverse fill penalty applied to bar t Open.
• Total Round-Trip Friction: 20 basis points (0.20%) per round turn.

Structural Strategy Comparison MatrixCopy Anchor Link

The table below summarizes the operational and mathematical differences between the two rules:

To understand how technical indicator strategies encounter statistical distortion, consult our analysis on Backtesting Technical Analysis Pitfalls.

Market Regime Conditioning: Why Each Rule Breaks in the Other's HabitatCopy Anchor Link

When trading strategies are evaluated in aggregate over multi-year backtests, overall summary statistics frequently mask acute regime vulnerability. A strategy can display an acceptable Sharpe ratio solely because one favorable macro cycle overwhelmed a catastrophic drawdown in another.

To unmask these dynamics, let us analyze the regime-by-regime breakdown from our controlled backtest:

                     REGIME-BY-REGIME PERFORMANCE BREAKDOWN
                     
Regime 1 (Stationary Range):
  Mean Reversion:  2 Trades | 100.0% Win Rate | Net PnL: +$5,570.12  ◄── Dominant
  Breakout:        2 Trades |   0.0% Win Rate | Net PnL: -$5,632.12  ◄── Chopped Up

Regime 2 (Squeeze & Powerful Bull Trend):
  Mean Reversion:  0 Trades |   0.0% Win Rate | Net PnL:      $0.00  ◄── Left Behind
  Breakout:        4 Trades |  50.0% Win Rate | Net PnL: +$12,847.58 ◄── Rides the Trend

Regime 3 (High-Volatility Broad Range):
  Mean Reversion:  5 Trades | 100.0% Win Rate | Net PnL: +$12,402.42 ◄── Dominant
  Breakout:        2 Trades |   0.0% Win Rate | Net PnL: -$9,956.79  ◄── Severe Whipsaws

The Mechanism of Mean Reversion Failure: "Walking the Bands"Copy Anchor Link

Why did the Mean Reversion strategy log exactly zero trades during the massive bull run of Regime 2?

In a raging bull trend, prices consistently close between the Middle Band and Upper Band, repeatedly touching or exceeding the upper envelope. Because a long-only mean reversion strategy requires price to touch the lower envelope, it remains stranded in 100% cash during the most profitable directional move of the multi-year cycle.

More critically, consider what happens to an unconstrained, two-sided mean reversion strategy that shorts the upper band:

                         THE TRAP OF "WALKING THE BANDS"
   
Price
  ▲                                             * Upper Band
  │                                     *  *  *  (Upper envelope dragged upward)
  │                             *  *  * ──▲
  │                     *  *  *           │ Short Entry #3 (Loss compounding)
  │             *  *  * ──▲               │
  │     *  *  *           │ Short Entry #2 (Underwater)
  │    /                  │
  │   / ──▲ Short Entry #1 (Stop triggered or margin call)
  │  /    │
  │ /
  └────────────────────────────────────────────────────────► Time
     Asset experiences structural trend; Mean Reversion experiences ruin

During a trend shock, price pushes standard deviation wider, which expands the bands upward. The indicator does not repel price; rather, price drags the indicator with it. If an algorithmic trader naively shorts every upper band breach without a strict trend filter, they are shorting directly into institutional order flow. The strategy suffers catastrophic drawdowns with unbounded negative skewness.

The Mechanism of Breakout Failure: The False Expansion ChopCopy Anchor Link

Conversely, why did the Breakout rule lose -$5,632.12 in Regime 1 and -$9,956.79 in Regime 3?

In a sideways oscillating regime, a momentary expansion of BandWidth often represents random stochastic noise rather than institutional accumulation. Price pierces the upper envelope on an intraday surge, triggering a long entry. However, because the underlying asset lacks directional drift, liquidity providers step in at the range high, absorbing buy orders. Price promptly mean-reverts back through the middle band, stopping out the breakout trader at the open of the next bar.

Because breakout strategies accept low win rates in exchange for large asymmetric winners, deploying them into stationary environments guarantees capital attrition through repeated friction drag and false triggers.

For deeper mathematical exploration of trend duration and regime-dependent trend following, see our guide on Donchian Channel Strategy Backtest and the impact of friction in Transaction Cost Analysis in Backtesting.

Complete Python Implementation: Side-by-Side Controlled Backtest EngineCopy Anchor Link

Below is the complete, reproducible Python implementation. It generates the synthetic multi-regime dataset, computes Bollinger Bands with Bessel-corrected sample standard deviations and normalized BandWidth, runs both strategies through a strictly causal bar-by-bar execution loop with slippage and commission, and outputs detailed performance metrics.

"""
Bollinger Bands Strategy Backtest: Mean-Reversion vs. Volatility Breakout
Author: OpenBacktesting Research Lab
Engine Target: Python >= 3.12, < 3.15
"""

import numpy as np
import pandas as pd


def generate_multi_regime_data(seed: int = 42) -> pd.DataFrame:
    """Generate 750 daily bars spanning three distinct macro market regimes:
    Regime 1: Mean-reverting stationary range (Bars 0-250)
    Regime 2: Low-volatility Squeeze + Explosive trend (Bars 250-500)
    Regime 3: High-volatility broad range (Bars 500-750)
    """
    np.random.seed(seed)
    dates = pd.date_range("2023-01-01", periods=750, freq="B")

    # Regime 1: Mean-reverting range around 100 (Ornstein-Uhlenbeck)
    p1 = [100.0]
    theta = 0.15
    mu = 100.0
    sigma = 1.2
    for _ in range(249):
        dp = theta * (mu - p1[-1]) + np.random.normal(0, sigma)
        p1.append(p1[-1] + dp)

    # Regime 2: Severe compression (Squeeze) bars 250-320, then trend bars 320-500
    p2_squeeze = [p1[-1]]
    for _ in range(70):
        dp = 0.20 * (100.0 - p2_squeeze[-1]) + np.random.normal(0, 0.35)
        p2_squeeze.append(p2_squeeze[-1] + dp)

    p2_trend = [p2_squeeze[-1]]
    for _ in range(180):
        dp = 0.38 + np.random.normal(0, 1.1)
        p2_trend.append(p2_trend[-1] + dp)

    # Regime 3: Wide volatile oscillation around the high plateau (Bars 500-750)
    p3 = [p2_trend[-1]]
    mu3 = p2_trend[-1]
    for _ in range(250):
        dp = 0.08 * (mu3 - p3[-1]) + np.random.normal(0, 2.2)
        p3.append(p3[-1] + dp)

    prices = np.array(p1 + p2_squeeze[1:] + p2_trend[1:] + p3[1:])

    df = pd.DataFrame(index=dates)
    df["Close"] = np.round(prices, 2)

    # Synthesize realistic Open, High, Low, and Volume
    noise_high = np.abs(np.random.normal(0.6, 0.3, size=len(df)))
    noise_low = np.abs(np.random.normal(0.6, 0.3, size=len(df)))
    noise_open = np.random.normal(0, 0.25, size=len(df))

    df["Open"] = np.round(df["Close"].shift(1).fillna(df["Close"].iloc[0]) + noise_open, 2)
    df["High"] = np.round(np.maximum(df["Open"], df["Close"]) + noise_high, 2)
    df["Low"] = np.round(np.minimum(df["Open"], df["Close"]) - noise_low, 2)
    df["Volume"] = np.random.randint(500_000, 2_500_000, size=len(df))

    return df


def calculate_bollinger_bands(
    df: pd.DataFrame,
    window: int = 20,
    k: float = 2.0,
    squeeze_window: int = 60,
    squeeze_quantile: float = 0.20,
) -> pd.DataFrame:
    """Compute Middle, Upper, Lower bands, BandWidth, and Squeeze conditions."""
    df = df.copy()
    df["Middle"] = df["Close"].rolling(window=window).mean()
    # Sample standard deviation (ddof=1)
    df["Std"] = df["Close"].rolling(window=window).std(ddof=1)
    df["Upper"] = df["Middle"] + k * df["Std"]
    df["Lower"] = df["Middle"] - k * df["Std"]
    df["BandWidth"] = (df["Upper"] - df["Lower"]) / df["Middle"]

    # Rolling quantile of BandWidth to define causal squeeze threshold
    df["BandWidth_Threshold"] = (
        df["BandWidth"].rolling(window=squeeze_window).quantile(squeeze_quantile)
    )
    df["Is_Squeeze"] = df["BandWidth"] <= df["BandWidth_Threshold"]
    # Persist squeeze status for 3 bars to detect subsequent breakouts
    df["Recent_Squeeze"] = df["Is_Squeeze"].rolling(window=3).max() > 0

    return df


def backtest_strategy(
    df: pd.DataFrame,
    rule_type: str = "mean_reversion",
    fee_rate: float = 0.0005,
    slippage_rate: float = 0.0005,
    initial_capital: float = 100_000.0,
) -> tuple[pd.DataFrame, pd.DataFrame]:
    """Execute causal bar-by-bar simulation with commission and slippage."""
    cash = initial_capital
    shares = 0
    in_position = False
    entry_price = 0.0
    entry_idx = 0

    trades = []
    equity_curve = []

    # Indicator warm-up period (60 bars for squeeze quantile)
    start_bar = 80

    for i in range(start_bar, len(df)):
        dt = df.index[i]
        curr_open = df["Open"].iloc[i]
        prev_close = df["Close"].iloc[i - 1]
        prev_upper = df["Upper"].iloc[i - 1]
        prev_lower = df["Lower"].iloc[i - 1]
        prev_middle = df["Middle"].iloc[i - 1]
        prev_squeeze = df["Recent_Squeeze"].iloc[i - 1]

        # 1. Evaluate Exit Conditions for Open Position
        if in_position:
            exit_signal = False
            if rule_type == "mean_reversion":
                # Exit when price bounces back to the middle band
                if prev_close >= prev_middle:
                    exit_signal = True
            elif rule_type == "breakout":
                # Trailing exit when price drops back below middle band
                if prev_close <= prev_middle:
                    exit_signal = True

            if exit_signal:
                fill_price = curr_open * (1.0 - slippage_rate)
                gross_proceeds = shares * fill_price
                fee = gross_proceeds * fee_rate
                cash += gross_proceeds - fee
                pnl = (fill_price - entry_price) * shares - fee
                pnl_pct = (fill_price - entry_price) / entry_price

                trades.append({
                    "entry_date": df.index[entry_idx],
                    "exit_date": dt,
                    "entry_price": entry_price,
                    "exit_price": fill_price,
                    "shares": shares,
                    "pnl": pnl,
                    "pnl_pct": pnl_pct,
                    "bars_held": i - entry_idx,
                    "rule": rule_type,
                })
                in_position = False
                shares = 0

        # 2. Evaluate Entry Conditions
        if not in_position:
            entry_signal = False
            if rule_type == "mean_reversion":
                # Pierced lower band on bar t-1
                if prev_close <= prev_lower:
                    entry_signal = True
            elif rule_type == "breakout":
                # Pierced upper band on bar t-1 following a recent squeeze
                if prev_close > prev_upper and prev_squeeze:
                    entry_signal = True

            if entry_signal:
                fill_price = curr_open * (1.0 + slippage_rate)
                # Allocate 99% of cash to prevent fee-induced cash deficits
                alloc_cash = cash * 0.99
                shares_to_buy = int(alloc_cash // fill_price)

                if shares_to_buy > 0:
                    gross_cost = shares_to_buy * fill_price
                    fee = gross_cost * fee_rate
                    cash -= gross_cost + fee
                    shares = shares_to_buy
                    entry_price = fill_price
                    entry_idx = i
                    in_position = True

        # Mark-to-market portfolio value at bar Close
        curr_equity = cash + (shares * df["Close"].iloc[i])
        equity_curve.append({
            "date": dt,
            "equity": curr_equity,
            "cash": cash,
            "shares": shares,
            "in_position": in_position,
        })

    equity_df = pd.DataFrame(equity_curve).set_index("date")
    trades_df = pd.DataFrame(trades)
    return equity_df, trades_df


def compute_metrics(
    equity_df: pd.DataFrame, trades_df: pd.DataFrame, initial_capital: float = 100_000.0
) -> dict:
    """Calculate standard portfolio risk and return statistics."""
    total_ret = (equity_df["equity"].iloc[-1] - initial_capital) / initial_capital
    days = (equity_df.index[-1] - equity_df.index[0]).days
    ann_ret = (1.0 + total_ret) ** (365.25 / days) - 1.0

    daily_returns = equity_df["equity"].pct_change().dropna()
    ann_vol = daily_returns.std() * np.sqrt(252)
    sharpe = (daily_returns.mean() * 252) / ann_vol if ann_vol > 0 else 0.0

    downside = daily_returns[daily_returns < 0]
    downside_std = downside.std() * np.sqrt(252)
    sortino = (daily_returns.mean() * 252) / downside_std if downside_std > 0 else 0.0

    peak = equity_df["equity"].cummax()
    drawdown = (equity_df["equity"] - peak) / peak
    max_dd = drawdown.min()

    num_trades = len(trades_df)
    if num_trades > 0:
        win_rate = len(trades_df[trades_df["pnl"] > 0]) / num_trades
        wins = trades_df[trades_df["pnl"] > 0]["pnl"]
        losses = trades_df[trades_df["pnl"] < 0]["pnl"].abs()
        profit_factor = (
            wins.sum() / losses.sum()
            if losses.sum() > 0
            else (wins.sum() if wins.sum() > 0 else 0.0)
        )
        avg_pnl = trades_df["pnl"].mean()
        avg_holding = trades_df["bars_held"].mean()
    else:
        win_rate = 0.0
        profit_factor = 0.0
        avg_pnl = 0.0
        avg_holding = 0.0

    return {
        "Final Equity ($)": equity_df["equity"].iloc[-1],
        "Total Return (%)": total_ret * 100.0,
        "Annualized Return (%)": ann_ret * 100.0,
        "Annualized Volatility (%)": ann_vol * 100.0,
        "Sharpe Ratio": sharpe,
        "Sortino Ratio": sortino,
        "Max Drawdown (%)": max_dd * 100.0,
        "Total Trades": num_trades,
        "Win Rate (%)": win_rate * 100.0,
        "Profit Factor": profit_factor,
        "Avg Trade PnL ($)": avg_pnl,
        "Avg Holding (Bars)": avg_holding,
    }


if __name__ == "__main__":
    market_data = generate_multi_regime_data(seed=42)
    market_data = calculate_bollinger_bands(market_data)

    eq_mr, tr_mr = backtest_strategy(market_data, rule_type="mean_reversion")
    m_mr = compute_metrics(eq_mr, tr_mr)

    eq_bo, tr_bo = backtest_strategy(market_data, rule_type="breakout")
    m_bo = compute_metrics(eq_bo, tr_bo)

    print("=================== MEAN REVERSION RESULTS ===================")
    for k, v in m_mr.items():
        print(f"{k:<26}: {v:>10.2f}" if isinstance(v, float) else f"{k:<26}: {v:>10}")

    print("\n================== BREAKOUT SQUEEZE RESULTS ==================")
    for k, v in m_bo.items():
        print(f"{k:<26}: {v:>10.2f}" if isinstance(v, float) else f"{k:<26}: {v:>10}")

Execution Output & Trade Log AuditCopy Anchor Link

Running the backtest across the 750-bar series produces the following verified metrics:

=================== MEAN REVERSION RESULTS ===================
Final Equity ($)          :  117603.11
Total Return (%)          :      17.60
Annualized Return (%)     :       6.54
Annualized Volatility (%) :       6.91
Sharpe Ratio              :       0.92
Sortino Ratio             :       0.49
Max Drawdown (%)          :      -6.59
Total Trades              :          7
Win Rate (%)              :     100.00
Profit Factor             :   17972.54
Avg Trade PnL ($)         :    2567.51
Avg Holding (Bars)        :       9.14

================== BREAKOUT SQUEEZE RESULTS ==================
Final Equity ($)          :   96861.56
Total Return (%)          :      -3.14
Annualized Return (%)     :      -1.24
Annualized Volatility (%) :       5.67
Sharpe Ratio              :      -0.18
Sortino Ratio             :      -0.11
Max Drawdown (%)          :     -13.01
Total Trades              :          8
Win Rate (%)              :      25.00
Profit Factor             :       0.85
Avg Trade PnL ($)         :    -342.67
Avg Holding (Bars)        :      12.12

Granular Trade Log InspectionCopy Anchor Link

To examine the exact execution dynamics, we audit sample trades from each system:

MEAN REVERSION TRADES:
Entry Date  Exit Date    Entry ($)   Exit ($)    Shares   PnL ($)     Return (%)  Bars
2023-05-24  2023-06-01   $97.67      $100.54     1013     +$2,857.29  +2.94%      6
2023-07-07  2023-07-20   $97.58      $100.22     1023     +$2,712.82  +2.72%      9
2025-01-08  2025-01-29   $161.43     $162.68      625     +$753.63    +0.77%      15
2025-06-11  2025-07-03   $168.55     $169.73      598     +$682.80    +0.70%      16
2025-08-05  2025-08-12   $162.35     $169.81      620     +$4,803.73  +4.60%      5

BREAKOUT SQUEEZE TRADES:
Entry Date  Exit Date    Entry ($)   Exit ($)    Shares   PnL ($)     Return (%)  Bars
2023-08-10  2023-08-16   $101.78     $99.94      972      -$1,837.89  -1.81%      4  (Chop)
2023-10-24  2023-11-06   $105.49     $101.42     931      -$3,794.23  -3.86%      9  (Chop)
2024-02-02  2024-02-13   $100.45     $99.72      983      -$724.57    -0.73%      7  (Chop)
2024-03-19  2024-05-03   $101.08     $108.51     907      +$6,744.42  +7.35%      33 (Trend)
2024-08-08  2024-09-17   $140.91     $153.30     698      +$8,658.32  +8.79%      28 (Trend)

The trade logs highlight the stark behavioral dichotomy:

• The Mean Reversion trades entered during brief dips below $98 in 2023, cleanly exiting within 6 to 9 bars as price snapped back to the $100 mean. In 2025, it repeated this pattern at the higher $162–$169 consolidation. It registered a 100% win rate across 7 trades, achieving a Sharpe ratio of 0.92 and keeping Max Drawdown under -6.6%.
• The Breakout Squeeze strategy suffered 3 consecutive losing trades during the choppy ranges of late 2023 and early 2024 (-$1,837, -$3,794, -$724). However, when the true breakout detonated in March 2024, it rode the trend for 33 bars, capturing +$6,744.42, followed by another trend runner in August 2024 gaining +$8,658.32 over 28 bars. Yet, because the broader environment spent 500 of the 750 bars in ranges, its overall net return ended slightly negative (-3.14%).

For comprehensive risk and drawdown measurement techniques, see our guide on Maximum Drawdown in Python and Profit Factor Backtesting.

Execution Realism and Microstructure Pitfalls: Where Naive Backtests LieCopy Anchor Link

When migrating Bollinger Bands strategies from stylized Python research scripts to production environments, algorithmic developers frequently encounter severe execution slippage and fill discrepancies. Four subtle failure modes explain why textbook simulations fail out of sample:

1. Intrabar Band Penetration vs. Bar-Close ConfirmationCopy Anchor Link

A classical backtest flaw involves conditioning execution on intrabar envelope breaches using coarse daily or hourly OHLC data:

Scenario A (Wick Rejection):
Bar t opens at $100 -> Dips to Low of $97 (touches Lower Band at $98) -> Rallies to Close at $101.

Naive Backtest: Assumes a Limit Buy filled perfectly at $98.00 at the lower band.
Reality:        At the moment price touched $98.00, the bar was still forming. 
                Was the band at $98.00? No! Because standard deviation incorporates Close_t,
                the band location was shifting continuously with every tick.

If your backtester calculates bands using df['Close'] and assumes an intrabar fill occurred when df['Low'] <= df['Lower'], it introduces two fatal errors:

1. Indicator Non-Stationarity Intrabar: The standard deviation envelope at the moment Low was printed was completely different from its value at the final bar Close.
2. Path Dependency: Without tick-level or sub-minute data, you cannot determine whether Low occurred before or after Open or High.

To maintain strict causal validity, conservative research models must require bar closure (Close[t-1] <= Lower[t-1]) before placing orders on the subsequent bar (Open[t]).

2. Microstructure Slippage on Breakouts vs. Mean-Reversion FillsCopy Anchor Link

Transaction costs do not impact all strategies symmetrically:

• Breakout Orders Consume Liquidity: When a BandWidth squeeze detonates and price breaks above the upper envelope, aggressive momentum algorithms rush to buy simultaneously. Order books thin out, bid-ask spreads widen, and market buy orders suffer severe adverse slippage. A backtest assuming fill at Open_t without penalizing slippage will dramatically overestimate returns.
• Mean-Reversion Orders Provide Liquidity: Buying when price breaches the lower envelope means buying into aggressive selling. While passive limit orders may receive fills, the strategy faces acute adverse selection: the trades that fill most easily are often the ones where price collapses through the band during a catastrophic structural liquidation.

For a rigorous framework on modeling execution drag, consult our walkthrough on Backtrader Slippage.

3. Squeeze Quantile Overfitting (Data Snooping)Copy Anchor Link

In our breakout model, the squeeze was defined as:

BandWidth_{t-1} <= Quantile_60(BandWidth, 0.20)

Why 60 bars? Why the 20th percentile?

If a researcher sweeps parameters across window in [20, 40, 60, 100, 120] and quantile in [0.10, 0.15, 0.20, 0.25, 0.30], they perform 25 hypothesis tests on the same historical series. Through the multiple testing problem, at least one parameter set will produce an attractive Sharpe ratio purely by chance. Squeeze thresholds must be validated across out-of-sample data or anchored by economic volatility metrics rather than curve-fitted thresholds.

4. Lookahead Leakage via Centered Rolling CalculationsCopy Anchor Link

In scientific backtesting, rolling indicators must strictly look backward. A common implementation error occurs when developers inadvertently call centered rolling functions:

# FATAL FLAW: Centers the window, leaking N/2 future bars into the current value
df["Middle_Leaked"] = df["Close"].rolling(window=20, center=True).mean()

Centered rolling calculations evaluate bar t using bars t+1, t+2, ..., t+10. Any backtest executing on centered rolling bands is trading on future knowledge, creating an illusion of infallible market timing. Read our foundational guide on Lookahead Bias in Backtesting for detection techniques.

Verification Checklist for Bollinger Bands Strategy ResearchCopy Anchor Link

Before allocating capital to any systematic Bollinger Bands trading system, verify your implementation against this 8-point quantitative checklist:

• Strict Causal Lagging: All indicators (Middle, Upper, Lower, BandWidth) are evaluated on completed bars (t-1), and orders are queued for execution on bar t Open.
• Degrees of Freedom Consistency: Verify whether your quantitative engine uses sample standard deviation (ddof=1) or population standard deviation (ddof=0), maintaining consistent definitions across backtesting and execution.
• Macro Regime Filter Conditioning: If running mean reversion, ensure a macro trend filter (e.g., ADX < 25, 200-day SMA slope, or Hurst exponent < 0.5) halts trading during strong trending expansions.
• Asymmetric Cost Modeling: Apply higher slippage penalties to momentum breakout entries that consume thin market depth during volatility spikes.
• Intrabar Path Disambiguation: Do not assume limit order fills at outer band prices without verifying sub-bar intrabar price trajectories.
• Squeeze Window Expansion Safety: Ensure the BandWidth quantile evaluation window does not peek into future bars or suffer survivor bias.
• Two-Sided Tail Risk Controls: If shorting upper band touches, implement strict structural stop-loss orders to prevent catastrophic losses when an asset walks the bands.
• Multi-Asset Cross-Validation: Test the identical parameter set across uncorrelated asset classes (equities, commodities, foreign exchange) to confirm genuine statistical edge.

Conclusion: The Indicator is a Measuring Tape, Not a StrategyCopy Anchor Link

Bollinger Bands are frequently marketed as complete trading systems in retail literature. In reality, John Bollinger's envelopes are an adaptive measuring tape. They measure where price resides relative to its second central moment, but they cannot inherently predict whether that dispersion will snap back or detonate into an explosive trend.

As our controlled experiment demonstrated:

• When the underlying price process is stationary and mean-reverting (Regimes 1 and 3), the Mean-Reversion rule generated a 100% win rate and smooth equity appreciation, while the Breakout rule bled capital through false alarms.
• When the underlying price process shifted into a persistent, low-volatility directional drift (Regime 2), the Breakout rule captured outsized gains (+8.79% and +7.35% runners), while the Mean-Reversion rule was completely sidelined.

The true quantitative edge does not lie in tweaking the moving average length from 20 to 21 or the multiplier from 2.0 to 2.1. The edge lies in regime identification: knowing when the market environment warrants playing the rubber band versus priming the fuse for a volatility explosion.

OpenBacktesting Architectural StandardCopy Anchor Link

At OpenBacktesting, our open-source Python framework (0.2.1, targeting Python >= 3.12, < 3.15) is built specifically to make these structural trade-offs inspectable and reproducible. Rather than relying on black-box vector approximations or uninspected metrics, OpenBacktesting provides:

• Deterministic, bar-by-bar single-asset historical OHLCV simulation.
• Explicit order and trade lifecycle audits recorded directly into SQLite trial persistence.
• Complete separation between signal generation, portfolio accounting, and execution drag.
• Local OpenBacktesting Studio UI for inspecting individual trade fills, adverse excursions, and equity curves.

By running controlled, causal experiments on transparent engines, quantitative researchers can eliminate lookahead leakage, measure realistic friction drag, and design robust strategies engineered to survive live market conditions.