Implementation Shortfall: Die wahren Execution-Kosten.

Eine Strategie generiert ein Signal: Kauf 50.000 Aktien zu 100,00 €. Bis die Order vollständig ausgeführt ist, hat sich der Preis auf 100,18 € bewegt — und ein Teil der nicht-ausgeführten Order musste ganz storniert werden. Wie groß war Ihr echter Verlust? Genau diese Frage beantwortet das Implementation-Shortfall-Konzept.

Die Grundidee von André Perold.

André Perold hat das Konzept 1988 in einem Paper veröffentlicht, das bis heute die Grundlage jeder seriösen Execution-Analyse bildet. Sein Argument war einfach: Wenn man die Performance einer Strategie auf Basis fiktiver „Paper-Preise" misst, ignoriert man systematisch die realen Reibungsverluste — und zwar typischerweise zwischen 20 und 50 Basispunkten pro Trade.

Implementation Shortfall (IS) misst den vollständigen Unterschied zwischen einem hypothetischen „Decision Price" — dem Preis zum Zeitpunkt der Investmententscheidung — und dem realen Ergebnis, das nach Abzug aller Kosten übrig bleibt.

Die Komponenten des Shortfalls.

Der Gesamt-Shortfall zerlegt sich in vier saubere Komponenten:

• Delay Cost: Preisbewegung zwischen Decision Time und dem Zeitpunkt, an dem die erste Order in den Markt geht. Wer 20 Minuten zögert, weil noch Compliance-Freigabe fehlt, sieht dies hier.
• Market Impact: Preisbewegung, die durch Ihre eigene Order verursacht wird. Je größer und aggressiver die Order, desto mehr Impact.
• Opportunity Cost: Kosten der Teile der Order, die nicht ausgeführt wurden. Wenn Sie 50.000 Stück wollten und nur 42.000 bekommen haben, müssen die fehlenden 8.000 zum Schlusspreis bewertet werden.
• Fees: Kommissionen, Börsengebühren, Steuern. Trivial zu messen, aber gehört vollständigkeitshalber dazu.

import pandas as pd
import numpy as np

def implementation_shortfall(decision_price: float,
                             executions: pd.DataFrame,
                             target_qty: int,
                             closing_price: float,
                             fees: float = 0.0,
                             side: str = "buy") -> dict:
    """
    executions: DataFrame mit Spalten ['timestamp', 'qty', 'price'].
    target_qty: ursprünglich gewünschte Menge.
    closing_price: Preis zum Bewertungsende für nicht-ausgeführten Rest.
    """
    sign = 1 if side == "buy" else -1
    executed_qty = executions["qty"].sum()
    executed_value = (executions["qty"] * executions["price"]).sum()
    avg_exec_price = executed_value / executed_qty

    # Komponenten in Basispunkten bezogen auf decision_price * target_qty
    notional = decision_price * target_qty

    market_impact = sign * (avg_exec_price - decision_price) * executed_qty
    unfilled = target_qty - executed_qty
    opportunity_cost = sign * (closing_price - decision_price) * unfilled

    total = market_impact + opportunity_cost + fees
    bps = lambda v: 1e4 * v / notional

    return {
        "executed_qty": executed_qty,
        "avg_exec_price": avg_exec_price,
        "market_impact_bps": bps(market_impact),
        "opportunity_cost_bps": bps(opportunity_cost),
        "fees_bps": bps(fees),
        "total_shortfall_bps": bps(total),
    }

execs = pd.DataFrame({
    "timestamp": pd.date_range("2026-05-15 09:35", periods=5, freq="10min"),
    "qty": [8000, 9000, 9500, 9000, 6500],
    "price": [100.04, 100.09, 100.14, 100.18, 100.22],
})
print(implementation_shortfall(100.00, execs, 50_000, 100.30, fees=120.0))

Warum Decision Price so wichtig ist.

Die unterschätzte Pointe am Implementation Shortfall ist die Definition des Decision Price. Bei einem systematischen Trader ist das eindeutig: der Preis zum Zeitpunkt des Signals. Bei einem diskretionären Trader wird es interessant — denn die „Entscheidung" beginnt oft Stunden oder Tage vor dem ersten Klick.

In der Praxis nehmen die meisten Häuser den Mid-Preis zum Zeitpunkt des Order-Tickets als Referenz. Das ist messbar und reproduzierbar — verschleiert aber einen Teil der Delay Cost. Wer ehrlich messen will, sollte den Preis zum Zeitpunkt der ersten internen Entscheidung verwenden.

Das Almgren-Chriss-Modell.

