Your backtest is lying to you — the hidden cost of dirty market data.

Your strategy shows a Sharpe of 1.8 in backtest and 0.4 in production. Before you blame your alpha model, check your data. In our experience, dirty market data accounts for 30–60% of the gap between backtest and live performance — and almost nobody measures it. The rest of this article is a structured dissection of why that number is not an exaggeration.

The pattern is so consistent it has a shape: a clean-looking backtest, a confident pitch deck, a real allocation, and then a month-three meeting where nobody can explain where the alpha went. The first reflex is always to re-tune the model. The second is to widen the universe. The third — eventually — is to look at the data. By then the capital has already been lost.

This article is for the engineers, quants, and risk managers who have lived that month. The premise is concrete: most of the alpha you lost was never there. It was data-quality artifact dressed up as edge. The taxonomy below names the eight mechanisms. The worked example shows the magnitude. The pipeline section gives you the structure to catch the next one before it costs anything.

Market data problems are not random noise. They are structured, recurring, and systematic — which means they bias results in a consistent direction. Below is a working taxonomy of the eight failure modes every backtesting engineer should internalise.

One concrete example per signal family:

• Momentum. A missing bar during a breakout suppresses volatility estimates, leading the ranking model to oversize a position — the actual signal is understated, but the backtest doesn't know that.
• Mean-reversion. Stale prices in illiquid ETFs create sequences of zero returns followed by a "reversion jump." The strategy sees this as a signal; it is actually a data artifact.
• Pairs trading. Timezone misalignment in a cross-listed pair introduces a one-bar lead-lag that doesn't exist in live markets — the "arbitrage" disappears on day one of production.

Based on industry literature and systematic QC pipeline analysis, typical findings for a liquid US equity dataset:

• Missing tick rate: 0.3–2.1% of expected ticks; rate spikes above 1.5% during high-volatility events (VIX > 30).
• Price spike rate: 0.01–0.05% of ticks exceed the 3σ threshold — low frequency, high impact.
• Stale price sequences: 0.5–3.0% of 1-minute bars in the bottom liquidity quintile have 5+ consecutive identical prices.
• Corporate action mismatches between two independent vendors: 3–8% of events differ on effective date or adjustment factor.
• Survivorship bias: annualised return overstatement of 1.6–4.9 percentage points depending on universe and strategy period.

For a simple 20-day momentum strategy (long-only, equal-weight, daily rebalance), the impact of each uncorrected issue type on the Sharpe ratio is material:

Ranges are calibrated to academic-literature benchmarks including Korajczyk & Sadka (2004), Chordia et al. (2011), and survivorship-bias studies by Brown, Goetzmann, Ibbotson & Ross. Actual degradation is strategy-dependent — HFT strategies are more sensitive to tick-level issues; lower- frequency strategies are disproportionately affected by corporate-action errors and survivorship bias. Corporate action errors and survivorship bias dominate, and that is not a coincidence: both produce systematic upward shifts in apparent returns, not just noise.

This is where the expertise gap between "data cleaning" and "data methodology" becomes decisive. Five methods — radically different risk profiles.

01Forward fill (LOCF).

Default in pandas ffill(). Simple and fast. The problem: LOCF introduces artificial positive autocorrelation in the filled series — a price held constant for 3 bars looks like a trend signal to any model with a rolling window. Acceptable only for gaps under 3 bars in highly liquid instruments.

02Linear interpolation.

Smooth and unbiased for slow-moving processes. Critical implementation risk: if the endpoint used to anchor the line is a future observation, you have introduced look-ahead bias — the bar at t+3 is being used to construct t+1. The correct implementation is causal linear only: extrapolate forward from the last observed value using the local drift estimate, with no future data.

03VWAP-based resampling.

Aggregate available ticks within each bar window using volume-weighted average price. Materially superior to LOCF for bar-construction accuracy. Not a gap-filling method: if the ticks are missing, VWAP gives you nothing.

04Kalman filter interpolation.

The state-space formulation treats price as a latent state and observations as noisy measurements. During gaps, the filter propagates state uncertainty via the prediction step — the gap is handled naturally without inventing data. pykalman supports masked observations natively, making implementation straightforward:

import numpy as np
from pykalman import KalmanFilter

def kalman_fill(prices: np.ndarray) -> np.ndarray:
    """
    Gap-fill a price series using a Kalman smoother.
    Missing values must be np.nan; convert to masked array.
    Returns smoothed series with gaps filled from state estimates.
    """
    from numpy import ma
    masked = ma.masked_invalid(prices)

    kf = KalmanFilter(
        transition_matrices=[1],
        observation_matrices=[1],
        initial_state_mean=masked[~masked.mask][0],
        initial_state_covariance=1.0,
        observation_covariance=1.0,   # tune to instrument σ²
        transition_covariance=0.01    # process noise: smaller = smoother
    )
    kf = kf.em(masked, n_iter=10)
    smoothed_means, _ = kf.smooth(masked)
    filled = prices.copy()
    filled[np.isnan(prices)] = smoothed_means.flatten()[np.isnan(prices)]
    return filled

