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 if j > 0 else 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.