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,
}
VWAP Model Calibration Details
The default market_impact_coefficient is 0.1, but for a specific market, it needs calibration based on historical trades. For highly liquid pairs (BTC/USD), the coefficient may be 0.05; for low liquidity, 0.2. Accurate calibration improves slippage prediction accuracy by 15%.
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
| Parameter | VWAP Model | Almgren–Chriss |
|---|---|---|
| Accuracy | Medium | High |
| Data | Candle volume only | Full order book, volatility, spread |
| Speed | High | Medium |
| Time risk considered | No | Yes |
| Application | Quick estimates, small orders | Large positions, optimal execution |
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
| Stage | Actions |
|---|---|
| Analysis | Examine your strategy, trading data, and goals |
| Design | Select liquidity models, design architecture |
| Implementation | Write code in Python with Foundry/Hardhat for smart contract simulation |
| Testing | Validate on historical data, compare with real trades |
| Deployment | Deliver code, documentation, and train your team |
How to Set Up Realistic Backtesting with Liquidity
- Collect historical order book data (exchange snapshots).
- Choose a liquidity model based on data volume and accuracy.
- Calibrate model parameters (market impact coefficient, participation rate).
- Integrate the model into the backtesting engine.
- Run backtests with order execution simulation.
- 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.