Latency-Conditional Slippage Surface Playbook

Why this matters

Most slippage models treat latency as a static nuisance (e.g., "+X bps expected"). In production, latency cost is state-dependent convex risk: the same 40ms delay can be harmless in calm tape and catastrophic during short volatility bursts. If you don’t model this interaction, you systematically underprice tail execution damage.

This playbook builds a practical framework for:

• estimating a slippage surface as a function of latency × volatility × order-book stress,
• using that surface in real-time throttles,
• and preventing “fast-average, slow-tail” blowups.

1) Data contract (minimum viable)

Per child order / attempt, store:

• t_decision (strategy decides)
• t_send (OMS emits)
• t_ack (venue/broker acknowledges)
• t_fill_start, t_fill_end
• side, qty, venue, order type
• decision benchmark price (mid_decision or custom)
• top-of-book snapshots around send/fill
• microvol estimate around send (e.g., 1s/5s realized vol)
• spread, depth, imbalance, cancellation intensity
• reject/cancel/replace events

Derived latencies:

• Decision latency: L_dec = t_send - t_decision
• Transport/venue latency: L_net = t_ack - t_send
• Effective execution latency: L_eff = t_fill_start - t_decision

Use L_eff for cost conditioning; L_dec and L_net for diagnosis.

2) Target variable: implementation shortfall per child

For buy child order: [ IS = 10{,}000 \cdot \frac{P_{fill} - P_{bench}}{P_{bench}} \quad (bps) ] (sign-flip for sells)

Use robust child-level aggregates:

• median IS
• p75/p90/p95 IS
• CVaR(95) if sample depth allows

Do not optimize only mean IS. Latency risk is usually a p95 problem.

3) Build a latency-conditional slippage surface

3.1 Feature buckets (production-friendly)

Discretize for stability:

• L_eff bins: [0–10ms], [10–25], [25–50], [50–100], [100+]
• σ_micro bins: quintiles by symbol/time bucket
• stress bin from microstructure state (next section)

Estimate: [ S(l, \sigma, s) = \text{Quantile}{q}(IS \mid L{eff}=l, \sigma=\sigma, stress=s) ] with q in {0.5, 0.9, 0.95}.

3.2 Smooth model (optional)

Fit quantile regression / GAM: [ Q_q(IS) = f_1(\log(1+L_{eff})) + f_2(\sigma_{micro}) + f_3(stress) + f_{12}(L_{eff},\sigma_{micro}) ] Key output: convexity of interaction term f12. If convexity rises fast, impose hard latency caps in stress.

4) Microstructure stress index (MSI)

Construct a lightweight stress score in [0,1]:

[ MSI = w_1 z(\text{spread}) + w_2 z(\text{depth}^{-1}) + w_3 z(|\Delta imbalance|) + w_4 z(\text{cancel intensity}) + w_5 z(\sigma_{micro}) ]

Then map to regimes:

• Calm: MSI < 0.4
• Tense: 0.4 ≤ MSI < 0.7
• Stress: MSI ≥ 0.7

This becomes the stress axis for the slippage surface.

5) Real-time control policy (state machine)

State A: Normal (Calm + acceptable surface)

• standard POV / schedule
• normal passive/aggressive mix

State B: Caution (Tense or rising p90 surface)

• tighten max allowed L_eff (e.g., 50ms)
• reduce passive queue exposure window
• increase refresh/reprice cadence selectively

State C: Defensive (Stress + p95 breach risk)

• hard latency budget (e.g., 25–35ms)
• cut participation cap
• prioritize execution certainty over queue lottery
• venue quarantine if venue-specific latency tail widens

Hysteresis required to avoid flapping:

• Promote only after 2–3 consecutive breached windows
• Demote only after sustained recovery (e.g., 10 minutes)

6) Budgeting rule: latency cost budget per parent order

Define parent-specific slippage budget B (bps). Reserve a latency slice: [ B_{lat} = \alpha \cdot B, \quad \alpha \in [0.2, 0.5] ]

Track consumed latency budget from expected surface: [ \widehat{C}{lat} = \sum_i S{0.9}(L_{eff,i}, \sigma_i, stress_i) \cdot w_i ]

If Ĉ_lat / B_lat crosses thresholds:

• 70%: shift to Caution

• 100%: Defensive + replan residual schedule

This prevents “quiet budget bleed” before the close.

7) Calibration and monitoring

Weekly:

1. Refit surface per symbol-liquidity tier.
2. Check drift: PSI or KS on latency/vol features.
3. Recompute breach rates by regime and venue.
4. Review false positives (too defensive) vs tail saves.

Core dashboards:

• p50/p90/p95 IS by L_eff bin
• interaction heatmap: L_eff × σ_micro → p95 IS
• state-machine occupancy + transition counts
• venue-level latency tail contribution

8) Common failure modes

1. Mean-only evaluation → misses convex tails.
2. No interaction term → underestimates latency damage in volatility spikes.
3. Global calibration only → ignores symbol/venue heterogeneity.
4. No hysteresis → policy oscillation and self-inflicted churn.
5. Using ack latency as proxy for fill latency → wrong control target.

9) Practical rollout path (2 weeks)

• Days 1–3: Validate timestamp integrity; build L_eff pipeline.
• Days 4–6: Produce empirical binned surface + stress regimes.
• Days 7–9: Add read-only real-time scorer and shadow state-machine.
• Days 10–12: Activate Caution actions with conservative caps.
• Days 13–14: Enable Defensive mode with manual override.

Ship in shadow first; promote only when p95 reduction is proven without unacceptable underfill drift.

Bottom line

Latency is not a constant tax. It is a regime-amplified slippage multiplier. Model it as a surface, control it as a state machine, and budget it explicitly. Teams that do this stop being surprised by “sudden” execution blowups—because those blowups were visible on the surface before they happened.