How the engine trades

This page describes, step by step and without shortcuts, what the backtest engine does with a recipe. Everything below is exactly how the engine computes; when a number on screen surprises you, the answer is here.

Three principles hold throughout:

• No lookahead. Every decision uses only data that existed at that minute: the index, the VIX and the option quotes are each the last value published by that instant, never a print that arrived a few seconds later. A filter that would need the future is rejected when you compose the recipe (for example an opening range that ends after the entry).
• No pure-mid fills. Unless you switch slippage off, every entry and every early exit costs you slippage: per position (the default) it is taken off the whole structure's fill, per leg you sell below the mid and buy above it.
• One arithmetic. The same function values the position for stops and targets, for the exit fills, for settlement and for Rewind's P&L path, and the per-leg stop reads each leg at those same closing prices. They cannot disagree.

A run

The engine takes every trading day of the dataset inside the period and processes each day independently (in parallel, with a deterministic result). For each day it:

1. applies the day filters; if one excludes the day, the day produces no trade;
2. makes one or more entry attempts (fixed times, a floating window, re-entries), each with its own time-dependent filters;
3. for each position opened, selects the strikes, prices the entry fills, then marks the position every minute until an exit rule fires or the day ends;
4. books each exit with fills, slippage and commissions;
5. adds up the day's P&L (every position, partial exit and adjustment of the day).

The output is a daily P&L series (one row per day of the period, zero on days without trades), the trade log at leg level, the statistics, the frozen recipe, the dataset version and the warnings.

The day cascade

Day filters run in this order. A day gets one outcome: the first step that excludes it. The filter funnel in the results counts days per step in the same order.

The "previous close" of the first day of the period is the previous day of the dataset, not a blank: two runs that start on different dates are comparable on their common days. Before the very first day of the options archive, the index's official daily closes are used.

Economic events

An economic event rule is resolved once per run, on the calendar in force at that moment (see the economic event calendar): the recipe holds the rule, the dates come from the calendar. The resolution follows three rules.

