Fill modeling: limit orders, queue, partial fills, gaps and stops.

The fill is also an assumption

A backtest does not execute anything: it decides, with the data it has, whether an order would have been filled and at what price. That decision is the fill model. With small market orders the model matters little: they are filled for sure, and the price is the bar's plus the slippage and costs from lesson 2.4.7. With limit orders and stops, the model decides the strategy: a limit order treated as filled when it would not have been, or filled at the price of a stop that the market jumped over, improves the result on every trade, always in the same direction.

The data in this lesson is synthetic: NOVA's June 2, 2025 session (level 1), simulated order by order, with its L2 book, its L3 messages and its trades, and the 5-minute bars of the fictitious ETF KAPA from 2022 to 2025 (level 2). None of it comes from a real market.

An order in the queue: NOVA at 10:00

NOVA's L3 messages cover 10:00 to 10:05 New York time (14:00 to 14:05 UTC) and start with a snapshot of all the live orders in priority order (lesson 1.1.3). With them you can follow exactly what would have happened to your own order arriving at 10:00 at the end of the queue at the best price:

• ahead of it are the orders that were already at that price;
• the queue moves forward when one of them is filled, cancelled or reduces its size;
• when nobody is left ahead, the next fill at that price would have been against your own order.

import numpy as np
import pandas as pd

l3 = pd.read_parquet("nova_libro_l3.parquet")
foto, mensajes = l3.iloc[:358], l3.iloc[358:]


def simular_cola(lado, precio, tamano=500):
    delante = foto[(foto["lado"] == lado) & (foto["precio"] == precio)]
    vivas = dict(zip(delante["id_orden"], delante["tamano"]))
    inicio = sum(vivas.values())
    toque = fill = None
    lleno = 0
    m = mensajes[(mensajes["lado"] == lado)
                 & (mensajes["precio"] == precio)]
    for msg in m.itertuples():
        if msg.evento == "ejecucion" and toque is None:
            toque = msg.ts                  # touch model
        if msg.id_orden in vivas:           # the queue moves forward
            if msg.evento == "cancelacion":
                vivas.pop(msg.id_orden)
            elif msg.evento == "modificacion":
                vivas[msg.id_orden] = msg.tamano
            elif msg.evento == "ejecucion":
                vivas[msg.id_orden] -= msg.tamano
                if vivas[msg.id_orden] <= 0:
                    vivas.pop(msg.id_orden)
        elif msg.evento == "ejecucion" and not vivas:
            lleno += msg.tamano             # against our own order
            if lleno >= tamano:
                fill = msg.ts
                break
    return inicio, toque, fill


for lado, precio in [("bid", 53.08), ("ask", 53.09)]:
    inicio, toque, fill = simular_cola(lado, precio)
    seg = lambda t: None if t is None else round(
        (t - pd.Timestamp("2025-06-02 14:00", tz="UTC"))
        .total_seconds(), 1)
    print(f"{lado} {precio}: {inicio} shares ahead · touch at",
          f"{seg(toque)} s · queue fill at {seg(fill)} s")

bid 53.08: 5966 shares ahead · touch at 0.5 s · queue fill at None s
ask 53.09: 2488 shares ahead · touch at 2.4 s · queue fill at 27.0 s

The two orders tell the whole story of limit orders.

• The buy at 53.08 would have been treated as filled in the touch model after 0.5 seconds: an aggressive sell traded at 53.08 almost immediately. But there were 5,966 shares ahead in eight orders. The queue did get emptied (by fills and cancellations) and, right then, the price went up and nobody else sold at 53.08: our own order is never filled in the window. The price moved up, which is exactly when the buyer wanted to be in.
• The sell at 53.09 is touched after 2.4 seconds and really filled after 27 seconds, when the 2,488 shares ahead run out. By then, the price was already rising.

cot = pd.read_parquet("nova_cotizaciones.parquet")
cot["medio"] = (cot["bid"] + cot["ask"]) / 2
ventana = cot[(cot["ts"] >= "2025-06-02 14:00")
              & (cot["ts"] <= "2025-06-02 14:05")]
ventana.set_index("ts")["medio"].resample("1min").last()

