The Short Answer
TradingView's Strategy Tester is one of the easiest ways to test a trading idea: write or load a Pine Script strategy, add it to a chart, and read the report. For many ideas that's a good first check.
Its accuracy depends on assumptions that are easy to miss. By default it simulates fills from chart bars, assumes a path for price inside each bar, and applies no commission or slippage unless you set them. Scripts can also repaint or leak future data. None of this makes the tester wrong; it means you need to know the settings before you trust a result. Everything below is based on TradingView's own documentation, linked in each section, as of September 2026.
What the Strategy Tester Does Well
It's fair to start here:
- Speed from idea to result. A strategy on a chart produces a report with trades, equity and performance metrics in seconds.
- Visual checking. Entries and exits appear on the chart, so you can see whether trades happen where the rules say.
- Adjustable realism. Commission, slippage, order size, pyramiding, limit-order fill behaviour and intrabar detail are all configurable in the strategy's properties or in code.
- A large community library of published scripts to learn from.
- Good documentation. The Strategies page of the Pine Script manual explains the simulation in detail, including the assumptions below.
Limitation 1: Fills Come From Chart Bars
TradingView's documentation says the Strategy Tester uses a broker emulator that, by default, fills orders using only the available chart data, and on historical bars it executes orders after a bar closes. By default, the emulator doesn't see the order book or the trades inside a time-based bar, so it can't know how much size was available at a price or where your order would have sat in the queue.
What it means for you: a strategy that relies on precise entries, small targets or larger order sizes can look better in the tester than it trades.
Limitation 2: Price Movement Inside a Bar Is Assumed
A bar only records open, high, low and close. To fill stops and targets inside a bar, the emulator infers a path. According to the Strategies page, if the open is closer to the high than to the low, it assumes price moved open → high → low → close; if the open is closer to the low, it assumes open → low → high → close.
That rule is reasonable, but it's an assumption. When a stop and a target both sit inside one bar, the assumed path decides which one filled, and a real market may have done the opposite. We walk through a worked example in Tick vs Bar Backtesting.
Limitation 3: Bar Magnifier Helps, but Doesn't Remove the Guess
TradingView offers a Bar Magnifier mode, which it describes as using intrabar inspection for more realistic order fills. When enabled, the emulator uses prices from a lower timeframe instead of assuming the path inside the chart bar. You can switch it on in the strategy's settings or with use_bar_magnifier = true in the strategy() declaration.
It's worth turning on for strategies with intrabar stops and targets. Keep two points in mind:
- Lower-timeframe bars are still bars. A lower-timeframe bar can also contain both your stop and your target, so some ambiguity remains.
- There are limits. The support page lists the lower timeframe used for each chart timeframe and notes that a strategy can't request more than 200,000 bars from the lower timeframe. The Pine Script manual says Premium and Ultimate plan users can enable it (as of September 2026).
Limitation 4: No Costs Unless You Add Them
The Strategies page states that if a strategy doesn't specify commission, none is applied to filled orders, and that the default slippage is 0 ticks. A published script may or may not set realistic values.
What it means for you: before reading any metric, open the strategy's properties and set commission and slippage for the market you trade. Strategies with a small average trade are the most sensitive to this.
Limitation 5: Limit Orders Fill on a Touch
By default, the emulator fills a limit order as soon as price reaches its level. TradingView's manual notes that in real trading some limit orders don't fill when price reaches them, and provides the backtest_fill_limits_assumption parameter (and a matching setting) to require price to move a number of ticks beyond the level first.
What it means for you: strategies that enter or exit with limit orders at exact levels, especially mean-reversion and scalping strategies, deserve a test with a stricter limit-fill assumption.
Limitation 6: Repainting and Future Leaks
Some scripts behave differently on historical bars than on live bars. TradingView's Repainting page defines repainting as script behaviour that causes historical and realtime calculations or plots to behave differently, and lists common causes, such as values from bars that haven't closed and some settings that recalculate on every tick.
A related risk is look-ahead in higher-timeframe requests. The Other timeframes and data page warns that request.security() with barmerge.lookahead_on can leak future data into historical bars unless the requested value is offset, and shows how to do it safely.
What it means for you: a strategy that repaints or leaks future data can show historical trades that live trading would never have produced. See Look-Ahead Bias in Backtesting: 7 Real Examples for the patterns to check.
Limitation 7: Non-Standard Charts Give Synthetic Results
The Strategies page notes that results from strategies on non-standard charts, such as Heikin Ashi or Renko, don't reflect actual market conditions by default, because trades are simulated on the chart's synthetic prices. TradingView recommends standard chart types for testing, and offers an option to fill on standard prices for Heikin Ashi charts.
Limitation 8: The Tester Isn't Your Live Execution
A strategy that tests well on TradingView still has to be traded somewhere. If orders go to a broker through alerts or another tool, live fills come from that path, with its own timing and costs, not from the emulator. Compare a period of live or demo trades with a backtest of the same days before you rely on the numbers. Why Your Backtest Doesn't Match Live Trading covers how to read the differences.
Settings to Check Before You Trust a Result
| Setting | Why it matters |
|---|---|
| Commission | None is applied unless set |
| Slippage | Defaults to 0 ticks |
| Bar Magnifier | Uses lower-timeframe prices for intrabar fills where available |
| Limit order fill assumption | Default fills a limit on a touch |
| Order size and pyramiding | Changes exposure and the size of every result |
| Recalculation settings | Some settings behave differently on historical and live bars |
| Chart type | Use standard candles, not synthetic chart types |
| Testing period | A short period with few trades says little |
When the Strategy Tester Is Enough
It's a good fit for:
- quick checks of whether an idea is worth more work;
- strategies that decide at bar close, hold for many bars and use wide stops;
- learning Pine Script and seeing how rules turn into trades.
Consider a tick-level or order-book-level test when the strategy uses tight stops and targets, stop entries or trailing stops, or trades sizes that matter compared with typical liquidity.
Where Roboquant Is Different
Roboquant is not a Pine Script tool. It doesn't run, backtest, deploy or export Pine Script. Strategies are written as compiled .rq files, which the AI can write from a plain-English description or from the rules of a Pine strategy you paste into the chat; the logic is rebuilt, not converted line by line, so check the trades afterwards.
What that gives you for testing:
- A choice of fill model per backtest. OHLCV bars for fast research; tick fills that follow the historical trade tape for intrabar entries, stops, targets and trailing stops; and order-book fills that walk market depth. Tick fills start on Starter and order-book fills on Elite, for supported symbols and covered dates.
- Costs as explicit inputs. Commission and slippage are set for every run.
- Causality enforced by the engine. Bar strategies see closed bars, and higher-timeframe indicators expose the previous completed value.
- The same compiled strategy runs in backtest, optimization, Replay and deployment to Tradovate Demo or Live, on plans with deployments.
Market data comes from CME today. The backtesting docs describe the fill models, and pricing shows which plan includes what.
Related Reading
- Tick vs Bar Backtesting: When Intrabar Fills Change Everything
- Look-Ahead Bias in Backtesting: 7 Real Examples
- Turn a Trading Idea into Code with AI
- Understanding Sharpe Ratio, Drawdown & Key Metrics
- Best Pine Script AI Generators in 2026
Try It
Describe your strategy's rules in the chat, then compare a bar backtest with tick fills.
Trading involves risk of loss. Backtest results are hypothetical and do not guarantee future performance.