Order types & execution

An order is an instruction to your broker. Beginners drown in jargon — market, limit, stop, MOC — but in systematic trading you usually express *intent* through `set_target_weights` and let the infrastructure translate it into orders.

The four orders that matter

Market-on-close deserves special attention because it matches what the lab simulates. The closing auction is typically the single most liquid moment of the US trading day — often around a tenth of total volume — so a daily-close strategy that submits MOC orders is trading when depth is best. That is a rare case where the realistic implementation is also the convenient one.

How Quant Buffet executes in code

def on_day(engine, dt):
    # Target 60% SPY, 40% TLT — engine sells and buys to reach it
    engine.set_target_weights(dt, {"SPY": 0.6, "TLT": 0.4})

• Rebalance uses the daily close as the reference price.
• Slippage of 2 bps makes buys slightly more expensive and sells slightly cheaper.
• Commission of 5 bps is charged on the notional of every fill.
• Sells execute before buys, so cash is available for the purchases.
• Weights are clamped to zero or below — negatives become 0 (long-only).
• Weights summing above 1.0 are scaled down proportionally, so you cannot accidentally use leverage.
• Unchanged targets are skipped entirely, which is why a daily-called strategy does not pay daily costs.

A fully worked rebalance

Start with $100,000 in cash. SPY closes at $500, TLT at $90. Your target is 60/40.

Total friction on this rebalance is roughly $62 on $100,000, or about 6.2 bps — a one-off cost of about 0.06%. That is negligible. Now suppose your signal flips completely every single day.

Real example: how turnover kills a good signal

The arithmetic is brutally simple: each full round trip costs roughly 14 bps in the lab's model (5 bps commission plus 2 bps slippage, on both the sell and the buy). Two hundred and fifty of those is about 3.5% per year, before taxes. Many published mean-reversion edges are worth 2–4% per year gross — which means execution cost alone can consume the entire signal. Whenever a daily strategy looks weak, check turnover before you blame the idea.

# Cheap way to cut turnover: only trade when the change is material
state = {"weights": {}}

def on_day(engine, dt):
    target = compute_weights(dt)   # your signal
    current = state["weights"]     # what you asked for last time

    keys = set(target) | set(current)
    drift = sum(abs(target.get(s, 0.0) - current.get(s, 0.0)) for s in keys)
    if drift < 0.05:               # less than 5% total drift
        return                     # skip the rebalance entirely

    state["weights"] = dict(target)
    engine.set_target_weights(dt, target)

Long-only weight math