ts
2025-06-02 14:00:00+00:00    53.085
2025-06-02 14:01:00+00:00    53.140
2025-06-02 14:02:00+00:00    53.155
2025-06-02 14:03:00+00:00    53.155
2025-06-02 14:04:00+00:00    53.175
Freq: min, Name: medio, dtype: float64

The midpoint goes from 53.085 to 53.175 in four minutes. The touch model buys at 53.08 in the first half second and profits from the rise; the queue model does not buy (and misses the rise) and sells at 53.09 just before the price rises almost nine cents. It is the adverse selection of the market makers from lesson 2.3.6, seen from a single order: a limit order gets filled mostly when it is not convenient.

stateDiagram-v2
  [*] --> IN_QUEUE
  IN_QUEUE --> IN_QUEUE: queue moves forward
  IN_QUEUE --> FIRST: queue empty
  FIRST --> FILLED: an aggressor arrives
  FIRST --> NO_FILL: the price moves away
  IN_QUEUE --> NO_FILL: the price moves away
  FILLED --> [*]
  NO_FILL --> [*]

Touch, cross and queue over the whole session

One order is not a sample. The L3 messages only cover five minutes, but the L2 snapshots every 10 seconds and the trades of the whole session make it possible to approximate the queue at any moment: our own order arrives at the end of the best bid in the snapshot, with the level's quantity ahead, and the queue moves forward with the volume traded at that price on the venues with a book. It is a conservative approximation (it does not see the cancellations ahead, which would move the order forward) and it is the one that can be done with L2 and trade data; NautilusTrader does something similar with queue_position=True.

For each of the 2,251 snapshots between 9:35 and 15:50, a limit buy of 200 shares at the best bid, valid for 60 seconds, is simulated with three models: touch (any trade on the consolidated tape at that price or lower), cross (a trade below it) and queue (the volume traded at that price on the visible books exceeds the quantity ahead plus our own, or the price crosses).

l2 = pd.read_parquet("nova_libro_l2.parquet")
op = pd.read_parquet("nova_operaciones.parquet")
con_libro = op[op["centro"].isin(["PRINCIPAL", "MTF_A", "MTF_B"])
               & (op["condicion"] == "regular")].reset_index(drop=True)
mejor_bid = l2[(l2["nivel"] == 1) & (l2["lado"] == "bid")]
mejor_bid = mejor_bid[mejor_bid["ts"].between(
    "2025-06-02 13:35", "2025-06-02 19:50")]
H, TAM = pd.Timedelta(seconds=60), 200


def tramo(df, desde, hasta):
    i = df["ts"].searchsorted(desde, side="right")
    j = df["ts"].searchsorted(hasta, side="right")
    return df.iloc[i:j]


filas = []
for foto_l2 in mejor_bid.itertuples():
    p, delante = foto_l2.precio, foto_l2.tamano
    cinta = tramo(op, foto_l2.ts, foto_l2.ts + H)
    libro = tramo(con_libro, foto_l2.ts, foto_l2.ts + H)
    toque = cinta.loc[cinta["precio"] <= p, "ts"].min()
    cruce = libro.loc[libro["precio"] < p, "ts"].min()
    en_p = libro["tamano"].where(libro["precio"] == p, 0).cumsum()
    cola = libro.loc[en_p >= delante + TAM, "ts"].min()
    cola = min(t for t in [cola, cruce] if pd.notna(t)) if (
        pd.notna(cola) or pd.notna(cruce)) else pd.NaT
    filas.append({"ts": foto_l2.ts, "precio": p, "delante": delante,
                  "toque": toque, "cruce": cruce, "cola": cola})
fills = pd.DataFrame(filas)
print(len(fills), "orders · quantity ahead (median):",
      int(fills["delante"].median()), "shares")
fills[["toque", "cruce", "cola"]].notna().mean().round(3)

2251 orders · quantity ahead (median): 6900 shares
toque    0.868
cruce    0.413
cola     0.444
dtype: float64

With the touch model, 87% of the orders are filled within a minute; with the queue model, 44%, and with the cross model, 41%. The difference is almost entirely the queue: the median quantity ahead at the best bid is 6,900 shares, thirty-odd times our own order, and that is not always traded within a minute.

