Implementation Shortfall

You decide to buy a stock when it trades at $50. By the time your order is fully worked, you've paid an average of $50.14, and you couldn't even get all the shares you wanted. How much did that decision actually cost you? Implementation shortfall (IS), introduced by Perold in 1988, answers that with brutal honesty: it is the difference between a paper portfolio that trades instantly and for free at your decision price, and the real portfolio you end up with after delays, impact, missed fills, and fees.

The beauty of IS is that it captures the costs most benchmarks hide. Compare your fills to VWAP and you flatter yourself, because VWAP moves with your own trading. IS instead nails a fixed reference — the price at the moment you decided — and charges you for every dollar the market slipped away between then and reality.

The one formula, in words

For a buy of a target quantity $Q$ at decision price $P_d$, implementation shortfall in dollars is

$$\text{IS} = \sum_i q_i\,(P_i - P_d) \;+\; (Q - Q_{\text{exec}})\,(P_{\text{end}} - P_d) \;+\; \text{fees}.$$

Reading each piece: $q_i$ is the shares filled in the $i$-th trade at price $P_i$, so the first sum is what you overpaid on the shares you got, measured against your decision price $P_d$. $Q_{\text{exec}} = \sum_i q_i$ is the total you managed to fill, so $Q - Q_{\text{exec}}$ is the shares you missed; the second term charges you the price move on those missed shares up to the price $P_{\text{end}}$ where you gave up. The last term is commissions and exchange fees. For a sell, flip the signs. Divide by $Q\,P_d$ to quote it in basis points.

The four-way decomposition

The real power is splitting IS into named costs a trader can act on. Insert two intermediate marks: $P_a$, the arrival price when the order actually reaches the market, and the fills in between.

• Delay cost $= (P_a - P_d)$: the market moved while the order sat between decision and arrival. This is a portfolio-manager / plumbing cost, not an execution cost.
• Market-impact / trading cost $= (\bar P_{\text{exec}} - P_a)$: how far the average fill drifted from arrival as your own trading pushed the price. This is what execution algorithms fight.
• Opportunity cost $=$ price move on unfilled shares: the penalty for being too passive and missing the trade.
• Fees: commissions, exchange fees, taxes.

Component	Reference move	Shares	Cost (\$)	bps of Q·Pd
Delay	50.05 − 50.00	10,000	500	10.0
Market impact	50.12 − 50.05	8,000	560	11.2
Opportunity cost	50.20 − 50.00	2,000	400	8.0
Fees	—	8,000	40	0.8
Total IS			1,500	30.0

Worked example

You decide to buy $Q = 10{,}000$ shares at a decision price $P_d$ of $50.00. Here is what happens:

1. Delay. By the time your order reaches the market the price is $50.05. Even if you filled everything instantly here, you've already lost 5 cents a share to delay.
2. Fills. You work the order and fill $Q_{\text{exec}} = 8{,}000$ shares at an average of $50.12. The trading cost above arrival is $50.12 - 50.05 = 0.07$ per share (7 cents) on those 8,000 shares.
3. Miss. The stock keeps running and you cancel the last 2,000 shares when it reaches $P_{\text{end}}$ of $50.20. Those unfilled shares cost you $50.20 - 50.00 = 0.20$ each (20 cents) in opportunity.
4. Fees. Commissions come to $40.

Totaling (all in dollars): delay $= 10{,}000 \times 0.05 = 500$; impact $= 8{,}000 \times 0.07 = 560$; opportunity $= 2{,}000 \times 0.20 = 400$; fees $= 40$. Implementation shortfall is $1,500, which on a notional of $10{,}000 \times 50 = 500{,}000$ dollars is

$$\frac{1500}{500000} = 0.0030 = 30 \text{ bps}.$$

Notice the lesson buried in the numbers: the opportunity cost of the shares you missed ($400) is nearly as large as the impact on the shares you traded ($560). Traders who obsess over minimizing impact by trading slowly often bleed even more through opportunity cost. This exact tension — trade fast and pay impact, or trade slow and pay opportunity cost / risk — is the trade-off that The Almgren-Chriss Model and Optimal Execution formalize.

Implementation shortfall is the objective function underneath modern execution: The Almgren-Chriss Model literally minimizes expected shortfall plus a risk penalty, and every scheduling algorithm is a different bet on how to trade off its components. Master the decomposition and you can read any execution report at a glance.