Parameter sensitivity is the core risk: underestimating observation noise overfits to data; underestimating process noise over-smooths through real price moves. Calibrate observation_covariance from the instrument's realized variance and transition_covariance from the expected price change per bar.

05Model-based (cross-sectional) imputation.

Train an imputation model on correlated instruments: when AAPL has a gap, use MSFT, QQQ and SPY to impute. Best accuracy for correlated universes, but computationally expensive and introduces model risk into the data layer itself. Justified use cases: option chains (put-call parity constrains missing strikes) and fixed-income curves (Nelson-Siegel fills missing maturities).

Scenario: 20-day momentum strategy, 500 US equities, daily rebalance, equal-weighted, long-only, January 2020 – December 2024.

The Kalman treatment correctly increases max drawdown slightly relative to LOCF — because LOCF artificially dampens volatility in gap periods, making drawdowns look shallower than they are. Corporate-action correction has the largest single-step impact (−0.12 Sharpe). Survivorship-bias correction brings the final degradation: the strategy that looked like 1.61 delivers 1.19 on a realistic historical universe.

A production QC pipeline is not a preprocessing script. It is a continuous validation layer with four independent checks — any single layer alone is insufficient.

1. Layer 1 — Schema validation (before storage). Timestamp monotonicity; price > 0, volume ≥ 0; bid ≤ ask for quote data; symbol in known universe. Fast, and catches the most egregious issues before they touch any data store.
2. Layer 2 — Statistical validation (per bar). Price deviation: |p_t − p_{t−1}| / σ_{20d} > θ → flag. Volume spike: V_t > 5 × ADV_{20d} → flag. Zero-volume bar during exchange hours → flag.
3. Layer 3 — Sequence validation (per session). Expected bar count vs. actual; gap detection with configurable tolerance; stale detection for N+ consecutive identical prices.
4. Layer 4 — Cross-source validation (daily). Compare the same instrument across two or more independent vendors. Price discrepancy > 0.1% on adjusted close → investigate. Corporate-action date discrepancy → manual review queue.

Here is a minimal Python implementation:

import pandas as pd
import numpy as np
from dataclasses import dataclass, field
from typing import Optional

@dataclass
class DataQualityChecker:
    series: pd.Series
    expected_freq: str = "1min"
    spike_threshold: float = 3.0
    stale_n: int = 5
    _issues: dict = field(default_factory=dict)

    def check_spike(self) -> pd.Index:
        returns = self.series.pct_change().dropna()
        roll_std = returns.rolling(20).std()
        spikes = returns.index[np.abs(returns) > self.spike_threshold * roll_std]
        self._issues["spikes"] = len(spikes)
        return spikes

    def check_gaps(self) -> pd.DataFrame:
        full_idx = pd.date_range(
            self.series.index[0], self.series.index[-1], freq=self.expected_freq
        )
        missing = full_idx.difference(self.series.index)
        gaps = pd.DataFrame({"timestamp": missing, "size": 1})
        self._issues["gaps"] = len(missing)
        return gaps

    def check_stale(self) -> pd.Index:
        diffs = self.series.diff().abs()
        stale_mask = diffs.rolling(self.stale_n).sum() == 0
        self._issues["stale_bars"] = int(stale_mask.sum())
        return self.series.index[stale_mask]

    def summary_report(self) -> pd.DataFrame:
        _ = self.check_spike()
        _ = self.check_gaps()
        _ = self.check_stale()
        total = len(self.series)
        rows = [
            {"issue": k, "count": v,
             "pct_of_series": round(v / total * 100, 3),
             "severity": "HIGH" if v / total > 0.01 else "MEDIUM" if v / total > 0.001 else "LOW"}
            for k, v in self._issues.items()
        ]
        return pd.DataFrame(rows)

No data vendor has zero data-quality issues. The distinction that matters is not Tier 1 vs. free — it is known failure modes vs. unknown failure modes.

Tier 1 vendors (Bloomberg, Refinitiv) have dedicated data operations and systematic corporate-action processing. They still have issues — particularly in non-US markets, small caps and OTC instruments. The gaps are documented and often correctable. Free or low-cost vendors have systematic gaps that are acceptable for research but categorically not for production capital allocation.

The most dangerous segment: paid vendors with institutional branding but retail-grade data operations. The feed looks credible until a corporate action is wrong — and that error persists in your backtest for five years of history.

At Nyquist, data-quality validation is not a preprocessing script that runs before backtesting — it is a continuous pipeline layer built into the data infrastructure itself. Every tick is validated against schema, statistical and cross-source checks before it reaches the API layer. We log every anomaly, every gap-fill method applied, and every data point that was imputed vs. observed — because when a strategy fails in production, the first question is always "was it the model or the data?" We make sure the answer is never ambiguous.

Two caveats keep the numbers honest. Sharpe degradation figures are illustrative and calibrated to academic-literature ranges — actual impact is highly strategy-dependent (HFT vs. daily vs. weekly rebalancing). And every fix carries its own risk: Kalman filters need careful noise calibration, cross-vendor validation is expensive and infeasible for exotic instruments, survivorship-bias correction requires a point-in-time universe not every vendor provides, and ML-based imputation imports model risk directly into the data layer.