Adverse selection: who gets filled and when

The fill percentage is half the problem. The other half is which orders get filled. The markout measures the quality of a fill: where the midpoint is some time later, compared with the price paid. For a buy, a negative markout means that the price kept falling after buying.

medio = cot.set_index("ts")["medio"]
ask = cot.set_index("ts")["ask"]


def a_los(serie, ts, segundos):
    i = serie.index.searchsorted(
        ts + pd.Timedelta(seconds=segundos)) - 1
    return serie.iloc[i].to_numpy()


markout = {}
for modelo in ["toque", "cruce", "cola"]:
    f = fills[fills[modelo].notna()]
    fila = {}
    for s in [5, 30, 60, 300]:
        m = a_los(medio, f[modelo], s)
        fila[f"{s}s"] = (1e4 * (m - f["precio"]) / f["precio"]).mean()
    a = a_los(ask, f[modelo], 60)
    fila["ida_vuelta_60s"] = (1e4 * (a - f["precio"])
                              / f["precio"]).mean()
    fila["p_fill"] = len(f) / len(fills)
    markout[modelo] = fila
pd.DataFrame(markout).T.round(2)

         5s   30s   60s   300s  ida_vuelta_60s  p_fill
toque  0.80  0.11 -0.57  -2.74            0.39    0.87
cruce -1.14 -3.32 -5.95 -13.20           -4.98    0.41
cola  -0.94 -2.98 -5.38 -12.27           -4.40    0.44

In all three models the markout worsens over time: passive buys get filled when the flow is selling, and the selling flow continues. But the touch model is much higher at every horizon: it includes the “free” fills from touches in which the price rebounds, which in the real queue never get filled.

The ida_vuelta_60s column is a minimal market-making strategy: buy at the bid and sell at the ask 60 seconds later, assuming (generously, equally in all three cases) that the exit gets filled. With the touch model it makes 0.39 bp per trade; with the queue model, it loses 4.40. The same code, the same data and the same exit: only the entry rule changes, and the strategy goes from winning to losing. The header figure sums it up on two axes, the fill probability and the result of each fill.

Does a fill probability, like NautilusTrader's prob_fill_on_limit (lesson 2.4.5), fix the bias? It can be checked: randomly fill 44% of the touches, the same proportion the queue model gives (over all orders, 38.9%).

rng = np.random.default_rng(2028)
p_cola = fills["cola"].notna().mean()
azar = fills[fills["toque"].notna()
             & (rng.random(len(fills)) < p_cola)]
a = a_los(ask, azar["toque"], 60)
m = a_los(medio, azar["toque"], 60)
print(f"fills: {len(azar) / len(fills):.1%}")
print(f"markout 60 s: {(1e4 * (m / azar['precio'] - 1)).mean():.2f} bp")
print(f"round trip: {(1e4 * (a / azar['precio'] - 1)).mean():.2f} bp")

fills: 38.9%
markout 60 s: -0.50 bp
round trip: 0.47 bp

It does not fix it: the round trip stays at +0.47 bp, versus −4.40 in the queue model. The probability adjusts how many orders get filled, but picks them at random among the touches, which are the good and the bad ones mixed together. The real ones are the bad ones. For a strategy that lives on limit orders, a random fill probability is better than nothing for the number of trades and almost nothing for the result.

Partial fills: participating in volume

A large order is not filled in one bar. The usual way to model this is a participation limit: on each bar, at most a fraction of the traded volume is filled (here, 10%) and the rest waits for the next one. With the KAPA bars, for each of the 1,003 sessions, a buy that starts at 10:00 and is filled at the close of each bar:

barras = pd.read_parquet("indice2_5min.parquet")
ny = barras["ts"].dt.tz_convert("America/New_York")
barras["dia"], barras["hora"] = ny.dt.date, ny.dt.strftime("%H:%M")


def participar(sesion, total, part=0.10, inicio="10:00"):
    s = sesion[sesion["hora"] >= inicio]
    llegada = s["apertura"].iloc[0]          # decision price
    resto, gasto, n = total, 0.0, 0
    for b in s.itertuples():
        q = min(resto, int(part * b.volumen))
        gasto, resto, n = gasto + q * b.cierre, resto - q, n + 1
        if resto == 0:
            break
    medio = gasto / (total - resto)
    return n, resto > 0, 1e4 * (medio / llegada - 1)


