Pine Script v6 Beginner Guide: Build a TradingView Indicator and Alert

Choose indicator, strategy or library before coding

An indicator calculates series and displays plots or drawings on TradingView. A strategy uses a `strategy()` declaration and `strategy.*` features to simulate orders across historical and realtime bars. A library publishes reusable functions or types for import by other scripts. For a first project, one neutral indicator is easier to trace than an order simulation or a generalized library.

Beginning with a “buy signal” encourages the visual result to be confused with profitability. The sample here shows the closing price’s percentage distance from a simple moving average and marks a confirmed cross above zero. It does not select entry, exit, stop, quantity or suitability. Converting it into a strategy later creates a new specification for order timing, commission, slippage and bar assumptions.

Changing script type changes execution and validation requirements; it is not a naming edit.

Pine executes bar by bar and repeats on an open realtime bar

When a script is added, it executes from older to newer bars in the accessible dataset. Built-in series such as `close` and `high` hold the values for the bar currently being processed, while `close[1]` refers to the previous bar. Historical bars contain confirmed values and are generally calculated once in sequence. On the open realtime bar, an indicator can execute repeatedly as updates arrive.

Before each realtime recalculation, rollback restores the bar to its last committed state. A condition can become true during the bar and be false at the close, making a temporary mark disappear. After reload, elapsed realtime bars become historical bars calculated from final values; temporary ticks may no longer be available. That is one route to behavior commonly described as repainting.

Read a neutral distance indicator one line at a time

`//@version=6` selects the language version. `indicator()` declares name and display location. `input.int()` creates a user-controlled length with a minimum of two. `ta.sma()` calculates the baseline on every bar, while `distancePct` expresses the close as a percentage away from it. The conditional returns `na` if a zero baseline were encountered, avoiding division by zero.

//@version=6
indicator("Confirmed MA Distance — learning example", overlay = false)

int lengthInput = input.int(20, "Baseline length", minval = 2)
float baseline = ta.sma(close, lengthInput)
float distancePct = baseline == 0.0 ? na : (close / baseline - 1.0) * 100.0

bool crossedAbove = ta.crossover(distancePct, 0.0)
bool confirmedCross = barstate.isconfirmed and crossedAbove

plot(distancePct, "Distance from baseline (%)", color = color.teal, linewidth = 2)
hline(0.0, "Baseline", color = color.gray)
plotshape(confirmedCross, title = "Confirmed cross", style = shape.circle,
     location = location.bottom, color = color.orange, size = size.tiny)

alertcondition(confirmedCross, "Confirmed cross above baseline",
     "Confirmed MA-distance cross on {{exchange}}:{{ticker}} at {{close}}")

`ta.crossover()` is evaluated on every bar, and its result is then combined with `barstate.isconfirmed`. Evaluating time-series functions consistently is easier to review than calling them only in a branch. `plot()` shows distance, `hline()` marks zero, and `plotshape()` marks a confirmed cross. `alertcondition()` exposes an event that a user can select when creating an alert; adding it to code does not automatically create a notification.

Treat input and chart changes as separate test cases

Changing an input reloads the script across the dataset. Lengths 2, 20 and 200 can have different warm-up, smoothness and cross counts under the same indicator name. Selecting the best-looking length after seeing one period can overfit the display. Predefine default, minimum, representative and extreme tests; inspect `na`, scale, first valid bar and calculation behavior.

The purpose is specification testing, not selection of a superior parameter.

Changing timeframe or symbol changes the bar sequence. Adding `request.security()` introduces gaps, lookahead, higher- or lower-timeframe confirmation and another data context. This sample intentionally uses only the chart context. Before adding requests, consult the current versionless Pine manual for recommended patterns and limitations.

Separate alertcondition from the alert instance

`alertcondition()` defines a condition that an indicator user can select in the Create Alert dialog. To run notifications, create an alert instance with script, symbol, timeframe, inputs, condition, frequency, message, expiration and delivery method. TradingView treats the instance as a server-side snapshot of the script and inputs at creation. Do not assume that later chart or code changes automatically update an existing instance.

The sample combines the cross with `barstate.isconfirmed`, targeting the close rather than an intrabar cross. This does not remove feed revisions, session differences, reload behavior or requested-data issues. Align alert frequency with the condition under current options, and preserve alert ID in the ledger from the TradingView alerts guide.

Compare historical, open realtime, confirmed and reload states

TradingView uses repainting broadly for historical versus realtime calculations or plots that behave differently. A live RSI or moving average changing on an open bar is common. Future-leaking lookahead, plotting into the past, unconfirmed higher-timeframe values, non-standard-chart strategies or intrabar dependence can be more misleading. Replace the binary question “does it repaint?” with a description of what changes, when and why.

1. 01Save historical state

   Record confirmed values and marks immediately after reload.

2. 02Observe the open bar

   Log temporary distance and intrabar crosses separately.

3. 03Confirm the close

   Check whether the condition and marker remain.

4. 04Reload

   Compare the same bar after it is recalculated as historical.

5. 05Change one context field

   Vary input, timeframe or session separately to isolate causes.

Apply the same checklist to scripts from the SG Group free TradingView indicator collection. A polished plot is not a quality guarantee. For a published script, review the author explanation, source availability, update history, permissions and alert behavior.

Document code, inputs, limitations and alert recreation together

Before saving or sharing, document purpose, formula, inputs, units, assumed symbol and timeframe, `na` handling, realtime behavior, repainting possibilities, alert condition and change history. State what the script calculates and does not calculate instead of claiming high accuracy or profit. Respect third-party source and licenses; do not publish copied logic as original when it is not understood.

• Store Pine version, script version and review date.
• Attach complete symbol ID and inputs, not only a chart image.
• Define when an alert must be recreated and an old instance stopped.
• Explain known limitations, repainting behavior and data dependencies.
• Treat a strategy conversion as a new validation contract for cost, timing and data.

After conversion to a strategy, use the existing TradingView Backtesting Guide to progress through data quality, costs, trade lists, robustness and out-of-sample review, then import suitable results into the Backtest & Robustness Lab. This article ends when the indicator and alert execute according to a documented specification; it does not duplicate strategy-performance analysis.