In short
- Stage 1: learn market basics: orders, candles, risk and position size.
- Stage 2: write one strategy as plain-English rules.
- Stage 3: backtest it honestly, with costs and out-of-sample data.
- Stage 4: paper trade it for weeks with virtual money and a journal.
- Stage 5: learn Pine Script, then Python, and automate only where your broker and regulator allow.
Algo trading attracts beginners with promises of "set and forget" profits. The reality is more interesting: it is a skill, built in stages, that teaches you how markets behave and how to test ideas honestly. This roadmap is the order we recommend, with what to practise at each step.
Stage 1: Market basics (2–4 weeks)
Before any code, understand what you are automating.
- Orders: market, limit and stop orders, and what slippage is.
- Charts: candlesticks, timeframes, volume, support and resistance. Start with how to read a candlestick chart.
- Indicators: moving averages, RSI, MACD, and when they fail. See SMA vs EMA and RSI and MACD.
- Risk: how much to risk per trade, and why a 50% loss needs a 100% gain to recover.
Stage 2: Write one strategy as rules (1 week)
Pick one idea and write it so a stranger could follow it without asking you anything. For example:
- Entry: buy at the close when the 9-period EMA crosses above the 21-period EMA, but only if RSI(14) is below 70.
- Exit: sell at the close when the 9-period EMA crosses back below the 21-period EMA.
- Risk: risk no more than 1% of the account per trade.
In the StockYatra app you can build exactly this in the no-code rule builder, or in Pine Script:
//@version=5
strategy("EMA cross with RSI filter", overlay=true)
fast = ta.ema(close, 9)
slow = ta.ema(close, 21)
r = ta.rsi(close, 14)
plot(fast, "EMA 9", color=color.green)
plot(slow, "EMA 21", color=color.red)
if ta.crossover(fast, slow) and r < 70
strategy.entry("Long", strategy.long)
if ta.crossunder(fast, slow)
strategy.close("Long")Stage 3: Test it honestly (2 weeks)
Backtest across several stocks and timeframes, with costs. Keep some data aside and test on it once. Read the trade count, drawdown and profit factor, not just the return. The full method, with a worked example, is in how to backtest a trading strategy.
Stage 4: Practise live with virtual money (4–8 weeks)
Follow the rules on live practice charts and log every trade: what the rule said, what you did, the result, how you felt. This is where you discover whether you can actually follow your own system, and how it behaves in markets your backtest did not include.
Stage 5: Code and automate, within the rules
- Pine Script first. It is designed for chart-based strategies and is easy to read. Learn variables,
ta.*indicators,ifconditions andstrategy.entry/strategy.close. - Python next for data handling, larger backtests and broker APIs.
- Automate only where allowed. In India, through your broker under SEBI's framework (rules). In Nepal, retail automation on TMS is not permitted today (why). In the US, through brokers that offer APIs.
The skills you are really building
Your practice toolkit in StockYatra
| Stage | What to use in the app |
|---|---|
| Basics | The Academy's free courses and quizzes in English, Nepali and Hindi; charts on NEPSE, NSE and US practice markets |
| Rules | The no-code rule builder (indicators, crosses above/below, AND/OR, stop-loss and target) |
| Testing | Pro Chart backtests of 41 built-in strategies, your builds and Pine Scripts, with fees, drawdown and profit factor |
| Practice | Virtual coins, Market/Limit/Stop orders, long and short, and a trade journal for setup, mood and lessons |
| Code | Pine Script editor with 15 example scripts and line-by-line error messages |
The guided version of this roadmap is on learn algo trading.
Key takeaways
- Learn basics, then rules, then honest tests, then practice, then code.
- Write one strategy so precisely a stranger could follow it.
- Backtest with costs and an out-of-sample check.
- Paper trade for weeks with a journal.
- Pine Script first, Python later, and automate only where allowed.
Start the roadmap today, free
StockYatra is a free practice app for Nepal (NEPSE), India (NSE) and US stocks. Test 41 transparent strategies, write rules without code or in Pine Script, and backtest them on the chart with virtual coins. Nothing connects to a broker and nothing is real money.
The algo trading series
- What is algorithmic trading?
- Algo trading in India: the 2026 rules
- Is algo trading allowed in Nepal?
- How to backtest a trading strategy
- Classic algo trading strategies, explained
- Algo trading vs manual trading
- Algo trading: the one-page guide
- Black box AI trading, explained
- Pro Chart: 41 strategies with every rule shown
StockYatra is an education app, not a broker, adviser or research analyst. Nothing here is a recommendation to buy or sell any security, to use any trading product, or legal advice. Rules and dates are summarised for learning; check the regulator's and your broker's current notices before acting. Practice prices are simulated and coins are virtual.
