Pine Script Indicators vs Strategies Explained

Lesson 36 introduced Pine Script as TradingView’s own scripting language. Before looking at any actual code, there’s an important fork in the road worth understanding first: every Pine Script is written as one of two broad types - an indicator or a strategy - and the two behave quite differently.

Indicator Scripts: Purely Visual

An indicator script calculates something and displays it on the chart - a line, a shaded band, a marker, a label - but it does not simulate placing or managing any trades. Everything covered in Module 5 (EMA, RSI, MACD, Bollinger Bands, and the rest) works this way conceptually, whether built into TradingView or custom-written: calculate, then display.

If your goal is simply “I want to see my own custom calculation plotted on the chart,” an indicator script is the appropriate type.

Strategy Scripts: Backtestable

A strategy script goes a step further: it defines simulated entry and exit rules - for example, “enter a simulated long position when price crosses above a moving average, exit when it crosses back below.” Because a strategy script defines these rules explicitly, TradingView can run it through the Strategy Tester, simulating how that exact rule set would have performed against historical price data.

   Indicator Script                      Strategy Script
   ─────────────────                     ─────────────────
   Calculates + plots something          Defines simulated entry/exit
   on the chart                          rules for trades
        │                                       │
        ▼                                       ▼
   No trade simulation involved          Can be run through the
                                          Strategy Tester for
                                          backtested performance

What the Strategy Tester Actually Shows

Running a strategy script through the Strategy Tester produces simulated performance statistics - things like the total number of simulated trades, an approximate win rate, and overall simulated profit or loss across the historical period tested. This is conceptually similar to the paper trading practice from Module 9: no real money changes hands, but the exercise builds a rule-tested track record instead of a purely subjective impression.

An Honest Caveat About Backtested Results

This is the single most important point in this lesson: a strategy performing well when backtested against historical data is not a guarantee that it will perform similarly going forward. A backtest reflects how a specific set of rules would have behaved under the exact historical conditions tested - price action, volatility, and market behavior can shift over time, and future conditions are never guaranteed to resemble the past closely enough for identical results to repeat.

This doesn’t make backtesting worthless - it can still reveal whether an idea has any historical basis at all, and roughly what its past drawdowns looked like. It simply means a strong backtest is useful context, never proof of future performance.

Real-Life Example: Two Traders, Two Goals

Suppose one trader wants to plot a custom volatility band on their Nifty chart, purely to visually assist their own manual decision-making - no backtesting needed, no simulated trades. An indicator script is exactly right for this.

A second trader has a specific rule in mind - “buy when price closes above the 20-period EMA with rising volume, sell when it closes back below” - and wants to know how often, historically, that rule would have worked on Bank Nifty over the past two years. This calls for a strategy script, run through the Strategy Tester, to see simulated historical performance for that exact rule.

Both traders are using Pine Script - but for genuinely different purposes, matching the type of script to the goal.

Analogy: A Dashboard Gauge vs a Flight Simulator

Think of an indicator script like a dashboard gauge in a car - it displays useful information (speed, fuel level) but doesn’t drive anywhere on its own. A strategy script is more like a flight simulator - it lets you run a specific set of maneuvers against realistic historical conditions to see how they would have played out, before ever getting into a real cockpit. The simulator is genuinely useful practice, but performing well in it still doesn’t guarantee identical results in the unpredictability of an actual flight.

Common Beginner Mistakes

• Treating a strong backtest as a guarantee of future performance. It reflects historical conditions specifically - a genuinely important distinction, not a technicality.
• Writing a strategy script when an indicator would do. If the only goal is visual display, adding unnecessary simulated trade logic overcomplicates the script.
• Assuming the Strategy Tester risks real money. It’s a historical simulation tool - no real capital is involved unless a script is separately and deliberately connected to a live account, a topic well beyond this lesson.
• Ignoring a poor backtest result out of attachment to an idea. A weak historical result is genuinely useful information, worth taking seriously rather than dismissing.

Conclusion

Knowing whether you're building something purely visual (an indicator) or something backtestable (a strategy) shapes how you think about a Pine Script from the very first line. With that distinction clear - and the honest caveat about backtested results in mind - the next lesson finally looks at a few actual lines of Pine Script, explained one at a time in plain English.