Register
Learn guide

Design Trading Rules Without Writing Code

A no-code strategy builder turns trading rules into an automated strategy without programming. The quality of the result depends on the rules, not the tool: a vague idea produces a strategy that does something different from what you meant. This guide shows how to turn a trading idea into precise rules, structure them in a builder, test them and avoid the design errors that cause most failures.

QuantPower Research · Updated 15 Nov 2026 · 18 min read

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

PartWhat you decideA typical choice
InstrumentUnderlying, product, expiry rule, strike ruleNifty, current weekly expiry, at the money
EntryTime, condition or breakout, and on which days9:20 am on expiry day only
SizeFixed lots, or lots worked out from a rupee risk1 lot, with a quantity multiplier for later
Exits per legStop loss, target, trailing step, what a hit doesStop at 25% of the leg's entry price
Exits for the whole strategyExit time, rupee target and stop, lock-and-trailExit at 3:10 pm; stop the strategy at a ₹3,000 loss
Account limitsRules above every strategyDaily loss limit, kill switch, Smart Exit
ExecutionOrder type, leg order, what happens on a rejectionBuy 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.

IdeaQuestions the builder will askPrecise rule
Sell a straddleWhich 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:20Every day or some days?Entry at 9:20 am on expiry day only
Exit at a 25% loss on either legOf 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:

  1. 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.
  2. 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.
  3. 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 ruleWhat it picksHow it behaves
At the moneyThe strike nearest the index priceMoves with the market, same distance every day
n strikes in or out of the moneyA fixed number of strikes awaySame distance in strikes, different in rupees as premiums change
By premiumThe strike whose price is nearest a valueMoves further out on volatile days, closer on quiet ones
By deltaThe strike whose delta is nearest a valueKeeps the probability of finishing in the money roughly constant
By straddle widthThe ATM strike plus a multiple of the straddle priceSets 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.

Example
You are willing to lose ₹3,000 on a Nifty futures trade with a 60-point stop. One lot of 65 units risks 60 × 65 = ₹3,900, which is more than your limit. The rule "risk ₹3,000 a trade" therefore cannot be met with a 60-point stop on one lot: either the stop moves closer, to 46 points (₹2,990), or the trade is skipped. Writing the size rule down is what surfaces this.

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.

ExitMeasured onCommon setting
Leg stop lossThe leg's premium, from its entry price25% to 50% for sold options
Leg targetThe leg's premium50% to 80% decay for sold options
Trailing stopMoves the stop as the leg gainsFor every 10 points in favour, move the stop 5
Stop to costMoves a leg's stop to its entry priceAfter the leg is 30% in profit, or after another leg stops out
Strategy stopThe combined rupee profit and lossA fixed rupee amount per lot
Lock and trailThe combined profitOnce up ₹2,000, lock ₹1,000; raise the lock ₹500 for every ₹1,000 more
Time exitThe clock3: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

The six parts of a strategy, each filled in for the expiry-day short straddle (illustration)

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

PartRule
InstrumentNifty, current weekly expiry, ATM strike nearest to the index price
Entry9:20 am on expiry day; sell 1 lot call and 1 lot put
Size1 lot each leg; increase only after a month that matches the backtest
StopPer leg: buy back when the premium reaches 125% of entry; the other leg's stop then moves to its entry price
TargetCombined: exit both legs when the combined premium has fallen to 50% of entry
Time exit3:10 pm, both legs
Daily limitThe strategy stops for the day after both legs have stopped out once
Account limitA daily loss limit and Smart Exit set across every strategy
ExecutionSell 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).

ItemWorkingAmount
Premium collected(92 + 88) × 65₹11,700
Call stop92 × 1.25 = ₹115Loss of 23 × 65 = ₹1,495 if hit
Put stop88 × 1.25 = ₹110Loss of 22 × 65 = ₹1,430 if hit
Combined targetPremium falls to ₹90 in totalProfit of 90 × 65 = ₹5,850 before charges
Brokerage4 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."

PartRule
InstrumentNifty futures, current month
Timeframe15-minute candles, conditions read at the close of each candle
EntryEMA 20 crosses above EMA 50, and RSI 14 is above 50
WindowBetween 9:45 am and 2:30 pm only
Size1 lot
Stop0.5% below the entry price
Target1% above the entry price
Exit ruleEMA 20 crosses back below EMA 50
Time exit3:15 pm
Daily limitAt 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

  1. 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.
  2. 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.
  3. 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.
  4. 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:

SituationA design that handles it
One leg of a two-leg entry is rejectedClose 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 timeDo 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 missingWait and say why, rather than picking a strike on a guess
An exit order is refusedTry again, with a short gap between tries, and show what is still owed
The market gaps through a stopExit 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 positionsDecide 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 tradeThe 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

  1. Write the idea in one sentence. If it needs two, it is two strategies.
  2. Write the six parts as plain sentences.
  3. Put rupee figures on the worst case at your intended size.
  4. Read every default in the builder before saving.
  5. Save it switched off. Nothing should trade until the tests are done.
  6. Backtest, then forward test, and keep notes of what you changed and why.
  7. Switch it on small, with account limits above it.
  8. 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

PartWhere it is set
Instrument and strikesOption 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
EntryAt the time, wait and trade, or opening range breakout (1 to 180 minutes); entry and exit times in IST; the days to trade
SizeLots per leg and a quantity multiplier from 1 to 50 that scales every leg and every rupee limit
Exits per legTarget 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 strategyExit time, rupee or % target and stop, net delta or theta band, lock profit and trail
ExecutionBuy legs first; market, limit with a buffer, stop-limit, or modify until filled; exits are market orders that only reduce
Indicator rulesSignal 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 limitsM2M 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.

References

  1. Perry J. Kaufman, *Trading Systems and Methods*, 6th edition (Wiley, 2019), on the development of systematic trading software and rule languages
  2. SEBI, circular on direct market access, 3 April 2008 (sebi.gov.in)
  3. Zerodha, "Introducing Streak v4" (zerodha.com), checked 12 November 2026
  4. 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)
  5. QuantPower: algo builder, signal algos, limits and prices, from the app's code and price list, checked 12 November 2026
Trading involves substantial risk. This page is for education and is not investment advice.