Realistic Backtesting: Order Book, VWAP & Almgren-Chriss

A strategy often performs wonderfully on a $10K demo account, but when moving to a real $1M, results degrade sharply. For example, a $500K trade on Uniswap might slip by 0.5%, while a $5M trade slips by 2%. The cause? Ignoring liquidity. Realistic backtesting that incorporates liquidity is the most complex yet critical aspect. Without it, you risk unrealistic results. Our team, with 10+ years of experience, builds backtesting engines that account for market liquidity and order impact on price. We've helped dozens of projects avoid losses from unaccounted slippage. Accurate modeling saves up to $15,000 per month in slippage for an average trader.

What is Realistic Backtesting with Order Book, VWAP & Almgren-Chriss?

Realistic backtesting that models liquidity is a method of evaluating trading strategies accounting for the impact of large orders on market price. Without such modeling, results can be overstated by 2-3 times. Our approach uses order book snapshots, VWAP models, and the Almgren–Chriss framework for accurate prediction of slippage and market impact. Every trade carries trading costs that are underestimated without liquidity-aware backtesting.

Problems Solved by Liquidity Modeling

A typical mistake: a backtest shows great results with small capital, but when scaling, the strategy stops working. For instance, on $10K, a trade is 0.01% of daily volume; on $1M, it's 1%, which noticeably affects price. The rule: an order exceeding 0.5–1% of daily volume starts moving the market. Without modeling, this leads to overestimated returns.

Another problem is misjudging slippage. Without a liquidity model, slippage is assumed zero or constant, which is unrealistic. We use three approaches:

• Order Book Simulation — accurate reconstruction of the order book
• VWAP Model — approximation via candle volume
• Almgren–Chriss Framework — optimal execution of large orders

Why Realistic Backtesting with Liquidity Is Critical?

Without accurate modeling, you cannot assess the real capacity of a strategy. Capacity is the maximum capital under which the strategy remains effective. Exceeding the threshold, market impact cancels out advantages. In one of our projects: a strategy showed a Sharpe of 2.5 on $100K but dropped to 1.1 on $5M — precisely due to unaccounted slippage. Proper modeling allows early detection of this threshold and strategy adjustment. Our clients save up to $30,000 per month in trading costs after implementing correct modeling.

When to Use Almgren–Chriss Framework?

Almgren–Chriss suits large positions where time risk is significant. If you trade 1% or more of daily volume, this model gives an optimal execution schedule. For small trades, the VWAP model is sufficient. Read more about the model in the Almgren–Chriss framework.

How We Do It: Implementation Details

Order Book Simulation

For precise modeling, we need order book snapshots. We reconstruct how much volume is available at each price level:

import numpy as np
from dataclasses import dataclass

@dataclass
class OrderBookLevel:
    price: float
    quantity: float

@dataclass
class SimulatedOrderBook:
    symbol: str
    timestamp: int
    bids: list[OrderBookLevel]
    asks: list[OrderBookLevel]

    def simulate_market_buy(self, quantity: float) -> tuple[float, float]:
        remaining = quantity
        total_cost = 0.0
        filled = 0.0
        for level in self.asks:
            if remaining <= 0:
                break
            fill_qty = min(remaining, level.quantity)
            total_cost += fill_qty * level.price
            filled += fill_qty
            remaining -= fill_qty
        if filled == 0:
            return 0.0, 0.0
        return total_cost / filled, filled

    def simulate_market_sell(self, quantity: float) -> tuple[float, float]:
        remaining = quantity
        total_proceeds = 0.0
        filled = 0.0
        for level in self.bids:
            if remaining <= 0:
                break
            fill_qty = min(remaining, level.quantity)
            total_proceeds += fill_qty * level.price
            filled += fill_qty
            remaining -= fill_qty
        if filled == 0:
            return 0.0, 0.0
        return total_proceeds / filled, filled

VWAP Market Impact Model

If full order book data is unavailable, we approximate via candle volume:

class VWAPLiquidityModel:
    def __init__(
        self,
        participation_rate: float = 0.05,
        market_impact_coefficient: float = 0.1,
    ):
        self.participation_rate = participation_rate
        self.impact_coeff = market_impact_coefficient

    def estimate_execution_price(
        self,
        side: str,
        order_size_usd: float,
        candle_volume_usd: float,
        candle_close: float,
        daily_volume_usd: float,
    ) -> dict:
        max_fillable_usd = candle_volume_usd * self.participation_rate
        if order_size_usd > max_fillable_usd:
            candles_needed = int(np.ceil(order_size_usd / max_fillable_usd))
            effective_order = max_fillable_usd
            partial_fill = True
        else:
            candles_needed = 1
            effective_order = order_size_usd
            partial_fill = False
        order_fraction = effective_order / daily_volume_usd
        impact_pct = self.impact_coeff * np.sqrt(order_fraction)
        if side == 'BUY':
            execution_price = candle_close * (1 + impact_pct)
        else:
            execution_price = candle_close * (1 - impact_pct)
        return {
            'execution_price': execution_price,
            'filled_usd': effective_order,
            'partial_fill': partial_fill,
            'candles_to_complete': candles_needed,
            'slippage_pct': impact_pct * 100,
        }

Almgren–Chriss Framework

A more complex but also more accurate model for evaluating trading costs of large positions:

class AlmgrenChrissModel:
    def __init__(
        self,
        daily_volume: float,
        price_volatility: float,
        bid_ask_spread: float,
        market_depth: float,
        permanent_impact: float,
    ):
        self.V = daily_volume
        self.sigma = price_volatility
        self.epsilon = bid_ask_spread / 2
        self.eta = market_depth
        self.gamma = permanent_impact

    def optimal_schedule(
        self,
        total_size: float,
        time_horizon: int,
        risk_aversion: float = 1e-6,
    ) -> list[float]:
        T = time_horizon
        N = T
        kappa_sq = (risk_aversion * self.sigma**2) / (self.eta / self.V)
        kappa = np.sqrt(max(kappa_sq, 0))
        schedule = []
        for j in range(N):
            t = j / N
            x_j = total_size * np.sinh(kappa * (1 - t)) / np.sinh(kappa)
            if j > 0:
                trade_j = schedule[-1] - x_j
            else:
                trade_j = total_size - x_j
            schedule.append(trade_j)
        return schedule

Model Comparison

VWAP model runs 5x faster than Almgren–Chriss, but slippage accuracy is 10% lower. This trade-off should be considered when choosing.

How to Scale a Strategy Without Losing Profitability?

Important analytics for investment decisions:

def analyze_capacity(
    strategy_backtest: BacktestResult,
    volume_data: pd.DataFrame,
    participation_rate: float = 0.05,
) -> pd.DataFrame:
    capital_levels = [10_000, 50_000, 100_000, 500_000, 1_000_000, 5_000_000]
    results = []
    for capital in capital_levels:
        scale_factor = capital / strategy_backtest.initial_capital
        adjusted_returns = []
        for trade in strategy_backtest.trades:
            order_size = trade['size_usd'] * scale_factor
            avg_daily_vol = volume_data.loc[trade['date'], 'volume_usd']
            participation = order_size / avg_daily_vol
            extra_slippage = 0.1 * np.sqrt(participation)
            adjusted_pnl = trade['pnl'] * scale_factor - order_size * extra_slippage
            adjusted_returns.append(adjusted_pnl / capital)
        adjusted_sharpe = np.mean(adjusted_returns) / np.std(adjusted_returns) * np.sqrt(252)
        results.append({
            'capital': capital,
            'sharpe': adjusted_sharpe,
            'annual_return_pct': np.mean(adjusted_returns) * 252 * 100,
        })
    return pd.DataFrame(results)

The result is a capital vs return curve. The strategy remains effective up to a certain threshold, after which market impact cancels out the advantage. This threshold is the maximum strategy capacity. Our clients save up to $15,000 per month in trading costs thanks to proper modeling.

Process

How to Set Up Realistic Backtesting with Liquidity

1. Collect historical order book data (exchange snapshots).
2. Choose a liquidity model based on data volume and accuracy.
3. Calibrate model parameters (market impact coefficient, participation rate).
4. Integrate the model into the backtesting engine.
5. Run backtests with order execution simulation.
6. Analyze capacity and scalability.

What's Included

• Modular code supporting order book simulation, VWAP, and Almgren–Chriss
• Integration with your existing backtesting system
• Documentation and usage examples
• Team training (2 hours online)
• 30-day post-delivery support

Timeline and Cost

Development timeline: from 3 to 6 weeks depending on complexity. Cost is estimated individually after analyzing your project. Get a consultation: we will analyze your strategy and suggest the optimal liquidity model. Experience: over 50 successful projects in crypto trading and DeFi. We guarantee code quality and deadline adherence. Request a consultation to learn how we can help your strategy.