TL;DR. AlgoLift is built around a single repeating workflow: design → backtest → analyze → optimize → forward-test → export. Each stage has its own tool; each tool is covered in depth elsewhere in the guide. This page is the 10-minute tour of how the pieces connect — read it once to build a mental map, then dive into the section for whichever step you're working on.
What you'll be able to do
- Trace a strategy from its first node on the canvas to its final live executable.
- Know which platform tool you're supposed to be in at each stage of strategy development.
- Avoid the most common workflow mistake: skipping a stage you'll wish you hadn't.
The AlgoLift workflow — six stages, one loop
The six-stage workflow
Every strategy that ends up trading real capital goes through the same six stages, in the same order. Skipping a stage is possible; it's also the most common reliable predictor of a strategy that fails live.
1. Design — the Visual Builder
You start on a blank canvas in the Visual Strategy Builder. The left side shows the node palette: indicators, logic, math, modifiers, order management, variables. You drag nodes onto the canvas and connect them.
Every connection is type-checked at the moment you make it. You can't wire a boolean into a numeric input or a price into a time slot — the canvas refuses. The result is that any strategy you can finish building is, at minimum, structurally valid. That doesn't mean it's profitable; it does mean the underlying engine will accept it.
The Visual Builder is also where multi-instrument and multi-timeframe strategies live. A 60-minute trend filter that gates 5-minute execution trades is two data series on the same graph. The Visual Builder page covers the mechanics.
2. Backtest — the Backtest Engine
When the graph is ready, you click Run Backtest. The engine takes your strategy, splits the date range into monthly chunks, and runs those chunks in parallel on cloud workers. A 10-year MES 5m test finishes in 30–90 seconds.
What "tick-accurate" means here, specifically:
- The engine processes every print in the historical tape, not just the open/high/low/close of each bar.
- It tracks the bid/ask spread changes between prints, so market orders pay the real spread.
- It models limit-order queue position, so your limits only fill when the historical volume actually cleared the orders ahead of yours.
- It walks the historical depth for market orders larger than the touch.
This stage produces a result packet — every trade, every signal evaluation, every per-bar indicator value, plus the summary metrics. That packet feeds into the next stage.
3. Analyze — Results & Analytics
The Analytics view turns the result packet into something you can read. Four lenses, applied in roughly this order:
- The summary metrics. CAGR, max drawdown, Sharpe, Sortino, profit factor, expectancy. The trading metrics page covers what each one actually measures.
- The equity and drawdown curves. The shape of the curve is often more informative than the headline numbers.
- The rolling diagnostics. Did the edge persist across time, or did it concentrate in one regime?
- The trade list and MAE/MFE distributions. Sort by worst PnL ascending and audit the worst 10 trades. This is where most strategy flaws are visible.
If the analysis looks promising, you move on. If it doesn't, you go back to step 1 and iterate.
4. Optimize — the Optimization tools
Once a strategy looks reasonable at default parameters, the next question is: which parameter set is best, and is the result robust to small changes?
The platform exposes three optimization workflows:
- Parameter sweeps — test a range of values for each parameter, see the surface, look for plateaus instead of spikes.
- Walk-forward optimization — automatically split the data into training and test windows, re-optimize at each step, and see how well "best parameters from window N" perform on window N+1.
- Monte Carlo simulation — shuffle the trade order and see whether the equity curve was determined by the strategy's edge or by lucky sequencing.
The overfitting in trading page covers what these tools detect and why each matters.
5. Forward-test — Forward Testing
A backtest is a controlled experiment on past data. Forward testing is the real experiment — the same strategy running on the live tape, without real capital at risk. The platform runs the strategy on its servers 24/7 against the live feed, and produces a divergence report comparing the live paper results to what the backtester would have produced over the same window.
A small divergence is normal. A large one means you have look-ahead bias, fill-model error, or the strategy is outside the regime it was tuned for. The forward testing page covers how to interpret the divergence report and decide whether the strategy is ready for capital.
Minimum forward-test window depends on trade frequency: intraday scalping wants 2+ weeks (~40+ trades), swing trading wants 8+ weeks. The trade-count is the diagnostic, not the calendar time.
6. Export — Exporting & Going Live
When the forward test passes, you generate a self-contained executable. You download it. You run it on your own machine (or a VPS near your broker's data center). You enter your broker API credentials directly into the local executable — they never touch AlgoLift's servers.
From this point, AlgoLift is not in the live-trading loop. The executable reads ticks directly from your broker's market data feed and sends orders directly back. If AlgoLift's web app is down, your live strategy is unaffected. If your machine is down, the strategy stops — which is why the exporting page covers kill-switches and monitoring infrastructure.
How the platform is organized
The dashboard mirrors the workflow. The four main areas you'll spend time in:
- Strategies. The list of every strategy you've built. Click any one to open it in the Visual Builder. Run a new backtest, fork a variant, or promote to forward testing.
- Portfolios. The Portfolio Builder — combine multiple validated strategies into a single weighted system. Read combined equity, correlation, and risk-adjusted metrics.
- Forward Tests. The list of strategies and portfolios currently running on live data. Their divergence reports and live alerts live here.
- Exports. The history of executables you've generated, with version numbers and the project state at each export.
Where the platform draws the line
Two specific choices that shape what the platform is and isn't:
- No script-based strategy authoring. Every strategy is a node graph. There's no "advanced mode" that drops you into Python. The reasoning: a typed visual builder catches structural errors at design time, which is faster than discovering them in a backtest log at 2 AM. The handful of things that are awkward to express in nodes are mostly things experienced quants don't want to express anyway.
- Cloud research, local execution. Backtests, optimization, and portfolio analysis run on AlgoLift's servers because they need cluster-scale compute. Live trading runs on hardware you control because you need uptime and key sovereignty. The two halves are intentionally separated.
The six-stage workflow — design, backtest, analyze, optimize, forward-test, export — is the heartbeat of the platform. Every page of this guide either explains one of those stages or teaches a concept you'll need at one of them. Build the mental map first; everything else is detail.
The workflow you'll actually do
In practice, the loop you'll spend the most time in is design → backtest → analyze → iterate. The first 10–20 iterations of any strategy live entirely in these three tools. Optimization, forward testing, and export only happen once a strategy clears the first round.
A typical research session for an experienced user looks like:
- Open the Visual Builder. Pull up an existing strategy or start a new one.
- Run a quick backtest with Simulate Fills off for fast iteration (~30s).
- Skim the Analytics view. Adjust a node, change a parameter, re-run.
- Repeat 5–15 times.
- Once the strategy looks promising: switch Simulate Fills on, set realistic commission and slippage, run again. This is the decision-grade test.
- If still promising: parameter sweep to check robustness. Walk-forward to check regime stability.
- If the strategy survives the previous step: promote to forward testing. Wait the minimum window. Read the divergence report.
- If forward-test aligns with backtest: export, start in paper mode on the broker, watch for a day, switch to live.
This is what you'll be doing repeatedly. The rest of the guide is the manual for each step.
How this fits the guide
Each of the six stages has at least one dedicated page; many have a whole section:
- Design → Visual Builder, strategy design, entry & exit logic.
- Backtest → Backtest Engine, backtesting explained, order types & fills.
- Analyze → Analytics, trading metrics.
- Optimize → parameter optimization, walk-forward, Monte Carlo, avoiding curve-fit, overfitting in trading.
- Forward-test → Forward Testing.
- Export → Exporting & Going Live.
You don't have to read everything before starting. The fastest path is to finish this section (one more page to go), build the first strategy hands-on, then circle back to the relevant deep-dive when you need it.