Almgren und Chriss haben 2000 ein Optimierungsmodell vorgeschlagen, das den Trade-off zwischen Market Impact und Timing-Risiko explizit modelliert. Die Grundidee: Eine schnelle Ausführung minimiert das Risiko ungünstiger Preisbewegungen, erzeugt aber hohen Market Impact. Eine langsame Ausführung minimiert Impact, erhöht aber die Varianz des Ergebnisses.

Das Modell findet den optimalen Trade-off als Funktion der Risikoaversion des Traders. Bei hoher Risikoaversion (großes Lambda) wird schneller gehandelt, bei niedriger Risikoaversion gleichmäßiger über den Tag verteilt.

import numpy as np

def almgren_chriss_schedule(X: float, T: float, N: int,
                            sigma: float, eta: float,
                            gamma: float, lam: float) -> np.ndarray:
    """
    X: Gesamtmenge.
    T: Gesamtzeit (in Sekunden oder Tagen, konsistent).
    N: Anzahl Tranchen.
    sigma: Preis-Volatilität pro Zeiteinheit.
    eta: temporärer Impact-Koeffizient.
    gamma: permanenter Impact-Koeffizient.
    lam: Risikoaversion.
    """
    tau = T / N
    kappa_sq = (lam * sigma**2) / (eta * (1 - gamma * tau / (2 * eta)))
    kappa = np.sqrt(kappa_sq)
    times = np.arange(N + 1) * tau

    x_t = X * np.sinh(kappa * (T - times)) / np.sinh(kappa * T)
    trade_list = -np.diff(x_t)
    return trade_list

schedule = almgren_chriss_schedule(
    X=1_000_000, T=1.0, N=20,
    sigma=0.30, eta=2.5e-7, gamma=2.5e-8, lam=2e-6
)
print(f"Erste 5 Tranchen: {schedule[:5]}")
print(f"Letzte 5 Tranchen: {schedule[-5:]}")
print(f"Front-loaded: {schedule[0] > schedule[-1]}")

Charakteristisch für Almgren-Chriss-Schedules ist, dass sie bei positiver Risikoaversion front-loaded sind: am Anfang werden größere Tranchen gehandelt, gegen Ende kleinere. Das Modell sagt damit: Wer keine Geduld für Preisrisiko hat, soll schnell handeln und höhere Impact-Kosten in Kauf nehmen.

IS in der Praxis: Was Sie wirklich messen sollten.

Drei pragmatische Empfehlungen aus Mandanten-Projekten. Erstens: messen Sie IS pro Strategie, nicht pro Order. Eine einzelne IS-Zahl ist statistisch wertlos. Erst über hundert Trades hinweg zeigt sich, ob Sie einen systematischen Execution-Edge oder Drag haben.

Zweitens: trennen Sie kontrollierbare und unkontrollierbare Komponenten. Market Impact und Fees sind kontrollierbar — durch Algorithmus-Wahl, Broker-Auswahl, Routing. Delay Cost und Opportunity Cost sind oft Folge organisatorischer Prozesse oder Marktbedingungen. Es macht keinen Sinn, einen Execution-Trader für Opportunity Cost verantwortlich zu machen, wenn die Strategie schlicht zu große Orders generiert.

Drittens: bauen Sie ein Pre-Trade-Cost-Modell. Bevor Sie eine Order in den Markt geben, sollte Ihre Infrastruktur Ihnen sagen: „Bei 50.000 Aktien in diesem Liquiditätsregime erwarte ich 18 Basispunkte Shortfall." Ohne diese Erwartung können Sie weder einen Algorithmus auswählen noch im Nachgang beurteilen, ob die Ausführung gut oder schlecht war.

Die häufigsten Fehler in der IS-Analyse.

Ein klassischer Fehler ist die Aggregation über Trades verschiedener Größe ohne Notional-Gewichtung. Wenn Sie 99 Trades zu 1.000 € Notional mit 5 Basispunkten Shortfall haben und einen einzigen mit 100.000 € Notional und 50 Basispunkten, ist Ihr durchschnittlicher Shortfall nicht (99·5 + 1·50)/100 = 5,45 bps, sondern (99·1000·5 + 100000·50)/(99·1000 + 100000) = 27,5 bps.

Ein zweiter Fehler ist die Verwendung des falschen Benchmarks. IS gegen den Decision Price ist die ehrliche Variante. IS gegen den VWAP ist zwar üblich, aber tautologisch — ein VWAP-Algorithmus hat per Definition kleinen Shortfall gegen VWAP.

Sie wollen wissen, was Ihre Execution wirklich kostet? Erstgespräch buchen — wir bauen ein TCA-Framework, das aussagekräftig ist.