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.
How to Avoid Look-Ahead Bias in Multi-Timeframe Backtesting?
Our architecture is based on a context that guarantees correct synchronization. Key classes:
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)
Synchronization starts by loading all timeframes in a single call:
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:
| Timeframe | Duration (ms) | Typical Use |
|---|---|---|
| 1m | 60 000 | Scalping |
| 5m | 300 000 | Short-term strategies |
| 15m | 900 000 | Intraday |
| 1h | 3 600 000 | Medium-term |
| 4h | 14 400 000 | Trend filters |
| 1d | 86 400 000 | Long-term |
Comparison with Ready-Made Solutions
| Criteria | Ready-Made Platforms | Our Custom Development |
|---|---|---|
| Control over synchronization | Limited, possible hidden bugs | Full control: every microsecond verified |
| Support for non-standard timeframes | Only preset | Any: from minutes to weeks |
| Integration with your ecosystem | No, needs adaptation | Full customization for your stack |
| Execution speed | Average (generic algorithms) | Optimized for your strategy, up to 3x faster |
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
- Analytics — dissect the strategy, identify all timeframes and dependencies
- Design — create synchronization architecture, define context structure
- Implementation — write code in Python using pandas and numpy
- Testing — verify on historical data with mandatory look-ahead test
- 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.