FNOTrader Algo — Help

A no-code builder for F&O algos. Author multi-leg strategies, backtest them against minute-bar history, and ship the exact same recipe to live trading through your broker. This page documents every feature in the builder, the backtest engine, and the live runtime — with worked examples for each.

Welcome

The execution engine is a standalone Go service that runs configurable multi-leg F&O strategies on your behalf. It pairs three pieces:

• A visual builder (this UI) where you describe a strategy as a recipe — no programming required.
• A backtest engine that replays the recipe against last year of minute-bar history (CE/PE OHLC + IV + OI per ATM±10 strike).
• A live runtime that ships the exact same recipe to your broker — Kite/Dhan/paper — and supervises the trade end-to-end.

Trader's mental model

Five-minute quick-start

1. Open the builder and pick a Template in Step 1 — e.g. Short Straddle. It seeds the legs for you.
2. Skip straight to Step 6 → press ▶ Run Backtest. You'll get a full report in 10–20 seconds covering the last month.
3. Tweak the SL/TG in Step 4 → re-run. Compare results in the Backtest History tab.
4. Press 💾 Save Strategy. The recipe is now reusable in live trading too.
5. From the home screen, attach the saved strategy to a Broker Account and press ▶ Start.

✨ New — build & backtest by just asking your AI

Colors & conventions

Badges: BACKTEST works in backtest, LIVE works in live trading, BETA accepted but not fully wired, TODO deferred.

Step 1 · Strategy identity

Three fields define what the strategy is and where it trades.

Step 2 · Instruments to Watch

The "vocabulary" your conditions can use. Anything you name here is readable in Step 3 conditions via ALIAS.METRIC.

Scope dropdown

Per-row fields

• Alias — what you'll type in Step-3 expressions. Auto-populates from Scope but is fully editable. Keep it descriptive (OPT_ATM_CE not foo).
• Timeframe — bucket size for indicator aggregation (1m / 3m / 5m / 15m / 30m / 1h / 1d). Drives EMA, RSI etc. on that alias. A 5m TF means OPT_ATM_CE.EMA(10) reads the 10-bar EMA of 5-min candles, not 10 raw minutes.
• Symbol / Expiry / Strike Distance — adapt to the chosen scope.

OPT_ATM_CE.CLOSE > OPT_ATM_CE.EMA(10)

Step 3A · Entry conditions

Multi-row builder. Each row is one boolean clause; rows combine with AND or OR (your choice). The full expression is evaluated every bar (or throttled — see Check Frequency) and the strategy enters on the first true.

Per-row fields

Operator catalog

Combine mode

Toggle AND (all rows must fire) or OR (any one). Rows cannot mix AND/OR within one block — for that, save two strategies and cascade them via On-Hit actions.

Check Frequency

How often the expression is evaluated:

• tick — every market tick (live) / every minute-bar (backtest).
• every X-min bar close — only when minute-of-day mod X == 0 (e.g. 5 = 09:20, 09:25, …).

Comparing two instruments — CE vs PE OI crossover

Pick RHS mode instrument to compare one instrument's metric against another's. The canonical intraday use: two ATM watches (ATM_CE, ATM_PE, ATM tracking = Auto, Timeframe 3m) and a row ATM_CE · OI Chg · Crossing Up · instrument · ATM_PE · OI Chg. Crossings against a moving right-hand side are TRUE crossings — both sides are read at the previous bar too, so the row is true on exactly the crossing bar, not while one side merely stays ahead. Pairs without a previous-bar form (e.g. IV Chg) compile as a plain level check — the Preview always shows exactly what will run.

Already crossed at the open? Some days the two lines START the session in the crossed state (e.g. CE OI above PE OI from the very first data point) and never cross again — a pure crossing row would sit silent all day. Tick "or fire on day's 1st bar if already crossed" on the crossing row to ALSO enter on the session's first closed bar when the condition already holds there. It evaluates exactly once, on the day's first bar-close check; after that only real crossings fire. Works in live and backtest identically.

On an Auto-tracking ATM watch, a strike change resets OI continuity: the new contract's book has nothing to do with the old one's, so OI-change metrics read 0 until the new strike establishes its own baseline (prices are left untouched).

