strategy / Strategies / Strategy Builder / Backtesting
Low-code strategy builder for traders who have rules worth testing and do not want to become Pine developers to do it.
Last updated: Jun 6, 2026
Crypto / Forex +4 / 1m / 5m +5
Monthly / Yearly / One-time access
$50.00/ month
14-day free trial
You need a TradingView account for tools that open or run on TradingView.
These tools support analysis, testing, planning, and review. They do not make trading decisions for you.
14-day monthly trial / 14-day yearly trial / 30-day one-time refund window
Explore the details to see whether the tool fits the problem you are trying to solve for.
You already have trading ideas.
Maybe they live in a notebook. Maybe they come from a repeatable chart-reading process. Maybe they combine price action, custom indicators, volume tools, market structure, and risk rules that you have been refining for years.
The hard part is not having ideas.
The hard part is turning those ideas into something you can actually test.
Most traders hit the same wall: to run a serious backtest in TradingView, you usually have to learn Pine Script, hire a developer, manually count trades, or trust a black-box strategy someone else built. Every option creates friction. Pine has a real learning curve. Developers cost money and slow down iteration. Manual backtesting is inconsistent and hard to reproduce. Black-box tools may show signals, but they rarely let you own the logic.
Axiom Strategy Lab Pro is built to close that gap.
It gives you a low-code strategy-building environment inside TradingView where you can define your own setups, entries, take profits, stop losses, and risk behavior using structured YAML instead of writing an entire Pine Script strategy from scratch.
You bring the methodology. Axiom handles the strategy engine.
AI can be useful for brainstorming, drafting logic, or helping you think through strategy structure.
But there is a big difference between asking AI to generate a Pine Script strategy and using a dedicated environment for testing trading logic.
Pine Script is specialized. Advanced Pine strategies require careful handling of order behavior, state, repainting risks, bar timing, pyramiding, exits, position sizing, Strategy Tester assumptions, and TradingView-specific execution quirks. Even strong AI models can produce Pine that looks right, compiles, and still does not behave the way the trader intended.
Axiom Strategy Lab Pro takes a different approach.
Instead of asking AI to rebuild everything from scratch, you work from a structured strategy framework designed specifically for TradingView testing.
You define the rules. You reference named tokens. You connect indicator outputs. You inspect the logic. You test the result.
That makes Axiom a stronger workflow than prompt, pray, paste, and debug.
Most AI-generated Pine workflows start from zero.
You describe your strategy in a prompt, then the AI tries to recreate every part of it: the indicator calculations, the conditions, the entries, the exits, the risk model, and the backtest behavior.
That is fragile.
Axiom Strategy Lab Pro lets you work differently.
If an indicator on your TradingView chart plots useful information, you can link that output into Strategy Lab as a custom token and use it directly in your YAML expressions. That means your strategy can reference data from external indicators without needing to rebuild those indicators inside a new Pine strategy.
This matters because many traders already have tools they trust.
They may use Axiom indicators. They may use marketplace indicators. They may use private scripts. They may use custom chart tools that expose plotted values or alert conditions.
With Axiom Strategy Lab Pro, those tools can become part of a testable strategy framework. You are not forced to rebuild your entire trading stack from scratch just to test an idea.
Axiom Strategy Lab Pro is not a prebuilt strategy.
It does not ship with hidden buy and sell rules. It does not promise profitable signals. It does not pretend a backtest is a forecast.
It is a strategy-building environment.
You write your trading logic in structured YAML configuration, paste it into the Strategy Lab settings panel, and the builder translates those definitions into executable strategy behavior inside TradingView's Strategy Tester.
You can define:
| Strategy component | What it controls |
|---|---|
| Setups | The market conditions where trading is allowed |
| Entries | The specific triggers and order behavior used to open positions |
| Take profits | How winning trades scale out or close |
| Stop losses | How risk is managed when trades move against you |
| Risk controls | Direction mode, drawdown limits, intraday loss limits, order caps, and more |
| External tokens | Custom values from indicators already on your chart |
When you want to change the strategy, you change the YAML and rerun the test.
No full Pine rewrite. No developer handoff. No waiting on someone else to interpret your rules.
Axiom Strategy Lab Pro is for traders who want more than a signal.
It is for people who want to answer questions like:
The builder does not replace your judgment.
It gives your judgment a testing environment.
Most trading strategies are not one condition.
They are layered.
A trader might want price above a moving average, volume above a threshold, volatility in a certain regime, an indicator confirmation, a specific entry trigger, a take-profit ladder, and a stop rule that behaves differently depending on the setup.
Strategy Lab Pro is designed for that kind of thinking.
It uses a three-layer structure:
Setups define when a market condition is worth paying attention to.
Each setup carries a gate condition that must be true before anything else evaluates, an activation expression that moves the setup toward confirmation, an optional confirmation period, cooldown rules, and a cap on how many entries can fill per activation.
Think of setups as structured windows of opportunity. They open when your conditions align and stop admitting new entries when the setup cancels, resets, or exhausts its activation-scoped entry cap.
Entries belong to setups.
An entry only evaluates when its owning setup is confirmed. Each entry can have its own gate condition, trigger expression, order type, allocation size, and optional price expressions for limit and stop orders.
This lets you separate the broader market context from the actual execution trigger.
Exits manage how positions close.
Take-profit and stop-loss intents each carry their own gate conditions, trigger expressions, order types, and allocation percentages. Exit quantities are calculated proportionally against the peak position size for each entry group, not against whatever is left after earlier exits fill, so your exit ladder holds its shape from the first fill to the last.
A built-in GLOBAL setup exists for each enabled direction. Any entry or exit that does not specify a parent setup attaches to GLOBAL, which is always confirmed. You can build a complete strategy using only GLOBAL, or you can define named setups that gate entries to specific market conditions.
Strategy Lab Pro is intentionally not a click a few buttons and hope tool.
You are still responsible for defining the trading logic.
The difference is that you do not have to write a complete Pine Script strategy engine to test it.
YAML gives you a structured way to describe the rules while preserving control over the details that matter:
That is the tradeoff.
There is a learning curve, but it is the learning curve of owning your system instead of outsourcing it.
When the builder evaluates entries on each bar, it follows this sequence:
Entries and exits support market, limit, stop, and stop-limit order types. Non-market entry orders stay working across bars until they fill, get cancelled by a cancel-when condition, expire if that entry defines entry_expire_after_bars, or get cleaned up when their parent setup resets. Non-market exits stay working until they fill, are cancelled, or lose their position cycle.
Price latching lets the limit or stop price lock at the moment the entry condition first triggers. The order holds that price on subsequent bars rather than recalculating, which helps prevent drift while the order is working.
One-shot vs. pyramiding matters. One-shot entries fire once per activation scope and stay latched until that scope resets. For named setups, that means once per setup activation. For GLOBAL entries, that means once per position cycle. Pyramiding entries can add to an open position up to the maximum you configure. The pyramiding maximum you set in YAML interacts with the strategy-level pyramiding cap in the Properties tab. Whichever is lower takes effect.
Exits evaluate per entry group. Each unique entry that has produced open trades is managed by its own applicable take-profit and stop-loss intents.
For each group, the builder follows this flow:
Price latching on exits works the same way as on entries. When enabled, the exit order's price locks at the moment the condition triggers and does not recalculate on subsequent bars.
One of the biggest problems with AI-generated Pine is that debugging quickly becomes technical.
A strategy may compile but behave incorrectly. An order may fire for the wrong reason. A condition may evaluate differently than expected. A generated script may include logic that looks reasonable but does not match your actual methodology.
Strategy Lab Pro gives you tools to inspect what is happening.
That means when something goes wrong, you are not just staring at generated code.
You can trace the path from your rule, to the parsed configuration, to the expression value, to the trade that appeared in the tester.
Strategy Lab Pro includes strategy-level controls that operate above your YAML-defined trade logic.
| Control | Default | What it does |
|---|---|---|
| Strategy Direction | Long Only | Restricts which direction the builder evaluates. Choose Long Only, Short Only, or Swing Mode. |
| Max Strategy Drawdown | 20% of equity | Halts simulated trading when drawdown from peak equity exceeds this threshold. |
| Max Consecutive Loss Days | 5 | Halts simulated trading after this many consecutive losing days. |
| Max Intraday Loss | 10% of equity | Halts simulated trading when single-day loss exceeds this threshold. |
| Max Intraday Filled Orders | 10 | Caps the number of order fills in a single day. |
These controls are not live brokerage safeguards. They operate inside the Strategy Tester simulation.
Their purpose is to help you model strategies that respect risk boundaries instead of testing ideas under unrealistic conditions, but they do not protect actual capital.
Order expiration is not a global risk control in this build. Non-market entry expiration is configured per entry with entry_expire_after_bars.
A consent checkbox requires you to confirm you have reviewed the Properties tab before the strategy will run. The Properties tab settings directly shape your backtest results. Testing under defaults you never reviewed means testing under assumptions you never chose.
Axiom Strategy Lab Pro is built for serious testing.
That means the tool does not treat a backtest as proof.
Every Strategy Tester result depends on assumptions: slippage, commission, fill model, bar resolution, historical depth, pyramiding, order timing, and the behavior of any external indicators you connect.
A beautiful equity curve can still be misleading.
A high win rate can hide poor risk-reward. A small sample can create false confidence. A zero-slippage test can make a weak idea look strong. A repainting indicator can contaminate the entire result. An overfit strategy can collapse the moment market behavior changes.
Strategy Lab Pro helps you run the experiment.
It does not tell you what to believe.
Every number the Strategy Tester produces is a product of assumptions. Change any one of these and the results change with it.
| Setting | Default | Why it matters |
|---|---|---|
| Slippage | 15 ticks | Models how far the fill price deviates from the order price. Fifteen ticks may be reasonable for liquid instruments and may understate the problem on illiquid ones. Setting it to zero simulates a market that does not exist. |
| Commission | 0.1% | Models per-trade cost. The default suits crypto spot trading at standard fee tiers. For equities, futures, or forex, match this to the venue and fee schedule you actually trade on. |
| Fill model | Standard OHLC | The tester decides whether your limit or stop order filled by checking the bar's open, high, low, and close, not intrabar tick data. |
| Process orders on open | Enabled | Orders submitted during a bar execute at the next bar's open, creating a timing gap between the condition and the fill. |
| Bar magnifier | Off | The tester does not refine fills using intrabar price paths. It assumes price can reach any point within the bar's range in any sequence. |
| Pyramiding | 50 | Up to 50 concurrent open trades are allowed by default. If your rules do not intentionally stack positions that deep, reduce this number or cap entries in your YAML. |
| Calc bars count | 50,000 | The backtest runs on up to 50,000 historical bars. Know how much history your test covers before drawing conclusions from it. |
Use conservative assumptions. Then test again with different date ranges, instruments, timeframes, and market conditions. The goal is not to create the perfect backtest. The goal is to make your assumptions visible enough to challenge them.
One of Strategy Lab Pro's biggest advantages is that it can work with indicator outputs already on your TradingView chart.
You can add an external indicator, link one of its plotted outputs into a custom token slot, give that token a name, and reference that name inside your YAML expressions.
For example, you might connect:
This lets you test strategies that depend on existing tools without asking AI or a developer to reverse-engineer those tools into a new Pine strategy.
Important: if an external indicator repaints, the backtest can become unreliable. Strategy Lab Pro cannot automatically verify whether a third-party indicator repaints. You are responsible for confirming that any connected indicator behaves appropriately for strategy testing.
Axiom indicators are designed with Strategy Lab compatibility in mind, making them a natural starting point for building reliable workflows inside the Axiom ecosystem.
When you hit an issue, start with diagnostics before changing the strategy. Confirm the YAML parsed. Confirm the expressions evaluate the way you think they do. Confirm the tester settings match the environment you intended to model.
Use Strategy Lab Pro to test ideas like:
Axiom Strategy Lab Pro is for traders who:
Axiom Strategy Lab Pro is not for people looking for:
This is a builder, not a prediction machine.
Generic AI can help you write code.
Axiom Strategy Lab Pro helps you build a repeatable strategy research workflow.
That difference matters.
| AI Pine generation | Axiom Strategy Lab Pro |
|---|---|
| Starts from a prompt | Starts from structured strategy logic |
| Often rebuilds indicators from scratch | Can reference indicator outputs already on your chart |
| Requires debugging generated Pine | Lets you inspect YAML, expressions, tokens, and tester behavior |
| Can drift from your original intent | Keeps the rules explicit and readable |
| Produces one-off scripts | Gives you a reusable strategy-building framework |
| May compile but behave incorrectly | Provides diagnostics to trace logic and execution |
| Depends on AI understanding Pine deeply | Uses a purpose-built TradingView strategy engine |
AI is useful.
But a serious trading workflow needs more than generated code.
It needs structure, repeatability, diagnostics, and a clear separation between the trader's rules and the engine that executes them.
That is what Strategy Lab Pro is built to provide.
The Strategy Tester produces numbers. Numbers feel objective. But every figure on the results tab is the output of a simulation running under the assumptions you configured, or left at default.
Net profit is the simulated outcome after the slippage and commission you set. Change either setting and the figure changes with it. It describes a historical simulation, not a forward projection.
Win rate reflects the pattern the simulation found under your specific conditions. It does not describe the future. A high win rate paired with a low average win and a large average loss is a losing approach disguised as a winning one.
Max drawdown is the deepest peak-to-trough decline the simulation recorded. It is the worst that happened in the test, not the worst that can happen in live markets, where liquidity gaps, exchange failures, and correlated moves create drawdowns no historical simulation can anticipate.
Equity curve shape is seductive and easy to overread. Ask whether that shape would survive a different data window, different cost assumptions, and a market regime that did not exist in the test period.
Trade count determines how much weight any statistic deserves. A strategy that produced 15 trades and a 70% win rate has not proven anything. Small samples support weak conclusions regardless of how good the numbers look.
Strategy Lab Pro runs inside TradingView's Strategy Tester, which is a simulation environment.
It does not model every real-world trading condition.
It does not fully represent order book depth, exchange downtime, partial fills, liquidity gaps, broker execution differences, or all intrabar sequencing behavior.
The Strategy Tester is not a market. Strategies that work in simulation can fail live for reasons the simulation has no way to represent.
Fill timing differs from live execution. Market entries process on the next bar's open, market exits in this build use same-bar immediate closes, and working exits fill against the bar's OHLC range rather than true tick-by-tick sequencing. Strategies with tight price targets or time-sensitive entries will behave differently in practice than in the tester.
Fast iteration creates overfitting risk. The more quickly you can change rules, the easier it becomes to keep adjusting until the visible equity curve looks good. That is not strategy development. That is fitting noise. Use out-of-sample testing, different markets, different regimes, and conservative assumptions before drawing conclusions from any result.
External indicators can contaminate results. When you link an indicator as a custom token, the strategy's behavior depends on that indicator's calculation. If the indicator repaints by revising past values with information that was not available when those bars closed, the backtest incorporates future data and the results are invalid. The builder cannot detect this. You need to verify it.
Complexity is not a feature. Thirty custom tokens, unlimited setups per direction, multiple entry and exit tiers, four order types, price latching, pyramiding, and OCA grouping give you room to build something elaborate. Elaborate strategies are harder to interpret, harder to debug, and more prone to overfitting. A simple set of rules that survives scrutiny across different conditions is worth more than a multi-layered configuration that only works on the data it was shaped against.
This builder does not automate live trading. The script includes no dedicated alert or webhook automation workflow. TradingView offers strategy-level alerts as a platform feature, triggered on simulated order fills, but connecting those alerts to a live broker requires external tooling and introduces execution risks that fall outside what the Strategy Tester models.
The builder is not a conventional strategy script with fixed conditions baked into the code. It is a runtime engine that reads, compiles, and evaluates trader-authored rules each time the script loads.
Here is what happens between the YAML you write and the trades that appear in the tester:
Parsing - A dedicated parsing library reads your YAML text, validates the structure, checks required fields, normalizes defaults, and produces a typed schema representing every setup, entry, take profit, and stop loss you defined.
Expression compilation - The engine compiles every expression in your YAML, including gate conditions, trigger logic, and price formulas, into an evaluable form before bar-by-bar processing begins. Expressions reference named tokens: price fields, bar state, strategy statistics, position information, and any custom indicator outputs you linked. These tokens resolve against a map that refreshes on every bar, so your conditions always reflect the current state.
Setup evaluation - Named setups move through inactive, confirming, and confirmed runtime states. The _ACTIVE token is a convenience boolean, not a distinct state. Conditions you define govern each transition. This means entries do not evaluate on every bar regardless of context. They evaluate only when their parent setup has reached the confirmed stage, creating structured windows of eligibility rather than a constant free-for-all.
Order reconciliation - Once the engine determines which entries and exits should fire, it translates those intents into native TradingView strategy calls and the Strategy Tester simulates the result.
What you can verify - The schema summary table shows exactly what the parser extracted from your YAML. The expression debug label shows how each expression evaluates in real time on every bar. The runtime error table catches anything that failed to parse, resolve, or validate. Between these three diagnostics, you can trace the full path from YAML to trades without guessing.
What this section does not cover - The parser's internal field resolution, the expression compiler's operator implementation, the state machine's transition constants, and the order reconciliation internals. Those details make the engine work. They are not needed to use it, verify it, or build confidence in what it produces.
I pasted my YAML but the strategy shows no trades. What is wrong?
Start with the basics. Is the consent checkbox checked? Without it, the strategy will not run at all. Next, enable the schema summary table and the runtime error table. If your YAML has a syntax problem, like a missing colon, a broken indent, or a field name the parser does not recognize, the error table will flag it. If the schema parses cleanly but no setups are activating, enable the expression debug label and check whether your gate and activation conditions are actually met on the instrument and timeframe in front of you. Sometimes the conditions are valid but never align on that particular data. That is a finding about your rules, not a problem with the builder.
My backtest shows strong results. Can I trade this live?
A strong backtest means your rules produced favorable simulated outcomes under the specific assumptions you configured, on the specific historical data the tester covered. It does not mean those rules will produce the same outcomes going forward. Before treating any backtest as actionable, verify the slippage, commission, and fill assumptions you ran with. Test on different date ranges or instruments. Ask yourself honestly whether you kept adjusting rules until the equity curve looked right. That is curve-fitting, and it is the most common way a tool like this creates false confidence. A positive backtest is a hypothesis that warrants further testing, not a conclusion.
How do I connect an indicator on my chart to use in my YAML expressions?
Add the indicator to your chart first. In the builder's settings, find the custom token section. There are 30 slots available. For each slot, select the indicator's output as the source and assign a name, such as RSI_VALUE or VOL_MA. That name becomes available in your YAML expressions wherever you need it.
One thing to know: the builder cannot check whether a linked indicator repaints. If it does, your backtest will use information that was not actually available at the time each bar closed, and the results will be unreliable. Verify repainting behavior yourself before trusting any test that depends on external indicator tokens. If in doubt, Axiom's own indicator library is the natural starting point because those tools are designed with Strategy Lab compatibility in mind.
Why did the strategy take a trade I did not expect?
Enable the expression debug label and find the bar where the trade occurred. Check what your setup gate, setup activation, entry gate, and entry trigger evaluated to on that specific bar. Common causes include a gate condition that is broader than you realized, a trigger expression that fired on an intrabar evaluation you were not watching, or an entry attached to GLOBAL, which is always confirmed, rather than to a named setup. Also check the Properties tab. If the pyramiding cap is higher than you intended, entries can stack in ways that look unplanned but still match exactly what the configuration allows.
What happens if I set slippage and commission to zero?
The backtest will look better than any real trading environment could produce. Slippage and commission model the costs that reduce every real trade's return. Removing them removes the simulation's connection to actual execution conditions. If you want to isolate whether your entry and exit logic has structural merit, keep costs at conservative levels and compare gross versus net equity. If the strategy only looks viable at zero cost, it does not work.
When you run into an issue, start with the built-in diagnostics:
These tools help you diagnose whether the problem is the YAML structure, the expression logic, the indicator token, or the strategy assumption itself.
For documentation, configuration reference, and support, visit the Axiom Charts website.
Axiom Strategy Lab Pro is provided for educational and informational purposes only.
It is not financial advice. It is not a recommendation to buy, sell, or hold any financial instrument. It is not a guarantee of profitability. It does not predict future performance.
TradingView's Strategy Tester simulates trades on historical data under assumptions configured by the user. Simulated results do not represent actual trading, do not account for all real-market conditions, and are not indicative of future results.
Trading involves substantial risk of loss and is not suitable for every person.
You are solely responsible for your own trading decisions, your own risk management, and your own interpretation of any backtest or strategy output.
If this one is close but not quite right, there may be a better fit nearby for the same kind of chart work, testing need, or workflow gap.
indicator / indicators
A five-slot multi-timeframe CVD oscillator with a weighted composite and optional structure context — divergence, Keltner, BBWP, and Donchian — all built on the composite itself. STR trades CTX's ten-slot breadth for blended-line structure.
Crypto / Stocks +3 / 1m / 5m +5
indicator / indicators
A five-slot multi-timeframe MACD oscillator with a weighted MACD/signal/histogram composite and optional structure context — divergence, Keltner, BBWP, and Donchian — all built on the composite itself. STR trades CTX's ten-slot breadth for blended-line structure.
Crypto / Forex +4 / 1m / 5m +5
indicator / indicators
Five independent RSI slots, a weight-gated blend, and pivot divergence, Keltner, BBWP, and Donchian context computed on that blend — all inside RSI's native 0..100 frame.
Crypto / Forex +4 / 1m / 5m +5
Tell us what you are trying to accomplish and we will help you narrow it down honestly.
