Backtesting Trading Strategies: The Matrix of Finance

#trading #finance #crypto #stocks

The Quest Begins (The "Why")

Honestly, I used to think backtesting was just a fancy way of saying “I ran my strategy on yesterday’s data and pretended I could see the future.” I’d slap together a quick Python loop, feed it some CSV prices, and watch the equity curve climb like a rocket—only to blow up the moment I tried it live. It felt like I was training a dragon to fetch my coffee, only to discover it preferred setting my desk on fire.

The turning point came after a painful live‑trade loss that wiped out a chunk of my side‑hustle savings. I stared at the screen, wondering where the disconnect was. Was my idea flawed? Or was the way I tested it lying to me? That night I dove into the literature, and the answer hit me like a Morpheus‑style red pill: the devil is in the details of how you simulate the past. If you don’t treat historical data like a live market—respecting order, latency, and the information actually available at each tick—you’re basically cheating.

The Revelation (The Insight)

The insight was simple but powerful: backtesting isn’t about running your code over a static dataframe; it’s about replaying the market tick‑by‑tick (or bar‑by‑bar) with the same information a trader would have had at that moment. Anything that peeks into the future—future prices, future indicators, or even future cash flows—creates look‑ahead bias and turns your backtest into a fantasy.

Think of it like a boss fight in Dark Souls: you can’t memorize the entire pattern ahead of time and then claim you won by sheer skill; you have to react to each move as it appears, using only what’s visible right now. The same discipline applies to your strategy.

Once I embraced that mindset, my backtests started to mirror live performance. The equity curves still had ups and downs, but the shocking gaps between simulation and reality vanished. It was like finally seeing the true layout of a maze instead of relying on a cheat‑sheet that showed the exit from the start.

Wielding the Power (Code & Examples)

Below is a before‑and‑after walk‑through of a simple moving‑average crossover strategy. The “before” version is the kind of quick‑and‑dirty script many of us start with—convenient, but riddled with look‑ahead bias. The “after” version shows how to do it right using pure pandas (vectorized, but still respecting the information set at each step).

The Struggle: Naïve Loop with Look‑Ahead

import pandas as pd

# Load daily OHLCV data
df = pd.read_csv('AAPL_daily.csv', parse_dates=['Date'])
df.set_index('Date', inplace=True)

# ---- THE PROBLEMATIC PART ----
# We calculate the moving averages on the *whole* series first.
df['SMA_50'] = df['Close'].rolling(window=50).mean()
df['SMA_200'] = df['Close'].rolling(window=200).mean()

# Then we generate signals *after* the averages are already known.
df['Signal'] = 0
df.loc[df['SMA_50'] > df['SMA_200'], 'Signal'] = 1   # long
df.loc[df['SMA_50'] < df['SMA_200'], 'Signal'] = -1  # short

# Shift to avoid using today's signal to today's price (still flawed)
df['Position'] = df['Signal'].shift(1)

# Compute returns
df['Market_Return'] = df['Close'].pct_change()
df['Strategy_Return'] = df['Market_Return'] * df['Position']

# Equity curve
df['Cumulative'] = (1 + df['Strategy_Return']).cumprod()

What’s wrong?

The moving averages are computed using the entire history up front. In a real‑time setting, you wouldn’t have tomorrow’s price to influence today’s average.
The signal is generated with full knowledge of the future average values, then merely shifted by one bar. This still leaks information because the average itself already incorporated future data.

The Victory: Proper Walk‑Forward Simulation

import pandas as pd
import numpy as np

df = pd.read_csv('AAPL_daily.csv', parse_dates=['Date'])
df.set_index('Date', inplace=True)

# We'll keep a column for the *current* signal only.
df['Signal'] = 0

# Pre‑allocate columns for speed (still vectorized, but we compute recursively)
df['SMA_50'] = np.nan
df['SMA_200'] = np.nan

# Rolling windows – we will update them manually to avoid look‑ahead.
close = df['Close'].values
signal = np.zeros(len(df))
sma_50 = np.full(len(df), np.nan)
sma_200 = np.full(len(df), np.nan)

for i in range(len(df)):
    # Update rolling means using only data up to i (inclusive)
    if i >= 49:   # need 50 points for SMA_50
        sma_50[i] = close[i-49:i+1].mean()
    if i >= 199:  # need 200 points for SMA_200
        sma_200[i] = close[i-199:i+1].mean()

    # Generate signal based on *available* averages only
    if not np.isnan(sma_50[i]) and not np.isnan(sma_200[i]):
        if sma_50[i] > sma_200[i]:
            signal[i] = 1
        elif sma_50[i] < sma_200[i]:
            signal[i] = -1
        # else stay flat

# Shift signal to avoid using today's signal for today's return
signal = np.roll(signal, 1)
signal[0] = 0   # first bar has no previous signal

df['SMA_50'] = sma_50
df['SMA_200'] = sma_200
df['Signal'] = signal

# Returns
df['Market_Return'] = df['Close'].pct_change()
df['Strategy_Return'] = df['Market_Return'] * df['Signal']
df['Cumulative'] = (1 + df['Strategy_Return']).fillna(1).cumprod()

Why this works:

At each iteration i, the moving averages are built only from prices 0 … i. No future data sneaks in.
The signal is derived from those current averages, then shifted so that today’s trade uses yesterday’s decision—exactly what a trader would do.

Common Traps to Avoid

Trap	What it Looks Like	How to Dodge It
Look‑ahead bias	Calculating indicators on the full series before generating signals.	Compute indicators incrementally (as shown) or use libraries like `backtrader`/`zipline` that enforce a bar‑by‑bar loop.
Survivorship bias	Backtesting only on stocks that are still in the index today, ignoring delisted losers.	Use point‑in‑time datasets (e.g., Quandl’s WIKI with delisted data) or explicitly include dead tickers.
Overfitting to noise	Tweaking parameters until the Sharpe ratio looks insane on‑sample, then failing out‑of‑sample.	Hold out a validation period, walk‑forward optimize, or use Bayesian optimization with strict out‑of‑sample checks.

Why This New Power Matters

Now that you can run a backtest that respects the information frontier, you can trust the numbers enough to iterate on ideas quickly. Want to test a volatility‑breakout system? Go ahead. Curious how a machine‑learning classifier would have fared during the 2008 crash? You can simulate it without cheating. The feedback loop shrinks from “wait weeks for live results” to “run a notebook, see the equity curve, tweak, repeat.”

What’s more, you start thinking like a real market participant: you ask “What would I have known at 9:31 am?” instead of “What does the whole chart say?” That mindset shift is the real super‑power—it makes your strategies robust, your risk controls honest, and your confidence genuine.

Your Turn

Pick a ticker, grab a few years of daily data, and implement a simple RSI‑mean‑reversion strategy using the walk‑forward method above. Run the backtest, calculate the Sharpe ratio, and then ask yourself: does the curve still look exciting after you’ve stripped away the look‑ahead magic?

Drop your results (or a snag you hit) in the comments—let’s compare notes and level up our questing parties together. Happy hacking, and may your equity curves be ever in your favor! 🚀

DEV Community