TL;DR. The Visual Builder is a node-based canvas where you wire indicators, logic, and order management together to build a strategy. The same blueprint you draw is what runs in the backtest engine and, later, on a live broker connection — there is no second translation step.
What you'll be able to do
- Open a blank canvas, find the right node, drop it on, and connect it correctly the first time.
- Recognize the four functional roles every node falls into, and which palette category contains the one you need.
- Build a multi-timeframe, multi-instrument strategy on one graph using the data series system — without code.
Visual Builder — a real EMA-cross-with-cooldown strategy on the canvas
What it lets you do
The Visual Builder is the design surface for every strategy you run in AlgoLift. A strategy is a directed graph: data flows from the left (indicators, price, time) through logic and math in the middle, and out the right side into order actions. There is no script, no templating engine, no "block-based programming" wrapper around code that you can't read. The graph is the strategy. The backtest engine consumes the same graph; so does the live executable.
Three things this gets you that wizard-style builders don't:
- Composability. Any output handle whose data type matches an input handle can be connected. The system catches type mismatches at connect time — you can't build a structurally invalid strategy.
- Inspectability. You can right-click any wire and see the live value it would carry at any bar in your backtest range. There is no "magic" happening between the indicator and the entry.
- Reuse. Logic you build once can be saved as a Cluster, then dropped into any future strategy as a single node.
Where to find it
The Visual Builder opens by default when you create a new strategy from the dashboard. The canvas takes up the center of the screen; the node palette sits on the left, and the inspector panel sits on the right and shows the settings for whichever node you have selected.
Empty Visual Builder — palette left, canvas center, inspector right
The four roles every node fills
Every node on the canvas does one of four jobs. Knowing which is which is the single fastest way to read a strategy graph.
- Data nodes — the sensors. They pull values into the graph. The Current Price node, the Current Time node, indicator nodes like RSI and EMA, and the Price Action library (Fair Value Gaps, Swing Points, etc.) all live here. Data nodes have output handles on the right and no input handles.
- Logic nodes — the brain. Comparison (
>,<,==), boolean gates (AND, OR, NOT), and math operators (+,−,×,÷). These nodes evaluate whether your conditions are met. - Control-flow nodes — the gates. Conditional Flow, Cooldown, and Tally shape when a signal can fire, not just whether it can. The Cooldown node, for example, refuses to re-trigger an entry until a reset condition is met — which is what prevents the classic "machine-gun" problem in trending markets.
- Action nodes — the hands. Entry, Scaled Entry, Bracket Order, Trade Management, Set Stop Loss, Set Target Profit. These are the only nodes that affect P&L.
Strategies read left-to-right: sensors → brain → gates → hands. If a graph doesn't read that way, it's probably wired wrong.
Every node on the canvas is either a sensor, a brain, a gate, or a hand. Read a graph by tracing those four roles in order and you'll understand any strategy in under a minute — including someone else's.
The palette — where things actually live
The palette is grouped into these categories. The grouping matches the four roles above, plus utilities:
| Palette category | What's in it | Role |
|---|---|---|
| Indicators | RSI, EMA, MACD, ATR, Bollinger Bands, the full indicator library (~40 indicators across 5 sub-categories) | Sensor |
| Price Action | Fair Value Gaps, Swing Points, Custom Candle, Multi-Bar Formation, channels — see the PA node reference | Sensor |
| Data | Current Price, Current Time, Time — Custom | Sensor |
| Logic & Flow | AND, OR, NOT, Comparison (>, <, ==), Conditional Flow, Conditional Value, Tally, Cooldown | Brain + gates |
| Math & Operators | +, −, ×, ÷, Constant, modifiers (Bars Ago, Rolling Min/Max, Z-Score, Percentile Rank, ROC) | Brain |
| Modifiers | Wrap any data source to transform it: EMA of EMA, Z-score of RSI, ATR from 5 bars ago | Brain |
| Order Management | Entry, Scaled Entry, Bracket Order, Trade Management, Set Stop Loss, Set Target Profit, Set Exit Condition | Hand |
| Variables | Set Variable, Get Variable — for state that persists across bars | Utility |
| Favorites / Recent / Custom Clusters | Your own shortcuts | Utility |
Palette — categories expanded to show what's inside
Step-by-step — your first connection
1. Drop a sensor
Open the Indicators category, find EMA, and drag it onto the canvas. The inspector on the right shows its settings — leave Period at the default for now.
Dropping an EMA node onto the canvas
2. Drop the brain
From Logic & Flow, drag a Comparison node onto the canvas. Drag the Current Price node from the Data category alongside it.
3. Wire them up
Click and hold the EMA node's output handle (right side), drag the wire to Input A on the Comparison node, and release. Repeat with Current Price → Input B. Set the Comparison operator to <.
You've now expressed: "Price is below the 20-EMA." That's the whole signal.
EMA + Price → Comparison — a complete bearish signal
4. Drop a hand
From Order Management, drag the Entry node onto the canvas. Connect the Comparison output to the Entry's condition handle.
The graph now reads: "When price is below the 20-EMA, enter a long position." That's a complete (terrible) strategy. The next pages — Entry & Exit Logic and Position Sizing — show how to turn this kind of one-condition signal into something worth running.
Multi-series and multi-instrument
A single strategy graph can read from multiple symbols and multiple timeframes at the same time. The mechanism is data series: each indicator node has a source series setting, and you can add as many series to a strategy as you want.
Common patterns this unlocks:
- Higher-timeframe filter. A 60-minute EMA filters trades taken on a 5-minute execution chart. Same graph, two series.
- Cross-instrument confirmation. A breakout on NQ is only valid if ES confirms — wire the two Current Price nodes into an AND gate together.
- Custom bar types. Mix time-based bars (1m, 5m) with tick bars, volume bars, or range bars on the same graph to filter out chop. The tick vs bar data page covers when each makes sense.
How data series flow
When you add a second series to a strategy, the engine evaluates the entire graph once per bar of the primary series. Indicators on slower series carry their last-known value until the slower series prints a new bar. This is what makes higher-timeframe filters cheap to compute — you're not running the slow EMA 60 times per minute, you're reading its current value 60 times per minute.
Dynamic logic — exits that adapt
The strongest pattern the builder enables is wiring logic into trade management, not just into entries. Three examples:
- Volatility-scaled stops. Pipe an ATR value into a math node, multiply by 1.5, and feed the result to Set Stop Loss. Now stops widen in volatile sessions and tighten in calm ones automatically.
- Scale-ins. Wire a second Entry node to the same trade with a different condition. The engine adds to the position when the second condition fires (and the first one is still active).
- Partial exits. Use Set Target Profit with a fractional position size to sell 50% at target A, then let a trailing stop run the remainder.
Volatility-scaled stop loss — ATR wired into Set Stop Loss
Node Clusters — reuse without copy-paste
When a piece of logic shows up in multiple strategies (a standard 3R bracket, a session-time filter, an ATR stop), select the nodes, right-click, and choose Save as Cluster. The cluster becomes a single node in your palette under Custom Clusters, with whatever inputs and outputs you exposed.
This is how power users keep their canvases readable. A 40-node strategy collapses into a 6-node strategy made of named blocks — and when you improve the cluster, every strategy using it picks up the change.
Pro pattern: build your own standard library
Most experienced AlgoLift users have 4–8 personal clusters that show up in nearly every strategy: a session filter, a volatility regime, a position-sizing block tied to account equity, a prop-firm daily-loss kill switch. Building these once saves hours over the next year.
Translate to Text
At any point you can toggle the Translate to Text view. The graph compiles into a human-readable rule set ("If 20-EMA is above 50-EMA AND RSI is below 30, enter long with a 1.5×ATR stop"). Clicking a line highlights the corresponding nodes on the canvas. This is the fastest way to:
- Verify a strategy says what you meant before you backtest it.
- Share a strategy idea with someone in chat without screenshotting.
- Diff two strategies — paste the text into any compare tool.
Common mistakes
- Forgetting the Cooldown. A strategy that fires every bar a condition is true will machine-gun trades in trending markets. Wire a Cooldown node into the Entry's cooldown handle, with a "reset condition" that says when re-entry is allowed. The Your First Strategy walkthrough demonstrates this.
- Hard-coding levels. Constants like "stop loss at 4290.50" don't survive contact with a different date range or instrument. Make exits relative to entry price or to ATR.
- Branchless graphs. A strategy with no
NOT, noOR, and no Conditional Flow usually means you've collapsed too many ideas into one condition. Break it up — clarity beats compactness here. - Building entry-only. Designing entries without designing exits is the most common reason backtests look great and live results don't. Treat the exit logic as half the strategy.
How this fits the workflow
You design here. You validate in the Backtest Engine. You read the results in Analytics. You combine strategies in the Portfolio Builder. You forward-test before going live. You export and run on your broker. Every other feature in AlgoLift either feeds this canvas or consumes what comes out of it.
The graph you draw is the strategy. There is no second translation layer to a script, no template to fight, and no "advanced mode" hiding the real engine. Master the four roles, the seven palette categories, and the Cluster pattern, and you can express almost any systematic trading idea on this canvas.