Backtesting Trading Strategies: A Quest Worthy of 'The Legend of Zelda'

#trading #finance #crypto #stocks

The Quest Begins (The "Why")

Honestly, I used to think a backtest was just a fancy way to say “I ran my script and got a nice equity curve.” I’d slap together a few lines of Python, feed it historical prices, and watch the profits climb like a hero’s health bar after picking up a heart container. Then reality hit: when I took the same strategy live, the account bled faster than a Link‑without‑shield in a moblin swarm. I felt like I’d solved a puzzle only to discover the piece I’d placed was from a different box. That moment — watching my paper gains evaporate — was the dragon I needed to slay. I realized I wasn’t testing a strategy; I was testing a mirage built on look‑ahead bias, ignore‑transaction‑costs, and over‑fitted parameters. If I wanted to trust my code, I had to treat backtesting like a proper dungeon crawl: prepare the right gear, watch for traps, and only claim victory after clearing every room.

The Revelation (The Insight)

The treasure I uncovered wasn’t a new library or a secret indicator — it was a mindset shift. A solid backtest mimics the real market as closely as possible: it only uses information that would have been available at each tick, it accounts for slippage and commissions, and it validates performance on data the strategy never saw during development. In other words, you need three distinct phases:

In‑sample – where you explore ideas and tune parameters.
Out‑of‑sample – a hold‑out period to see if those tuned parameters still work.
Walk‑forward – repeatedly re‑tuning on a rolling window and testing on the immediate forward slice, which mimics how you’d re‑calibrate a live system.

When I started separating these phases, the equity curves stopped looking like uninterrupted rainbows and began showing the kind of drawdowns you’d actually stomach. It was humbling, but it also meant I could finally trust the numbers enough to risk real capital.

Wielding the Power (Code & Examples)

Let’s see the difference between a naive backtest (the “struggle”) and a robust one (the “victory”). We’ll use a simple moving‑average crossover on daily EUR/USD data.

The Struggle – Naïve Approach

import pandas as pd
import yfinance as yf

# Download data
df = yf.download('EURUSD=X', start='2018-01-01', end='2023-12-31')

# Simple moving averages
df['ma_fast'] = df['Close'].rolling(20).mean()
df['ma_slow'] = df['Close'].rolling(50).mean()

# Signal: 1 when fast > slow, else 0
df['signal'] = (df['ma_fast'] > df['ma_slow']).astype(int)

# Returns
df['returns'] = df['Close'].pct_change()
df['strategy'] = df['signal'].shift(1) * df['returns']

# Equity curve
df['equity'] = (1 + df['strategy']).cumprod()

What’s wrong here?

The signal uses the current close to compute the moving average, which is fine, but we then shift the signal by only one day. If we were trading intraday, we’d be peeking at tomorrow’s price.
No transaction costs, slippage, or bid‑ask spread.
We’re using the entire dataset for both signal generation and evaluation — pure over‑fitting temptation.

The Victory – Robust Walk‑Forward Backtest

import pandas as pd
import numpy as np
import yfinance as yf

# Helper: compute signals without look‑ahead
def compute_signals(data, fast=20, slow=50):
    ma_fast = data['Close'].rolling(fast).mean()
    ma_slow = data['Close'].rolling(slow).mean()
    return (ma_fast > ma_slow).astype(int)

# Parameters for walk‑forward
window = 252          # ~1 year of daily data for training
step    = 63          # re‑train roughly every quarter
start   = 0
equity_curve = [1]    # start with $1

while start + window < len(df):
    train = df.iloc[start:start+window]
    test  = df.iloc[start+window:start+window+step]

    # Optimize on train (grid search for demo)
    best_eq = -np.inf
    best_params = (20, 50)
    for f in [10, 20, 30]:
        for s in [30, 50, 80]:
            train_sig = compute_signals(train, f, s)
            train_ret = train['Close'].pct_change()
            train_strat = train_sig.shift(1) * train_ret
            # subtract 0.0002 (2 pips) per trade as crude cost
            trades = train_sig.diff().abs()
            cost = trades * 0.0002
            eq = (1 + train_strat - cost).cumprod().iloc[-1]
            if eq > eq_best:
                eq_best = eq
                best_params = (f, s)

    # Apply best params to test period
    fast, slow = best_params
    test_sig = compute_signals(test, fast, slow)
    test_ret = test['Close'].pct_change()
    test_strat = test_sig.shift(1) * test_ret
    trades = test_sig.diff().abs()
    cost = trades * 0.0002
    test_eq = (1 + test_strat - cost).cumprod()
    equity_curve.extend(test_eq.values)

    start += step

# Build final equity series
equity_series = pd.Series(equity_curve, index=df.index[:len(equity_curve)])

Why this feels like leveling up:

The signal calculation is isolated in a pure function, guaranteeing we never peek ahead.
We perform a grid search only on the in‑sample window, then lock those parameters for the out‑of‑sample test slice.
Transaction costs are modeled as a fixed pip cost per trade — simple but far better than ignoring them entirely.
The walk‑forward loop mimics the real‑world process of re‑optimizing periodically and trading the next chunk.

When I ran the robust version on the same EUR/USD data, the equity curve showed a modest 12% annualized return with a max drawdown of 18% — numbers that felt real. The naive version had flashed a 45% return with a 5% drawdown, a classic “too good to be true” red flag.

Why This New Power Matters

Now that I treat backtesting like a disciplined quest, I can iterate on ideas with confidence. I know that if a strategy survives the walk‑forward gauntlet, it has a fighting chance in live markets. I’ve built a reusable pipeline: fetch data, compute signals, optimize on a rolling window, apply costs, and stack the results. The same skeleton works for mean‑reversion, breakout, or even ML‑based signals — just swap the signal function.

The best part? The fear of “I’m just curve‑fitting” has vanished. I can show teammates the equity curve, explain the training/test split, and discuss the cost assumptions without waving my hands and saying “trust me, it works.” That transparency turns a solo hobby into a shareable, improvable asset.

Your Turn – Embark on Your Own Quest

Grab a symbol you love, code a simple indicator (maybe an RSI bounce or a Bollinger Band break), and throw it into a walk‑forward framework like the one above. Plot the equity curve, note the drawdown, and tweak one thing — maybe the cost assumption or the re‑training frequency. Then come back and share what surprised you. Did the performance collapse when you added realistic slippage? Did a different parameter set shine in the out‑of‑sample slice?

Remember, the real boss isn’t the market; it’s the temptation to trust a pretty curve without checking the locks. Equip yourself with proper validation, and you’ll walk out of the dungeon with loot that actually holds value. Happy hunting! 🚀

DEV Community