When conditions evaluate — and when entries fill

With Check Frequency every X-min bar close, the expression is evaluated ONCE per bar, in the first second after the bar closes — never mid-bar, never on an intrabar spike, and never against the half-formed bar the strategy started inside. A condition fires the first time it is true (a crossing is true for exactly one bar; a level like LTP > 100 fires once when first satisfied). The entry then executes immediately — effectively the next bar's open. The backtest enforces the same discipline: signal on bar X's close → fill at bar X+1's open (see no-lookahead-bias). tick mode evaluates in real time, live only at tick granularity (the backtest's floor is 1-minute bars).

Step 3B · Exit conditions

Same builder as 3A but evaluated after entry. If any exit row fires (when combine = OR) or all exit rows fire (combine = AND), the engine flattens every open leg at next bar's open.

Exit conditions compose with the per-leg SL/TG (Step 4) and Combined SL/TG (Step 5). Whichever triggers first wins — they're not mutually exclusive.

Step 3C · BTST / STBT mode

Buy-Today-Sell-Tomorrow / Sell-Today-Buy-Tomorrow. Two time pickers: Start Time (today's entry window) and Exit Time (next trading day's square-off). When both are set, the engine flips overnight_hold = true and the strategy is held across the EOD square-off boundary. Entry/Exit conditions 3A/3B remain available but optional.

Step 3D · Overnight Protection

Carrying short option legs overnight exposes you to gap risk and higher peak margin. Overnight Protection automatically buys a protective hedge against every open short option leg at a set time (typically just before close) and sells it back at a set time the next trading morning — no manual step, and it survives engine restarts (the hedge is rebuilt from the order ledger).

Controls

Strike-selection methods

Step 4 · Strategy Legs

Table of legs the strategy fires. One row per leg.

Main-row columns

Strike Selection modes

Advanced (⚙) — tabbed panel

Tab 1 · Wait & Trade

Delay this leg's entry until its premium crosses a trigger price. Useful for buying weakness or selling strength after the basket has already fired.

• Wait & Trade Trigger — value + unit (pts absolute / pts_rel relative to LTP at entry / %).
• 📎 Sell a CE, then Wait & Trade Trigger = pts_rel +10 → the leg only fires once the CE trades ₹10 ABOVE its price when the basket armed — you sell strength (a bounce) instead of chasing a falling premium.

Tab 2 · Stoploss (SL1+)

