Implementation Shortfall: What an Order Really Costs

Imagine a portfolio manager decides at 10:00 to buy 200,000 shares, with the stock at 50.00. Two things now exist.

One is the paper portfolio: the position as though 200,000 shares had appeared instantly at 50.00, free of charge. It is what the strategy's backtest assumed.

The other is the real portfolio: whatever quantity actually got bought, at whatever prices, over however long it took.

Andre Perold named the difference between their returns the implementation shortfall, in "The Implementation Shortfall: Paper vs. Reality", Journal of Portfolio Management, volume 14, issue 3, Spring 1988, pages 4 to 9.

The framing is what makes it useful. It is not a measure of how well the trading desk performed against a market benchmark. It measures the total leakage between an idea and its result, including parts nobody would think to call trading costs.

Every cost measure needs a reference price, and the choice of reference is where most transaction cost analysis goes wrong.

Implementation shortfall uses the decision price: the market price at the moment the decision was made. Not the price when the order reached the desk, not the average price during the execution, and not the closing price.

That choice is deliberately unforgiving. It includes the drift that occurred while the order sat in a queue, while a trader thought about it, and while the algorithm worked it. All of that is real money the strategy did not receive, and all of it is invisible to a benchmark measured from when execution started.

Compare the alternatives. Measuring against the arrival price, when the order reached the desk, excludes delay and measures only the execution. Measuring against VWAP over the execution window compares the algorithm to the market during a period the algorithm partly caused.

Each answers a legitimate question. Only the decision price answers the one the person who owns the capital is asking.

The shortfall splits into pieces that have different causes and different owners.

def shortfall(decision_price, fills, target_qty, final_price, commission_ps=0.001):
    """fills: list of (price, quantity) actually executed."""
    executed = sum(q for _, q in fills)
    spent    = sum(p * q for p, q in fills)
    avg      = spent / executed if executed else decision_price

    execution   = (avg - decision_price) * executed       # paid above decision
    commissions = commission_ps * executed
    unfilled    = target_qty - executed
    opportunity = (final_price - decision_price) * unfilled   # the miss
    total       = execution + commissions + opportunity

    return {"executed": executed, "avg_price": round(avg, 4),
            "execution": round(execution, 2),
            "commissions": round(commissions, 2),
            "opportunity": round(opportunity, 2),
            "total": round(total, 2),
            "bps": round(1e4 * total / (decision_price * target_qty), 1)}

shortfall(50.00, [(50.02, 120_000), (50.08, 40_000)], 200_000, 50.60)
# executed 160,000 | avg 50.035 | execution 5,600 | commissions 160
# opportunity 24,000 | total 29,760 | bps 29.8

The execution cost was 5,600. The trade that never happened cost 24,000, more than four times as much.

The right-hand branch is the one that conventional cost reporting omits, and it is frequently the largest.

A desk measured only on the average price of what it traded has an obvious way to look good: trade less, and trade only when the price is favourable. Every unfilled share is excluded from the average, so passivity improves the score while costing the strategy real money.

Implementation shortfall closes that loophole by charging for the miss. An order that fills 80% at an excellent price, while the stock runs away from the remaining 20%, is correctly reported as expensive.

This is also why the measure cannot be delegated cleanly. The delay component belongs partly to the portfolio manager, the execution component to the trader or algorithm, and the opportunity cost to whoever set the urgency. It is a shared number, which is precisely what makes it honest.

Absolute currency amounts are not comparable across orders, so costs are expressed as a fraction of the value traded, in basis points, where one basis point is one hundredth of a percent.

The example above cost about 30 basis points. Whether that is good depends entirely on context, and the context that matters most is the size of the order relative to the instrument's normal volume.

That ratio, order size divided by average daily volume, is the single best predictor of execution cost. An order that is a rounding error against daily volume costs roughly the spread. An order that is a substantial fraction of a day's trading costs a multiple of that, because it must consume liquidity that has not arrived yet.

The relationship between size and impact is closer to a square root than to a straight line, so cost per share rises with size but less than proportionally. The lesson Costs, Capacity, and a Protocol You Can Trust develops that relationship and its consequence: every strategy has a capital ceiling beyond which its own trading consumes the edge.

Here the concern is the complementary one. Given the order, what is the cheapest way to work it?

Two further costs sit outside the arithmetic above and are routinely underestimated.

Information leakage. Working an order reveals its existence. Other participants who infer that a large buyer is present can trade ahead of the remaining quantity, and the resulting price move is charged to the order as impact. It is indistinguishable from ordinary impact in the data, which is why it is hard to police and easy to ignore.

Adverse selection on passive fills. Resting a limit order rather than crossing the spread looks free: you earn the spread rather than paying it. But a resting buy order fills when someone chooses to sell to you, and the previous cursus established what that choice implies. Passive fills are concentrated in the moments just before the price moves against you.

The second point has a practical consequence that surprises people. A strategy showing excellent execution prices on passive orders may be selecting the fills that were worst to receive. Measuring the price shortly after each fill, rather than at the fill, is the diagnostic.

The fourth column is the practical test for any proposed benchmark: what behaviour does it reward that you do not want?

VWAP is the clearest illustration. It is popular because it is objective and easy to compute, and it can be beaten by simply concentrating trading in the parts of the window where the price happened to be favourable, which is a bet rather than good execution. It also compares an order to a market average that the order itself helped set.

None of this makes VWAP useless. It makes it a measure of algorithm behaviour rather than of cost, and reporting it as though it were cost is the error.

Reading the components together reveals that they cannot be minimised jointly, and that is the finding this cursus is built on.

Execution cost falls when you trade slowly. Spreading an order over hours consumes less liquidity per unit time, so impact is smaller and the book has time to replenish.

Opportunity cost rises when you trade slowly. The longer the order takes, the more the price can drift away, and the greater the chance of finishing unfilled.

They move in opposite directions with respect to the same control, so there is no schedule that minimises both. Any choice accepts more of one to get less of the other, and the correct balance depends on something the execution desk cannot observe: how quickly the reason for the trade decays.

An order driven by a signal good for weeks should be worked patiently. An order driven by something that will be public in twenty minutes should be executed aggressively regardless of impact, because the opportunity cost of missing it is the entire trade.

The next lesson turns that trade-off into an explicit optimisation.