• Only scheduled events count. Releases and FOMC meetings are published in advance, so knowing in the morning that today is a CPI day is not looking ahead. An unscheduled event (the emergency cuts of 3 and 15 March 2020) was known to nobody that morning: it stays in the calendar as a fact but never decides a day. A release that was rescheduled (for example by a government shutdown) counts on the date it actually came out, since the new date was announced before.
• An event belongs to a session. It is the trading session of its release date; if the release lands while the market is closed (a holiday, a weekend, or after the session's close, 13:00 on half-days) it belongs to the next session. A jobs report released on Good Friday counts for the following Monday.
• Day before and day after are sessions. They are the previous and the next trading session of the event's session.

With Only and Skip rules together, a session is first checked against the Only set, then against the Skip set: the funnel counts each excluded session once, at the first of the two that excludes it. Like Blackout, the rule decides the first entry of the day, on both entry paths (clock and signals); a re-entry can only follow an entry that happened.

A Skip rule around the release works on minutes instead of sessions. On the day of each release, at the time the calendar records for it (not the usual one: a release moved to 10:00 counts at 10:00), it refuses every entry attempt from the release time minus the minutes before to the release time plus the minutes after, both ends included. Only the part of the window during the session counts: one that starts before 09:30 starts at 09:30, one that ends by 09:30 does nothing. The session itself goes ahead, so the day cascade doesn't count it; each refused attempt is counted as economic event (around the release) in the entry filters.

The close before economic events (an exit rule) is resolved the same way: on each session where a chosen release comes out between the open and the session's close, the close time is the release time minus N minutes (not earlier than 09:30); with several releases that day, the earliest counts. Positions opened before the release close at the first minute at or after the close time, exit reason Economic event; entry attempts from the close time through the release minute are refused (at hh:mm:00 the quotes are still the ones from before the news); positions opened after the release aren't touched. Like the recipe's other exits it acts on the main position: the adjustments of a Tactic keep their own exits.

A re-entry that falls inside either pause (a window, or the minutes between the close and the release) doesn't fail: it waits for the first minute after the pause, and in Rewind its entry cause says it waited for the release.

If an event in a rule has no dates loaded on the server, the run stops with a message instead of running unfiltered. If the period goes beyond the dates known for an event (before its history starts, or after the last date the calendar knows), the run says how many days couldn't be checked; a close before a release that finds no release during market hours in the whole run says so too. Each result records the calendar version it was resolved on and the sessions the rules skipped (or, with Only, the sessions they let through), the windows that paused entries and the early closes.

Entry attempts

Entry filters

For each attempt, in this order (each refusal is counted in the funnel as an attempt, not a day). With Max positions, the open-position limit is checked first, before any of these: an attempt that finds the limit full is skipped without evaluating them. With Close the oldest it is evaluated normally, and makes room only if it passes.

1. Market already closed: on a half-day, an entry at or after 13:00 is refused.
2. No quote: no index price at the entry minute. This is always the case at 9:30 (the recipe form starts at 9:32, but a recipe can reach the engine by other routes): the index prints its first value at 9:30:01, so at 9:30:00 there is no price to pick strikes from, and the run's warnings say so.
3. Economic event (around the release): the entry minute falls in a window around a release, or between the close before a release and the release (see Economic events).
4. Intraday move: index at the entry minute versus the day's open.
5. VIX at entry: with an overnight or intraday VIX move filter, VIX not open yet while the session's first VIX print isn't known; then the level (Min/Max), the intraday move, the VIX9D ÷ VIX ratio.
6. Opening range breakout.
7. Technical indicators (and their warm-up).
8. Custom indicators (and their warm-up), see Custom indicators.
9. Chain missing, strikes not quoted, spread too wide, short/long ratio, premium, not enough margin: these need the selected strikes, see below.

Directional move filters (gap, intraday, VIX moves)

A move filter has four optional bounds, all magnitudes (≥ 0): Min up, Max up, Min down, Max down, in % of the reference price or in points. The engine looks at the side the move actually took (a zero move counts as both sides):

• if that side has bounds, the size of the move must be within them;
• if it has none, the day passes only if the other side doesn't require its own direction, i.e. has no Min (a Max alone limits its side and leaves the opposite moves free).

So Min on both sides means "at least X in either direction", Max on both sides means "|move| ≤ X", and Min up = 0 means "only up moves", not "any day".

VIX values

When a value is missing (a day without minute VIX, VIX9D before its first minute closes at 09:32) the condition is ignored, never treated as a pass or a fail in silence: the warnings count how often it happened.

Opening range breakout

The range covers the minutes from the open to the range end. With Use intraday extremes the range is the highest and lowest index price in that window; without, the open and the price at the range end. At entry, a breakout up is an entry price above the high, a breakout down below the low. High or Low requires either, High only / Low only one direction, No breakout requires the price still inside the range.

Technical indicators

Computed on the SPX price at the entry minute:

Without enough history for an indicator (the first days of the data), the entry is skipped and counted as indicator without enough history. Exit indicators use the same definitions, evaluated on every minute's price.

Custom indicators

Your own indicators (Pine Script, see Indicators) are computed once on the whole history of their chart (symbol and timeframe), in isolated workers, and cached: a run, or a study that repeats the recipe, reads the stored values. The engine reads them with one rule:

The data covers the indices and ETFs (SPY, QQQ, IWM) Veeman has by the minute. A session without the indicator's bars isn't traded (no indicator data that day). If the script stops with a runtime error, its outputs are empty from that bar on and the warnings say where, also when the bar falls before the backtest period. A crossing that can't happen during the session (a daily indicator against a number, or against another daily reading: the daily bar closes at 16:01) is refused before the run.

Building the position

The entry snapshot

At the entry minute the engine reads the chain as of that minute: for each contract, the last quote with a timestamp not after the entry. A contract is tradable when it has an ask above zero, a mid and a delta. With Round strikes only multiples of the chosen number are tradable.

Strike selection

Independent legs are resolved first, then offset legs (wings). For each leg, among the tradable contracts of its type (with an offer, ask above zero; for a leg you sell, also with a bid, because selling where nobody bids can't be executed):

Ties go to the lowest strike, so the selection never depends on the order of the data. If a leg's type has no tradable contract, the attempt fails (strikes not quoted). A target strike that isn't quoted at the entry minute (an offset landing on a missing strike, say) takes the nearest quoted one, the same tie rule included: a 25-point wing can come out 20 or 30 points wide on that day.

With a fixed premium, a tie goes first to the strike nearest the money (closest to spot), and only then to the lowest. Cheap far strikes are quoted on the nickel grid, so ties are the norm there: 0.10/0.15 (mid 0.125) and 0.05/0.10 (mid 0.075) are both 0.025 from a 0.10 target, and a whole run of strikes can share that distance. At the same price the strike nearest the money protects the most; the lowest one would put a bought put at the far end of the run.

With Ignore wide spreads on, the attempt is refused if any selected leg has a spread above 100% of its mid. A spread of one tick (0.05 below $3, 0.10 from $3) is never wide; an ask of zero always is.

Entry fills

Each leg's entry price comes from the fill model (see Fills and costs): a short leg sells (below the mid), a long leg buys (above it). The entry credit, the quote of one structure in $ (as a broker quotes the combo), is

credit = Σ short prices × qty − Σ long prices × qty − position entry slippage

Positive = credit received, negative = debit paid. Then:

• Short/long ratio: Σ short mids × qty ÷ Σ long mids × qty must be inside the bounds.
• Premium filter: the credit must have the chosen direction and a magnitude within the bounds. The bounds are typed as the quote ($16) and stored in $ per contract, the quote × m, the contract multiplier of the recipe's underlying (100 on SPX: max $16 = $1,600). Exactly at the bound passes.
• Sizing: contracts = Max contracts, or with Margin %: min(⌊ starting capital × % ÷ margin ⌋, Max contracts); fewer than one → not enough margin.

The margin per contract is the maximum loss at expiration, max(0, −min over S of P&L(S)) × m, where the payoff is evaluated at zero, at every strike and beyond the highest strike (the payoff is piecewise linear, so the worst case is on one of those points). It is undefined when the structure is net short calls or net short puts; margin sizing then falls back to fixed contracts with a warning.

Marking minute by minute

From the minute after entry to the minute before the close (15:59, 12:59 on half-days), the engine reads the series of only the selected contracts and, for every minute where all legs have a price, computes the cost to close one structure, as a quote in $:

cost = Σ short legs: buy price × qty − Σ long legs: sell price × qty

with the same fill model as the entry (closing side). The open P&L per structure is credit − cost. Minutes where a leg has no bid or ask are skipped rather than valued with a hole (a bid/ask of zero is a real price: a wing worth nothing). This is the only place where the value of a position is computed; values are rounded to 1e-9 so that a P&L exactly equal to a threshold always triggers it, whatever the order the data was read in.

The same pass gives the position delta (Σ long deltas × qty − Σ short deltas × qty) and the short and long premiums at mid used by the ratio exit.

Exits

Thresholds

Target and stop become thresholds on the quote of one structure (in $):

The target fires when the open P&L is ≥ its threshold, the stop when it is ≤ its level. With Two consecutive touches (target) or Ignore single-bar stop violation (stop), the condition must hold for two minutes in a row and fires on the second.

Per-leg stop

The per-leg stop compares each watched leg's own open P&L with its level, minute by minute: for a short leg, its entry price minus the price to buy it back; for a long leg, the price to sell it minus its entry price; times the leg quantity, on the quote of one structure, at the same closing prices the position is marked with. The watched legs are the ones chosen in the recipe, otherwise the short legs of the position (every leg if the structure has none). When any watched leg's P&L is ≤ its level, the whole position closes at that minute, every leg at its fill, with the exit reason leg stop. With Ignore single-bar stop violation the same leg must stay at or below its level for two minutes in a row. A leg filled at zero premium has no % level and isn't watched: the warnings count those trades. A bought leg can lose at most 100% of its premium, so a % level above 100 never fires on it; the warnings flag a recipe where that happens.

In the composer the per-leg stop is the Stop with Per leg switched on (see Target and stop): a recipe written there has a stop on the structure or a per-leg stop, never both. A saved recipe that has both still runs as written, each stop watching on its own, and at the same minute the structure stop wins.

Full exits

Every other exit rule is evaluated as a mask over the minutes ("is the rule true at this minute?") and fires at its first true minute:

Cooldown

A rule with a cooldown of N minutes isn't watched for the first N minutes of the trade, starting with the entry minute. Exits are checked once a minute, on the minute's prices: with entry at t, the check at t+1 reads the entry minute (the VIX printed during it, the option prices at its end). The cooldown skips the checks t+1 … t+N, so the rule is watched from minute t+N and the first possible exit is at t+N+1 (entry 10:03, N = 1 → watched from 10:04, first exit 10:05). The reference doesn't move: the VIX, the index and the premium of the entry minute. Each rule has its own cooldown; the stop's covers the per-leg stop and the leg groups' stops, the target's the groups' targets, the VIX exit's the VIX9D ÷ VIX ratio, and one cooldown covers every profit action. Clock-time exits, minutes in trade, the close before an economic release and timed actions have none.

The exit cause records the cooldown, and whether the rule was already true when it ended.

When several rules fire at the same minute

The engine collects, for the current phase, the first minute of every rule, and takes the earliest. At the same minute, the adverse outcome wins: stop, then per-leg stop, then trailing stop, then the target and the other full exits (in the order listed above), and only then the partial actions.

Partial exits and moving levels

Profit actions and timed actions close part of the position and can move the levels, so the plan runs in phases: when an action fires, its contracts are closed at that minute (⌊ initial contracts × % ⌋, never more than what remains), the stop (and for timed actions the target) moves to its new level, and evaluation restarts from that minute with the updated thresholds (the per-leg stop doesn't move: it keeps watching the legs of the contracts still open). Each action fires once. Levels are always computed on the initial premium. A profit action is subject to Two consecutive touches like the target, and with Cap profits its partial close books at its level.

Leg groups

With leg groups, the legs are entered together and then each group runs its own exit plan: its own premium (the group's legs' credit), its own target and stop, the same other exit rules. Rules that read the position (delta, short/long ratio, tested short) read the group's own legs. The per-leg stop picks its legs on the whole position (by default its short legs, so a group made only of wings doesn't end up watching them); each group watches its own among those and closes that group when one hits its level. A group's target or stop left empty is the recipe's: a percentage applies to the group's premium, a level in $ stays as it is. Each group's exit is a separate row in the trade log; the statistics merge them back into one position.

Settlement

Whatever is still open at the end of the day settles at intrinsic value with the index's last print of the session (13:00 on half-days): max(index − strike, 0) for calls, max(strike − index, 0) for puts. No closing commission and no slippage are charged. If a position never had a minute with all legs quoted after entry, it settles directly.

The minute of the bell belongs to settlement only. At that time an expiring option is no longer bought back, and its quote is often meaningless: a put worth 1.45 at settlement can be quoted 54.80 / 75.60. No exit rule reads it (stop, per-leg stop, target, time exits, Tactics), and neither do the trade log's Max Profit and Max Loss. Whatever no rule has closed by 15:59 settles, just as no entry opens at the bell.

Fills and costs

The fill model

The marking used for stops and targets uses the same leg prices as the closing fills. In the per-position model the position slippage is not part of the marking (it is a cost of executing, not a level the market reached), so a target is triggered by the market and the slippage is then charged on the fill.

Commissions

commission = rate × Σ leg quantities × contracts, per transaction: the open rate at entry, the close rate at each early exit, nothing at settlement. A 1-2-1 butterfly pays four commissions per transaction, not three.

Booking an exit

For each exit event (the whole position, a partial close or a group):

1. Gross at the fill: (credit − close value) × contracts × m, with m the contract multiplier of the underlying (100 on SPX).
2. Cap: with Cap profits, a target (or profit action) books at most its threshold; with Cap the stop-out, a stop books no worse than its level, and a per-leg stop books the leg that hit it at its level (the other legs at their fill).
3. Position slippage for that exit, × contracts × m (per-position model, early exits only).
4. Commissions: the opening commission pro rata (contracts closed ÷ initial contracts) plus the closing commission of the contracts closed.
5. Booked P&L = gross after cap − slippage − commissions.

Each row of the trade log carries this exit cause (the rule, its parameter and who set it, the threshold, the value observed, the booking): it is what Rewind tells you at the exit minute.

It also carries an entry cause, recorded when the position opens: the trigger (the scheduled time, the first minute of the floating window that passed every filter with the minutes held back by each filter, the re-entry after a given exit, or the entry signal), every active entry filter with the value read at that minute and its bounds, and the strike criterion of each leg with the value it found. The values are the ones the filters compared, so they always satisfy the rules: if the position exists, every filter passed. Rewind tells it at the entry minute.

Tactics in the backtest

When the recipe arms one or more Tactics, after the day's main positions are computed the engine replays each one minute by minute and runs the Tactics' rules mechanically: a fresh ladder of each Tactic for every trade, adjustments opened without confirmation, each with its own exits or held to settlement. Rungs of different Tactics that fire in the same minute open in the order the Tactics were armed. The recipe's target and stop act on the main structure only. Adjustments are separate rows in the trade log (marked Tactic), their P&L is part of the day's P&L and of the equity; win rate and the per-trade figures count the main positions only. Details in Tactics.

In a portfolio: the strike guard

A backtest runs alone. When it is part of an Analysis portfolio with other Veeman backtests or strategies imported from a file, the strike guard can re-run it so that it never opens a contract another strategy already holds at that minute. It acts at the moment the strategy has decided to enter (filters, premium, sizing and the re-entry wait have all passed): the chosen structure is shifted one strike step, or the entry is skipped, according to the strategy's rule. A shifted structure is priced with the same fill model at that minute and keeps its contract count; a shifted strike with no market skips the entry. The archived backtest itself is never re-run in place.

Warnings

The engine never drops a condition in silence: every approximation is reported, aggregated by type (never one line per day) with the count and the dates involved. The ones you may see:

Reproducibility

The engine is a pure function of the recipe and the data: the same recipe on the same dataset version gives the same result to the cent, whatever the number of threads. Tie-breaks are deterministic (lowest strike), equality with a threshold is exact, and the recipe and the dataset version are frozen inside every result and every saved backtest.

A recipe with custom indicators carries each indicator's script, inputs, chart and the version of the compiler that ran it. A saved backtest run again uses the current compiler on that same script: if a correction to the compiler changed the numbers, the recorded compiler version says so. New index data or a new compiler always means a new computation, never a result served from before.