Backtesting: How to use today's closing prices to act at tomorrow's market open?

[Hari-Shankar-Karthik]

I have a look-ahead bias problem while backtesting and I am unsure how to solve it.

Strategy

• This is a single-stock strategy.
• If today's closing price is greater than the average closing price of the last 100 days, I will go long the stock.
• Else, I will remain neutral.

Backtesting

• I obtained historical data for this stock as a df: pd.DataFrame.
• I created 1-DAY-LAST Bars using df.
• In MyStrategy.__init__, I instantiated self.sma and in on_start, I invoke register_indicator_for_bars on it.
• This means that on every invocation of on_bar, self.sma would automatically be updated with the Bar's closing price.
• Say bar.close > self.sma.value and I decide to go long.
• I don't want to submit the order now because it will get processed at today's closing price but it really should be processed at tomorrow's opening price.
• What do I do?

[yhay81]

With only external daily bars, there is no native “submit after bar N closes, fill at bar N+1 open” mode.

The important detail is the backtest event order:

1. the exchange processes all four prices of bar N,
2. your strategy receives on_bar(N),
3. orders submitted by that callback are settled against the current book, which now reflects N's close.

This is why the market order fills at today's close. Adding a small LatencyModel does not turn it into a next-open order either: with bar-only data, the next bar's OHLC sweep occurs before the delayed command is drained, so it will generally see the next bar's close. The current bar-execution documentation describes both behaviors and explicitly notes that a native next-bar-open mode is not provided: https://github.com/nautechsystems/nautilus_trader/blob/develop/docs/concepts/backtesting/bar-execution.md#order-submission-timing

Although TimeInForce.AT_THE_OPEN exists in the order model (for representing a MOO instruction to venues which support it), I would not use it as a workaround here; it does not change this daily-bar simulation sequencing.

A robust approach is to separate signal time from execution time:

class MyStrategy(Strategy):
    def __init__(self, config):
        super().__init__(config)
        self.enter_at_next_open = False
        self.sma = SimpleMovingAverage(100)

    def on_bar(self, bar: Bar):
        # This daily bar is complete here; the registered SMA is already updated.
        self.enter_at_next_open = bar.close > self.sma.value

    def on_trade_tick(self, tick: TradeTick):
        if not self.enter_at_next_open:
            return
        if not self.is_first_regular_session_tick(tick):
            return

        self.enter_at_next_open = False
        order = self.order_factory.market(
            instrument_id=tick.instrument_id,
            order_side=OrderSide.BUY,
            quantity=self.instrument.make_qty(self.config.trade_size),
        )
        self.submit_order(order)

Feed a trade/quote tick at the regular-session open (or sufficiently granular intraday data) in addition to the completed daily bars, and replace is_first_regular_session_tick with your exchange-calendar/session test. When that opening tick is processed, the simulated book is first updated to the opening price; the callback then submits the market order and it settles against that price.

If your source timestamps daily bars at the session open, also shift ts_init to the bar close (for example via ts_init_delta). Otherwise the strategy sees the completed close too early and the test still contains look-ahead bias.

If the data set truly contains only one completed OHLC record per day, exact next-open execution cannot be modeled causally by the daily Bar callback alone; you need a separate open event/tick (or a custom execution model that explicitly implements this convention).