The idea behind no-code design is old. Traders have always written rules down; the change is that a screen of choices now turns those rules into orders. What has not changed is the hard part: deciding, before the market opens, exactly what the strategy does in every case, including the cases you would rather not think about. A builder asks the questions. This guide is about answering them well, with a worked short straddle, a worked indicator strategy on Nifty futures, the six parts every strategy needs, and the way each part maps to QuantPower's own screens.
What a no-code strategy is made of
| Part | What you decide | A typical choice |
|---|---|---|
| Instrument | Underlying, product, expiry rule, strike rule | Nifty, current weekly expiry, at the money |
| Entry | Time, condition or breakout, and on which days | 9:20 am on expiry day only |
| Size | Fixed lots, or lots worked out from a rupee risk | 1 lot, with a quantity multiplier for later |
| Exits per leg | Stop loss, target, trailing step, what a hit does | Stop at 25% of the leg's entry price |
| Exits for the whole strategy | Exit time, rupee target and stop, lock-and-trail | Exit at 3:10 pm; stop the strategy at a ₹3,000 loss |
| Account limits | Rules above every strategy | Daily loss limit, kill switch, Smart Exit |
| Execution | Order type, leg order, what happens on a rejection | Buy legs first, limit orders with a buffer |
Every row is a decision. A builder that offers a default for a row has made the decision for you, which is fine only if you have read the default.
A short history of no-code trading
For most of the twentieth century, a trading rule lived in a notebook and was executed by a person reading a chart. The first change came with charting software for personal computers in the 1980s, when packages such as MetaStock let traders plot indicators and scan for conditions without writing a program. In the late 1980s and early 1990s, platforms such as TradeStation added simplified rule languages, which read almost like English, so that a trader could backtest a rule on years of data in an evening.1 These were not no-code tools in today's sense, because the rule still had to be typed in a language, but they moved strategy design from the programmer's desk to the trader's.
In India, the order path was the barrier for longer. Until brokers opened trading APIs in the 2010s, automating a strategy meant working through a broker's own systems or a direct market access arrangement, which SEBI first allowed for institutional clients in 2008.2 When brokers began offering APIs to retail clients, a wave of platforms appeared that let traders build strategies by choosing from menus: an index, a strike, a time, a stop. Zerodha's Streak, built around indicator conditions, and several options-focused builders made rule-based trading available to traders who had never written a line of code.3
The latest change is regulatory. SEBI's circular of 4 February 2025 on safer participation of retail investors in algorithmic trading brought every retail algo under a broker's responsibility, required algos offered to retail traders to be registered with the exchange, and tied API access to a registered static IP. The framework applies to every broker from 1 April 2026.4 A no-code builder now sits inside that framework: the rules you design are the rules that run, through your broker, under the exchange's checks.
From idea to rules
Most trading ideas start as a sentence: "sell a straddle at 9:20 on expiry day and exit at a 25% loss on either leg." A builder needs every term defined.
| Idea | Questions the builder will ask | Precise rule |
|---|---|---|
| Sell a straddle | Which index? Which expiry? Which strike? How many lots? | Nifty, current weekly expiry, ATM strike nearest to the index price, 1 lot each leg |
| At 9:20 | Every day or some days? | Entry at 9:20 am on expiry day only |
| Exit at a 25% loss on either leg | Of the premium received, or of the combined premium? Per leg or combined? | Per leg: buy back a leg when its price reaches 125% of its entry price |
| And then? | What happens to the other leg? When does the trade end? | Keep the other leg with its own stop; square off everything at 3:10 pm |
Each answer is a decision that changes the results. Writing the rules out in full before opening the builder is the single most useful step, and it takes less time than most traders expect: a page of plain sentences, one per rule, is enough.
Three tests for a rule
A rule is ready for a builder when it passes three tests:
- Two people would build it the same way. If a colleague reading your rule could choose a different strike, a different stop basis or a different exit time, the rule is not finished.
- It uses only information known at the time. "Enter at the day's low" cannot be traded, because the day's low is known only at the close. Conditions on closed candles pass this test; conditions on the candle still forming usually do not. Our guide to look ahead bias covers the trap.
- It says what happens when something goes wrong. A leg is rejected, the broker session ends, the market gaps through a stop. A rule that is silent about these cases leaves them to the builder's defaults.
The six parts of every strategy
A complete strategy in any builder has six parts. If one is missing, the builder fills it with a default that may not be what you want.
1. Instrument and contract selection
The underlying (Nifty, Bank Nifty, Sensex, a stock, a commodity), the product (futures, options, equity), the expiry rule and, for options, the strike selection. A strike can be chosen in several ways, and the choice changes how the strategy behaves when volatility changes:
| Strike rule | What it picks | How it behaves |
|---|---|---|
| At the money | The strike nearest the index price | Moves with the market, same distance every day |
| n strikes in or out of the money | A fixed number of strikes away | Same distance in strikes, different in rupees as premiums change |
| By premium | The strike whose price is nearest a value | Moves further out on volatile days, closer on quiet ones |
| By delta | The strike whose delta is nearest a value | Keeps the probability of finishing in the money roughly constant |
| By straddle width | The ATM strike plus a multiple of the straddle price | Sets distance by what the market is pricing as the expected move |
A rule by premium or delta adapts to volatility; a rule by points does not. Neither is right in general. The point is to choose on purpose.
2. Entry conditions
A time, an indicator condition, a price level, or a combination. Conditions should be evaluated on closed candles, with a stated timeframe: "15-minute close above the 20 EMA" is precise; "price above the 20 EMA" is not. Add the days the strategy trades, a window in which entries are allowed, and a limit on the number of entries per day.
Three entry styles cover most option strategies:
- At a time. Every leg enters at, say, 9:20 am.
- Wait and trade. Each leg waits from the entry time until its premium or the underlying moves by a set amount, then enters. A straddle seller might wait for a leg to rise 10% before selling it, to avoid selling into a fast open.
- Opening range breakout. The strategy reads the high and low of the first 15 or 30 minutes and enters on the first price beyond either.
3. Position size
Fixed lots, or lots calculated from a rupee risk per trade and the stop distance. Builders that only support fixed lots need the size recalculated when the account or volatility changes. Since lot sizes in India were revised several times in 2024 and 2025, a rule written in lots should be checked against the current lot size: a Nifty lot is 65 units, a Bank Nifty lot 30 and a Sensex lot 20 at the time of writing.
4. Exit conditions
A stop loss, a target, a trailing rule, a time exit, or a condition such as an indicator crossing back. Specify what each is measured against: the underlying's price, the option's premium or the position's combined profit and loss. Specify what happens to other legs when one exits. Always include a time exit, so that no position is left to the broker's square-off.
| Exit | Measured on | Common setting |
|---|---|---|
| Leg stop loss | The leg's premium, from its entry price | 25% to 50% for sold options |
| Leg target | The leg's premium | 50% to 80% decay for sold options |
| Trailing stop | Moves the stop as the leg gains | For every 10 points in favour, move the stop 5 |
| Stop to cost | Moves a leg's stop to its entry price | After the leg is 30% in profit, or after another leg stops out |
| Strategy stop | The combined rupee profit and loss | A fixed rupee amount per lot |
| Lock and trail | The combined profit | Once up ₹2,000, lock ₹1,000; raise the lock ₹500 for every ₹1,000 more |
| Time exit | The clock | 3:10 pm, before the broker's square-off |
5. Risk limits
A maximum loss per day for the strategy, a maximum number of trades, and account-level limits that override every strategy. These are the rules that keep a bad day from becoming a bad month. An account-level limit matters most when several strategies run at once: each can have a reasonable stop while their combined loss for the day does not.
6. Execution settings
Order type (limit with a buffer rather than market for entries), the sequence for multi-leg entries (buy the hedge legs first, so that a sold option is never left without its hedge), re-entry rules after a stop, and what to do if a leg is rejected. Exits are usually best as market orders that can only reduce the position, so that an exit is never left unfilled at a limit price while the market runs.
Design principles
- One idea per strategy. A strategy that sells straddles on expiry day and also trades breakouts on other days is two strategies; build them separately so that each can be tested and judged.
- Few parameters. Every adjustable number is a chance to overfit. Prefer standard indicator settings and round numbers until a test shows otherwise.
- Rules that do not depend on hindsight. Entries on closed candles; levels known before the candle that tests them.
- Consistent units. If a stop is 25% of premium, decide the target the same way. Mixed units hide the real risk and reward.
- An exit for every entry. Including a time exit and a what-if-rejected rule.
- Defaults checked. Read every default the builder applies: product type, order validity, exit time, monitoring frequency, slippage assumption.
- Visible rules. A strategy whose logic you cannot read is one you cannot fix. Prefer builders, templates and samples that show every rule.
Worked example 1: an expiry-day short straddle
| Part | Rule |
|---|---|
| Instrument | Nifty, current weekly expiry, ATM strike nearest to the index price |
| Entry | 9:20 am on expiry day; sell 1 lot call and 1 lot put |
| Size | 1 lot each leg; increase only after a month that matches the backtest |
| Stop | Per leg: buy back when the premium reaches 125% of entry; the other leg's stop then moves to its entry price |
| Target | Combined: exit both legs when the combined premium has fallen to 50% of entry |
| Time exit | 3:10 pm, both legs |
| Daily limit | The strategy stops for the day after both legs have stopped out once |
| Account limit | A daily loss limit and Smart Exit set across every strategy |
| Execution | Sell orders as limit orders with a small buffer; exits as market orders that only reduce |
Now put numbers on it. Suppose at 9:20 am the 25,000 call trades at ₹92 and the 25,000 put at ₹88, and you sell one lot of each (65 units).
| Item | Working | Amount |
|---|---|---|
| Premium collected | (92 + 88) × 65 | ₹11,700 |
| Call stop | 92 × 1.25 = ₹115 | Loss of 23 × 65 = ₹1,495 if hit |
| Put stop | 88 × 1.25 = ₹110 | Loss of 22 × 65 = ₹1,430 if hit |
| Combined target | Premium falls to ₹90 in total | Profit of 90 × 65 = ₹5,850 before charges |
| Brokerage | 4 orders at ₹20 | ₹80, before statutory charges |
The worst case for the rules is not both stops: it is one stop followed by the other leg reversing to its own stop, which here costs about ₹2,925 before charges. Writing the figures down shows whether that worst case fits the account. The short straddle and expiry day strategy guides cover the trading logic.
Worked example 2: an indicator rule on Nifty futures
The second kind of strategy is an indicator rule. Take this idea: "buy Nifty futures when the trend turns up, and get out when it turns down."
| Part | Rule |
|---|---|
| Instrument | Nifty futures, current month |
| Timeframe | 15-minute candles, conditions read at the close of each candle |
| Entry | EMA 20 crosses above EMA 50, and RSI 14 is above 50 |
| Window | Between 9:45 am and 2:30 pm only |
| Size | 1 lot |
| Stop | 0.5% below the entry price |
| Target | 1% above the entry price |
| Exit rule | EMA 20 crosses back below EMA 50 |
| Time exit | 3:15 pm |
| Daily limit | At most two entries a day |
At an entry of 25,000, the stop is 125 points away (₹8,125 on a lot of 65) and the target 250 points (₹16,250). If you cannot accept an ₹8,125 loss on one trade, the rule needs a closer stop or a smaller instrument, and it is better to find that out on paper than in the market.
Both examples follow the same pattern: write the rule, put rupee figures on it, check the worst case, then build it.
Testing the design
- Backtest with costs and slippage, and read the trade list, not just the summary. Check that the first ten trades did what the rules say. Our backtesting page explains what QuantPower's engine tests.
- Vary one parameter at a time and confirm that neighbouring values give similar results. If a 25% stop works and 30% fails, the result is fragile.
- Forward test for two to four weeks on live prices, and compare each signal and fill with what the backtest would have shown. A forward test meets the real spread and the real broker session, which a backtest does not.
- Go live small with an account-level loss limit in place, then scale.
Where no-code designs fail
- Missing rules. The builder's default exit time, not yours, closes the position.
- Ambiguous stops. A "25% stop" set on the combined premium when the trader meant per leg, or the reverse.
- Unmanaged legs. One leg stops out and the other runs with no revised stop.
- Fixed sizes. The same five lots in a quiet month and a volatile one.
- No daily limit. A strategy re-enters after every stop and loses five times on a trending day.
- Tuned parameters. Settings chosen because they fit last quarter.
- Wrong monitoring. Stops checked once per 15-minute candle when the strategy needs them checked on every tick, or the reverse for a strategy that should not react to a single wick.
- Stale contracts. A leg fixed to one strike and expiry stops working when that contract expires; a rule leg that picks a fresh strike at each entry keeps running.
If an idea cannot be expressed in the builder, consider whether it is precise enough yet. Ideas that are precise and still cannot be built are the case for code; see no code vs coded strategies.
Designing for the bad cases
The cases a design forgets are the ones that cost the most, because they happen on the days the market is moving. Decide each of these before the strategy goes live:
| Situation | A design that handles it |
|---|---|
| One leg of a two-leg entry is rejected | Close the leg that filled at once and stop the strategy for the day, rather than holding half a structure |
| The broker session has ended before the entry time | Do not enter; sign in again before the next entry time. A good platform refuses the entry and says why |
| Prices or Greeks needed for a strike rule are missing | Wait and say why, rather than picking a strike on a guess |
| An exit order is refused | Try again, with a short gap between tries, and show what is still owed |
| The market gaps through a stop | Exit at the next available price; size the position so that a gap of twice the stop is survivable |
| The strategy is stopped by hand while it holds positions | Decide in advance: square off, or keep the positions and manage them yourself without the strategy's stops |
| The account limit is hit while the strategy is in a trade | The account rule wins: positions are squared off and the strategy stops for the day |
Writing these down is also the fastest way to understand a builder. Every row is a question you can put to the platform: what does it do when this happens? If the answer is "nothing", the rule is yours to add.
How to design well: a routine
- Write the idea in one sentence. If it needs two, it is two strategies.
- Write the six parts as plain sentences.
- Put rupee figures on the worst case at your intended size.
- Read every default in the builder before saving.
- Save it switched off. Nothing should trade until the tests are done.
- Backtest, then forward test, and keep notes of what you changed and why.
- Switch it on small, with account limits above it.
- Review monthly, not after every bad day. Change rules at the review, not in the middle of a drawdown.
Building it in QuantPower
QuantPower's Algos screen has four tabs: Option bots, Signal algos, Webhooks and M2M. Each part of a design maps to a setting:5
| Part | Where it is set |
|---|---|
| Instrument and strikes | Option bots: legs on an index option chain, or contracts by search (futures, stocks, stock options, commodity and currency). A rule leg picks its strike at each entry: ATM, ITM or OTM by 1 to 20 strikes, by premium, by delta, theta, gamma or vega, by straddle width or by % from ATM |
| Entry | At the time, wait and trade, or opening range breakout (1 to 180 minutes); entry and exit times in IST; the days to trade |
| Size | Lots per leg and a quantity multiplier from 1 to 50 that scales every leg and every rupee limit |
| Exits per leg | Target and stop loss in points, %, underlying points or %, or by Greek; trailing; stop to cost; exit the leg or all legs on a hit; re-enter or reverse up to 20 times a day |
| Exits for the strategy | Exit time, rupee or % target and stop, net delta or theta band, lock profit and trail |
| Execution | Buy legs first; market, limit with a buffer, stop-limit, or modify until filled; exits are market orders that only reduce |
| Indicator rules | Signal algos: up to 20 conditions in ALL and ANY groups on chart indicators, candle patterns and chart patterns, checked on closed candles from 1 minute to 1 week |
| Account limits | M2M tab: Smart Exit for the whole account, the daily loss limit and the kill switch |
Templates such as Short Straddle, Iron Condor and Bull Call Spread are open samples: once loaded, the algo is your own and every rule is visible and can be changed. They are available to every user. If an indicator you need is not on the chart, you can write it with Arth Script and use it in rules, backtests and Forward tests. You can also describe the strategy in words and let Quanty build it for you to check; Quanty saves it switched off and cannot switch it on.
A new algo is off. When you switch it on, live or in Forward test, the app checks that a broker is connected and signed in for a live algo, that the kill switch and daily loss limit allow an entry, that no fixed leg has expired, and that the wallet covers the tokens. If a check fails, the algo stays off, you are told why, and no tokens are taken. Up to 20 algos can run at a time, each with up to 6 legs. Our option strategy builder page covers the payoff screen, where "Run as algo" turns legs into an algo.
What it costs
QuantPower is priced in tokens (1 token = ₹1, GST extra). Building a strategy, the option chain, the charts and the payoff screen are free. A backtest costs 2 tokens, with the first 10 each week free. A Forward test costs 100 tokens per algo per 28 days, and a live algo 200 tokens per 28 days, with orders unlimited inside it. A signal that places its own order costs no tokens. New accounts get free sign-up tokens.
Where no-code design is going
Two changes are under way. The first is AI: assistants that write a strategy from a sentence make the first draft fast, which moves the work to reading and checking the rules, so builders that show every rule plainly matter more, not less. The second is regulation: since 1 April 2026, retail algos in India run through brokers under exchange rules, with each strategy registered and tagged.4 A strategy designed as a complete, readable set of rules is easier to run, review and explain under that framework than one whose behaviour depends on unread defaults.
Start with 500 free tokens
Connect your broker, build a strategy and test it on paper before a single live order goes out.
Frequently asked questions
What is a no-code trading strategy?
A set of trading rules entered in a visual builder, which the platform then runs automatically, without the trader writing code.
How do I design a trading strategy without coding?
Write the rules in full first: instrument, entry, size, exits, risk limits and execution. Then enter them in the builder, backtest, forward test and go live small.
What is the most common mistake in no-code strategies?
Leaving a rule undefined, so the builder's default applies. Exit times and the basis of a stop loss are the usual ones.
Should a strike be chosen by points, premium or delta?
It depends on what you want to keep constant. Points keep the distance constant; premium and delta keep the risk roughly constant as volatility changes. Test the choice rather than assuming one is better.
How do I write a rule an algo cannot misread?
Name the timeframe, use closed candles, state what each stop is measured on, and say what happens when a leg is rejected or the session ends. If two people would build it differently, it is not finished.
How long does it take to build a strategy?
Minutes to enter once the rules are written. Writing and testing them properly takes days to weeks.
Related guides
- No-code vs coded strategies: when a builder is enough and when code is needed
- Prebuilt vs custom strategies: starting from a template or from your own rules
- Trading automation checklist: what to confirm before the first live order
References
- Perry J. Kaufman, *Trading Systems and Methods*, 6th edition (Wiley, 2019), on the development of systematic trading software and rule languages
- SEBI, circular on direct market access, 3 April 2008 (sebi.gov.in)
- Zerodha, "Introducing Streak v4" (zerodha.com), checked 12 November 2026
- SEBI, circular on safer participation of retail investors in algorithmic trading, 4 February 2025, in force for every broker from 1 April 2026 (sebi.gov.in)
- QuantPower: algo builder, signal algos, limits and prices, from the app's code and price list, checked 12 November 2026