Your TradingView strategy shows a winning trade. The alert arrived at a different time, and your broker recorded a different entry price. Before changing the strategy, find out which part of the trade actually changed.
Table of Contents
- Backtests, alerts and broker trades: what are you comparing?
- 1. Does the strategy trade before the candle closes?
- 2. Is the historical signal repainting?
- 3. Are you using the same fill assumptions?
- 4. Does the alert represent the intended event?
- 5. Is the running alert using an older setup?
- 6. Did the webhook reach PickMyTrade and the broker?
- 7. Do live size and exit rules match the backtest?
- TradingView backtest vs live: a reconciliation checklist
- Frequently asked questions
The TradingView backtest vs live difference comes from comparing a historical simulation with a real execution process. A backtest models orders on chart data. An alert sends an event from a running script. A live trade depends on the instructions received, the account’s position and the broker’s execution. Those records answer different questions.
This guide covers seven places to investigate, then gives you a practical reconciliation checklist. It focuses on TradingView strategies automated through PickMyTrade, including Tradovate setups.
Backtests, alerts and broker trades: what are you comparing?
Start with the record behind each result. A Strategy Tester entry isn’t proof that your broker received an order. Likewise, a triggered alert doesn’t prove that an order filled. Keeping these records separate helps you investigate a missing trade without confusing it with a price difference.
| Record | What it tells you | What to compare next |
|---|---|---|
| Historical strategy trade | The simulator’s entry and exit under the tested settings | Signal rule and simulated order timing |
| TradingView alert log | The alert event and outgoing message | Event type, timestamp and webhook status |
| PickMyTrade alert log | The message received and its processing result | Account, instrument, action and quantity |
| Broker order and execution history | Order status and actual fills | Accepted quantity, fill price and resulting position |
For the setup behind that chain, see the PickMyTrade strategy automation guide. When troubleshooting, preserve the message that actually arrived. A screenshot of today’s alert settings may not explain yesterday’s trade.
1. Does the strategy trade before the candle closes?
A condition can become true during a candle and disappear before the close. TradingView’s Pine execution model explains that strategies normally calculate at bar close. Settings such as calc_on_every_tick change their realtime behavior. Check these settings before comparing an intrabar alert with a completed historical candle.
Consider an illustrative five-minute breakout rule. Price moves above the previous high while the candle is forming, then falls back below it. An intrabar version can act on that move. A version requiring a confirmed closing breakout won’t take the same entry.
Neither observation tells you whether the strategy is profitable. They tell you that the entry rules differ. Write down whether the strategy intends to act on a temporary crossing, a closing price or another explicitly defined event.
For indicator alerts intended to use confirmed signals, check the applicable bar-close frequency. For strategy automation, inspect the script’s calculation settings and selected alert event. Don’t assume every strategy alert exposes the same frequency controls as an indicator alert.
2. Is the historical signal repainting?
Repainting means a script can show different historical and realtime behavior. TradingView’s repainting documentation describes causes including changing realtime values, higher-timeframe data and misleading use of future information. A marker that disappears after reloading deserves a script review before you blame order execution.
A five-minute strategy using a developing hourly value is one example. The hourly value can change until that hour ends. Waiting for the five-minute candle to close doesn’t automatically confirm the hourly input.
Ask the script’s author which requested values are confirmed, whether signals move after refresh, and whether any plots are shifted into earlier bars. A label drawn on an earlier candle may become known only later. Its chart position alone doesn’t establish when an executable signal existed.
Keep a forward-testing record of signals as they happen. Save the event time and relevant values, then compare them with the chart after reload. This is a diagnostic recommendation, not a guarantee that every repainting issue will appear during a short test.
3. Are you using the same fill assumptions?
A historical fill depends on the simulator’s assumptions. TradingView uses a broker emulator; by default, newly created market orders fill on the next available tick, typically the next bar’s open in historical testing. Its strategy documentation also covers historical price-path assumptions, costs and non-standard chart limitations.
Review order timing, commission and slippage settings. Heikin Ashi and other synthetic charts also require care because displayed prices may differ from tradable market prices. Available intrabar testing tools can improve detail, but don’t turn a simulated fill into a broker fill.
Suppose one historical candle reaches both your stop and your target. The sequence matters. Compare the simulator’s treatment with the forward execution record instead of assuming the candle’s high and low prove which exit happened first.
TradingView’s strategy FAQ warns that recalculation after fills can produce unrealistic historical outcomes. It also explains how process_orders_on_close changes simulated timing. Enabling a same-close simulation doesn’t reserve that price for an order sent to a broker afterward.
4. Does the alert represent the intended event?
Strategy order-fill alerts refer to fills inside TradingView’s emulator. They don’t report fills from your external broker. TradingView’s alert documentation distinguishes these events from explicit alert() calls. Selecting both can send different kinds of messages from the same script.
For PickMyTrade’s standard strategy workflow, its alert setup guide specifies Order fills only. A deliberately coded custom-message workflow needs its own matching configuration. Don’t change the event type without checking what the receiver expects.
A useful distinction: a signal says a condition occurred, an order-creation event says the script submitted a simulated order, and an emulator fill says that simulated order executed. If you compare different events, the timestamps can differ even when each component behaves as configured.
Check the delivered payload alongside the event type. If placeholders arrive as literal text or the action doesn’t match the intended order, use the TradingView strategy placeholder reference to review the message context.
5. Is the running alert using an older setup?
TradingView saves a snapshot of the script, its inputs and chart context when you create an alert. Later changes on the chart don’t update that running copy. TradingView’s alerts FAQ explains why an existing alert can keep producing signals from an earlier configuration.
You might backtest an updated entry filter while the alert still runs the previous version. That creates a misleading comparison: the current chart appears to reject a trade that the older alert correctly accepts under its own rules.
After changing source code, inputs or the intended chart context, stop the obsolete alert and create a replacement. Record the configuration and creation time. Also check for overlapping alerts so an old copy doesn’t continue sending orders beside the new one.
6. Did the webhook reach PickMyTrade and the broker?
A triggered TradingView alert can encounter a delivery failure. TradingView says webhook requests may occasionally fail and provides a Webhook status column in the alert log. Its webhook documentation also specifies a three-second processing timeout for the receiving server. That timeout isn’t a broker-fill deadline.
Investigate in order: confirm the alert event, inspect delivery status, find the received message in PickMyTrade, then check the broker order record. If PickMyTrade never received the request, a broker fill-price investigation is premature.
If the request arrived, check the processing result. Validate the account, token, mapped symbol and quantity using the PickMyTrade JSON configuration guide. Copy the webhook URL from your current dashboard rather than an old example.
A delivery acknowledgment, an accepted broker order and a completed fill are separate milestones. Use the relevant record to establish each one. Don’t resend a message blindly while an order’s status is uncertain; first reconcile the broker’s working orders and position.
7. Do live size and exit rules match the backtest?
Compare the complete trade instruction, including size and exits. A strategy backtested with one contract won’t reproduce the same account result if live settings multiply its quantity. Likewise, a broker-managed stop and a TradingView-generated exit need explicit coordination.
Check the selected futures contract, account multiplier, pyramiding behavior and reversal handling. Record the position immediately before each signal. An instruction that behaves correctly from flat can behave differently when a manual trade or earlier unmatched order has changed the account.
Decide which component owns each exit. If the broker has already closed a position at its stop, determine how a later strategy exit message will be handled. Don’t assume the chart’s simulated position automatically tracks your broker account.
For a hypothetical cost comparison, suppose average gross profit is $12 per trade. If combined round-trip fees and execution friction average $7, only $5 remains. These are illustrative numbers, not measured PickMyTrade results. Use your own execution history to estimate the actual cost.
TradingView backtest vs live: a reconciliation checklist
Pick one mismatched trade and follow it through the records. Comparing total profit first can hide the cause: a missing entry, a larger position and a worse fill can all change the equity curve. A single-trade investigation gives you a specific problem to fix.
| Check | Record to keep | Question to resolve |
|---|---|---|
| Configuration | Script version, inputs, timeframe, chart type and calculation settings | Was the same strategy running? |
| Signal | Candle time and confirmation rule | Did the condition exist when the alert acted? |
| Alert | Event type, event time and delivered payload | Was the intended event sent? |
| Delivery | Webhook status and receiver log | Did the instruction reach PickMyTrade? |
| Order | Broker order ID, status, symbol and quantity | Was the correct order accepted? |
| Execution | Fill time, average price and filled quantity | Did timing or execution change the result? |
| Position and exit | Position before and after, protective orders and exit fills | Did account state and exit handling agree? |
Normalize timestamps to the same timezone. Distinguish a candle’s displayed time from the alert-event time and broker-fill time. Keep those fields separately rather than treating them as interchangeable.
Run this process in a demo environment across the cases your strategy supports: entries, exits, reversals and partial exits where applicable. Demo testing checks the workflow; it doesn’t prove live execution quality or future profitability.
Once the logs agree on the intended actions, evaluate price differences and trading costs. Change one setting at a time and repeat the relevant case. If the trade count differs, keep investigating signals and routing before attributing the gap to slippage.
Frequently asked questions
Check intrabar calculation, repainting, the selected alert event and the alert’s saved configuration. A historical chart and a running alert can use different information or settings. Start with the first signal that disagrees and compare the script configuration before investigating broker execution.
No. A strategy order-fill alert reports a simulated fill in TradingView’s broker emulator. In a webhook automation workflow, that event sends instructions onward. Your broker’s execution history is the record to use for the actual fill price, filled quantity and execution time.
They can reduce differences caused by temporary intrabar conditions when the strategy is designed for confirmed signals. They don’t eliminate higher-timeframe confirmation issues, delivery failures, stale alert configurations or broker execution differences. Confirm the strategy’s intended timing before changing its alert behavior.
PickMyTrade routes configured TradingView alert instructions to your connected account. It doesn’t make a repainting signal reproducible or guarantee historical fill prices. Validate the received instructions and broker results in a demo setup, then use actual execution records to assess remaining differences.
Ready to check your automation? Set up TradingView automation with PickMyTrade, start with a demo account, and reconcile an entry and exit across the alert and broker logs before using live funds.
Disclaimer:
This content is for informational purposes only and does not constitute financial, investment, or trading advice. Trading and investing in financial markets involve risk, and it is possible to lose some or all of your capital. Always perform your own research and consult with a licensed financial advisor before making any trading decisions. The mention of any proprietary trading firms, brokers, does not constitute an endorsement or partnership. Ensure you understand all terms, conditions, and compliance requirements of the firms and platforms you use.
Also Checkout: Automate TradingView Indicators with Tradovate Using PickMyTrade
