Execution Algorithms & Slippage

The Silent Profit Killer

You developed a strategy. Backtested it. 18% annual return. Sharpe ratio of 1.8. Looks amazing.

You go live. After 6 months, you're at 11% return. Sharpe is 1.1.

What happened?

Slippage. The difference between the price you WANTED and the price you GOT.

Backtests assume perfect execution (buy at the close, sell at the close). Reality is messier:

• Bid-ask spreads ($0.01-$0.05 per share)
• Market impact (your order moves the price)
• Timing delay (price moves between decision and execution)
• Partial fills (can't get full size at desired price)

On a $100,000 trade, 0.3% slippage = $300 loss. Do that 50 times per year = $15,000 in friction.

Good news: Institutions solved this decades ago with execution algorithms. You can too.

Understanding Slippage

The Four Components

1. Bid-Ask Spread

Definition: The difference between best bid and best ask.

Example:

• SPY bid: $500.00, ask: $500.01
• Spread: $0.01
• You want to buy 1,000 shares
• Cost: 1,000 × $0.01 = $10

Typical Spreads:

Stock Type	Typical Spread	Cost Per 1,000 Shares
Large-cap (SPY, AAPL)	$0.01	$10
Mid-cap	$0.02-$0.05	$20-$50
Small-cap	$0.05-$0.20	$50-$200
Micro-cap / Illiquid	$0.20-$1.00+	$200-$1,000+

Key Insight: Spread cost is GUARANTEED. Every market order pays half the spread (round-trip = full spread).

2. Market Impact

Definition: Your order moves the price against you.

Example:

• You want to buy 100,000 shares of XYZ
• Best ask: 500 shares at $50.00
• Next level: 1,000 shares at $50.01
• Next level: 2,000 shares at $50.02
• Your 100,000 shares eat through multiple levels (average fill: $50.08)
• Market impact: $0.08 per share × 100,000 = $8,000

Market Impact Formula (Empirical):

Market_Impact = σ × √(Q / V) × I

Where:
σ = Daily volatility (%)
Q = Order size (shares)
V = Average daily volume (shares)
I = Immediacy factor (1.0 for market orders, 0.3-0.5 for algo execution)

// Example:
// XYZ: σ = 2%, Q = 100,000, V = 5,000,000, I = 1.0 (market order)
// Impact = 0.02 × √(100,000 / 5,000,000) × 1.0
//        = 0.02 × √0.02 × 1.0
//        = 0.02 × 0.141 = 0.283% = $0.14 per share

// With TWAP (I = 0.4):
// Impact = 0.02 × 0.141 × 0.4 = 0.113% = $0.06 per share
// Savings: $0.08 per share × 100,000 = $8,000

Key Insight: Market impact grows with √(order size). Doubling order size increases impact by 41%, not 100%.

3. Timing Risk (Opportunity Cost)

Definition: Price moves between decision and execution.

Example:

• Signal says buy at $50.00 (at 10:00 AM)
• You use TWAP over 30 minutes
• By 10:30 AM, price is $50.25
• Average fill: $50.12 (TWAP executed gradually)
• Opportunity cost: $0.12 vs instant fill at $50.00

Trade-off:

• Fast execution (market orders): Low timing risk, HIGH market impact
• Slow execution (algos): Low market impact, HIGHER timing risk

Key Insight: There's no free lunch. You balance impact vs timing based on urgency.

4. Hidden Costs

• Exchange fees: $0.0030-$0.0050 per share (taking liquidity)
• Rebates: -$0.0020 to -$0.0030 per share (providing liquidity) - can be negative cost!
• SEC fees: $0.000008 per dollar (tiny, but exists)
• Borrowing costs (shorts): 0.3-20% annual (hard-to-borrow stocks)

Total Transaction Cost Example

Scenario: Buy 50,000 shares of AAPL at $152 (market order)

Cost Component	Per Share	Total (50K shares)
Spread (half-spread)	$0.005	$250
Market impact	$0.025	$1,250
Exchange fees	$0.003	$150
Commission (IB)	$0.0005	$25
Total	$0.0335	$1,675

As % of $7.6M trade: 0.022% one-way, 0.044% round-trip

Doesn't sound like much? Trade 20 times per year: 0.044% × 20 = 0.88% annual drag. On a 12% strategy, that's 7.3% of your returns gone to friction.

Execution Algorithms

1. TWAP (Time-Weighted Average Price)

How It Works

Concept: Split order evenly across time intervals.

Example:

• Want to buy 100,000 shares over 60 minutes
• Split into 12 slices (5-minute intervals)
• Each slice: 100,000 ÷ 12 = 8,333 shares
• Every 5 minutes, send 8,333 shares to market

Algorithm Logic:

// TWAP Implementation
total_shares = 100000;
duration_minutes = 60;
interval_minutes = 5;

slices = duration_minutes / interval_minutes;  // 12 slices
shares_per_slice = total_shares / slices;      // 8,333 shares

for (i = 0; i < slices; i++) {
    wait(interval_minutes);
    execute_market_order(shares_per_slice);
}

// Result: 8,333 shares every 5 min for 60 min

Pros and Cons

Advantages:

• Simple: Easy to implement and understand
• Predictable: Execution schedule is fixed
• Low impact: Spreads order over time (reduces market impact by 50-70%)
• Works in any market: Doesn't require volume data

Disadvantages:

• Ignores volume patterns: May trade when volume is low (higher impact)
• Predictable to others: Algos can detect TWAP and front-run
• Timing risk: If stock moves against you, average fill is worse

When to Use TWAP

• Rebalancing: You care about time consistency, not volume matching
• Small orders: Order < 5% of daily volume (impact minimal anyway)
• After hours: No volume profile to match (VWAP not applicable)

Performance Stats

• Slippage reduction: 55-65% vs market orders
• Average TWAP fill: Within 0.08-0.15% of decision price (liquid stocks)
• Win rate: 58% (fills better than decision price, due to mean reversion)

2. VWAP (Volume-Weighted Average Price)

How It Works

Concept: Match your order distribution to market's historical volume profile.

Why this matters: Most volume happens at open (9:30-10:00 AM) and close (3:30-4:00 PM). If you TWAP, you're over-trading during low-volume periods (higher impact).

VWAP Solution: Trade MORE when market trades more, LESS when it's quiet.

Example:

Typical SPY Volume Profile (by hour):

Time	% of Daily Volume	Your Order (100K shares)
9:30-10:00 AM	22%	22,000 shares
10:00-11:00 AM	12%	12,000 shares
11:00-12:00 PM	8%	8,000 shares
12:00-1:00 PM	6%	6,000 shares
1:00-2:00 PM	7%	7,000 shares
2:00-3:00 PM	10%	10,000 shares
3:00-4:00 PM	35%	35,000 shares

Algorithm Logic:

// VWAP Implementation
total_shares = 100000;
historical_volume_profile = [22%, 12%, 8%, 6%, 7%, 10%, 35%];

for (hour = 0; hour < 7; hour++) {
    target_shares = total_shares × historical_volume_profile[hour];
    execute_throughout_hour(target_shares);
}

// Adaptive VWAP (even better):
// Adjust in real-time based on today's actual volume
for (interval in trading_day) {
    actual_volume_so_far = get_volume();
    expected_volume_so_far = historical_profile.cumulative_at(interval);

    if (actual_volume_so_far > expected_volume_so_far) {
        // Higher volume than expected, trade more aggressively
        speed_up_execution();
    } else {
        // Lower volume, slow down
        slow_down_execution();
    }
}

VWAP Benchmark

Goal: Your average fill price should match the day's VWAP.

Daily VWAP Calculation:

VWAP = Σ (Price × Volume) / Σ (Volume)

// For each time interval (1-min or 5-min bars)
// Example (simplified):
// 9:30: $500.00 × 1M shares = $500M
// 9:31: $500.05 × 800K shares = $400.04M
// ...
// Sum all: $45.2B
// Total volume: 90M shares
// VWAP = $45.2B / 90M = $502.22

// Your algo tries to match this

Performance Metric:

• Beat VWAP (bought below VWAP): Good execution
• Match VWAP: Neutral (market-neutral execution)
• Worse than VWAP: Poor execution (overpaid)

Pros and Cons

Advantages:

• Industry standard: Institutional benchmark (portfolio managers compare to VWAP)
• Lower impact than TWAP: Trades when liquidity is high (10-15% less impact)
• Fair price: VWAP represents "average" institutional price for the day

Disadvantages:

• Requires volume profile: Needs historical data (doesn't work for new stocks)
• Still predictable: Others know the VWAP schedule (can be gamed)
• Ignores price trends: If stock is trending, VWAP may not be optimal

When to Use VWAP

• Large orders: 10-30% of daily volume (need to minimize impact)
• Benchmark requirement: Portfolio manager expects VWAP execution
• Liquid stocks: Established volume patterns (SPY, AAPL, etc.)

Performance Stats

• Slippage reduction: 60-72% vs market orders
• Beat VWAP rate: 52% (coin flip, as expected for neutral algo)
• Average deviation from VWAP: ±0.05-0.10% (very tight)

3. Implementation Shortfall (Optimal Execution)

The Theory

Problem: TWAP and VWAP minimize impact, but ignore timing risk (price moves against you while you're executing).

Implementation Shortfall asks: What's the optimal balance between impact and timing risk?

Components:

Implementation_Shortfall = Decision_Price - Actual_Avg_Fill

Breakdown:
= Market_Impact + Timing_Cost + Opportunity_Cost + Fees

// Goal: Minimize total shortfall, not just market impact

The Trade-Off

Execution Speed	Market Impact	Timing Risk	Total Cost
Immediate (market order)	HIGH (0.3%)	ZERO	0.30%
Slow (VWAP over full day)	LOW (0.05%)	HIGH (0.40%)	0.45%
Optimal (IS algo)	MEDIUM (0.12%)	LOW (0.08%)	0.20% ✅

Key Insight: Going too slow can INCREASE total cost (due to timing risk). Optimal is somewhere in the middle.

How IS Algos Work

Inputs:

• Volatility (higher vol = faster execution, more timing risk)
• Order size (larger = slower execution, more impact)
• Urgency (alpha decay rate - how fast your signal loses value)
• Liquidity (volume, spreads)

Algorithm decides:

• High urgency + low volatility: Execute quickly (timing risk dominates)
• Low urgency + high volatility: Execute slowly (impact dominates)
• Large order + low liquidity: Execute very slowly (impact huge)

Example:

// Simplified IS algo logic
urgency_score = signal_strength × alpha_decay_rate;
impact_score = (order_size / daily_volume) × volatility;

if (urgency_score > impact_score) {
    // Urgency dominates, trade faster
    execution_time = 15 minutes;
} else {
    // Impact dominates, trade slower
    execution_time = 120 minutes;
}

// Then use TWAP/VWAP over that duration

Pros and Cons

Advantages:

• Optimal cost: Balances impact vs timing (lowest total cost)
• Adaptive: Adjusts to market conditions in real-time
• Theoretically sound: Based on academic research (Almgren-Chriss model)

Disadvantages:

• Complex: Requires volatility models, alpha decay estimates
• Less predictable: Execution time varies (harder to plan around)
• Needs accurate inputs: Garbage in, garbage out

When to Use IS

• Sophisticated traders: You can model alpha decay and volatility
• Fast-decaying signals: Momentum, mean reversion (signal loses value quickly)
• Variable urgency: Sometimes fast, sometimes slow (IS adapts)

Performance Stats

• Cost reduction vs VWAP: 15-25% (when properly tuned)
• Sharpe improvement: 0.1-0.2 (lower costs = higher risk-adjusted returns)
• Complexity cost: High (mis-calibration can INCREASE costs)

4. Limit Order Strategies (Passive Execution)

How It Works

Concept: Instead of taking liquidity (market orders), PROVIDE liquidity (limit orders). Get rebates instead of paying fees.

Example:

• SPY bid: $500.00, ask: $500.01
• You want to buy 10,000 shares
• Market order: Pay $500.01 (take liquidity, pay $0.003 fee)
• Limit order: Place bid at $500.00, wait to get filled (provide liquidity, RECEIVE $0.002 rebate)

Cost Comparison:

Method	Fill Price	Fee/Rebate	Total Cost
Market Order	$500.01	+$0.003	$500.013
Limit Order (filled)	$500.00	-$0.002	$499.998
Savings	$0.015 per share = $150 on 10K shares

The Problem: Fill Rate

Trade-off: Limit orders are cheaper IF they fill. But they don't always fill.

Example:

• You place limit buy at $500.00
• Stock trades at $500.00 for 5 minutes (you get 3,000 shares filled)
• Then stock rallies to $500.15 (your order never fills the remaining 7,000 shares)
• Now you have to chase at $500.15 (worse fill than market order at $500.01)

Fill Rate Stats:

• Limit at bid/ask (passive): 40-60% fill rate
• Limit inside spread (mid-point): 15-30% fill rate
• Limit beyond spread: 5-15% fill rate (very passive)

Smart Limit Order Algo

// Adaptive limit order strategy
target_shares = 10000;
filled_shares = 0;
time_limit = 30 minutes;

start_price = get_mid();
limit_price = start_price - (spread / 2);  // Join the bid

place_limit_order(limit_price, target_shares);

// Monitor every 30 seconds
for (t = 0; t < time_limit; t += 30_seconds) {
    filled_shares = get_filled_quantity();
    current_price = get_mid();

    // If price moving away and we're <50% filled, get aggressive
    if (current_price > start_price + 0.1% && filled_shares < target_shares * 0.5) {
        cancel_limit_order();
        // Switch to market order for unfilled shares
        execute_market_order(target_shares - filled_shares);
        break;
    }

    // If we're mostly filled (>80%), be patient with remainder
    if (filled_shares > target_shares * 0.8) {
        // Keep waiting, we got most of it
        continue;
    }
}

// If time expired, market order the rest
if (filled_shares < target_shares) {
    execute_market_order(target_shares - filled_shares);
}

When to Use Limit Orders

• Low urgency: Can wait hours or days for fill
• Range-bound market: Price oscillating (will come back to your limit)
• Small trades: < 1% of daily volume (high fill probability)
• Cost-sensitive: Every $0.01 matters (HFT, market-making)

Performance Stats

• Cost savings (when filled): 0.01-0.03% vs market orders
• Fill rate (at bid/ask): 45-55%
• Opportunity cost (when NOT filled): 0.10-0.50% (price runs away)

Choosing the Right Algorithm

Decision Framework

Condition	Best Algorithm	Why
Order < 5% of daily volume	TWAP (15-30 min)	Impact is low anyway, keep it simple
Order 10-30% of daily volume	VWAP (full day)	Need to match volume to minimize impact
High urgency (fast signal decay)	Implementation Shortfall	Balance speed vs impact optimally
Low urgency (rebalancing)	Limit orders (passive)	Save costs, time is on your side
Trending market (strong momentum)	TWAP (fast, 5-10 min)	Don't wait, price moving away
Range-bound market	Limit orders or slow VWAP	Price will oscillate, be patient
High volatility (VIX > 25)	TWAP (shorter duration)	Timing risk high, execute faster
Low volatility (VIX < 15)	VWAP or slow execution	Timing risk low, minimize impact

Measuring Execution Quality

Key Metrics

1. Implementation Shortfall (Total Cost)

IS = (Avg_Fill - Decision_Price) / Decision_Price × 100

// Example:
// Decision price: $500.00
// Average fill: $500.15
// IS = ($500.15 - $500.00) / $500.00 = 0.03% (3 bps)

// Benchmark: <5 bps = excellent, 5-10 bps = good, >15 bps = poor

2. VWAP Deviation

VWAP_Dev = (Avg_Fill - Daily_VWAP) / Daily_VWAP × 100

// Example:
// Average fill: $500.15
// Daily VWAP: $500.10
// VWAP_Dev = 0.01% (1 bp worse than VWAP)

// Benchmark: ±3 bps = good, >5 bps = poor

3. Fill Rate (For Limit Orders)

Fill_Rate = Filled_Shares / Target_Shares × 100

// Benchmark: >70% = good, 40-70% = acceptable, <40% = too passive

Practical Implementation (For Retail)

Broker Algos (Easy Option)

Interactive Brokers:

• TWAP, VWAP, Adaptive (IS-like)
• Free for all accounts
• Works well for 1,000-100,000 share orders

Fidelity Active Trader Pro:

• TWAP, VWAP
• Free for active traders

TD Ameritrade:

• VWAP via thinkorswim
• Free (but limited customization)

DIY Algo (Python)

Simple TWAP Script:

import time
from ib_insync import *

ib = IB()
ib.connect('127.0.0.1', 7497, clientId=1)

# Parameters
symbol = 'SPY'
total_shares = 10000
duration_minutes = 30
interval_minutes = 5

# Calculate slices
slices = duration_minutes // interval_minutes
shares_per_slice = total_shares // slices

# Execute TWAP
stock = Stock(symbol, 'SMART', 'USD')

for i in range(slices):
    order = MarketOrder('BUY', shares_per_slice)
    trade = ib.placeOrder(stock, order)

    print(f"Slice {i+1}/{slices}: {shares_per_slice} shares")

    # Wait for fill
    ib.sleep(2)

    # Wait until next interval
    time.sleep(interval_minutes * 60)

print("TWAP execution complete")
ib.disconnect()

Key Takeaways

Next Steps

You now understand how to minimize trading costs through smart execution.

Continue with: Trading & Market Timing Index - Explore all deep dives and advanced strategies.