tabla = {}
for total in [50_000, 500_000, 2_000_000, 10_000_000]:
    r = pd.DataFrame([participar(g, total)
                      for _, g in barras.groupby("dia")],
                     columns=["barras", "incompleta", "desl_pb"])
    tabla[f"{total:,}"] = {
        "barras_mediana": r["barras"].median(),
        "incompleta_pct": 100 * r["incompleta"].mean(),
        "desl_medio_pb": r["desl_pb"].mean(),
        "desl_desv_pb": r["desl_pb"].std()}
pd.DataFrame(tabla).T.round(2)

            barras_mediana  incompleta_pct  desl_medio_pb  desl_desv_pb
50,000                 1.0             0.0           0.59         12.62
500,000                6.0             0.0           0.75         18.21
2,000,000             31.0             0.0           1.42         30.36
10,000,000            72.0            98.4           3.23         48.43

With 50,000 shares the order fits in one bar; with two million it takes a median of 31 bars, two and a half hours, and with ten million it is not completed within the day in 98% of the sessions. The average slippage versus the arrival price is small and positive (KAPA rises over the sample: buying later costs a bit more), but its standard deviation grows with execution time, from 13 to 48 bp. Splitting an order reduces impact, but exposes it to the market while it is being executed: the cost turns into risk.

A warning about this data: KAPA prices do not react to the simulated order, as no historical series does. The participation model decides how much and when is filled; the impact those buys would have caused has to be added separately, with the square-root law from lesson 2.4.7. And if a strategy only works with orders that need days to be executed, the problem is not the fill model: it is its capacity (lesson 2.2.3).

Stops and gaps

A stop is a dormant market order (lesson 1.1.4): when the price reaches the trigger, it is filled at the first available price. Within a continuous session that price is close to the trigger. Between sessions it is not: if the price opens below a sell stop, the first trade is the open, and the order is filled there. The optimistic model, which always fills at the stop price, gives away the difference.

With KAPA: each day the position is bought at the close and protected with a sell stop at a percentage of the close. The honest fill is the open if the session opens below the stop, and the stop otherwise (in these bars the open of each bar is the close of the previous one, so there are no gaps within the session):

diario = barras.groupby("dia").agg(
    apertura=("apertura", "first"), minimo=("minimo", "min"),
    cierre=("cierre", "last"))
diario["cierre_previo"] = diario["cierre"].shift()
diario = diario.dropna()

filas, huecos_1pct = [], None
for pct in [0.005, 0.01, 0.015, 0.02]:
    stop = (diario["cierre_previo"] * (1 - pct)).round(2)
    dispara = diario["minimo"] <= stop
    hueco = diario["apertura"] <= stop
    ejecucion = diario["apertura"].where(hueco, stop)
    desl = 1e4 * (stop - ejecucion) / stop
    filas.append({"stop_pct": 100 * pct, "disparos": dispara.sum(),
                  "en_hueco": hueco.sum(),
                  "desl_medio_hueco_pb": desl[hueco].mean(),
                  "desl_max_pb": desl.max(),
                  "coste_total_pb": desl.sum()})
    if pct == 0.01:
        huecos_1pct = diario[hueco].assign(stop=stop, desl_pb=desl)
pd.DataFrame(filas).set_index("stop_pct").round(1)

          disparos  en_hueco  desl_medio_hueco_pb  desl_max_pb  coste_total_pb
stop_pct
0.5            565       122                 27.9        138.1          3405.5
1.0            277        18                 27.9         88.5           502.2
1.5            127         4                 19.1         38.0            76.6
2.0             52         0                  NaN          0.0             0.0

