An option strategy builder lets you define a multi-leg options strategy as a set of explicit rules, without writing code, so an engine can execute it exactly as specified. You describe the structure and the conditions; the engine does the rest, the same way, every day.
This guide covers what you actually control, what the builder cannot express, and how to go from an idea to something running.
Why a builder instead of code
Writing a trading bot in code means handling market data, broker authentication, order routing, retries, partial fills, position reconciliation and scheduling — before you get to the part that is actually your idea. Most of that work is identical for every strategy and none of it is where your edge lives.
A builder removes that layer. What remains is the specification: which legs, which strikes, when to enter, when to exit, and what protects each position. The trade is expressiveness — you get a structured vocabulary rather than a general-purpose language.
The anatomy of a strategy
Every strategy in the builder is made of the same parts. Understanding them is most of the learning curve.
1. The underlying
Which index the strategy trades. On Arthalab that is NIFTY or SENSEX index options, on NSE and BSE respectively. The choice affects expiry schedule, lot size and liquidity, so it is not merely cosmetic — a strategy tuned on one does not automatically transfer to the other.
2. The legs
A leg is one option position. A strategy has one or more. For each leg you set:
| Setting | What it controls | Typical values |
|---|---|---|
| Position | Whether you buy or sell this leg | Buy, Sell |
| Option type | Call or put | CE, PE |
| Lots | Size of this leg | 1 or more |
| Expiry | Which expiry series | Weekly, next weekly, monthly |
| Strike criteria | How the strike is chosen | See below |
A short straddle is two legs: sell one call and sell one put, both at the same strike. An iron condor is four. The builder does not care how many — it cares that each one is specified completely.
3. Strike selection, which is where the subtlety is
You do not hardcode a strike number. If you did, the strategy would be useless the moment the index moved. Instead you specify a rule that picks a strike at execution time.
| Criteria | How it chooses | When it suits |
|---|---|---|
| ATM strike offset | The at-the-money strike, optionally stepped n strikes away | Structures anchored to the current level |
| Closest premium | The strike whose premium is nearest a target value | Keeping premium collected roughly constant |
| Premium less than | The nearest strike under a premium ceiling | Capping cost on a buy leg |
| Premium greater than | The nearest strike above a premium floor | Ensuring a sell leg is worth selling |
| ATM straddle premium | A strike set as a percentage of the ATM straddle premium | Width that adapts to volatility |
4. Entry and exit times
Intraday index option strategies are usually time-anchored. You set the time legs are placed and the time everything is squared off. At the exit time, open positions are closed regardless of P&L.
A hard exit time is a feature, not a limitation. It guarantees the strategy is flat before the close rather than carrying an unintended overnight position — which, for a short options strategy, is a meaningfully different risk.
Risk rules, per leg and per strategy
This is the half of the builder people underuse, and it matters more than the structure. A mediocre structure with disciplined risk rules will usually outlast a clever structure without them.
Per-leg rules
- Stop loss — close this leg at a loss threshold, expressed in points, percent, or against the underlying's movement.
- Target — close this leg at a profit threshold.
- Trailing stop loss — move the stop in your favour as the leg gains, locking in progress.
- Re-entry — after a stop or target fires, re-enter under defined conditions rather than sitting out the rest of the day.
Strategy-wide rules
- Max profit — close everything once combined profit reaches a level.
- Max loss — close everything once combined loss reaches a level. This is the one that protects the account.
- MTM rules — lock in profit once a threshold is hit, and trail the locked level as profit grows.
- Square off all legs on a leg stop — when one leg stops out, close the rest rather than holding a now-unbalanced structure.
Which days it runs
Index option behaviour is not uniform across the week. Expiry day behaves differently from the day after a new series opens, and many strategies are explicitly built for one part of that cycle.
The builder lets you restrict a strategy to specific days, and the scheduler can auto-start live bots on chosen days relative to expiry. A strategy designed for expiry day should not be running on every other day simply because nobody switched it off.
What the builder cannot do
An honest list, because discovering these after signing up is worse than reading them now.
- Instruments other than NIFTY and SENSEX index options. No equities, no commodities, no crypto.
- Arbitrary conditional logic. Chains like "if X then watch Y and trade Z unless W" are outside a structured vocabulary.
- Cross-instrument strategies. Reacting to one instrument and trading another is not expressible.
- Discretionary rules. Anything requiring judgement at execution time cannot be automated, by definition.
- Indicator scans across a universe. There is no universe here — there are two indices.
If your strategy needs any of these, a more flexible platform is the right call. The Tradetron comparison covers that trade-off directly, and the Streak comparison covers the indicator-driven case.
From idea to running
1
Write the strategy in plain English first
If you cannot state it unambiguously in a sentence or two, it is not yet a rule set and cannot be automated honestly.
2
Build the legs
Position, option type, lots, expiry and strike criteria for each.
3
Set entry and exit times
Then the per-leg stop loss, target and trailing stop.
4
Set the strategy-wide max loss
Do this before backtesting, not after. Choosing it once you have seen the results is how curve fitting starts.
5
Backtest it
Run it against historical data and read the drawdown before the profit.
6
Nudge one parameter and re-run
A robust strategy degrades gently. One that collapses was fitted to noise.
7
Paper trade for at least two expiry cycles
Paper trading needs no broker, no IP and no capital.
8
Go live at minimum size
One lot for a few weeks. The point of that period is measuring your real execution cost, not profit.
Three structures, built
The fastest way to understand the builder is to see how familiar strategies map onto it.
| Strategy | Legs | Typical strike rule | Main risk setting |
|---|---|---|---|
| Short straddle | Sell 1 CE, sell 1 PE | ATM for both | Per-leg stop loss, square off all on a leg stop |
| Short strangle | Sell 1 CE, sell 1 PE | Closest premium, or ATM offset either side | Per-leg stop loss, strategy max loss |
| Iron condor | Sell 1 CE + 1 PE, buy 1 CE + 1 PE further out | ATM offset for inner, wider offset for outer | Defined by structure; max loss still worth setting |
The pattern is the same each time: decide the legs, decide how strikes are chosen relative to the index rather than as fixed numbers, then decide what protects you. The third part is where most of the difference between a strategy that survives and one that does not actually lives.
Why defined risk is not automatic
An iron condor has a defined maximum loss by construction, which is why people treat it as the safe option. That is true of the structure and not of the deployment — a condor whose outer legs fail to fill is not a condor, and the strategy-wide max loss is what catches that.
Buckets, when you run more than one
Once you have several strategies, managing them individually becomes the bottleneck. A bucket groups strategies so you can deploy, start and backtest them together.
Worth knowing before you build a large one: a bucket backtest costs one backtest credit per active strategy inside it. A bucket of four uses four of your ten daily credits.
What a bucket does not change
Buckets do not change the running-strategy limit. Three simultaneous strategies is three whether they sit in a bucket or not, and paper bots count towards the same number.
Testing a strategy before you trust it
The builder makes it easy to produce strategies quickly, which creates its own hazard: a folder of twelve untested ideas is worse than one tested one.
1
Backtest over a long, varied period
Read the max drawdown before the profit, and convert it to rupees at your intended size.
2
Run the fragility check
Change the stop loss or entry time slightly. Results should degrade gently, not collapse.
3
Backtest a second, non-overlapping period
Two reports that look like siblings suggest robustness. Two that look like different strategies suggest fitting.
4
Paper trade for at least two expiry cycles
This catches logic errors a backtest cannot, because it runs forward in real time.
5
Go live at one lot
Measure slippage and peak margin before scaling.
Each step rejects a different class of bad strategy. Skipping steps does not save time — it moves the rejection to a stage where it costs money instead of credits.
Common mistakes
| Mistake | Why it hurts | Instead |
|---|---|---|
| No strategy-wide max loss | One bad day can undo months | Set it before backtesting |
| Stop loss tuned until backtest looks good | Fits noise, fails live | Pick a defensible value, then test |
| Hardcoded thinking about strikes | Breaks as the index moves | Use a selection rule, not a level |
| Ignoring what happens when a leg stops | Leaves an unintended structure | Decide the square-off rule explicitly |
| Running an expiry-day strategy every day | Trades conditions it was not built for | Restrict the days it runs |
| Going live straight from a backtest | Skips the step that catches logic errors | Paper trade first |
The last row is the most common and the most expensive. A backtest earns a strategy the right to be paper traded, not the right to be funded — and the gap between the two is where most surprises live.
Editing a strategy that is already running
Changes apply to the strategy definition. A running bot executes the configuration it was deployed with, so a live bot does not pick up an edit mid-session.
The safe sequence is: stop the bot, apply the change, start it again. Deploying and starting are separate actions, and knowing which state a bot is in is the first thing to check whenever behaviour surprises you.
The short version
A builder trades expressiveness for speed, and that trade is the whole decision.
- Strike selection is a rule evaluated at execution, never a fixed number
- The risk settings matter more on a bad day than the structure does
- Decide what happens when one leg stops out, before you deploy
- Restrict a strategy to the days it was designed for
- A running bot executes the configuration it was deployed with, not your latest edit
If your idea needs an instrument other than NIFTY or SENSEX index options, or logic a structured vocabulary cannot express, a more flexible platform is the right call.
Frequently asked questions
Two legs: sell one call and sell one put, both with an ATM strike rule, same expiry. Then set the entry and exit times, a per-leg stop loss, and decide whether one leg stopping should close the other.
The strategy-wide max loss, and the rule deciding what happens when one leg stops out. Both matter more on a bad day than any part of the structure itself.
You would build it twice, once per index. They have different expiry schedules, lot sizes and liquidity, so a strategy tuned on one does not automatically transfer.
No. You define the legs, strike selection rules, timings and risk rules through the interface, and the engine executes exactly that.
The index, each leg's side, option type, lots, expiry and strike selection rule, entry and exit times, per-leg stop loss, target and trailing stop loss, strategy-wide max profit and max loss, MTM rules, re-entry rules, and which days it runs.
You set a rule rather than a fixed strike. The rule is evaluated at execution time, so it picks an appropriate strike for wherever the index actually is.
That depends on how you configured it. The leg can close on its own, or you can set the strategy to square off every leg when one stops. The second option avoids holding a structure whose risk profile has changed.
Not on Arthalab. It supports NIFTY and SENSEX index options on NSE and BSE only.
Three simultaneously on the Monthly Plan. You can deploy more than that — the limit is on how many run at the same time, and paper bots count towards it.
Dashboard, then Strategy Hub, then Option Strategy Builder.
Changes apply to the strategy definition, but a running bot executes the configuration it was deployed with. Stop it, apply the change, and start it again rather than expecting a live bot to pick up an edit mid-session.
Start with a free 3-day trial
Build a strategy, backtest it and run it on paper — no broker, no IP and no money needed to try it.
