Transaction Costs and Slippage: The Hidden Killers of Trading Strategies

Transaction costs are the wedge between a strategy's gross signal and its net PnL, and for most quantitative strategies that wedge — not the signal — decides profitability. Modeling them is not a finishing touch you bolt on after tuning; it belongs in the objective function from the first optimization, because cost structure changes which parameters are optimal. This guide decomposes cost into its components, gives defensible models for each, and shows how to calibrate them against your own fills in a backtest.

The right unit throughout is basis points per unit of notional traded, and the right summary statistic is implementation shortfall: the difference between the decision-time mid price and your realized average fill, including fees. Everything else is a component of that single number.

The cost taxonomy

1. Commissions and fees

Explicit charges per trade, per share, or per notional. Near zero for some equity brokers, but material in crypto maker/taker schedules (often 0.01%–0.10% per side) and in any multi-leg trade. A three-leg triangular arbitrage pays the fee three times; an apparent mispricing nets to nothing after fees precisely because of this multiplication. Fees apply to both sides — a "0.1% fee" is 0.2% round-trip before you cross the spread.

2. Bid-ask spread

You buy at the ask and sell at the bid. The effective spread you actually pay depends on whether you take liquidity (cross it, paying the half-spread) or provide it (post a limit and, if filled, earn part of it). This taker/maker distinction drives fee schedules and is the foundation of market making. A quoted spread of 10 bps costs 5 bps per side if you cross.

3. Slippage

The gap between decision price and fill price from latency and from your order exceeding top-of-book depth. A market order larger than the best level "walks the book," filling at progressively worse prices. Slippage rises with volatility, thins books, and order size relative to volume — and concentrates around the open, the close, and news.

4. Market impact

Your own order moves the price against you. It has a temporary component (price reverts after you stop) and a permanent component (your trade reveals information and shifts fair value). Impact is negligible for retail size and dominant for institutional size — the reason execution algorithms slice parent orders, and the reason some edges cannot scale (see strategy capacity).

The square-root impact law

The empirically robust model for impact, central to the Almgren-Chriss framework, is concave in participation rate:

impact_bps ≈ Y * sigma_daily_bps * sqrt(Q / ADV)

where Q is order size, ADV is average daily volume, sigmadailybps is daily volatility in basis points, and Y is an instrument-specific constant typically between 0.3 and 1.0. The square root is the key feature: doubling order size raises impact per share by only ~41%, but total impact cost (impact × size) still rises faster than linearly in size. This is why participation-rate caps, not absolute size limits, govern execution.

Participation (Q/ADV)	Impact factor sqrt(Q/ADV)	Relative cost per share
0.5%	0.071	1.0x
1%	0.100	1.4x
5%	0.224	3.2x
10%	0.316	4.5x
25%	0.500	7.1x

Modeling costs in a backtest

A turnover-proportional linear cost plus a size-aware concave impact term covers most use cases. The impact term requires volume data; without it, be deliberately pessimistic on the linear term.

import numpy as np
import pandas as pd

def apply_costs(position, price, volume, notional,
                spread_bps=4.0, commission_bps=1.0, impact_Y=0.5,
                vol_window=21):
    """Net return after linear and square-root impact costs.
    position is target weight, already lagged to avoid lookahead."""
    ret = price.pct_change().fillna(0.0)
    turnover = position.diff().abs().fillna(position.abs())

    # Linear: half-spread + commission, charged on traded fraction
    linear_bps = 0.5 * spread_bps + commission_bps
    linear_cost = turnover * linear_bps / 1e4

    # Square-root impact (Almgren): scale by daily vol and participation
    daily_vol_bps = ret.rolling(vol_window).std() * 1e4
    adv = (volume * price).rolling(vol_window).mean()         # ADV in notional
    participation = (turnover * notional) / adv.replace(0, np.nan)
    impact_bps = impact_Y * daily_vol_bps * np.sqrt(participation.clip(lower=0))
    impact_cost = (turnover * impact_bps / 1e4).fillna(0.0)

    gross = position * ret
    net = gross - linear_cost - impact_cost
    return pd.DataFrame({"gross": gross, "net": net,
                         "linear_cost": linear_cost, "impact_cost": impact_cost})

Calibrating from real fills

Model parameters should come from your own execution data, not guesses. Once live, log decision-time mid and realized fill for every order and regress the realized slippage on the square-root participation term to estimate Y:

# slippage_bps = signed (fill - mid) / mid * 1e4, in the trade's direction
# x = sigma_daily_bps * sqrt(Q / ADV)
import numpy as np
def calibrate_impact(slippage_bps, x):
    x = np.asarray(x); y = np.asarray(slippage_bps)
    Y_hat = np.sum(x * y) / np.sum(x * x)      # OLS through origin
    resid = y - Y_hat * x
    r2 = 1 - resid.var() / y.var()
    return Y_hat, r2

Until you have live fills, err toward pessimism — underestimating costs is far more dangerous than overestimating them, because the former ships a losing strategy while the latter only rejects a marginal one. This feedback loop is the heart of transaction cost analysis.

Why turnover dominates

Net annual return is approximately (edgepertrade − costpertrade) × tradesperyear. Doubling frequency only helps if each trade still clears costs. The worked case below shows how thin the margin is for high-turnover strategies.

Cost component	Per round trip (bps)
Commission (both sides)	2
Half-spread crossed twice	6
Slippage	3
Market impact	1
Total	12

A mean-reversion strategy with a 12 bps gross edge trading 1,000 times a year nets exactly zero after these costs. Shave costs to 8 bps and you have a 4 bps net edge; let them drift to 15 bps and you pay the market to trade. This is why scalping and HFT live or die on execution, while low-turnover trend following tolerates fat per-trade costs.

Reducing costs

• Post passively with limit (maker) orders to earn rather than pay the spread —

but model the fill probability and the adverse selection (your passive orders fill when the market moves against you; see adverse selection).

• Add a no-trade band so the position only changes when the signal moves

materially, cutting round trips that don't clear costs.

• Slice large orders with TWAP/VWAP

to cap participation and tame impact.

• Trade liquid instruments in deep books, and avoid the most volatile,

illiquid moments unless the signal demands them.

• Use fee tiers and rebates where your volume qualifies.

Honest limitations

The square-root law is an average; realized impact on any single order is highly variable and fattens in stressed markets exactly when you most need to trade. Maker-fill modeling requires queue-position assumptions a bar-level backtest cannot verify. And calibrated parameters drift as liquidity regimes change, so a model fit in calm markets understates costs in a crisis. Treat your cost model as a conservative central estimate, run sensitivity at 1x, 2x, and 3x, and accept that live slippage will occasionally exceed all of them.

Conclusion

Transaction costs are the center of strategy design, not a footnote. Decompose them into commission, spread, slippage, and square-root impact; charge them on turnover inside the optimization objective; calibrate them against your own implementation shortfall; and stress-test the result. Express edge and cost in the same units — basis points per round trip — so you can see at a glance whether a strategy clears its frictions. Combine disciplined cost modeling with walk-forward validation and the rest of the backtesting biases to build strategies that survive the trip from paper to live.