Multi-Timeframe Backtesting System Development

Multi-Timeframe Backtesting System Development

You ran a strategy on historical data: incredible returns, minimal drawdown. In live trading — loss. Sound familiar? With 70% probability the problem is look-ahead bias in multi-timeframe testing. When a strategy uses higher timeframe data that was not yet closed at decision time, results become unrealistic. Our team specializes in building correct MTF backtesters that eliminate this error.

Multi-timeframe backtesting is one of the most technically challenging tasks in algo trading. Most effective crypto strategies use multiple timeframes: higher for trend, lower for entry point. Without proper synchronization, you are guaranteed to get look-ahead bias. This defect makes historical tests unrealistic. According to our data, about 70% of MTF strategies contain hidden look-ahead bias. This bias is only revealed during verification.

The Look-Ahead Problem in MTF

Consider a strategy: entry signal on 1h EMA, filter by 4h trend. At the close of the 1h candle at 14:00, the 4h candle for 12:00–16:00 is not yet closed. If you use the 4h close of that candle — that is look-ahead bias. You are using data not yet known in reality.

Rule: at each point in time T, only data from higher timeframes that have already closed before T are available.

from dataclasses import dataclass from typing import Optional import pandas as pd @dataclass class MTFContext: """Context with data from different timeframes, correctly synchronized""" current_timestamp: int # Dictionary: timeframe -> DataFrame with available data _bars: dict[str, pd.DataFrame] def get_bars(self, timeframe: str, n: int = 100) -> pd.DataFrame: """Returns the last N bars of the timeframe available at the current moment""" bars = self._bars.get(timeframe, pd.DataFrame()) if bars.empty: return bars # Only closed bars: timestamp + duration < current_timestamp tf_duration_ms = self._timeframe_to_ms(timeframe) available = bars[bars.index + tf_duration_ms <= self.current_timestamp] return available.tail(n) def get_last_closed_bar(self, timeframe: str) -> Optional[pd.Series]: bars = self.get_bars(timeframe, n=1) return bars.iloc[-1] if not bars.empty else None @staticmethod def _timeframe_to_ms(timeframe: str) -> int: mapping = { '1m': 60_000, '5m': 300_000, '15m': 900_000, '1h': 3_600_000, '4h': 14_400_000, '1d': 86_400_000, } return mapping.get(timeframe, 3_600_000) 

class MTFDataSynchronizer: def __init__(self, timeframes: list[str], symbol: str): self.timeframes = timeframes self.symbol = symbol self.bars: dict[str, pd.DataFrame] = {} def load_all(self, source, start: str, end: str) -> None: for tf in self.timeframes: self.bars[tf] = source.fetch_ohlcv( symbol=self.symbol, timeframe=tf, start=start, end=end, ) self.bars[tf].set_index('timestamp', inplace=True) def create_context(self, timestamp: int) -> MTFContext: """Create context for a specific point in time""" return MTFContext( current_timestamp=timestamp, _bars=self.bars, ) 

Why is Timeframe Synchronization Important?

Without proper synchronization, every backtest will show inflated results. We have seen strategies that looked profitable but failed in production due to this single error. Our approach uses a strict filter based on timestamps. This ensures only fully closed bars are used.

Additionally, our system supports all popular time intervals:

Comparison with Ready-Made Solutions

Our custom backtester is up to 3 times faster than generic solutions. This reduces development cycles and allows more iterations.

What's Included in the Work

• Strategy analysis and identification of required timeframes
• Design of synchronization architecture with guarantee of no look-ahead
• Implementation of backtester core with MTFContext and MTFDataSynchronizer classes
• Writing a strategy example
• Set of unit tests for verification
• Documentation for integration
• Team training

The full list of look-ahead checks includes:

• Test for availability of 4h candle inside its interval
• Test for correctness of timestamp indexing
• Test for edge cases (start/end of trading session)
• Test with multiple timeframes (3 and more)

Development Process

1. Analytics — dissect the strategy, identify all timeframes and dependencies
2. Design — create synchronization architecture, define context structure
3. Implementation — write code in Python using pandas and numpy
4. Testing — verify on historical data with mandatory look-ahead test
5. Deployment — deploy to infrastructure, carry out integration

Example MTF Strategy

class TrendFollowingMTF: """ Strategy: trade in direction of 4h trend, entry on 1h signal """ def on_bar_1h(self, ctx: MTFContext, bar_1h: pd.Series): # Get 4h data (only closed candles) bars_4h = ctx.get_bars('4h', n=50) if len(bars_4h) < 21: return None # insufficient data # 4h trend: EMA(21) ema_21_4h = bars_4h['close'].ewm(span=21).mean().iloc[-1] last_4h_close = bars_4h['close'].iloc[-1] trend_up = last_4h_close > ema_21_4h # 1h signal: EMA(9) crossover bars_1h = ctx.get_bars('1h', n=20) ema_9 = bars_1h['close'].ewm(span=9).mean() ema_21_1h = bars_1h['close'].ewm(span=21).mean() # Crossover up cross_up = ema_9.iloc[-1] > ema_21_1h.iloc[-1] and ema_9.iloc[-2] <= ema_21_1h.iloc[-2] # Crossover down cross_down = ema_9.iloc[-1] < ema_21_1h.iloc[-1] and ema_9.iloc[-2] >= ema_21_1h.iloc[-2] if trend_up and cross_up: return Signal.LONG elif cross_down: return Signal.CLOSE return None 

MTF Backtest Runner

class MTFBacktester: def run( self, strategy, synchronizer: MTFDataSynchronizer, base_timeframe: str, # timeframe for main loop initial_cash: float = 100_000, ) -> BacktestResult: portfolio = Portfolio(initial_cash) primary_bars = synchronizer.bars[base_timeframe] for timestamp, bar in primary_bars.iterrows(): # Create context with correct synchronization ctx = synchronizer.create_context(timestamp) # Process pending orders self._process_orders(portfolio, bar) # Execute strategy with MTF context signal = strategy.on_bar_1h(ctx, bar) if signal: self._execute_signal(portfolio, signal, bar) # Snapshot equity portfolio.equity_curve.append((timestamp, portfolio.get_equity(bar['close']))) return BacktestResult(portfolio) 

Verification of Correctness

Test for absence of look-ahead:

def test_mtf_no_lookahead(synchronizer: MTFDataSynchronizer): """Ensure that at time T, 4h candle closing after T is not available""" # Moment: 14:30 (inside 4h candle 12:00-16:00) timestamp_14_30 = pd.Timestamp('2023-01-01 14:30:00').value // 10**6 ctx = synchronizer.create_context(timestamp_14_30) bars_4h = ctx.get_bars('4h', n=5) # Last available 4h candle should be 08:00-12:00, not 12:00-16:00 last_bar_ts = bars_4h.index[-1] last_bar_close_ts = last_bar_ts + 4 * 3600 * 1000 assert last_bar_close_ts <= timestamp_14_30, \ f"Look-ahead bias detected! Bar closing at {last_bar_close_ts} is visible at {timestamp_14_30}" 

This test is a mandatory part of any MTF backtester test suite. Without it, you can accidentally get fantastically good historical results that do not reproduce in live trading. We guarantee complete absence of look-ahead bias in the developed system. This is confirmed by formal tests.

Order the development of a system with a guarantee of no look-ahead bias. Our experience includes over 15 projects in crypto trading automation. Each system undergoes strict historical data verification. This avoids losses in the real market. Our clients typically save $10,000–$50,000 in prevented trading losses. Get a consultation right now. We will help evaluate your strategy and offer the optimal solution.