The 10-point trend ignition system is a TradingView Pine Script (v6) indicator that scores ten statistical, structural and behavioural conditions on the daily chart and flags an “IGNITE” signal when five agree and a “BULL” or “BEAR” confirmation when seven agree. It is built to catch swing trends earlier than RSI, MACD or moving average crossovers, and it does not repaint because every input uses the previous confirmed bar.
Every trader’s screen looks the same. RSI in one corner. MACD humming below. Bollinger Bands hugging price. Two or three moving averages stacked in colors borrowed from the 1980s.
These tools work, kind of. They worked better when fewer people watched them. Today, by the time your 20 EMA crosses the 50, the move is half over and the institutions that front-ran the signal are unloading their positions onto retail traders who just got their entry confirmation.
I wanted something different. Something that didn’t smooth price into oblivion. Something that asked harder questions than “is this overbought?” Something that responded to what the market was actually doing rather than predicting what it might do next.
This is what I built. A 10-point scoring system using statistical, structural, and behavioral signals you won’t find in your average TradingView indicator library. It runs on daily charts, uses short lookback periods optimized for swing traders, and most importantly, it doesn’t repaint.

Recommended timeframe: Daily timeframe
- Ten binary components (z-score, range position, volume asymmetry, relative strength, Hurst, acceleration, volatility term structure, value area, recovery velocity and spike clustering) add up to a bull score and a bear score out of 10.
- Score of 5 or more triggers an early IGNITE marker; 7 or more triggers a BULL or BEAR confirmation.
- Signals use prior-bar data, barstate.isconfirmed and lookahead_off, so they do not repaint.
- Designed for daily charts with short 7 to 30 day lookbacks; the default benchmark is NSE:NIFTY.
- Set alerts to “Once Per Bar Close” and treat signals as a starting point for your own risk rules.
The Core Idea: Response Over Prediction
Traditional momentum indicators are predictive. They take past price data, smooth it, and try to extrapolate what comes next. That works in trending markets and gets crushed in choppy ones.
Response-based indicators don’t predict. They observe and react. When a stock moves three standard deviations from its recent mean, that’s not a forecast, it’s a fact. When volume on up days dwarfs volume on down days over the past two weeks, that’s accumulation happening right now, not a guess about tomorrow.
The shift in mindset is subtle but important. Instead of asking “where is this going?” the system asks “what is actually happening?” The answer to the second question is verifiable. The answer to the first is speculation.
Trend ignition system: TradingView Pine Script code
Copy the complete script below. It is written for Pine Script version 6.
// This Pine Script® code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © algostudio
//@version=6
indicator("Daily Trend Ignition - Short Term", overlay=true, max_labels_count=500)
// ============ INPUTS ============
grp_t = "Thresholds"
earlyT = input.int(5, "Early Signal Threshold", minval=3, maxval=8, group=grp_t)
confirmT = input.int(7, "Confirm Threshold", minval=5, maxval=10, group=grp_t)
grp_p = "Daily Lookback Periods"
zShort = input.int(13, "Short Z-Score (days)", group=grp_p, tooltip="Try 7, 10, or 13 for faster")
zLong = input.int(25, "Long Z-Score (days)", group=grp_p, tooltip="Try 20, 25, or 30")
hurstLen = input.int(25, "Hurst Lookback (days)", group=grp_p, tooltip="25-30 for short term")
vaLen = input.int(20, "Value Area Lookback (days)", group=grp_p)
weekLen = input.int(7, "Weekly Range Period (days)", group=grp_p, tooltip="7 = 1.5 weeks lookback")
asymLen = input.int(13, "Vol Asymmetry Period (days)", group=grp_p)
recLen = input.int(10, "Recovery Lookback (days)", group=grp_p)
spikeLen = input.int(10, "Spike Cluster Window (days)", group=grp_p)
grp_v = "Volatility Periods"
shortVolLen = input.int(7, "Short Volatility Period", group=grp_v)
longVolLen = input.int(30, "Long Volatility Period", group=grp_v)
grp_b = "Benchmark"
benchSym = input.symbol("NSE:NIFTY", "Benchmark Index", group=grp_b)
rsLen = input.int(13, "Relative Strength Lookback", group=grp_b)
grp_d = "Display"
showTable = input.bool(true, "Show Score Table", group=grp_d)
showLines = input.bool(true, "Show Value Area", group=grp_d)
// ============ NON-REPAINT REFERENCES ============
c1 = close[1]
h1 = high[1]
l1 = low[1]
v1 = volume[1]
ret = math.log(c1 / close[2])
// ============ COMPONENT 1: MULTI-PERIOD Z-SCORE CONVERGENCE ============
zS = ta.stdev(ret, zShort) != 0 ? (ret - ta.sma(ret, zShort)) / ta.stdev(ret, zShort) : 0.0
zL = ta.stdev(ret, zLong) != 0 ? (ret - ta.sma(ret, zLong)) / ta.stdev(ret, zLong) : 0.0
zBull = zS > 1.5 and zL > 1.0
zBear = zS < -1.5 and zL < -1.0
// ============ COMPONENT 2: WEEKLY RANGE POSITION ============
weekHigh = ta.highest(h1, weekLen)
weekLow = ta.lowest(l1, weekLen)
weekRange = weekHigh - weekLow
weekPos = weekRange != 0 ? (c1 - weekLow) / weekRange : 0.5
weekBull = weekPos > 0.8 and c1 > close[2] and close[2] > close[3]
weekBear = weekPos < 0.2 and c1 < close[2] and close[2] < close[3]
// ============ COMPONENT 3: VOLUME-WEIGHTED RETURN ASYMMETRY ============
upDayVol = ret > 0 ? v1 * math.abs(ret) : 0.0
downDayVol = ret < 0 ? v1 * math.abs(ret) : 0.0
upSum = math.sum(upDayVol, asymLen)
downSum = math.sum(downDayVol, asymLen)
asymmetry = (upSum + downSum) != 0 ? (upSum - downSum) / (upSum + downSum) : 0.0
asymBull = asymmetry > 0.20
asymBear = asymmetry < -0.20
// ============ COMPONENT 4: RELATIVE STRENGTH VS NIFTY ============
benchClose = request.security(benchSym, "D", close[1], lookahead=barmerge.lookahead_off)
stockRet = (c1 / close[rsLen + 1]) - 1
benchRet = benchClose[rsLen] != 0 ? (benchClose / benchClose[rsLen]) - 1 : 0.0
relStr = stockRet - benchRet
rsBull = relStr > 0.02 and relStr > relStr[1] and relStr[1] > relStr[2]
rsBear = relStr < -0.02 and relStr < relStr[1] and relStr[1] < relStr[2]
// ============ COMPONENT 5: HURST EXPONENT (DAILY) ============
maxR = ta.highest(ret, hurstLen)
minR = ta.lowest(ret, hurstLen)
rngR = maxR - minR
stdR = ta.stdev(ret, hurstLen)
rsRatio = stdR != 0 ? rngR / stdR : 0.0
hurst = rsRatio > 0 ? math.log(rsRatio) / math.log(hurstLen) : 0.0
hurstTrend = hurst > 0.5
hurstBull = hurstTrend and c1 > close[hurstLen + 1]
hurstBear = hurstTrend and c1 < close[hurstLen + 1]
// ============ COMPONENT 6: MULTI-PERIOD ACCELERATION ============
// Using 7-day periods instead of weekly (5-day) for faster response
accPeriod = 7
weekRet = (c1 / close[accPeriod - 1]) - 1
weekRetPrev = (close[accPeriod - 1] / close[accPeriod * 2 - 1]) - 1
weekRetOld = (close[accPeriod * 2 - 1] / close[accPeriod * 3 - 1]) - 1
weekVel = weekRet - weekRetPrev
weekVelPrev = weekRetPrev - weekRetOld
weekAcc = weekVel - weekVelPrev
accBull = weekAcc > 0 and weekVel > 0 and weekVel > weekVelPrev
accBear = weekAcc < 0 and weekVel < 0 and weekVel < weekVelPrev
// ============ COMPONENT 7: VOLATILITY TERM STRUCTURE ============
shortVol = ta.stdev(ret, shortVolLen) * math.sqrt(252)
longVol = ta.stdev(ret, longVolLen) * math.sqrt(252)
volRatio = longVol != 0 ? shortVol / longVol : 1.0
volIgnite = volRatio > 1.2 and volRatio[5] < 1.0
vtsBull = volIgnite and c1 > close[shortVolLen + 1]
vtsBear = volIgnite and c1 < close[shortVolLen + 1]
// ============ COMPONENT 8: DAILY VALUE AREA ACCEPTANCE ============
vaHighVis = ta.highest(high, vaLen)
vaLowVis = ta.lowest(low, vaLen)
vaHigh = ta.highest(h1, vaLen)
vaLow = ta.lowest(l1, vaLen)
vaRange = vaHigh - vaLow
vaUpper = vaLow + vaRange * 0.85
vaLower = vaLow + vaRange * 0.15
vaBull = c1 > vaHigh[1] and close[2] > vaUpper[2]
vaBear = c1 < vaLow[1] and close[2] < vaLower[2]
// ============ COMPONENT 9: DRAWDOWN RECOVERY VELOCITY ============
recoveryLow = ta.lowest(l1, recLen)
recoveryHigh = ta.highest(h1, recLen)
recoveryUp = recoveryLow != 0 ? (c1 - recoveryLow) / recoveryLow : 0.0
declineDn = recoveryHigh != 0 ? (recoveryHigh - c1) / recoveryHigh : 0.0
ddBull = recoveryUp > 0.05 and c1 > close[3] and close[3] > close[5]
ddBear = declineDn > 0.05 and c1 < close[3] and close[3] < close[5]
// ============ COMPONENT 10: SIGMA SPIKE CLUSTERING ============
retStdRef = ta.stdev(ret, 30) // 30-day baseline for what counts as "big"
bigUp = ret > retStdRef ? 1 : 0
bigDown = ret < -retStdRef ? 1 : 0
spikesUp = math.sum(bigUp, spikeLen)
spikesDown = math.sum(bigDown, spikeLen)
spikeBull = spikesUp >= 3 and spikesUp > spikesDown
spikeBear = spikesDown >= 3 and spikesDown > spikesUp
// ============ SCORING ============
b1 = zBull ? 1 : 0
b2 = weekBull ? 1 : 0
b3 = asymBull ? 1 : 0
b4 = rsBull ? 1 : 0
b5 = hurstBull ? 1 : 0
b6 = accBull ? 1 : 0
b7 = vtsBull ? 1 : 0
b8 = vaBull ? 1 : 0
b9 = ddBull ? 1 : 0
b10 = spikeBull ? 1 : 0
bullScore = b1 + b2 + b3 + b4 + b5 + b6 + b7 + b8 + b9 + b10
s1 = zBear ? 1 : 0
s2 = weekBear ? 1 : 0
s3 = asymBear ? 1 : 0
s4 = rsBear ? 1 : 0
s5 = hurstBear ? 1 : 0
s6 = accBear ? 1 : 0
s7 = vtsBear ? 1 : 0
s8 = vaBear ? 1 : 0
s9 = ddBear ? 1 : 0
s10 = spikeBear ? 1 : 0
bearScore = s1 + s2 + s3 + s4 + s5 + s6 + s7 + s8 + s9 + s10
// ============ SIGNALS (NON-REPAINTING) ============
bullEarly = barstate.isconfirmed and bullScore >= earlyT and bullScore[1] < earlyT
bullConfirm = barstate.isconfirmed and bullScore >= confirmT and bullScore[1] < confirmT
bearEarly = barstate.isconfirmed and bearScore >= earlyT and bearScore[1] < earlyT
bearConfirm = barstate.isconfirmed and bearScore >= confirmT and bearScore[1] < confirmT
// ============ PLOTTING ============
plotshape(bullEarly, "Bull Early", shape.diamond, location.belowbar, color.new(color.aqua, 0), size=size.small, text="IGNITE", offset=-1)
plotshape(bullConfirm, "Bull Confirm", shape.triangleup, location.belowbar, color.new(color.green, 0), size=size.normal, text="BULL", offset=-1)
plotshape(bearEarly, "Bear Early", shape.diamond, location.abovebar, color.new(color.fuchsia, 0), size=size.small, text="IGNITE", offset=-1)
plotshape(bearConfirm, "Bear Confirm", shape.triangledown, location.abovebar, color.new(color.red, 0), size=size.normal, text="BEAR", offset=-1)
bgcolor(bullScore >= confirmT and barstate.isconfirmed ? color.new(color.green, 88) : bearScore >= confirmT and barstate.isconfirmed ? color.new(color.red, 88) : na, offset=-1)
// ============ TABLE ============
if showTable and barstate.islast
var table t = table.new(position.top_right, 3, 13, border_width=1)
table.cell(t, 0, 0, "Daily Unconventional Signal", bgcolor=color.navy, text_color=color.white)
table.cell(t, 1, 0, "Bull", bgcolor=color.navy, text_color=color.white)
table.cell(t, 2, 0, "Bear", bgcolor=color.navy, text_color=color.white)
labels = array.new<string>()
array.push(labels, "1. Z-Score (" + str.tostring(zShort) + "/" + str.tostring(zLong) + ")")
array.push(labels, "2. Range Pos (" + str.tostring(weekLen) + "D)")
array.push(labels, "3. Vol Asymmetry (" + str.tostring(asymLen) + "D)")
array.push(labels, "4. RS vs NIFTY (" + str.tostring(rsLen) + "D)")
array.push(labels, "5. Hurst (" + str.tostring(hurstLen) + "D)")
array.push(labels, "6. Acceleration (7D)")
array.push(labels, "7. Vol Term (" + str.tostring(shortVolLen) + "/" + str.tostring(longVolLen) + ")")
array.push(labels, "8. Value Area (" + str.tostring(vaLen) + "D)")
array.push(labels, "9. Recovery (" + str.tostring(recLen) + "D)")
array.push(labels, "10. Spike Cluster (" + str.tostring(spikeLen) + "D)")
bullArr = array.new<int>()
array.push(bullArr, b1)
array.push(bullArr, b2)
array.push(bullArr, b3)
array.push(bullArr, b4)
array.push(bullArr, b5)
array.push(bullArr, b6)
array.push(bullArr, b7)
array.push(bullArr, b8)
array.push(bullArr, b9)
array.push(bullArr, b10)
bearArr = array.new<int>()
array.push(bearArr, s1)
array.push(bearArr, s2)
array.push(bearArr, s3)
array.push(bearArr, s4)
array.push(bearArr, s5)
array.push(bearArr, s6)
array.push(bearArr, s7)
array.push(bearArr, s8)
array.push(bearArr, s9)
array.push(bearArr, s10)
for i = 0 to 9
table.cell(t, 0, i + 1, array.get(labels, i), text_color=color.white, bgcolor=color.new(color.gray, 70))
bv = array.get(bullArr, i)
sv = array.get(bearArr, i)
table.cell(t, 1, i + 1, str.tostring(bv),
bgcolor=bv == 1 ? color.new(color.green, 30) : color.new(color.gray, 70), text_color=color.white)
table.cell(t, 2, i + 1, str.tostring(sv),
bgcolor=sv == 1 ? color.new(color.red, 30) : color.new(color.gray, 70), text_color=color.white)
table.cell(t, 0, 11, "TOTAL", bgcolor=color.black, text_color=color.yellow)
table.cell(t, 1, 11, str.tostring(bullScore) + "/10", bgcolor=color.black, text_color=color.lime)
table.cell(t, 2, 11, str.tostring(bearScore) + "/10", bgcolor=color.black, text_color=color.red)
regime = hurst > 0.5 ? "TRENDING" : "MEAN-REVERT"
table.cell(t, 0, 12, "Hurst Regime", bgcolor=color.new(color.purple, 30), text_color=color.white)
table.cell(t, 1, 12, regime, bgcolor=color.new(color.purple, 30), text_color=color.white)
table.cell(t, 2, 12, str.tostring(hurst, "#.##"), bgcolor=color.new(color.purple, 30), text_color=color.white)
// ============ ALERTS ============
alertcondition(bullEarly, "Bull Ignition", "Daily Unconventional Bull Ignition")
alertcondition(bullConfirm, "Bull Confirmed", "Daily Unconventional Bull Confirmed")
alertcondition(bearEarly, "Bear Ignition", "Daily Unconventional Bear Ignition")
alertcondition(bearConfirm, "Bear Confirmed", "Daily Unconventional Bear Confirmed")
How to add the indicator to TradingView
- Open a daily chart on TradingView and click Pine Editor at the bottom of the screen.
- Delete the default template, paste the code above and click Save, then Add to chart.
- Open the indicator settings to change the thresholds, lookback periods or the benchmark symbol.
- Turn on Show Score Table to see which of the ten components are firing on the latest bar.
- Create alerts from the four alert conditions (Bull Ignition, Bull Confirmed, Bear Ignition, Bear Confirmed) with the frequency set to Once Per Bar Close.
The 10 components of the trend ignition system
Each component scores either zero or one, and the scores aggregate into a bull score and a bear score, both out of ten. Here’s what each one measures and why it matters.
| # | Component | Lookback | Bull condition (summary) |
|---|---|---|---|
| 1 | Z-score convergence | 13D and 25D | Short z above 1.5 and long z above 1.0 |
| 2 | Weekly range position | 7D | Close in top 20% of range with two rising closes |
| 3 | Volume-weighted return asymmetry | 13D | Asymmetry above +0.20 |
| 4 | Relative strength vs benchmark | 13D | Outperformance above 2% and rising for two bars |
| 5 | Hurst exponent | 25D | Hurst above 0.5 and price above its level 25 days ago |
| 6 | Multi-period acceleration | 7D blocks | Positive acceleration and rising velocity |
| 7 | Volatility term structure | 7D vs 30D | Vol ratio above 1.2 after being below 1.0, price rising |
| 8 | Value area acceptance | 20D | Close above prior 20-day high after closing in the top 15% |
| 9 | Drawdown recovery velocity | 10D | Up 5% from 10-day low with higher closes |
| 10 | Sigma spike clustering | 10D | Three or more big up days, more than big down days |
1. Multi-Period Z-Score Convergence (13D and 25D)
Z-score measures how unusual today’s return is compared to recent history. A z-score of 2 means today’s move is in the top 2.5% of recent moves. By requiring convergence across both a 13-day and 25-day window, the system filters out one-off anomalies and only flags moves that look statistically significant on multiple timeframes.
This is your earliest warning system. When something genuinely unusual happens, this fires first.
2. Weekly Range Position (7D)
Where did today close within the last seven days of trading? If we’re closing in the top 20% of the weekly range with rising momentum, buyers won the auction. If we’re in the bottom 20% with falling closes, sellers took control.
This is auction theory in its simplest form. It treats each week as a battle and tells you who won.
3. Volume-Weighted Return Asymmetry (13D)
Are the up days backed by more volume than the down days over the last 13 sessions? This is essentially Wyckoff’s effort versus result on a structural timeframe. Genuine accumulation shows up here long before it shows up in price.
A score of plus 0.20 or better means up-day volume dominates by 60/40 or stronger. That’s serious money committing to the long side.
4. Relative Strength vs Benchmark (13D)
This might be the single most important component for stock traders. A stock can score well on every other metric and still be a bad trade if it’s lagging the broader market.
The system compares the stock’s 13-day return to the benchmark index’s 13-day return. If the stock is outperforming by 2% or more and that outperformance is improving, you’re looking at a leader. If it’s underperforming, you’re looking at relative weakness regardless of what its own chart says.
5. Hurst Exponent (25D)
This is the regime detector. The Hurst exponent measures whether a price series is trending or mean-reverting. Values above 0.5 indicate trending behavior. Values below indicate mean reversion.
Why does this matter? Because trend signals only work in trending regimes. If Hurst is 0.42, your stock is currently behaving like a slingshot, snapping back from extremes. Buying breakouts in mean-reverting regimes is how accounts get destroyed.
Note on the implementation: the script uses a fast rescaled-range style proxy (range of daily log returns divided by their standard deviation over 25 days). The textbook Hurst calculation uses the range of cumulative deviations across several window sizes, so treat the value as a regime indicator rather than a precise Hurst estimate. Values hovering near 0.5 are best read as “no clear regime”.
6. Multi-Period Acceleration (7D)
This is the second derivative of price. Conventional momentum measures velocity, the rate of change. Acceleration measures whether the rate of change is itself changing.
Mathematically, acceleration is the earliest signal of a regime shift. By the time velocity is high, the move is established. When acceleration first turns positive while velocity is still modest, that’s the ignition point.
7. Volatility Term Structure (7D vs 30D)
This compares short-term volatility to longer-term volatility. When short vol expands above long vol after a period of compression, regime shifts are happening. This is borrowed from VIX futures analysis and adapted to single-stock data.
The system flags when the ratio crosses above 1.2 with the prior reading below 1.0. Combined with directional price movement, this catches the exact moment volatility starts feeding a new trend.
8. Daily Value Area Acceptance (20D)
Real Market Profile traders watch for price acceptance beyond the value area. The system uses a 20-day high/low range and requires the close to break and hold beyond the upper or lower 15% of that range for two consecutive days.
If the value area concept is new to you, read Market Profile: understanding price vs value for the auction logic behind this component.
This isn’t just a breakout. It’s a breakout that the market accepted. That distinction matters enormously.
9. Drawdown Recovery Velocity (10D)
How fast did we bounce from the recent low? If a stock has rallied 5% or more from its 10-day low with sustained momentum (close greater than three days ago, three days ago greater than five days ago), you’re seeing a V-shape reversal in real time.
These reversals often mark important pivot points, especially in midcaps and smallcaps where moves are sharper than in large caps.
10. Sigma Spike Clustering (10D)
The system counts how many days in the last ten had absolute returns greater than the 30-day standard deviation. When you get three or more such “big” days clustered in the same direction within a small window, you’re seeing a volatility regime change.
This is the structural signal. Big moves clustering together means the previous low-volatility regime is over and a new one has started.
Why Short Periods Matter
The system uses 7, 10, 13, 20, 25, and 30-day lookbacks rather than the conventional 20, 50, 100, 200 windows. This is deliberate.
Modern markets move fast. Earnings cycles, options expiry weeks, and macro headlines create volatility spikes that distort longer averages. Most swing rallies complete within four to six weeks. By the time a 50-day moving average curls up, the meat of the move is gone.
Shorter lookbacks mean more signals, yes, but also earlier signals. The trade-off is acceptable when paired with multi-component confirmation. A single component firing means little. Five components agreeing means something is genuinely happening.
The Scoring Logic
Each component contributes one point to either the bull score or the bear score (or zero if the condition isn’t met). The system uses two thresholds.
The early threshold (default 5) catches trend ignition. When the score crosses from below 5 to 5 or above, an “IGNITE” diamond appears on the chart. These signals appear first, often before the move is obvious to anyone watching conventional indicators.
The confirm threshold (default 7) requires majority agreement. Seven of ten components must align for a “BULL” or “BEAR” triangle to appear. These signals are rarer but carry much higher conviction.
The genius is in the gap between the two. You scout positions on early ignitions and size up when confirmation arrives. If confirmation never comes, you exit on the next sign of weakness without waiting for an obvious top.
Worked example of the scoring
Suppose a stock has been basing for three weeks. Over two sessions, the 13-day relative strength against Nifty turns positive, up-day volume starts to dominate (asymmetry +0.25), the close moves into the top of its 7-day range, and three daily returns in the last ten sessions exceed the 30-day standard deviation. That is four components. On the next bar, the short-term volatility ratio jumps above 1.2, and the bull score crosses from 4 to 5: an IGNITE diamond prints. If over the next few sessions the price holds above the 20-day high and the z-score and acceleration conditions also turn on, the score reaches 7 and a BULL triangle confirms the trend.
The Non-Repainting Architecture
This took several iterations to get right.
Repainting is the silent killer of indicator-based strategies. You see beautiful signals on historical bars, deploy live, and watch in horror as signals appear and disappear in real time. Backtests become meaningless. Trust evaporates.
The system addresses repainting through three mechanisms operating together.
First, all calculations reference prior-bar confirmed data. The score on today’s bar reflects yesterday’s closing values. There’s no peeking at intrabar data that might still be moving.
Second, signal triggers are gated on barstate.isconfirmed. Signals only evaluate after the bar closes. No flickering during the trading day.
Third, plots use an offset of negative one to anchor markers to the bar that actually triggered the signal. Combined with lookahead_off on the benchmark security request, this ensures the historical chart appearance matches what would have been visible in real time.
The result is honest. What you see on the chart today will still be there tomorrow. Backtests are valid. Alerts fire when they should and only when they should.
If you write your own indicators, my guide on how to convert repainting code to non-repainting explains the same principles in AmiBroker terms.
Settings for International Users
The default benchmark in the script is set to NSE:NIFTY. Traders outside India should change this to a benchmark that matches the asset they’re analyzing. The benchmark is what the stock’s relative strength is measured against, so picking the right one is critical for component four to work correctly.
For US equity traders, set the benchmark to AMEX:SPY for S&P 500 stocks, or NASDAQ:QQQ for tech-heavy names. If you’re trading sector-specific stocks, use the sector ETF instead, such as XLF for financials, XLE for energy, or XLK for technology. For Russell 2000 small caps, use AMEX:IWM.
For European traders, use the appropriate broad index for your market. Examples include INDEX:DEU40 for German equities, INDEX:UKX for FTSE 100 stocks, INDEX:CAC for French equities, or INDEX:STOXX50E for pan-European exposure.
For UK traders specifically, FTSE 100 stocks should use INDEX:UKX, while AIM and smaller-cap stocks can use INDEX:UKX100 or the relevant FTSE All-Share equivalent.
For Asian markets outside India, Hong Kong stocks pair with INDEX:HSI, Japanese equities with INDEX:NKY or TVC:NI225, and Australian stocks with INDEX:XJO or ASX:XJO.
For crypto traders, this system can work on daily Bitcoin or Ethereum charts but the relative strength component becomes less meaningful since crypto correlates heavily with itself. Either set the benchmark to BINANCE:BTCUSDT to measure altcoin strength against Bitcoin, or accept that component four will rarely fire and treat the system as a 9-of-10 scorer with thresholds adjusted accordingly. Lower the early threshold to 4 and confirm threshold to 6 in this case.
For forex traders, the system is less suitable because relative strength against a single benchmark doesn’t translate cleanly. If you adapt it, use DXY (dollar index) as benchmark for non-USD pairs, but expect noisy results.
For commodity traders, gold and silver work reasonably well with the system using INDEX:GOLD or COMEX:GC1! as self-reference. For oil, energy sector ETFs like XLE provide useful relative strength readings.
The other parameters, including all lookback periods and thresholds, should work across markets without modification. The statistical relationships these components measure are universal. A stock breaking out of its 20-day value area in Mumbai behaves mathematically identical to one breaking out in New York or London.
One adjustment worth considering for US large-cap traders: since these stocks tend to trend more smoothly than emerging market equities, you can lengthen the Hurst lookback to 30 or 35 for more stable regime detection. For high-volatility crypto markets, shorten the Hurst lookback to 20 and the long volatility period to 25 to react faster to regime shifts.
What This System is Not
Let me be direct about limitations.
This is not a holy grail. No single indicator system catches every move or avoids every loss. The system will miss trends that develop slowly without statistical fireworks. It will give early signals that fail to confirm. It will occasionally fire on news-driven spikes that reverse within a week.
This is not a substitute for risk management. A 7 of 10 bull signal on a stock about to report earnings is still a coin flip. Position sizing, stop placement, and risk per trade matter more than any signal.
This is not optimized for intraday trading. The components are designed for daily timeframes where statistical relationships have time to establish themselves. Applying this to 5-minute charts will produce noise.
This is not a black box. Every component has a clear rationale and adjustable parameters. If something isn’t working for your style or your market, change it. The defaults are starting points, not gospel.
Common mistakes when using the trend ignition system
- Acting on every IGNITE signal without checking the Hurst regime. In a mean-reverting regime, early signals fail more often.
- Running it on stocks with thin volume, where the volume asymmetry and spike components become noisy.
- Using the wrong benchmark. A pharma stock compared with Nifty can look strong simply because the sector is outperforming. Comparing sectors first with an RRG relative strength study helps.
- Setting alerts to Once Per Bar instead of Once Per Bar Close, which brings back intrabar noise.
- Ignoring scheduled events such as results and index rebalancing, where statistical signals can be swamped by news.
How to Use It
Start by loading the indicator on a major index daily and observing the signals over the past year. Notice where ignite signals fired before major moves. Notice where they fired and the move failed to develop. Build intuition for what genuine ignition looks like.
Then move to liquid stocks where the relative strength component becomes meaningful. Look for stocks where ignite signals coincide with strong RS readings. These are your highest-probability setups.
For very short-term traders, lower the early threshold to 4 and act on early ignite signals with tight stops. For positional traders, wait for the confirm threshold and use wider stops with trailing exits.
Set alerts on “Once Per Bar Close” rather than “Once Per Bar” to ensure non-repainting alert delivery.
Once you are comfortable with the signals, you can route the alerts to your broker through a webhook. See how to automate your trading with OpenAlgo and TradingView.
The Bigger Picture
The trading edge isn’t in the indicators anymore. Everyone has the same RSI and the same EMAs. The edge is in asking different questions and acting on different information.
Statistical anomaly detection asks a different question than overbought/oversold. Auction theory asks a different question than support and resistance. Volatility regime detection asks a different question than trend direction.
When you stack different questions whose answers happen to align, you’re not just confirming what conventional indicators already showed. You’re seeing the same market through multiple independent lenses and finding the rare moments when all of them agree. Those moments are where edge lives.
The 10-point system isn’t magic. It’s a framework for asking better questions. The signals it produces are starting points for your judgment, not replacements for it. Used that way, it becomes a genuinely useful tool for catching market trends earlier than the crowd.
Frequently Asked Questions
Does the trend ignition system repaint?
No. All calculations use the previous confirmed bar, signals are gated on barstate.isconfirmed, the benchmark request uses lookahead_off, and markers are plotted with an offset of minus one. What you see on historical bars matches what was visible in real time.
Which timeframe is best for the trend ignition system?
The daily timeframe. The lookbacks are measured in trading days, and the statistical relationships need daily bars to settle. On 5-minute charts the components produce mostly noise.
Can I use it for Bank Nifty or individual NSE stocks?
Yes. Keep NSE:NIFTY as the benchmark for most stocks, or switch to a sector index for sector-heavy names. For Bank Nifty itself, relative strength against Nifty still works as a measure of banking leadership.
Is this a TradingView strategy or an indicator?
It is an indicator with alert conditions, not a strategy script, so it does not produce a strategy tester report. To backtest it you would convert the signals into strategy.entry and strategy.exit calls with your own stop and exit rules.
Learn by watching: free videos every week
Market Profile, order flow, Python, AI and OpenAlgo tutorials on YouTube.

