High Slippage with Future Fill Model

Here's a detailed and friendly explanation you can share with 'Loki' regarding the rationale and industry practice behind the difference in stop market order fill models between QuantConnect's Future and Equity FillModels:

Hi Loki,

Great question—this is a point of confusion for many users transitioning between equities and futures on QuantConnect or other trading/backtesting platforms!

Why does the FutureFillModel fill stop market orders at close + slippage rather than max(open, stop) + slippage?

According to QuantConnect’s documentation, the FutureFillModel, after the stop is triggered, fills stop market orders “at the close price (of the same bar or next bar depending on data), plus slippage (docs).” This is different from the EquityFillModel, which fills at max(open price, stop price) + slippage (docs).

The rationale for this difference is two-fold:

1. Conservative/Pessimistic Simulation:

   • For futures, QuantConnect assumes a scenario where, after your stop price is breached, you may only get filled at the worst price of that bar because of how the market trades (especially with bar data). The model fills at the close of the bar in which the stop was triggered.
   • This is intentionally pessimistic—it assumes you may not get the "ideal" fill and better avoids look-ahead bias in backtesting.

2. Market Microstructure Differences:

   • Equities: Stocks often open with gaps; the opening price is usually the first fillable price after a stop triggers overnight. Hence, the max(open, stop) logic makes sense—it protects you from a stop-out at an inaccessible price within a gap.
   • Futures: Electronic futures trade continuously with fewer off-session microstructure gaps. But, in reality, exactly when and at what price your order fills once the stop is breached is less deterministic, especially with bar-resolution data (not ticks). The pessimistic assumption (fill at close after breach) better models "worst-case" fills on bar data.

Why add slippage to the close price rather than to the stop price?

Adding slippage to the (already worse) close price is a way to further pessimistically simulate real market conditions:

• In a fast market, by the time your stop is breached and your market order hits the book, you often can't capture the stop price itself.
• The model therefore "lets" the price move past your stop, then fills you at the (possibly further moved) close, plus slippage for additional realism.
• This can look like heavy slippage, but it's actually simulating the worst-case in a fast or low-liquidity futures market especially when using coarse resolution data.

Is this "industry standard"?

• Conventions vary. Many brokers and platforms use the next-tick or bar open after the trigger as the fill for stops—particularly for equities.
• The QuantConnect approach with futures is arguably more bearish than some, but it is rarely wrong: the fills are at least as poor as reality could deliver, so your backtest will not be over-optimistic.
• If you use tick data, QuantConnect’s model will fill at the next qualifying tick after the stop is triggered, which more closely matches real-world fills.

What if this is too pessimistic for your style?

You can subclass and customize the fill model for your futures security. For example, you could override the stop_market_fill method to use the max(open, stop) + slippage logic—just as in the equity model—if you believe it reflects your live expectations better.

If you want example code for how to do this customization, let me know!

Summary Table: (from the docs)

Hopefully, this clears up the rationale and helps you decide if you want to customize the behavior for your use case. If you want code for a custom fill model or more links from the docs, just ask!

Let me know if you’d like to see an example for a custom futures fill model with equity-style stop fills.

Sources: Equity Model - QuantConnect.com, Future Option Model - QuantConnect.com, Future Model - QuantConnect.com, Custom Models Algorithm, Forward Data Only Fill Model Algorithm