SL Wait (sec) — SL breach debounce (next to the tab's Check Frequency): a breached stoploss must STAY breached for this many consecutive seconds before the exit fires; a recovery inside the window resets the timer. Ignores flash-spikes / single-tick wicks. 0 = exit on first breach. The same knob exists at basket level on the Combined Stoploss tab (Step 5).

Per-rung fields: SL Qty (% or lots), On-Hit action, Check Frequency. Add SL2 / SL3 rungs for laddered exits.

On-Hit action catalog

Tab 3 · Target (TGT1+)

Same structure as SL. Target Types include all SL types plus r_multiple (risk-reward — target distance = N × stop distance).

Tab 4 · Per-leg Trailing

• Trail Trigger — profit ₹ threshold that arms the trail.
• Trail Step — every N₹ further profit, ratchet the stop up.
• Trail Lock — minimum ₹ locked in once trail is armed.
• Check Frequency — tick / xm_close.

Profit Lock & Trail (per leg)

₹-P&L guards on ONE leg, independent of the price trail and of its "Trailing enabled" switch. Profit Locking: when this leg's P&L reaches ₹X, a minimum of ₹Y is locked — if P&L falls back to ₹Y, the leg exits in full. Profit Trailing: every further ₹X of PEAK P&L lifts the locked floor by ₹Y. Evaluated on every tick live (a ₹ guard, like Combined SL); at bar closes in backtest.

The per-leg price trail's Trigger / Step / Lock take a unit — % of entry premium (default) or Pts (absolute premium points). The hints and "What this means" readback speak whichever unit you pick.

Step 4B · Strategy Adjustment Conditions

The engine's most powerful section — modify a LIVE position without stopping the run. Where SL/Target close a leg, adjustment rules re-strike it: roll a threatened short leg further OTM, roll a decayed winner back in, re-center a straddle when spot drifts, or delta-hedge the whole book. Each rule is a card — click + Add rule and pick its type (one rule per type; a duplicate type overrides the earlier card).

A roll closes the leg (fill-confirmed) and re-opens at the target strike off the live option chain; the new leg gets a fresh SL/Target from its own entry. Every action is journaled.

Global guards (apply to every rule)

Rule types

1 · Roll / exit a leg at a price level

Per-side premium trigger off each leg's own entry (% / points / absolute ₹). On breach: roll away N strikes, roll in, or exit.

2 · Price-diff band around entry (two-sided)

One band, a different action on each side: LTP ≥ entry + band fires the ▲ action; LTP ≤ entry − band fires the ▼ action.

3 · Roll / exit a leg at a delta level

The delta twin of the price rule — fires on the leg's |delta| off the live chain greeks (a short 0.45δ call is a threatened call regardless of premium). Roll by strikes, exit, or roll AWAY to a target |delta|.

4 · CE/PE divergence — winner & loser actions

Straddle/strangle only. When |CE − PE| crosses a threshold, the winner (decayed, in profit) premium-matches IN and the loser rolls AWAY — in one inversion-guarded action.

5 · Rebalance — roll the cheap side in (premium match)

Straddle/strangle only. When one side's premium reaches N× the other, the CHEAP (decayed) leg rolls IN to the strike worth ≈ the target % of the expensive side — the running side is left alone.

6 · Delta / gamma hedge — re-balance when net delta skews

Watches the whole book's net delta (Σ ±δ·qty / Σqty off the live greeks; SELL negates) — 0 when balanced, drifting toward ±1 as one side runs ITM. Two actions:

• Roll the heavy leg (default) — the side whose |delta| ran up is re-struck AWAY to match the light side's delta.
• Hedge with FUTURES — the classic hedge: BUY/SELL the front-month future against the net delta (rounded to whole lots, optional max-lots cap). It manages itself — re-balances as the book moves, unwinds when net delta falls inside half the trigger, closes with the strategy.

An optional net-gamma trigger fires the same fix earlier, before the delta itself looks bad.

7 · Spot re-center at ATM ± offset

Straddle/strangle only. When the underlying moves ≥ X% from the armed reference, close both legs and re-open at the new ATM ± offset. The reference re-bases after each fire.

Step 5 · Strategy Risk Settings (Combined)

Same shape as the per-leg advanced panel but at the basket level. Four tabs: Wait & Trade, Stoploss, Target, Trailing.

Combined SL/TG fires when the basket-level MTM (sum of all open-leg PnLs) crosses a ₹ or % threshold. On hit, the action choices include:

• just exit — flatten all legs.
• close_current_strategy — explicit version of above.
• close_and_re_enter_strategy — flatten, then re-fire after a configured delay (capped by NTimes).
• close_all_losing / close_all_profitable — partial flatten. 📎 On a 4-leg book at +₹2,000 combined, close_all_profitable books the two green legs and lets the two red ones run for a possible recovery.
• close_all_ce_buys / _ce_sells / _pe_buys / _pe_sells — close by option-type + side. 📎 Spot breaks down hard → close_all_ce_sells removes only your short calls (the safe side isn't earning much anyway) and keeps the short puts + hedges working.
• move_sl_to_cost_profitable_legs — lock breakeven on the winners.
• execute_other_leg / execute_other_strategy — cascade.

SL Wait (sec) — the same debounce as the per-leg one, at basket level (next to the group Check Frequency): a breached Combined SL must STAY breached for N consecutive seconds before its action fires; if the basket MTM recovers inside the window the timer resets. Applies to every Combined SL condition (AND groups included). In backtests (1-min bars) waits under 60s are absorbed into the bar; longer waits require the breach to persist across bars.

Profit Locking & Trailing (basket)

The same two ₹ guards on the WHOLE basket's combined MTM, next to Combined Trailing: when combined P&L reaches ₹X, a floor of ₹Y is locked (and optionally lifted by ₹L per further ₹S of peak). Falling back to the floor squares off every leg. Works alongside — not instead of — the classic Combined Trailing.

Step 6 · Execution Settings

Step 7 · Summary & Save

A single-page English-prose recap of everything you've configured. Refresh it (↻) any time. Then ▶ Start Strategy (live), 💾 Save Strategy (reusable recipe), or Export JSON / Import JSON (share/version).

Expression language

Conditions internally compile to a small expression language. The builder writes it for you, but you can also type it directly into the Preview box (advanced).

Operators & precedence

Symbol resolution

Three styles, all interchangeable:

• NIFTY.CLOSE — bare underlying token. Recognised symbols: NIFTY, BANKNIFTY, FINNIFTY, MIDCPNIFTY, SENSEX, BANKEX.
• ATM_CE.IV, OTM2_PE.OI, ITM3_CE.DELTA — relative option symbols. Strike-offset computed automatically; CE/PE explicit.
• LEG1.CLOSE, LEG2.IV — refers to leg #1, #2, … of this strategy.
• ALIAS.METRIC — any alias you defined in Step 2.

Special identifiers

Multi-instrument (Phase 4.6)

// NIFTY straddle, only when SENSEX is trending up
TIME >= 0920 AND SENSEX.CLOSE > SENSEX.EMA(10)

Arithmetic between metrics

The evaluator supports full arithmetic between metric reads. Strike-wise PCR is the canonical example:

// Strike-wise PCR > 1.5 (puts dominate at ATM = bearish hedging)
ATM_PE.OI / ATM_CE.OI > 1.5

// Straddle premium relative to spot > 1.5%
(ATM_CE.LTP + ATM_PE.LTP) / NIFTY.CLOSE * 100 > 1.5

// Credit-spread net premium > ₹50
LEG1.LTP - LEG2.LTP > 50

Every condition row in Steps 3A/3B has an optional arithmetic combinator between the primary metric and the operator — a small dropdown reading — by default. Pick +, −, ×, or ÷ and a second [Symbol] + [Metric] + [args] block appears, so you can build composite LHS expressions like ATM_PE.OI ÷ ATM_CE.OI > 1.5 entirely from dropdowns. The Preview textarea is still available for power users who want to type longer compound expressions directly.

Metrics & indicator catalog

Every metric below works on any symbol — spot, option, alias.

Price & structural

Momentum

Volatility & channels

Volume / OI / CDV

Spot instruments have no OI — OI metrics on a spot watch read 0. The condition-row basis picker ("vs prev bar / vs day open / vs prev day close") writes these forms for you; you rarely type them by hand.

Option Greeks

Computed via Black-Scholes (Hull 11e) at risk-free rate 6.5%. Returned per option symbol; backtest computes on-the-fly from (spot, strike, IV, DTE).

Pivots, CPR, Camarilla

TIME & PREV_CLOSE

// Window-only entry
TIME >= 0925 AND TIME < 1100

// Gap-up open
NIFTY.OPEN > PREV_CLOSE * 1.005

Backtest engine

Replays your saved strategy against minute-by-minute history — years of option prices (open/high/low/close), implied volatility and open interest for strikes around the money, plus the index itself. Hit ▶ Run Backtest on any saved strategy; reports are persisted to Backtest History.

External signals — backtest a TradingView strategy (or any signal list)

The Backtest tab has an optional Entry signals row (below the main settings). Upload a CSV of timestamped entry/exit signals and the backtest fires your strategy only when the file says so — your SuperTrend / Pine-script / Python / Excel logic decides when, while everything you built in the Builder decides what: legs, strikes, expiry, SL/Target, trailing, square-off. It works in Single-strategy, Portfolio and Parameter-sweep runs, and costs the same credits as a normal backtest.

Two accepted file formats

• TradingView export, as-is. Put your strategy (not just an indicator) on the chart → Strategy Tester → List of Trades → Export data. Upload the downloaded CSV without editing. Rows TradingView marks as still-open ("Open") are skipped automatically, and a re-exported file's duplicate rows are de-duplicated.
• The template ("Download the template" link) for hand-written or program-generated signals. Two columns matter — Date and time (IST, 24h, YYYY-MM-DD HH:MM) and Signal; a third Notes column in the template documents everything and is ignored by the upload.

Signal types

A signal row is a pure entry or exit event — the engine never reads a direction out of it and never changes your strategy's legs because of it. The long/short tag is only a label you can filter on:

Word order and case don't matter (Entry Long, exit_short, close long all work). Every entry needs an explicit exit row — an opposite-side entry does not imply one. This is the same E/X/LE/LX/SE/SX taxonomy the live Signals page (webhooks) uses, so a system you backtest from a file can go live on a webhook unchanged.

The "Use rows" filter

• All signals (default) — every row drives the run.
• Long only — only LONG ENTRY/LONG EXIT rows are used.
• Short only — only SHORT ENTRY/SHORT EXIT rows.

Untagged ENTRY/EXIT rows pass every filter. Build the strategy for the side you want, then pick the matching rows. Example — a SuperTrend stop-and-reverse export: run a BUY CE strategy with Long only (holds a call through the long stretches) and a BUY PE strategy with Short only (holds a put through the short stretches).

How the gate actually fires

• The signal is a state, not a one-bar event: it is ON from an entry row until the next exit row — riding overnight if the file holds overnight. A signal that fired at 09:05 still admits an entry when your strategy's window opens at 09:20; a position squared off at day-end re-enters next morning while the state is still ON.
• Built with an External Signal condition? If the strategy's entry (or exit) conditions contain the Builder's External Signal row, the file drives that exact SIGNAL term inside your composition — e.g. (TIME ≥ 09:20) AND SIGNAL AND (LTP > VWAP) replays verbatim, so you can gate the signal with time windows and price conditions.
• No SIGNAL condition? The gate wraps the whole entry automatically: entry = signal ON AND your entry conditions; exit = signal OFF OR your exit conditions.
• Entries fill at the next bar's open after the combined condition turns true (the engine's standard no-lookahead rule); exits, SL, Target, trailing and square-off all keep working exactly as configured — a stop can close you out while the signal is still ON.
• The engine remains one entry-cycle per day per strategy (plus your configured re-entries), and the report's rules header + warnings strip always state how many signal events were used and which rows.

Backtest vs Live — what matches, what doesn't

What's loaded

• Spot bars for the primary underlying (NIFTY / SENSEX) + every foreign underlying referenced in expressions (Phase 4.6).
• Option bars (CE/PE OHLC + IV + OI) for the strike offsets the strategy needs — folded from per-leg Distance + any ATM_CE/OTM2_PE tokens in the entry/exit expressions.
• The day's ATM strike, expiry and days-to-expiry.

On-the-fly Greeks

The archive carries OHLC + IV + OI but not Δ Γ Θ Vega. The engine computes them per-minute from (spot, strike, IV, DTE) via Black-Scholes. Theta ticks down throughout the day as DTE shrinks. Verified by 7 unit tests including ATM sanity, deep ITM/OTM bounds, Γ-peak-at-ATM, vega-peak-at-ATM, garbage-input guards, and put-call parity at 1e-9 precision.

Multi-instrument

Expression tokens like SENSEX.RSI(14) in a NIFTY backtest transparently load SENSEX spot bars in lock-step. Unsupported foreign underlyings (BANKNIFTY, FINNIFTY, MIDCPNIFTY, BANKEX) surface a clear Warnings entry instead of silently zeroing — see multi-instrument.

No-lookahead-bias

Friction model

Two knobs in the Run-Backtest dialog:

• cost_inr_per_leg — flat ₹ deducted per round-trip (brokerage + STT + exchange + GST + stamp). Typical ₹50–80 for NIFTY.
• slippage_pct — adverse fill at entry and exit. SELL at mid×(1−slip%) on entry, mid×(1+slip%) on exit; BUY direction reverses. You pay both sides.

The report has 3 tabs: Plain, Costs only, +Slippage — so you can see the friction sensitivity instantly.

Check Frequency throttle

Honored independently per surface: entry expression, exit expression, per-leg SL1/SL2/TGT1/TGT2/Trail, and combined SL/TG/Trail. You get three modes:

• tick — every minute bar.
• every_xm — N-min interval from StartHHMM.
• xm_close — minute-of-day grid (MM mod N == 0).

Use this to model "evaluate SL only on 5-min close" or "Combined SL every minute, per-leg SL every 5 minutes" mixtures.

Strike clamp at ATM±10

The archive only has ATM±10 strike data. Out-of-range legs are clamped to the boundary (with a warning) — never silently skipped. Live trading uses the exact strike you specified.

You'll also see a clamp notification toast in the Builder when:

• You pick a Distance outside ATM±10 (OTM12, ITM15, etc.).
• You pick any dynamic mode (Premium / Delta / Absolute / Straddle / UndPrice) — since the resolved strike is unknown at build time.

Report & History

Every backtest produces:

• Daily P&L list with trade-by-trade detail, ATM, skip reasons.
• Headline stats — total PnL, win rate, day count, best/worst day, max drawdown, avg daily.
• Monthly calendar — hedge-fund-style P&L heat-map.
• Equity curve + running drawdown chart (TradingView Lightweight Charts).
• Strategy rules header — exact entry/exit/SL/TG echoed back.
• Warnings panel — strike clamps, unsupported metrics, missing data, and a line describing exactly which advanced features were simulated (overnight carry, protection hedges, adjustment rules).

Every run is persisted to Backtest History — a professional table you can filter by strategy/symbol/result, with one-click 🧪 Forward test and 🚀 Deploy live on each row.

Parameter sweep — variants, not clones

On the Backtest page, tick Parameter sweep to compare tweaks of ONE strategy without saving a copy per tweak. The composer mirrors the sections your strategy actually configures — each leg's Stoploss row (type / value / then / then) and the enabled Adjustment rules — using the builder's own controls. Change any combination, name it, ＋ Save as variant. Variants persist on the strategy, so the same comparison re-runs later on any date range.

• The run replays the original as the baseline plus every ticked variant; results sort best-P&L first with each variant's changes and its delta vs the original, and each row opens its full report.
• Use this applies the winning variant's settings onto the strategy itself — what won the backtest is what trades, live and in forward test. No cloned strategies.
• Credits: 1 per year of range × runs (original + variants) — quoted on the button before you click.

Live trading · broker adapters

Strategy lifecycle

1. Start — registry spawns a supervised goroutine for the strategy.
2. Wait for entry — evaluates entry condition every tick (or per check_freq) until firing.
3. Resolve strikes — uses the per-leg strike-selection mode (Distance / Premium / Delta / OI-based / etc.).
4. Fire legs — atomically, per execution-mode (parallel / sequential / buy-first).
5. Monitor — quote feed per leg → per-leg SL/TG → combined SL/TG → trail SL — all gated by their own check_freq.
6. Exit — on SL/TG hit, exit-condition fire, sqoff time, or kill-switch.
7. Settle — records realised P&L, updates daily-loss counters, marks strategy complete.

Leg execution modes

• parallel — all legs fired concurrently (default).
• sequential — wait for leg N to fill before firing leg N+1.
• buy_first — all BUY legs in parallel; wait HoldSellSec; then all SELL legs. Locks hedges before opening short exposure.

Fail policies when any leg fails to fill:

• cancel_all — square off any filled legs and abort.
• keep_placed — proceed with the partial basket.
• retry_failed — retry up to MaxRetries before falling back to cancel_all.

On-Hit actions

Fire on SL or TGT events at the leg level (Step 4 → SL/TGT tabs) or the basket level (Step 5 → Combined SL/TGT). See the Step 4 action catalog for per-leg; basket-level actions are listed in Step 5. All actions can chain and most carry a delay parameter for staged behaviour.

Hedges & Move-SL-to-Cost

• IsHedge flag (checkbox on a leg) — that leg is excluded from Move-SL-to-Cost and is exited last when flatting the basket. Use on BUY legs that protect a SELL.
• Move-SL-to-Cost (Combined SL action) — once profitable legs cross a threshold, move every other (non-hedge) leg's SL to its entry price. Locks breakeven on the open legs.

Risk gate

Webhook entry (OnSignal)

Get a private token from the Webhook page. POST to /api/webhook/signal/{token} with no body — the token is the auth. The configured saved-strategy fires immediately. Useful for TradingView / Python alerts / external scanners.

curl -X POST https://your-engine/api/webhook/signal/AbC123xyz

Telegram notifications

Tick Send to Telegram in Step 6 to mirror every lifecycle event to your bot — entry fills, SL/TG hits, leg closes, re-entries, auto-hedge applied. Configure bot_token + chat_id in config.yml. Buffered, non-blocking, Markdown-formatted.

Signals · repeat policy (ignore vs pyramid)

A webhook sender can retry or double-fire. Each Signal chooses what a REPEAT same-side entry does while that strategy is already live on that broker: with Pyramid on repeat signals unticked (the default), the repeat is ignored and logged in the signal log — your position cannot be multiplied by a duplicated alert. Ticked, each repeat ADDS another position up to Max positions (a ceiling always applies). A same-side check is side-aware: a Short Entry while a long is open is a reversal, not a repeat, and still fires. Exit signals always close every matching run.

Deployments & mornings

• Only logged-in & enabled brokers can be assigned. The Assign picker offers an account only when it can actually place an order right now; hidden accounts are counted with a note pointing at the Brokers page.
• 08:45 IST pre-open check. On trading days, everyone holding a live deployment gets an email (and WhatsApp, when your 24-hour window is open) listing each deployment and whether its broker is ready — with time to log in before 09:15.
• A blocked launch says why. If the broker is still logged out at launch time, the deployment shows an amber ⚠ with the reason, and the strategy launches by itself the moment the broker is ready.
• No late auto-entries. If the entry time has already passed by the time the broker is ready, the strategy is NOT auto-started for the day — a late entry at a different price is your call, via ▶ Run now.
• Deployment log. The pre-open check, blocked launches and skipped late starts are all recorded per strategy and per portfolio — visible in Logs even on days no run was created.

Strategy recipes

Fifteen worked examples covering the breadth of features. Each is a complete spec you can paste into the builder.

Known limits

• Backtest strike range — ATM±10 only. Beyond that, legs clamp with a warning. Live trading unaffected.
• Backtest spot underlyings — NIFTY, SENSEX and BANKNIFTY have archived spot bars. FINNIFTY / MIDCPNIFTY / BANKEX references warn and read 0 in backtests. Live trading unaffected.

Glossary

FAQ

Why are my backtest trades different from yesterday's run?

Most likely you tweaked something in the Builder, or the engine received a lookahead-bias fix / Greeks fix / TF-fix in a recent release. If the recipe is unchanged and pre-dates a fix, results should diverge — the older results were quietly wrong.

My strategy never enters in backtest. Why?

Check the Warnings panel of the report. Common reasons:

• Foreign underlying referenced but unarchived (e.g. BANKNIFTY).
• Out-of-archive strike (Distance > ATM±10 or Premium/Delta/etc. resolving outside).
• Entry condition that depends on an indicator that hasn't warmed up yet — e.g. EMA(200) with only ~50 bars in history.

Why is my entry timing one bar later than my signal?

That's the lookahead-bias guard working as intended — see No-lookahead-bias. Pure-TIME entries don't defer; only indicator-driven entries do.

How do I compute strike-wise PCR?

Pick the primary metric (e.g. ATM_PE · OI), then choose ÷ from the arithmetic-combinator dropdown in the same row, then pick the second metric (ATM_CE · OI). Set the operator to greater than and the RHS value to 1.5. The Preview compiles to (ATM_PE.OI / ATM_CE.OI) > 1.5 and the backtest/live engine evaluates it natively — no special PCR metric needed because the same UI supports any ratio / sum / difference / product of two metrics.

What's the difference between "tick" and "xm_close" check freq?

tick evaluates every minute bar. xm_close only evaluates on bars whose minute-of-day mod X is zero — so 5m_close fires at 09:20, 09:25, 09:30, … and ignores the bars between. Use xm_close to model "candle-close confirmation" entry/exit logic.