Block Bootstrap for Trading: Respecting Streaks When You Resample

Block bootstrap is a resampling method that draws contiguous blocks of consecutive observations rather than individual data points, so the internal ordering inside each block is preserved. Trading needs it because returns are not independent: volatility clusters, trends persist, and losing runs bunch together. A plain bootstrap that shuffles individual returns implicitly assumes each day is independent of the last, which is false for almost every strategy's equity curve. When you shuffle daily returns freely, you break the exact thing that determines how deep and how long a drawdown gets. A sequence of five bad days in a row hurts far more than five bad days scattered across a year, even when the arithmetic sum is identical, because the peak-to-trough excursion depends on order.

The practical consequence is that a naive bootstrap tends to understate tail risk. It manufactures equity paths that are smoother than anything the strategy would actually produce, because it has quietly assumed away serial dependence. Block bootstrap keeps runs intact by resampling whole segments, so streaks survive resampling and the resulting drawdown distribution reflects the clustering that real trading exhibits. This is a robustness technique, not a performance technique: it tells you more honestly how bad things can get, not how good. If you are new to resampling for validation, start with our [Monte Carlo simulation for backtests](/learn/monte-carlo-simulation-backtests) primer and then come back to why the block structure matters.

Consider what a plain (IID) bootstrap physically does: it puts every return in a bag and draws with replacement, one at a time, until it has rebuilt a series of the same length. Every draw is independent, so any relationship between adjacent returns is gone by construction. If your strategy's losses tend to arrive together (a momentum system in a choppy regime, say), the bag doesn't know that. It is equally likely to place a loss next to a gain as next to another loss.

Autocorrelation is precisely the memory the bag throws away. Positive autocorrelation in returns lengthens drawdowns; volatility clustering deepens them. Both are second-order structure that survives only if you keep neighbours together. The visible symptom of ignoring this is a maximum-drawdown distribution whose tail is too thin: your resampled worst cases look milder than the single realised path, which should make you suspicious rather than reassured. A validation method that makes your strategy look safer than its own history is not doing its job.

This is the same failure mode, from a different angle, as the errors catalogued in [why most backtests fail](/learn/why-most-backtests-fail): a modelling shortcut quietly flatters the result. The fix is not more simulations. Ten thousand IID resamples of a dependent series just gives you a very precise estimate of the wrong distribution.

Use block bootstrap whenever the quantity you care about depends on the ordering of returns, and use a plain bootstrap only when it genuinely does not. The table below is a rough guide, not a rule.

| Question you are asking | Ordering matters? | Method | |---|---|---| | Distribution of maximum drawdown | Yes | Block | | Distribution of drawdown duration | Yes | Block | | Mean return / simple aggregate | No | Plain is usually fine | | Path-dependent risk of ruin | Yes | Block | | Sharpe point estimate uncertainty | Somewhat | Block if returns are autocorrelated |

The honest default for anything drawdown- or path-related is block bootstrap, because those are exactly the statistics that ordering drives. There is one important caveat: block bootstrap trades one bias for a smaller one. By keeping blocks intact you preserve within-block dependence, but you still break dependence at the seams where blocks join. The longer your blocks, the more structure you keep and the fewer independent pieces you have to resample from, which raises variance. It is a genuine trade-off with no free setting. This connects to sample-size reality: if you only have a few hundred trades, no resampling scheme rescues you. See [how many trades is enough](/learn/how-many-trades-is-enough) before you lean hard on any of these distributions.

Block length is the one parameter that matters, and there is no universally correct value. Too short and you leak back toward the IID case, destroying the streaks you were trying to keep. Too long and you have very few distinct blocks, so your resamples all look like slightly rearranged copies of the original path and your uncertainty estimate collapses. A common starting point in the literature scales the block length with the sample size (roughly on the order of n to the one-third power), but treat that as a place to begin a sensitivity check, not an answer. The honest practice is to report results across several block lengths and show that your conclusion does not hinge on one lucky choice.

Three variants are worth knowing by name. The moving-block bootstrap (Kunsch; Liu and Singh) draws fixed-length overlapping blocks. The stationary bootstrap (Politis and Romano) randomises the block length using a geometric distribution, which keeps the resampled series stationary and removes the need to pin one exact length. The circular block bootstrap wraps the series end-to-start so every observation gets equal weight. For most trading work the stationary bootstrap is a sensible default precisely because it softens the block-length decision.

Here is a minimal, look-ahead-clean stationary bootstrap of a returns series. It only ever reads past-and-present values and never normalises across the whole series:

import numpy as np

def stationary_bootstrap(returns, mean_block, rng):
    n = len(returns)
    p = 1.0 / mean_block
    out = np.empty(n)
    i = rng.integers(n)
    for t in range(n):
        out[t] = returns[i]
        if rng.random() < p:
            i = rng.integers(n)   # start a new block
        else:
            i = (i + 1) % n       # continue the current block
    return out

Run this many times, compute the maximum drawdown of each path, and you get a drawdown distribution that respects streaks.

Block bootstrap can give you a more honest spread of outcomes conditional on your history being representative. It answers questions like: given the dependence structure I actually observed, how bad might the drawdown have been under a different ordering of the same market behaviour? That is genuinely useful for sizing, for setting a drawdown you are willing to tolerate, and for pressure-testing a strategy before you trust it. It is a robustness check in the same family as [walk-forward analysis](/learn/walk-forward-analysis) and the [deflated Sharpe ratio](/learn/deflated-sharpe-ratio): each attacks a different way a backtest can lie to you.

What it can never do is manufacture information your sample doesn't contain. If your history has no crisis in it, no resampling scheme will invent one; block bootstrap re-orders the regimes you lived through, it does not conjure regimes you didn't. It also cannot correct for look-ahead bias, survivorship bias, or a strategy that was overfit before it ever reached this stage. Resampling a contaminated return series just gives you a well-quantified picture of a contaminated strategy. Clean the inputs first, using the checks in [look-ahead bias](/learn/look-ahead-bias), then resample.

None of this speaks to whether a strategy will make money, and this article makes no such claim. Block bootstrap is a tool for describing risk and dependence more honestly, nothing more. To fold it into a broader integrity check, run your equity curve through the free [Backtest Health Check](/backtest) and treat its drawdown output as one input among several, not a verdict. This content is educational and is not investment advice.