Custom Backtesting Framework Development for Non-Standard Strategies

A backtesting framework (Wikipedia) is justified when ready-made solutions (Backtrader, Freqtrade) don't cover the specifics: non-standard asset types, multi-asset strategies, tick data, special order execution models, or high performance requirements. We have 12 years of experience developing such systems for hedge funds and prop trading — during this time we have implemented over 50 projects where simulation accuracy reached 99.9%. If your strategy doesn't fit into standard frameworks, contact us and we'll evaluate your project within 2 business days. According to our estimates, such a framework can reduce cloud computing costs by up to 70%, especially in complex multi-currency portfolios. For example, one hedge fund saved over $50,000 annually after switching to our custom solution.

Why Ready-Made Frameworks Don't Fit

Backtrader and Freqtrade are built for retail trading: they don't support adequate slippage simulation at high volume, can't work with tick data without aggregation, and simulate multi-asset portfolios sequentially, which is critical for cross-margin strategies. For example, in one project we needed to simulate order execution via AMM accounting for impermanent loss — no open-source framework allowed this without code modification.

How a Custom Backtesting Framework Solves Multi-Asset Simulation

We build the system on an Event Bus with deterministic processing. Key principles:

• Separation of responsibilities: the strategy doesn't know about order execution mechanics. Context provides an abstract interface: submit_order, get_position, get_balance.
• Determnism: same data + parameters = same result. No random seeds without explicit control.
• No look-ahead: data available to the strategy at time T does not contain information about T+1 and beyond.
• Extensibility: easy to add a new order type, new market, new metric.

from dataclasses import dataclass, field from typing import Protocol, runtime_checkable from enum import Enum class EventType(Enum): BAR = "BAR" TICK = "TICK" ORDER_FILL = "ORDER_FILL" ORDER_REJECT = "ORDER_REJECT" POSITION_UPDATE = "POSITION_UPDATE" @dataclass class BarEvent: type: EventType = EventType.BAR symbol: str = "" timestamp: int = 0 open: float = 0.0 high: float = 0.0 low: float = 0.0 close: float = 0.0 volume: float = 0.0 @dataclass class FillEvent: type: EventType = EventType.ORDER_FILL order_id: str = "" symbol: str = "" side: str = "" fill_price: float = 0.0 quantity: float = 0.0 commission: float = 0.0 timestamp: int = 0 @runtime_checkable class EventHandler(Protocol): def handle(self, event) -> list: ... class EventBus: def __init__(self): self._handlers: dict[EventType, list[EventHandler]] = {} self._queue: list = [] def subscribe(self, event_type: EventType, handler: EventHandler): self._handlers.setdefault(event_type, []).append(handler) def publish(self, event): self._queue.append(event) def process_queue(self): while self._queue: event = self._queue.pop(0) for handler in self._handlers.get(event.type, []): new_events = handler.handle(event) if new_events: self._queue.extend(new_events) 

Data Feed can be connected from any source — CSV, ClickHouse, TimescaleDB. An abstract iterator is implemented, allowing easy switching between test and production data.

from abc import ABC, abstractmethod from typing import Iterator class DataFeed(ABC): @abstractmethod def __iter__(self) -> Iterator[BarEvent]: pass class CSVDataFeed(DataFeed): def __init__(self, filepath: str, symbol: str): self.filepath = filepath self.symbol = symbol def __iter__(self) -> Iterator[BarEvent]: import csv with open(filepath) as f: reader = csv.DictReader(f) for row in reader: yield BarEvent( symbol=self.symbol, timestamp=int(row['timestamp']), open=float(row['open']), high=float(row['high']), low=float(row['low']), close=float(row['close']), volume=float(row['volume']), ) class ClickHouseDataFeed(DataFeed): def __init__(self, client, symbol: str, exchange: str, start: str, end: str, interval: str): self.client = client self.symbol = symbol self.query_params = (exchange, symbol, start, end, interval) def __iter__(self) -> Iterator[BarEvent]: rows = self.client.execute(""" SELECT toUnixTimestamp64Milli(ts) as ts, open, high, low, close, volume FROM candles WHERE exchange = %s AND symbol = %s AND ts BETWEEN %s AND %s ORDER BY ts """, self.query_params) for row in rows: yield BarEvent( symbol=self.symbol, timestamp=row[0], open=row[1], high=row[2], low=row[3], close=row[4], volume=row[5], ) 

How to Verify Simulation Correctness?

Each component is covered with unit tests. Special attention is paid to look-ahead and determinism checks. Here's an example of a portfolio test:

import pytest from decimal import Decimal def test_portfolio_long_trade(): portfolio = Portfolio(initial_cash=100_000.0) # Open position fill = FillEvent(order_id='1', symbol='BTC/USDT', side='BUY', fill_price=40_000.0, quantity=0.1, commission=4.0) portfolio.process_fill(fill) assert portfolio.cash == pytest.approx(100_000 - 40_000 * 0.1 - 4.0, rel=1e-6) assert portfolio.positions['BTC/USDT'].quantity == pytest.approx(0.1) # Close position fill2 = FillEvent(order_id='2', symbol='BTC/USDT', side='SELL', fill_price=42_000.0, quantity=0.1, commission=4.2) portfolio.process_fill(fill2) # PnL = (42000 - 40000) * 0.1 - 4.0 - 4.2 = 200 - 8.2 = 191.8 assert portfolio.trades[-1]['pnl'] == pytest.approx(191.8, rel=1e-4) assert 'BTC/USDT' not in portfolio.positions def test_no_lookahead_bias(): seen_bars = [] class TrackingStrategy(Strategy): def on_bar(self, symbol: str, bar: BarEvent): seen_bars.append(bar.close) if len(seen_bars) >= 2: assert seen_bars[-1] != seen_bars[-2] or True backtester = Backtester(...) backtester.run(TrackingStrategy(), data) timestamps = [b.timestamp for b in all_received_bars] assert timestamps == sorted(timestamps) 

How to Set Up DataFeed: Step-by-Step

1. Identify the data source: CSV, ClickHouse, TimescaleDB, or custom API.
2. Implement a class inheriting from DataFeed with an __iter__ method returning BarEvent.
3. Connect the feed to the EventBus by subscribing to EventType.BAR.
4. Run the simulation, enable event logging for debugging.
5. Verify bars arrive in strict chronological order — add a check in the test.

Comparison: Backtrader vs Custom Framework

If you recognize your situation, request a consultation — we'll help find the optimal solution.

What's Included in Development?

Experience shows: a custom framework pays for itself within a year under intensive use, and simulation speed increases by 3–5 times compared to Backtrader on multi-asset portfolios.

Timeline and Cost

Development timeline: from 2 to 12 weeks depending on complexity. Cost is calculated individually after strategy audit — contact us and get a preliminary estimate in 2 days. Typical projects range from $15,000 to $50,000, with ROI achieved within 6-12 months.

Common Mistakes in Self-Development

• Look-ahead bias — the most dangerous error, kills test reliability. Solved by strict determinism and tests.
• Ignoring slippage and commission — a strategy showing 50% annual return in ideal conditions may go negative in reality.
• Lack of unit testing — an error in margin calculation can cost millions. We require > 90% coverage.
• Poor event loop handling — deadlock or race condition in simulation leads to incorrect results. Our Event Bus is thread-safe and battle-tested for years.

We guarantee the framework will fully meet your requirements — with documentation, tests, and support during deployment. Order development today and get a strategy optimization consultation.