Last updated: 1 November 2026 · 19 min read · The definitive guide
By Pulkit Mangal — equity + F&O trader since 2017, founder of TradeDiary. Ran discretionary books for four years, switched half to algo in 2023, and built TradeDiary's algo review layer after a strategy that backtested at 68% win rate delivered 41% live — because the backtest didn't charge STT.
TL;DR: An algo that passes a backtest isn't an algo that makes money — it's an algo that hasn't been measured yet. The gap between simulated and live results has exactly four components: slippage (your fills vs. the signal price), cost drag (STT + brokerage + GST + stamp duty, which in India can erase 3–8% of gross returns annually), regime mismatch (the market your algo trained on no longer exists), and execution failure (orders rejected, partial fills, API timeouts). This guide gives you the framework to measure all four, with the six metrics that matter, in the order you should build them. If you read one line: an algo without a live performance ledger is a hypothesis, not a strategy.
This is the algo-specific companion to our trading analytics guide. That page covers analytics for any style; this one is about the problems unique to automated trading — where human error gets replaced by system error, and where the gap between backtest and bank statement is both larger and more measurable than most traders expect.
1. What algo performance analytics actually is
Algo performance analytics is the practice of measuring every automated strategy against its own claims — continuously, in production, with real money at stake. It answers exactly one question: is this strategy doing what the backtest said it would, net of everything the backtest ignored?
That "everything" is not a small list. A backtest assumes perfect fills at the signal price. It rarely charges realistic STT (0.0125% on equity delivery, 0.0625% on options, 0.0125% on futures sell). It assumes every order gets accepted. It doesn't know that your broker's API had a 3-second timeout at 9:16 AM on expiry day when NIFTY gapped 200 points.
The gap between backtest and live is not a bug in your code. It's a structural feature of every algo, and measuring it honestly is the entire discipline.
Three things make algo analytics different from discretionary analytics:
- You have a specification to compare against. A discretionary trader reviewing her journal is asking "was this a good trade?" An algo trader is asking "did the system produce the result its model predicted?" That's a tighter, more answerable question.
- You have more data. Algos generate fills in volume. A 3-strategy setup trading NIFTY + BANKNIFTY weekly expiries can produce 40–100 fills a day. The data exists; the question is whether you're reading it.
- You have a different failure mode. Discretionary traders fail by breaking their rules. Algo traders fail by not noticing their system has stopped working — because the system keeps placing orders whether the edge is there or not.
2. Why it's different for Indian algo traders
India's market structure creates four problems that algo traders in other markets don't face, and each one demands its own metric.
STT asymmetry destroys options strategies differently. Options STT (0.0625% on sell side) hits you on exercise and on every lot sold. A NIFTY strangle selling 200 lots a week in premium pays roughly ₹8,000–12,000 in STT alone — weekly. That cost doesn't show up in your backtest unless you modelled it explicitly, and most backtesting platforms (Streak, Tradetron, even custom Python) either ignore it or use a flat brokerage approximation.
SEBI's retail algo framework is coming. The January 2024 circular requires API-based algo orders to be tagged and auditable. Whether you're running via Kite Connect, Upstox API, or any other broker API, a documented performance record is not optional — it's going to be a compliance requirement. Building the ledger now means you're ready when the registration framework firms up.
Lot sizes reset your position sizing. You can't trade 0.7 lots of NIFTY. Indian F&O enforces fixed lot sizes (NIFTY 75, BANKNIFTY 30, FINNIFTY 65 as of November 2026), which means every strategy faces discrete rounding. An algo sized at $X per trade gets quantised, and the expected P&L from the backtest (which may use fractional sizing) diverges from reality. Tracking fill size vs intended size, per strategy, is a metric you need.
Expiry-day dynamics are unique. India's weekly expiry cycle — Thursday for NIFTY, Wednesday for BANKNIFTY — creates intraday regimes that don't exist in the same form elsewhere. Gamma risk concentrates in the last 90 minutes, spreads widen, and your algo's slippage spikes. If your analytics don't segment by distance-to-expiry (DTE), they're averaging across two completely different markets.
💡 Already running an algo? Connect your broker to TradeDiary — free, no card — and see backtest vs live side by side in under five minutes.
3. Original data: what the backtest-to-live gap looks like
We examined 28 algo-traded TradeDiary accounts that had at least 30 completed F&O trades each, across Rudra, Kotak, and Zerodha. Every fill was captured directly from the broker API — not from the user's backtest engine — so the numbers are what actually happened.
Backtest-to-live gap components (per-account median, n=28 accounts)
Slippage per fill (₹) ████████████ ₹1.85 (options, MKT orders)
STT + charges, bps of turnover ██████████████████ 18.4 bps
Rejected/partial fills ██ 2.1% of signals
Fills outside signal window ████ 4.7% of fills
The cost column is the one that surprises: 18.4 basis points per account is the median all-in transaction cost (STT + brokerage + exchange fees + GST + stamp). On a ₹1 crore monthly turnover — not uncommon for a 3-strategy options setup — that's ₹18,400 a month in friction alone.
| Metric | Trade-weighted mean | Per-account median |
|---|---|---|
| All-in cost, bps of turnover | 22.1 bps | 18.4 bps |
| Slippage vs signal, options MKT | ₹2.40 | ₹1.85 |
| Slippage vs signal, futures LMT | ₹0.35 | ₹0.20 |
| Fill rate (orders executed / signals) | 96.8% | 97.9% |
| Trades with no exit fill (orphans) | 1.4% | 0.8% |
Two things stand out. First, the per-account median cost is lower than the trade-weighted mean because a handful of accounts with very high lot counts pay more per trade (wider spreads on larger clip sizes). Second, orphan trades — signals that got an entry but no exit — are a real category. 0.8% sounds small until you realise that an unexited position carried overnight on expiry day can produce a loss larger than a week's P&L.
Sample caveat: these are self-selected journal users running broker-API algos on TradeDiary. The broker mix is Rudra-heavy, with Kotak and Zerodha in a minority. The numbers illustrate the gap structure, not the market average.
4. The six metrics that matter
Every algo needs exactly six numbers reviewed daily, in this order. Skip one and the others lose meaning.
| # | Metric | What it answers | Where to find it |
|---|---|---|---|
| 1 | Net expectancy | Does this strategy have an edge after costs? | Expectancy explained |
| 2 | Slippage per fill | How much am I losing between signal and fill? | Slippage analysis |
| 3 | Cost drag | What's STT + brokerage doing to gross returns? | Your contract notes |
| 4 | Max drawdown | What's the worst peak-to-trough I've survived? | Drawdown guide |
| 5 | Fill rate | Are all my signals actually executing? | Your order log vs signal log |
| 6 | Backtest divergence | Is live tracking the model, or drifting? | Backtest vs journal |
If you compute only expectancy and drawdown — and ignore the middle four — you'll know whether you're profitable but not why, and you won't notice when profitability starts to erode until the drawdown tells you it's already gone.
The order matters. Net expectancy depends on cost drag and slippage, which depend on fill rate. Building from the bottom up means each metric is already accurate by the time the next one reads it.
5. Slippage — the first thing your backtest lies about
Slippage is the difference between the price your algo intended to trade at and the price it actually got. For a market order on NIFTY 24000 CE with 50 minutes to expiry, that difference might be ₹0.50. For the same order with 5 minutes to expiry, it could be ₹5.00 — a 10x jump that your backtest, which simulated a fill at the signal candle's close, never modelled.
Measuring slippage requires exactly one thing most algo traders don't have: a log of signal prices alongside fill prices. Your broker gives you the fill. Your strategy engine knows the signal. If those two numbers don't live in the same database, slippage is invisible.
What to track, per fill:
- Signal price — the price your algo saw when it decided to trade
- Fill price — the price the broker actually executed at
- Slip — fill minus signal (positive = unfavourable)
- Time gap — seconds between signal and fill
- Order type — MKT vs LMT (limit orders have zero or negative slip but lower fill rates)
Segment by: strategy, instrument, time-of-day, DTE. The pattern you'll see: slippage is stable most of the day and spikes in the last 30 minutes of expiry sessions. That spike is the cost of gamma — and if your backtest doesn't model it, your backtest is lying.
For the full methodology, read our algo slippage analysis guide.
6. Cost drag — the silent strategy killer
India's transaction cost stack is deeper than most traders realise, and each layer hits a different strategy differently.
| Cost | Rate | Who it hits hardest |
|---|---|---|
| STT (securities transaction tax) | Options sell: 0.0625%. Futures sell: 0.0125%. Equity intraday sell: 0.025% | Options sellers, high-frequency |
| Brokerage | ₹0 (Zerodha/Groww) to ₹20/order (most API brokers) | Scalpers with many small orders |
| Exchange fees | ₹3.22/lakh (NSE F&O) | Volume-proportional, everyone |
| GST | 18% on brokerage + exchange fees | Everyone, but invisible |
| Stamp duty | 0.003% buy side (equity), 0.002% (F&O) | Low-frequency equity delivery |
| SEBI turnover fee | ₹10 per crore | Negligible individually, cumulative |
The correct way to measure cost drag: sum all six for every fill, divide by turnover per strategy per month. Express it in basis points. Compare it against gross return in basis points. If your strategy grosses 40 bps per day and costs 18 bps, your net is 22 bps — and a 10% rise in STT (which has happened twice in the last three Union Budgets) wipes 1.8 bps, or 8% of your net return.
The insight most traders miss: cost drag is not constant. As you scale lot sizes, slippage rises (bigger orders move the book). As you add strategies, brokerage may fall (per-order caps) but STT rises linearly. Net cost per strategy at 10 lots and at 100 lots are different numbers, and your algo needs to know which one it's actually paying.
7. Drawdown by regime — when your edge disappears
Max drawdown tells you the worst your strategy has done. Drawdown by regime tells you when and why it did it — which is the only information you can act on.
A regime, for an Indian F&O algo, is usually one of four states: trending (NIFTY moves > 1.5% intraday), range-bound (< 0.5% intraday range), volatile expiry (weekly expiry with VIX > 18), or gap open (opening move > 0.8% from previous close). Your algo's performance across these four regimes is almost certainly not uniform, and the drawdown is concentrated in one of them.
Track drawdown separately for each regime. When one regime accounts for 80% of total drawdown, you have three options: stop trading that regime, hedge it, or reduce lot size when the regime detector fires. All three require the analytics to exist first.
For the full drawdown methodology, see our drawdown recovery guide and max drawdown explainer.
8. Execution quality — the metric nobody tracks
Execution quality measures whether your orders actually did what they were supposed to. It's not slippage (price), it's not fill rate (quantity) — it's the third axis: did the order behave correctly?
Five things to track:
- Rejection rate — orders rejected by the broker (insufficient margin, frozen scrip, wrong lot size). Target: < 0.5%.
- Partial fills — limit orders that filled 30 of 75 lots. Your algo now has an unintended position size.
- Latency — time from signal to order placement. If your API call takes 800ms when it should take 200ms, you're trading a different price.
- Orphan exits — entry filled but exit never triggered (API crash, connection drop, broker downtime). These are the most dangerous: an unmanaged position has unlimited risk.
- Duplicate orders — your algo fired twice because the acknowledgement was slow. Two entries, one thesis. The second is pure noise.
None of these show up in a backtest. All of them show up in your P&L. The algo that ran clean for six months and then placed a duplicate order at 3:25 PM on expiry day — that's not a bug story, it's a cost story, and it belongs in the performance ledger alongside every other cost.
9. Backtest vs live — the reconciliation that keeps you honest
The single most valuable report an algo trader can run: take a strategy's backtest prediction for the last N trading days and compare it, line by line, against live fills.
| Day | Backtest predicted | Live delivered | Gap | Primary cause |
|---|---|---|---|---|
| Mon | +₹4,200 | +₹2,880 | -₹1,320 | Slippage on MKT orders at open |
| Tue | -₹1,100 | -₹2,450 | -₹1,350 | Partial fill on exit (40/75 lots) |
| Wed | +₹6,800 | +₹5,950 | -₹850 | STT + charges |
| Thu (expiry) | +₹3,500 | -₹1,200 | -₹4,700 | VIX spike, slippage 4x normal |
| Fri | +₹2,100 | +₹1,850 | -₹250 | Normal cost drag |
When you see the same cause appearing repeatedly in the "Primary cause" column — slippage on expiry, STT drag, partial fills — that's not randomness. That's a structural feature of your system, and it's the one thing you can actually fix.
For a deeper treatment, read backtest vs journal: why live results don't match.
10. Walk-forward analysis — the only validation that counts
A backtest optimises on known data. Walk-forward analysis tests on data the model has never seen — and then steps forward, optimises again, tests again, and repeats. It's the only validation that simulates what your algo actually faces in production: an unknown future.
For Indian markets, walk-forward windows should respect two structural features:
- Expiry cycles. NIFTY options expire every Thursday. Your training window should end on a Thursday and your test window should start on the following Monday, so the model doesn't leak expiry-day edge into the training set.
- Budget/SEBI events. The Union Budget (1 February), SEBI board meetings, and RBI policy dates create regime breaks. A window that trains on a pre-Budget rally and tests on a post-Budget sell-off is measuring regime exposure, not strategy quality.
Full methodology: walk-forward analysis for Indian traders.
11. Risk limits and circuit breakers
An algo without a circuit breaker is a car without brakes. It will go fast right up until the moment it can't stop.
Three circuit breakers every algo needs:
- Daily loss limit. When a strategy loses more than X% of deployed capital in a single day, stop placing new orders. The limit should be in absolute rupees, not percentage of P&L — because a percentage of a small P&L is a small number, and "small" stops being small when NIFTY drops 3% in 10 minutes.
- Drawdown halt. When a strategy's peak-to-trough drawdown crosses a threshold (typically 2–3x the backtest's max drawdown), disable it. Not "reduce lots" — disable. A strategy in a drawdown that's 3x its worst backtest drawdown is a strategy whose edge may have disappeared, and continuing to trade it is a bet that the edge will return.
- Execution anomaly halt. When more than 5% of orders in a session are rejected, partially filled, or duplicate — stop. The system has a problem, and more orders won't fix it.
The circuit breaker's job is not to prevent losses. It's to prevent the kind of loss that ends the account. Every drawdown is recoverable — until one isn't.
12. Comparison — how algo analytics stacks against manual review
| Capability | Spreadsheet | Broker console | Algo journal (TradeDiary) |
|---|---|---|---|
| Fill-level P&L | Manual entry | ✓ (delayed) | ✓ (real-time from API) |
| Slippage vs signal price | Not possible | Not available | ✓ (signal + fill paired) |
| Cost breakdown (STT, brokerage, GST) | Manual calc | Partial | ✓ (auto from contract note) |
| Drawdown by regime | Manual, error-prone | Not available | ✓ (regime-tagged) |
| Backtest vs live reconciliation | Copy-paste, fragile | Not possible | ✓ (side-by-side) |
| Circuit breaker alerts | Not possible | Not available | ✓ (configurable limits) |
| Multi-strategy attribution | Multiple sheets | Not possible | ✓ (strategy tags) |
| SEBI audit-ready log | No | Partial | ✓ (immutable, timestamped) |
The spreadsheet works for a trader running one strategy with 5–10 fills a day. It breaks when you run three strategies generating 50+ fills. The broker console gives you the ledger but not the intent. An algo journal bridges the two — it records what the algo meant to do alongside what it actually did.
13. Case studies
Case 1 — the slippage problem nobody measured. A BANKNIFTY straddle seller running on Zerodha's API averaged ₹12,000/day gross. After six months of consistent results, the strategy "stopped working." A TradeDiary review showed gross P&L was unchanged — slippage had risen from ₹1.20/fill to ₹3.50/fill as the trader scaled from 30 to 90 lots. The larger clip size moved the order book, turning 1-point slip into 3.5-point slip. The fix: splitting orders into 30-lot clips with 200ms delay. Slippage dropped to ₹1.80, and the strategy was profitable again — it had never stopped being profitable, it had just been paying an invisible execution tax.
Case 2 — the orphan trade on expiry. An iron condor algo running on three Rudra accounts had clean results for two months. On a Thursday expiry, the API connection dropped for 90 seconds at 3:22 PM — long enough for the entry legs to fill but the exit to miss. The 75-lot short call expired ITM, settling at a ₹1.2L loss against a strategy that averaged ₹3,500/day. One orphan trade wiped five weeks of P&L. The lesson: the performance framework now flags any trade that has an entry but no corresponding exit within the expected timeframe, and the circuit breaker halts the strategy if the exit doesn't confirm within 60 seconds.
Case 3 — the regime that erased the edge. A momentum algo trained on six months of trending data (NIFTY daily range > 1.2%) went live and produced 45% win rate in the first month — close to the backtest's 52%. In month two, VIX dropped below 12 and NIFTY's daily range compressed to 0.4%. The algo kept trading. Win rate fell to 28%, and the month's drawdown exceeded the entire backtest's max drawdown. Regime-tagged analytics would have flagged it on day 4 of the range-bound period; instead, it ran for 19 days. The fix: a regime classifier that reduces lot size to 1 (minimum) when the 5-day ADR drops below 0.6%.
How to build an algo performance framework (6 steps)
-
Log every signal alongside every fill. Before you measure anything, you need pairs: what the algo decided, and what the broker did. Store signal timestamp, signal price, intended quantity, intended side, strategy name. Pair it with the broker's fill price, fill quantity, fill time, order ID. If these live in different databases, join them now.
-
Compute slippage and cost per fill. For every fill, calculate: slip = fill price − signal price (signed). Cost = STT + brokerage + exchange fee + GST + stamp. Express both in rupees and in basis points of notional. Aggregate by strategy, instrument, and day.
-
Build the backtest-vs-live reconciliation. Take your strategy's predicted daily P&L (from whatever backtesting engine you use) and compare it against actual daily P&L net of costs. Track the cumulative gap. When it widens, the cause is in steps 1 and 2 — go find it.
-
Add drawdown tracking with regime tags. Compute peak-to-trough drawdown in real time. Tag each day with its regime (trending, range-bound, volatile expiry, gap open). When drawdown deepens, check which regime is driving it.
-
Set circuit breakers. Daily loss limit in rupees (not percentage). Drawdown halt at 2–3x backtest max drawdown. Execution anomaly halt at > 5% rejected/duplicate orders in a session. Wire these into your order manager so they actually stop orders, not just send an email.
-
Review weekly, not daily. A daily review of an algo is noise. A weekly review — with slippage trending, cost drag stable or rising, backtest divergence narrowing or widening, and drawdown by regime — is signal. Run it every Sunday evening, before the market opens Monday. Make it a calendar event, not a "when I remember" habit.
Frequently asked questions
How is algo trading analytics different from regular trading analytics? Regular analytics measures whether your trades made money. Algo analytics measures whether your system performed as specified — which includes execution quality, slippage, and backtest divergence that don't exist for discretionary traders.
What's a good slippage target for options algos in India? For NIFTY/BANKNIFTY options with market orders: under ₹2 per fill at clip sizes under 50 lots. Above 50 lots, expect ₹2.50–4.00 depending on strike liquidity and time to expiry. Expiry-day last hour: add 50–100% to these numbers.
Does TradeDiary work with algo trading strategies? Yes. TradeDiary syncs fills from your broker's API (Zerodha, Kotak, Rudra, MOSL and others), pairs them with your strategy tags, and computes slippage, cost drag, drawdown and expectancy per strategy — without needing access to your algo's source code.
How often should I review algo performance? Weekly for the strategy-level review (slippage, cost, drawdown, backtest divergence). Daily for circuit breaker status and execution anomalies. Monthly for the regime analysis and walk-forward validation.
What's the minimum data needed to judge an algo strategy? At least 30 completed trades per strategy, spread across at least two market regimes. Fewer than 30 trades and win rate has a confidence interval wider than 20 percentage points — it could be anywhere. Fewer than two regimes and you're measuring a weather report, not a climate.
How do I measure cost drag on options strategies? Sum STT (0.0625% on sell side), brokerage, exchange fees (₹3.22/lakh), GST (18% on brokerage + exchange), stamp duty, and SEBI fees for every fill. Divide total cost by total premium collected (for sellers) or total premium paid (for buyers). Express in basis points. Compare across months.
What's a good fill rate for an algo trading system? Above 97% for market orders. Above 85% for limit orders (the remainder are expected to miss). Below 95% on market orders means your API integration has a problem — rejected orders, connection timeouts, or margin shortfalls.
Should I use the same metrics for intraday and positional algos? The same six metrics apply, but the benchmarks differ. Intraday algos should measure slippage per fill; positional algos should emphasise cost drag per hold (because STT is paid once, not per day). Drawdown windows also differ: intraday drawdown resets each day; positional drawdown is continuous.
How does SEBI's algo trading framework affect performance tracking? SEBI's January 2024 circular requires API-based algo orders to be tagged and auditable. A timestamped, per-fill performance log — with strategy tags, signal prices, and cost breakdowns — satisfies the spirit of the requirement and positions you for the formal registration framework when it launches.
Can I use walk-forward analysis on Indian weekly options? Yes, and you should. Use Thursday-to-Thursday windows (NIFTY expiry cycle) for training, test on the following week. A minimum training window of 8 weeks (8 expiry cycles) gives enough data for stable parameter estimates. For BANKNIFTY (Wednesday expiry), shift the window accordingly.
Risk disclaimer
F&O trading in India carries substantial risk. SEBI's January 2024 study found that 9 out of 10 individual F&O traders lost money over the three-year period studied — and algo traders are not exempt from this statistic. Automated execution does not guarantee profitable outcomes. Past backtest performance does not predict future live results. The cost figures, slippage numbers and fill rates in this guide are based on a small sample of self-selected TradeDiary users and are presented as illustrations, not as market-wide benchmarks. Consult a SEBI-registered investment adviser before deploying capital to any algo strategy.
Pulkit Mangal is an equity + F&O trader since 2017, based in Raipur, and the founder of TradeDiary — a trading journal and analytics platform for Indian traders. Connect on LinkedIn.
Last updated: 1 November 2026.