A Rolling Z-Score Without Look-Ahead

Question

A z-score is a natural way to standardise a price or signal, but in a backtest you must be careful which mean and standard deviation you use.
def rolling_zscore(prices: np.ndarray, window: int) -> np.ndarray:
    pass
Task
Return, for each point, the z-score of the current value computed using only the trailing window of past values (the window values strictly before the current point). The first window outputs have insufficient history and must be NaN.

Also answer
Explain why standardising with the full-sample mean and standard deviation is look-ahead bias, and why it corrupts a backtest.

Example

 	With prices = [10, 11, 12, 13, 100] and window = 3, the output at index 3 uses the mean and std of [10, 11, 12].

Accepted Answer

The whole question is about information availability. A z-score standardises a value by subtracting a mean and dividing by a standard deviation, \begin{equation} z_t = \frac{x_t - \mu}{\sigma} \end{equation} and the only honest choice of $\mu$ and $\sigma$ in a backtest is one computed from data that was already observable at time $t$. Two subtle traps live here, and both are forms of look-ahead bias.

Trap 1: full-sample statisticsIf you standardise with $\mu_{full}$ and $\sigma_{full}$ computed over the entire series, then at time $t$ your z-score depends on prices from $t+1, t+2, \ldots$ that had not happened yet. The model is implicitly told where the series will settle in the future — e.g. that today's price of 100 is a wild outlier only becomes "known" because the rest of the sample is small. In a live system that information does not exist, so any edge measured this way is fictitious and evaporates in production. This is the classic reason a beautiful backtest dies on contact with real markets.

Trap 2: leaking the current point into its own meanEven a rolling window leaks if it includes the current observation. If the window at time $t$ is $prices[t-window+1 : t+1]$, then $x_t$ helps determine its own $\mu$ and $\sigma$. When a genuine shock arrives (the jump to 100), an inclusive window absorbs part of that shock into the mean and inflates the std, shrinking the very z-score that was supposed to flag the event. To detect that 100 is anomalous relative to the past, the statistics must be built from the trailing window strictly before $t$: the slice $prices[t-window : t]$.

Clean vectorised solutionThe most readable correct implementation uses pandas' rolling with a shift, which guarantees the current point is excluded; below it is the explicit NumPy version for those who want no pandas dependency.
import numpy as np
import pandas as pd

def rolling_zscore(prices: np.ndarray, window: int) -> np.ndarray:
    """Z-score of each value using ONLY the trailing `window` PAST values.

    The statistics at index t are computed from prices[t-window:t], i.e.
    strictly before t. The first `window` outputs are NaN (warm-up).
    """
    if window < 2:
        raise ValueError("window must be at least 2 to define a std")

    s = pd.Series(prices, dtype=float)
    # shift(1) drops the current point so it cannot leak into its own stats.
    past = s.shift(1).rolling(window=window)
    mean = past.mean()
    # ddof=0 (population std) keeps the warm-up boundary clean and avoids
    # division by a near-zero sample std on tiny windows; ddof=1 is also fine.
    std = past.std(ddof=0)
    z = (s - mean) / std
    return z.to_numpy()


def rolling_zscore_numpy(prices: np.ndarray, window: int) -> np.ndarray:
    """Dependency-free equivalent using a sliding window view."""
    prices = np.asarray(prices, dtype=float)
    n = prices.size
    out = np.full(n, np.nan)
    if n  NaN (warm-up); index 3 uses [10,11,12]; index 4 uses [11,12,13]
assert np.isnan(z[:3]).all()

# Manual check at index 3: stats from [10, 11, 12]
mu, sd = np.mean([10, 11, 12]), np.std([10, 11, 12])  # 11.0, 0.8165
assert np.isclose(z[3], (13 - mu) / sd)

# Manual check at index 4: stats from [11, 12, 13]; the 100 must NOT be in its own stats
mu4, sd4 = np.mean([11, 12, 13]), np.std([11, 12, 13])  # 12.0, 0.8165
assert np.isclose(z[4], (100 - mu4) / sd4)
print(z)

The test confirms the two design choices: the first window entries are NaN, and at index 4 the explosive value 100 is scored against the past $[11,12,13]$ only — producing a large z-score that correctly flags the anomaly, instead of being diluted by its own presence.

Why it matters for backtest integrityA backtest is a simulation of decisions you could have made in real time. Every statistic feeding a decision at time $t$ must be a function of data up to and including $t$ — and standardisation is no exception. Full-sample or inclusive-window scaling is a silent leak: it inflates Sharpe ratios, makes outliers look predictable, and produces strategies that cannot be reproduced live. The same discipline extends to fitting scalers inside (not across) cross-validation folds, and to purging and embargoing around train/test boundaries. The one-line rule: standardise with the past, never with the present or the future.

Title	Category	Subcategory	Difficulty	Status
Leakage-Free Pipeline	Machine Learning	Coding	Medium	Unlock
Vectorization and Broadcasting	Machine Learning	Coding	Easy	Unlock

The Interview Guide for Quants and Traders

A Rolling Z-Score Without Look-Ahead

What do you think of this page?