The gap between "this strategy looks good in backtest" and "this strategy is running live" is where most trading ideas die. You optimized the parameters, saved the results, and then what? Manually type the numbers into a live workflow? Run the full sweep on every trigger?
The Parameter Loop worker was designed to bridge that gap. Here's how to go from sweeping to shipping in one workflow.
Every Parameter Loop node has a prodMode dropdown with three options — and choosing the right one for each stage of development is the key to a smooth deployment pipeline.
What happens: During "Run Test", the full sweep executes as normal. During scheduled runs, the worker loads the best parameters from the most recent saved session and uses them directly — no sweep runs.
When to use: Once you've found a good parameter set and want to use it in production, but still want the ability to re-sweep manually on demand.
How it works under the hood:
Your last successful sweep saved a session (because you set sessionLabel)
The session contains bestParameters and bestValue
On production triggers, use_best loads bestParameters and writes them into the worker's vars
The strategy executes with optimized values — no computational waste
What happens: The sweep runs every single time — whether manual test, schedule, or webhook.
When to use: Rarely. Only when market regimes change fast enough that yesterday's optimum is today's loser, and you have enough compute budget to run a full sweep every 15 minutes.
Pinned parameters take priority over the saved session — useful if you've manually verified the values and don't want any risk of loading a wrong session.
Every hour, the workflow runs. The Parameter Loop loads the best parameters, the Backtest runs with those values, and your strategy stays optimized without consuming compute on unnecessary sweeps.
Markets change. The parameters that worked in a trending market may fail in a ranging one.
The fix: Every week (or month), run a manual sweep to verify the current parameters are still optimal. If the results shift significantly, save a new session — production automatically picks up the latest session on the next scheduled run.
One Parameter Loop node. Three modes. A complete path from discovery to deployment.
The takeaway: Don't re-invent strategy deployment. The Parameter Loop's production modes handle it — so you can focus on building strategies, not plumbing.
Your strategy's stop loss works great on Gold — but how does it hold up on Bitcoin? Will the same take-profit target that nails EURUSD also work for GBPJPY? Until now, you had to guess, or run separate workflows for every symbol and stitch the results together manually.
The Parameter Loop worker doesn't care what symbols your strategy trades. Connect a multi-symbol data fetcher and your strategy runs exactly the same way for every asset — but the Parameter Loop adds a second dimension: it also sweeps the parameters.
The result is a 3D optimization grid:
Symbol × Stop Loss × Take Profit = Total Iterations 3 × 5 × 5 = 75
Every combination runs automatically. The best parameter set for XAUUSD might be different from the best set for BTCUSD — and the results table shows you both.
The Swing Finder detects swing points across all three independently. The Backtest evaluates each symbol's signals separately and returns combined statistics.
Find parameters that balance risk across all assets
Cross-market validation
If parameters only work on one symbol, they're overfitted
Volatility regime testing
See which symbol needs tighter SL vs wider TP
Strategy generalization
Build strategies that adapt to any market, not just one
Live Production: Auto-Deploy Per-Symbol Parameters
Save the sweep results as a session, then set the Backtest's Production Mode to use_best. On every scheduled run, the optimized parameters load automatically — no re-sweep needed.
The takeaway: One workflow, one sweep, unlimited symbols. Stop guessing which parameters work where — let the Parameter Loop find out.
Strategies are easy to invent and hard to tune. The same trading idea can be profitable with one combination of (stop_loss, take_profit, size) and a money pit with another. Until now ApudFlow forced you to either hand-pick numbers or write one-off Python scripts (sweep_workflow.py, optimize_swing_strategy.py) outside the platform. The new Parameter Loop worker changes that — you describe the parameter grid once, click Run sweep, and watch every iteration stream into a results table inside the workflow editor.
Parameter Loop runs a single sub-worker multiple times with a different combination of input parameters on every iteration and stores the result of every iteration. The cartesian product of all values lists is executed, so a 3 × 5 grid produces exactly 15 iterations. The result of every iteration is rendered as a row in the right-hand panel of the dialog; the winning iteration (per rankingField / rankingMode) is highlighted in green, failures in red.
It is the worker you reach for when you are trying to answer "which combination of parameters is best?":
backtest → find the best (stop_loss, take_profit, size) triple
The node has its own custom rendering: a dashed border on the canvas (it is a sink — it has no input handle and no output handle) and a two-column layout inside the dialog. The left column holds the sweep configuration (sub-worker selector, parameter grid, ranking settings); the right column holds the per-iteration results table. There is no "central settings" column and no "output of the previous node" column — neither makes sense for a sweep.
The same rendering mode is now available to any worker that wants it. WorkerDefinition gained a new ui_layout field — set it to "two-column" and the dialog switches to the new layout.
subWorkerParameters is the base set of parameters passed to the sub-worker on every iteration. The sweep combination is deep-merged on top of it (the sweep value wins when the keys collide). For example, with:
…the sub-worker will see "symbol": "XAUUSD" on every iteration and "stop_loss" alternating between 2.0 and 3.0.
The sweep values are also reachable from the sub-worker's vars context as vars._sweep (a dict of all sweep values for the current iteration) and vars._sweepIndex / vars._sweepTotal, which is handy when the sub-worker wants to do early-exit logic or label its output.
collectField — dotted path of the field to extract from the sub-worker output (e.g. "result.sharpe"). Leave empty to keep the whole output.
rankingField — dotted path inside the collected result used to pick the best iteration (e.g. "sharpe_ratio").
rankingMode — "max" (default) or "min".
The best iteration is exposed as vars.<nodeName>.bestParameters and vars.<nodeName>.bestValue for downstream workers, so you can act on the winner in a follow-up step (run the best parameters through a live trade, log them to a webhook, send a Telegram notification, …).
continueOnError (default true) — keep going when an iteration throws. Set to false to stop at the first failure.
maxIterations (default 0 = no cap) — safety cap on the total number of iterations to run (useful to avoid accidentally running a 10 000-iteration sweep on a slow sub-worker).
Start with a coarse grid (3 × 3 = 9 iterations) to find the rough optimum, then refine around the winner with a finer grid.
When the sub-worker is slow, set maxIterations to a small number during development and lift it for the final run.
Use continueOnError: true while exploring so a single bad combination does not abort the whole sweep.
Always set a session label — saved sessions let you load results later and enable Production Mode's use_best functionality.
The Parameter Loop node does not route execution to a downstream graph — it is a sink. If you want to act on the result, read vars.<nodeName>.bestParameters in the next node.
Parameter Loop is in the flow category. Drop it onto a canvas, pick the sub-worker, fill in sweepParameters, and the new two-column dialog takes over from there. Happy hunting.
Professional-grade trading strategy development has traditionally required expensive software, complex coding skills, and significant time investment. Today we're showcasing two powerful workers that transform how you build, test, and optimize trading strategies: the Signal Generator and Backtest Strategy with AI-powered optimization.
The Signal Generator is a flexible condition-based signal engine that transforms your indicator data into actionable trading signals. Think of it as a visual "if-then" builder for trading rules.
The Backtest Strategy worker is a high-performance backtesting engine that evaluates your signals against historical data with realistic execution modeling.
Simply check the "🤖 AI Find Best Strategy" checkbox and select your optimization target. That's all - every other parameter is hidden because AI determines them automatically.
Why close_mode: none?
This tells Signal Generator to never generate close signals - the Backtest Strategy handles all exits via stop loss, take profit, and trailing stops. This is the professional approach for momentum strategies.
Why signal_mode: first?
This generates a signal only when conditions BECOME true, preventing duplicate signals on every bar the condition remains true.
A strategy that scores 80+ across 6 blocks is far more likely to perform in live trading than one that shows great overall results but inconsistent block performance.
### Schedule and Automation - Run strategies on schedule (1min, 5min, hourly) - 24/7 monitoring without manual intervention - Automatic position management --- ## Getting Started: 5-Minute Quick Start 1. **Create new workflow** in ApudFlow 2. **Add data source** (any supported market data provider) 3. **Add Signal Generator** with simple RSI conditions: ```json { "long_conditions": [{"left": "rsi", "operator": "<", "right": "30"}], "short_conditions": [{"left": "rsi", "operator": ">", "right": "70"}] }
Add Backtest Strategy and enable AI optimization
Run and analyze - AI finds optimal parameters automatically!
Summary: Why Signal Generator + Backtest Strategy?
Benefit
Impact
No coding
10x faster strategy development
AI optimization
Find parameters you'd never guess
License-safe
Deploy commercially without worries
Walk-forward validation
Trust your results
Direct execution
Backtest → Live in one platform
Professional stats
Institutional-grade analytics
Whether you're a discretionary trader looking to validate your ideas, a quant developer seeking rapid prototyping, or a fund manager requiring robust validation - ApudFlow's Signal Generator and Backtest Strategy provide the complete toolkit.
Ready to build your first strategy? Start with a simple RSI strategy, let AI optimize it, and experience the difference of professional-grade backtesting without the complexity.
Questions? Our community is here to help you develop winning strategies! 📈🚀
