The honest 52-week high is slower than the tempting one
A weekly high or low overlay should avoid using a final weekly value before that week is complete.
Read note →Pine Script discoveries worth keeping.
A separate archive of Pine Script edge cases, timing traps and odd chart behaviours I keep coming back to while building TradingView indicators.
VWAP disagreements are often anchor disagreements
A Pine VWAP can be mathematically correct and still disagree with another VWAP because the anchor or source is different.
Read note →The version directive can change the meaning of old security code
Migrating Pine scripts needs a timing review, especially around older `security()` and lookahead behaviour.
Read note →UDTs are cleaner when library boundaries stay boring
Pine user-defined types and libraries can make large scripts clearer, but cross-library object design needs restraint.
Read note →Extended-session tickers should be built, not guessed
Pine ticker helpers make session and symbol context explicit, which is safer than assembling ticker strings by hand.
Read note →A Pine template is not the same thing as a snippet
Reusable Pine code works best when snippets stay small and templates define the whole script structure.
Read note →Systematic trading rules do not automatically make a good bot
A Pine indicator can formalize a trading process without turning every decision into automation.
Read note →A trade is not always one entry and one exit
Pine strategy reports depend on entries, orders, pyramiding, reversals, and the way the script defines a position.
Read note →Strategy alerts are order events, not just indicator alerts with trades
Pine strategy alerts need separate thinking around order fills, alert messages, replay tests, and live execution.
Read note →A session open is a rule, not just a timestamp
Pine session logic should account for timezone, missing ticks, and the difference between a boundary and a script execution.
Read note →The request.security lookahead fix can become the future leak
Offset and lookahead patterns are useful in Pine, but copied carelessly they can make historical bars see higher-timeframe data too early.
Read note →request.security_lower_tf returns arrays, not a smaller normal series
Lower-timeframe requests in Pine are powerful, but their array results need different handling from ordinary series values.
Read note →request.security in local logic still needs a portable expression
Dynamic requests can make Pine scripts more flexible, but the requested expression still runs in another context.
Read note →When a Pine script miscalculates, reduce the chart before changing the idea
A reliable Pine debugging pass starts with state, settings, timing, and data context before rewriting the strategy.
Read note →The first usable request.security value is a design decision
Requested series can appear before the chart has enough local context, so scripts should define their warm-up rules.
Read note →Replay ticker IDs can carry more context than a plain symbol
Ticker strings in TradingView can include replay and modifier context, so Pine scripts should avoid naive symbol parsing.
Read note →Renko scripts need to know whether they are reading bricks or prices
Renko chart context, ticker construction, and strategy assumptions can change what a Pine script is actually calculating.
Read note →Range-chart volume does not behave like time-chart volume
Volume requests on range charts can expose realtime and synthetic-chart assumptions that normal candles hide.
Read note →A pivot's plotted location is not when the script discovered it
Pine pivot functions can plot on the pivot bar with an offset, but confirmation happens only after the right-side bars exist.
Read note →Partial exits change the meaning of a trade report
Scaling out in Pine strategies is useful, but the performance table needs to be read with order reservations and trade definitions in mind.
Read note →Strategy fills are built from an assumed path through the bar
The Strategy Tester can only infer historical order fills from available bar data and broker-emulator rules.
Read note →Order blocks make more sense as ranges than as perfect lines
In Pine, order-block logic becomes more honest when zones, invalidation, and age are explicit.
Read note →na, empty, and zero are three different states
Pine scripts get easier to debug when unavailable values, empty arrays, and real zeroes are kept separate.
Read note →timeframe.multiplier is not the timeframe
A Pine script that reads only the numeric multiplier can misunderstand seconds, minutes, days, weeks, and months.
Read note →Pine is a chart language, not a machine-learning lab
Machine-learning ideas can inform an indicator, but Pine is usually the place to display or apply them, not train them.
Read note →Indicator settings are risk settings once people trade from them
Inputs in a Pine indicator can change frequency, confirmation, and exposure, even when they look harmless.
Read note →Confluence is weaker when every indicator is asking the same question
A Pine dashboard can make ten signals look independent even when they all measure the same underlying move.
Read note →Higher-timeframe values need a trust label
A multi-timeframe Pine script should distinguish completed higher-timeframe data from developing values and impossible history.
Read note →Hidden or reloaded scripts are a useful test for realtime assumptions
If a Pine script changes after being hidden, reloaded, or reactivated, the issue is often realtime state rather than the visible plot.
Read note →Heikin Ashi candles can make a backtest look cleaner than the market was
Synthetic candles are useful visually, but strategy fills and signal timing need to respect the prices that could actually trade.
Read note →Fundamental data is not just another price series
`request.financial()` and `request.earnings()` have timing, period, and availability rules that can confuse chart logic.
Read note →varip escapes realtime rollback, but it does not make history remember the ticks
Pine realtime rollback, drawing objects, and `varip` can produce behaviour that is useful live and impossible to reproduce after reload.
Read note →A Pine script needs style before it becomes someone else's tool
Readable Pine code matters once a script is shared, maintained, moderated, or reused beyond the first author.
Read note →calc_on_every_tick creates a live script the backtest cannot fully replay
Strategy intrabar calculation can be useful, but it opens a gap between historical bars and realtime execution.
Read note →Bar Replay is not the missing tick history
TradingView Bar Replay is useful, but it does not turn historical OHLC bars into the realtime stream that originally formed them.
Read note →Automation work should start with the alert contract
Before a Pine script can drive a bot or webhook, the signal states and failure cases need to be written down.
Read note →Arrays keep state, but not always the state you think you saved
Pine arrays are useful for carrying levels and objects forward, but mutation makes previous-state logic easy to misread.
Read note →alert() and alertcondition() are not two spellings of the same thing
Pine scripts need different alert tools depending on whether the message is static, dynamic, visual, or automated.
Read note →Webhook alerts should be valid JSON before they are clever JSON
A TradingView webhook payload is an interface. If the JSON is loose, the whole automation becomes fragile.
Read note →Alert frequency is a timing contract, not a dropdown
TradingView alert frequency settings decide what the receiver is allowed to believe about a signal.
Read note →