With a 1% stop, 18 of the 277 triggers come through a gap, and on those the optimistic model saves an average of 28 bp per trade; in the worst one (May 18, 2022) it is 88 bp. The closer the stop, the more triggers come through a gap. A 2% stop is never jumped in this data, but the tail of the gaps of an ETF on an index is short; in an individual stock, the day after an earnings release, the gap can be several times the stop (lesson 1.1.4, NOVA's 5.1% gap).

huecos_1pct.sort_values("desl_pb", ascending=False)[
    ["cierre_previo", "stop", "apertura", "desl_pb"]].head(4).round(2)

            cierre_previo    stop  apertura  desl_pb
dia
2022-05-18         243.12  240.69    238.56    88.50
2023-12-22         366.15  362.49    360.05    67.31
2024-02-29         372.71  368.98    366.62    63.96
2025-03-27         365.66  362.00    359.89    58.29

There is a second trap with stops on bars: if the stop and the profit target both fall within the same bar, the bar does not say which was touched first. The prudent rule is to assume that the stop (the loss) came first. NautilusTrader walks each bar in the order open, high, low, close, or with bar_adaptive_high_low_ordering=True, first the extreme closest to the open (lesson 2.4.5): both are conventions, not information.

Which model to use

flowchart TB
  O{Order type} --> M[Market]
  O --> L[Limit]
  O --> S[Stop]
  M --> MP[Price and costs]
  L --> D{Book data}
  D -- L3 --> CE[Exact queue]
  D -- L2 and tape --> CA[Approximate queue]
  D -- bars --> CR[By cross]
  S --> HA[Open on gap]

The general rule is to choose the most pessimistic model the data allows and check how much the result changes with the optimistic one. If the strategy only works with the optimistic one, it does not work. In the experiment log (lesson 2.2.4), the fill model goes next to the costs: two backtests with different models are two different experiments.

Exercises

1. Repeat the study of the three models for limit sells at the best ask (lado == "ask", filled by trades at that price or higher). Does the conclusion hold?

mejor_ask = l2[(l2["nivel"] == 1) & (l2["lado"] == "ask")]
mejor_ask = mejor_ask[mejor_ask["ts"].between(
    "2025-06-02 13:35", "2025-06-02 19:50")]
bid = cot.set_index("ts")["bid"]
res = {"toque": [], "cola": []}
for foto_l2 in mejor_ask.itertuples():
    p, delante = foto_l2.precio, foto_l2.tamano
    cinta = tramo(op, foto_l2.ts, foto_l2.ts + H)
    libro = tramo(con_libro, foto_l2.ts, foto_l2.ts + H)
    toque = cinta.loc[cinta["precio"] >= p, "ts"].min()
    cruce = libro.loc[libro["precio"] > p, "ts"].min()
    en_p = libro["tamano"].where(libro["precio"] == p, 0).cumsum()
    cola = libro.loc[en_p >= delante + TAM, "ts"].min()
    cola = min([t for t in [cola, cruce] if pd.notna(t)],
               default=pd.NaT)
    for modelo, t in [("toque", toque), ("cola", cola)]:
        if pd.notna(t):
            b = a_los(bid, pd.Series([t]), 60)[0]
            # sells at the ask, buys back at the bid
            res[modelo].append(1e4 * (p - b) / p)
for modelo, v in res.items():
    print(f"{modelo:6} p_fill {len(v) / len(mejor_ask):.1%}",
          f"· round trip 60 s {np.mean(v):.2f} bp")

toque  p_fill 84.9% · round trip 60 s 0.88 bp
cola   p_fill 43.1% · round trip 60 s -4.20 bp

2. In the stop study, compute the total cost of the optimistic model in USD for a position of 1,000 shares with the stop at 1%, and compare it with what a commission of 1 USD per order would cost over the 277 triggers.

desl_usd = 1000 * (huecos_1pct["stop"] - huecos_1pct["apertura"])
print(f"hidden slippage: {desl_usd.sum():,.0f} USD",
      f"in {len(huecos_1pct)} gaps")
print(f"commissions on 277 sells at 1 USD: {277 * 1:,} USD")

hidden slippage: 15,940 USD in 18 gaps
commissions on 277 sells at 1 USD: 277 USD

3. A colleague presents a mean reversion strategy on daily bars that buys with limit orders 1% below the close and sells at the next close, with a fill “if the day's low touches the price”. Which three changes would you ask for in the backtest before discussing the result?