Strategy Builder: Overview & Getting Started

The Strategy Builder is BitPredict's visual, node-based strategy creation tool. Unlike traditional algorithmic trading development workflows — which require writing code in Python, Pine Script, or similar languages — the Strategy Builder lets you construct, test, and deploy trading strategies by connecting visual blocks (nodes) on an interactive canvas. Every node represents a discrete component of your strategy: a data source, a technical indicator, a candlestick pattern, a logical condition, a market structure concept, a machine learning model, a risk filter, or an execution rule.

What is the Strategy Builder?

At its core, the Strategy Builder is a drag-and-drop DAG (Directed Acyclic Graph) editor for algorithmic trading strategies. Each strategy is a graph: data flows from source nodes on the left, through transformation nodes (indicators, patterns, conditions, logic gates), and arrives at execution nodes on the right (entry long/short, exit, risk management). The DAG structure enforces a strict left-to-right data flow with no cycles — meaning your strategy logic is always valid and never circular.

Think of it like building a flowchart, but for trade signals. You drag a Data Source node onto the canvas, connect it to an Indicator node (e.g., a 20-period SMA), connect that to a Condition node (e.g., “price crosses above SMA”), and route the result to an Entry node. The system validates every connection in real time, catching type mismatches and missing data sources before you waste time running a broken backtest.

What You Can Build

The Strategy Builder scales from simple to sophisticated. Here is the spectrum of what is possible:

• Simple SMA crossover: Two moving averages, one condition, one entry. A 5-minute first strategy that actually trades.
• Multi-indicator confluence: RSI filter + MACD confirmation + Bollinger Band breakout — all combined through logic gates (AND/OR/NOT) for precise entry conditions.
• Multi-timeframe (MTF) strategies: A 15-minute entry signal confirmed by a 4-hour trend filter. Individual nodes override their timeframe when MTF is enabled on the data source.
• Machine learning signals: Classifier nodes (Random Forest, XGBoost, Logistic Regression) trained on engineered features produce directional probability signals routed into conditions.
• Market structure analysis: Fibonacci retracement levels, pivot points (Standard, Camarilla, Woodie), volume profile (VPVR), and Smart Money Concepts (SMC) — all as reusable nodes.
• Risk-managed execution: Exit nodes with configurable stop-loss, take-profit, trailing stops, and time-based exits. Risk management is a first-class node, not an afterthought.
• Full pipeline: Build a strategy, backtest it, run hyperparameter optimization (TPE/NSGA-II), walk-forward validation, Monte Carlo simulation — all within the same interface.

The Output

The Strategy Builder produces a fully backtestable, optimizable, and deployable strategy definition. This definition is a structured JSON document that captures every node, every connection, every parameter, and every configuration. It is the single source of truth for your strategy — feed it into the backtester, the optimizer, or the live execution engine, and it produces identical results. No hidden state, no ambient configuration, no implicit assumptions.

Who It's For

• Quantitative researchers: Prototype ideas in minutes instead of hours. Iterate on signal logic visually, then validate rigorously with the optimization pipeline.
• Algorithmic traders: Build production-grade strategies without writing a single line of code. Focus on edge discovery, not software engineering.
• Strategy developers: Save, version, and share strategy definitions. The JSON export is portable and auditable.
• Beginners learning systematic trading: The visual DAG makes strategy logic explicit: you can see exactly how data flows from source to signal. No black boxes, no opaque code — every decision is visible.

Traditional strategy development requires writing code — Python, Pine Script, MQL, or similar. While powerful, code-based workflows carry hidden costs: syntax errors, silent logic bugs, long debug cycles, and a high barrier to entry. The visual approach addresses each of these systematically.

No Code Required

Build strategies entirely through drag-and-drop and configuration. Every node is self-documenting: its inspector panel shows exactly what it does, what parameters it accepts, and what output it produces. You never need to remember function signatures, parameter order, or library-specific idioms. The system handles all the plumbing: data fetching, indicator computation, signal generation, and backtest execution.

Instant Feedback

The visual canvas makes data flow explicit. A connection from an indicator's value output to a condition's left input tells you, at a glance, exactly what data is flowing where. Compare this to code: you would need to trace variable assignments across multiple functions and files to reconstruct the same understanding. The DAG is the documentation.

Fewer Errors

The DAG validation system catches mistakes before you backtest. Invalid connections (e.g., connecting a condition output to a data source input) are rejected in real time. Missing data sources — the most common error in strategy construction — are flagged immediately. Type mismatches (e.g., sending a binary signal where a numeric value is expected) are prevented by handle type restrictions. The system validates your graph before a single bar of data is processed.

Faster Iteration

The build-test-refine cycle collapses from hours to minutes. Drag a node, adjust a parameter, reconnect a signal wire, and hit Backtest — the full cycle takes seconds. You can test a dozen variations of an idea in the time it would take to write and debug a single code-based implementation.

Full Pipeline Integration

The Strategy Builder is not a standalone toy — it feeds directly into BitPredict's optimization pipeline:

• Backtesting: Run full historical simulations with configurable date ranges, starting balances, commission models, and slippage.
• Hyperparameter optimization: TPE (Tree-structured Parzen Estimator) for single-objective, weighted sum for multi-metric, or NSGA-II for Pareto-front multi-objective search.
• Walk-forward validation: Purged and embargoed cross-validation that simulates real-world periodic re-optimization.
• Monte Carlo simulation: Trade-sequence reshuffling to estimate the distribution of possible outcomes and identify fragile strategies.
• Robustness testing: Sensitivity analysis, noise injection, regime consistency, synthetic data testing, and temporal stability — an 11-phase validation gauntlet.

Reusable Components

Strategies are saved as structured JSON and can be loaded, modified, and re-saved. Copy/paste individual nodes or entire subgraphs between strategies. Build a library of proven patterns: a “Trend Filter” subgraph (EMA + ADX condition), a “Mean Reversion Entry” subgraph (Bollinger Bands + RSI + Stochastic), an “ML Signal” subgraph (Classifier + threshold condition). Reuse instead of rebuilding.

Transparency

Every node's configuration is visible and auditable. Click any node and its Inspector panel shows every parameter, every selection, every value. There are no hidden hyperparameters, no default values that silently change behavior between versions, no black-box logic. The strategy definition JSON is the complete, unambiguous specification of exactly what your strategy does. This is critical for reproducibility: two users with the same JSON definition will produce identical backtest results.

The Strategy Builder interface is organized into four resizable panels. Each panel serves a distinct purpose, and understanding the layout is the fastest way to become productive.

Panel 1: Block Library (Left Panel, Resizable 200–480px)

The Block Library is your palette of building blocks. It contains 22 draggable block types organized into 9 categories:

• Data Source (1 block): The root of every strategy — market symbol, bar type, and timeframe.
• Indicators (50+ blocks): SMA, EMA, RSI, MACD, Bollinger Bands, ATR, ADX, Stochastic, CCI, Ichimoku, Keltner Channels, Donchian Channels, PSAR, and more.
• Patterns (40+ blocks): Candlestick patterns — Doji, Hammer, Engulfing, Morning/Evening Star, Three Soldiers/Crows, Harami, Marubozu, etc.
• ML Models (3 blocks): Classifier (Random Forest, XGBoost, Logistic Regression), Regressor (Linear, Ridge, Lasso), Strategy (meta-learner ensembles).
• Strategies (1 block): Custom strategy node for advanced signal composition.
• Logic (3 blocks): Condition (comparison operations), Logic Gate (AND/OR/NOT/XOR), Signal Gate (signal routing).
• Filters (5 blocks): Trend filter, Volatility filter, Volume filter, Time filter, Regime filter.
• Market Structure (6 blocks): Fibonacci, Pivot Points, Price Levels, Volume Profile (VPVR), SMC (Smart Money Concepts), Market Structure.
• Execution (4 blocks): Entry Long, Entry Short, Exit (with stop-loss/take-profit/trailing), Risk Management.

Each category in the library has a collapsible header and a search bar at the top. Drag any block from the library onto the canvas to create a new node. You can also double-click a block to add it at the center of the current view.

Panel 2: Canvas & Toolbar (Center)

The canvas is the main work area where you arrange and connect nodes to build your strategy graph. It is an infinite pan-and-zoom surface:

• Zoom: Scroll wheel up/down to zoom in/out. The zoom level is displayed in the bottom-left corner.
• Pan: Middle-mouse-button drag, or hold Space and left-click drag to pan the canvas.
• Multi-select: Shift + click to add nodes to the selection, or left-click drag on empty canvas space to draw a selection rectangle.
• Node movement: Click and drag any node to reposition it. Connections follow automatically.
• Connection drawing: Click and drag from an output handle (right edge of a node) to an input handle (left edge of another node) to create a connection. Valid targets glow green; invalid targets show a red rejection indicator.

The canvas toolbar sits above the canvas and provides quick-access buttons:

• New: Create a blank strategy (clears the canvas).
• Save: Save the current strategy to your account. The first save prompts for a name.
• Load: Open a saved strategy from your library. Replaces the current canvas content.
• Undo: Revert the last action (add node, delete node, change connection, modify parameter). Keyboard shortcut: Ctrl+Z / Cmd+Z.
• Redo: Re-apply the last undone action. Keyboard shortcut: Ctrl+Shift+Z / Cmd+Shift+Z.
• Auto-Layout: Automatically arrange all nodes in a left-to-right tree layout. Useful for tidying up a strategy after extensive editing.
• Fit View: Zoom and pan to fit all nodes in the visible canvas area.
• Backtest: Open the backtest configuration modal to run a historical simulation.
• Optimize: Open the optimization pipeline modal to run hyperparameter search and validation.

Panel 3: Node Inspector (Right Panel, Resizable 200–480px)

The Inspector appears when you click any node on the canvas. It shows every configurable option for the selected node in a scrollable form. Changes in the Inspector are reflected immediately on the node's visual representation and take effect in the next backtest.

The Inspector panel includes:

• Header: Node type icon, type name (e.g., “Indicator”), and a close (X) button.
• Alias field: Every node gets an auto-generated unique label (e.g., “SMA #1”). Rename it to something meaningful like “Fast MA” or “Entry Signal”.
• Node-specific fields: All parameters for the node type (e.g., indicator name + period + source for an Indicator node; operator + left/right sides for a Condition node).
• MTF Override section: When the data source has Multi-Timeframe enabled, many nodes show additional symbol/bar_type/timeframe fields to override their data feed.
• Validation status: Any configuration errors are highlighted in red with explanatory messages.

Panel 4: Backtest Panel (Bottom)

The Backtest Panel slides up from the bottom of the interface after you run a backtest. It is resizable (height) and collapsible. It contains:

• Equity Curve chart: Interactive Plotly chart showing the strategy's cumulative equity over time vs. buy-and-hold benchmark. Zoom, pan, hover for values.
• Metrics table: Key performance statistics — Sharpe Ratio, Sortino Ratio, CAGR, Max Drawdown (%), Win Rate (%), Profit Factor, Total Return (%), Annual Volatility (%), Calmar Ratio, number of trades, average trade duration.
• Trade ledger: A sortable, filterable table of every individual trade: entry time, exit time, side (long/short), entry price, exit price, P&L, P&L %, bars held, exit reason.
• Monthly returns heatmap: Calendar-style grid showing P&L by month, color-coded green (profit) to red (loss).

Understanding these five core concepts — nodes, edges, DAGs, signals, and handle types — is essential before building your first strategy. They form the vocabulary of the Strategy Builder, and every interaction with the interface is expressed in these terms.

What is a Node?

A node is a visual block representing one discrete component of your trading strategy. Every node has:

• Colored header bar: The top strip identifies the node type at a glance. Colors map to categories: blue (data-source), violet (indicator), orange (pattern), amber (condition), teal (logic/signal-gate), pink (classifier), indigo (regressor/pivot_points), emerald (strategy/volume_profile), green/red (entry long/short), rose (exit/risk-management), and sky (filter).
• Input handles: Small circles on the left or top edges of the node where incoming connections arrive. Each handle is labeled (e.g., left, cond-0, filter-indicator). A node can have zero or more input handles depending on its type.
• Output handles: Small circles on the right edge where connections depart. Labeled by type (e.g., data, value, result, gate, level, signal). A node typically has one output handle, though some (like data source) can fan out to many targets.
• Body: The center region displays a summary of the node's configuration — the indicator name and parameters for an Indicator node, the operator and comparison for a Condition node, the pattern name for a Pattern node. This summary updates live as you change settings in the Inspector.
• Status badge: A small indicator in the corner showing validation state: green checkmark (valid), red exclamation (invalid/incomplete configuration), or yellow warning (valid but suboptimal — e.g., an indicator with no connection and no manual input selected).
• Selection ring: A blue glow border appears around the node when it is selected (clicked). Only one node can be selected at a time unless multi-select is active.

What is an Edge / Connection?

An edge (also called a connection or wire) is a visible line connecting the output handle of one node to the input handle of another. Edges represent data flow: the output value of the source node becomes the input value for the target node.

For example, when you connect an Indicator node (SMA 20) to a Condition node, the SMA's computed moving average value flows along the edge into the Condition's left-hand-side input. The Condition then compares this value against its right-hand side (which could be another indicator, a fixed number, or a pattern signal).

Edge characteristics:

• Direction: Always left-to-right. Data flows from source/transformation nodes on the left toward execution nodes on the right.
• Color: Edge colors match the source node's category color, making it easy to trace which node is feeding which. A violet edge comes from an indicator; an amber edge comes from a condition.
• Handle type enforcement: Edges can only connect compatible handle types. An edge from a data handle can connect to a data-compatible input. An edge from a signal handle can connect to a signal-compatible input. Invalid connections are rejected visually (red glow on the target handle) and prevented programmatically.
• Deletion: Click an edge to select it (it highlights), then press Delete or Backspace to remove it. You can also right-click an edge for a context menu with a “Delete Connection” option.

What is a DAG?

DAG stands for Directed Acyclic Graph. Every strategy you build must be a DAG:

• Directed: Every edge has a direction (from output to input). Data flows in one direction — left to right, source to execution.
• Acyclic: No cycles are allowed. You cannot connect Node B back to Node A if data already flows from A to B, either directly or through intermediate nodes. The validation system detects and rejects cycles immediately.

The DAG constraint is not arbitrary — it reflects the fundamental nature of trading strategies: historical price data flows forward in time, indicators transform that data, conditions evaluate it, and execution decisions are made at the end of the pipeline. A cycle (e.g., an indicator depending on its own output) would be physically impossible in real trading — there is no time travel on exchanges.

The data flow is strictly left-to-right: Data Source (far left) → Indicators / Patterns / ML Models (center-left) → Conditions / Logic Gates / Filters (center) → Entry / Exit / Risk Management (far right).

What is a Signal?

A signal is the final output of your strategy — the decision to enter or exit a position. Signals come in two forms:

• Buy / Long: Open a long position (betting the price will rise).
• Sell / Short: Open a short position (betting the price will fall).

Signals flow through the pipeline: data sources provide raw market data, indicators and patterns transform it into numerical or categorical values, conditions evaluate those values against thresholds or other values, logic gates combine multiple conditions, filters eliminate trades in unfavorable conditions, and finally entry/exit nodes convert the surviving signals into concrete buy/sell orders.

The signal path through the graph is the core of your strategy logic. You can trace any trade back through the graph to understand exactly which conditions triggered it. This traceability is essential for debugging and refining strategies.

Handle Types

Handle types are the type system of the Strategy Builder. Each output handle produces a specific type of data, and each input handle accepts only specific types. This prevents nonsensical connections at the graph level before any backtest is run.

• DATA: Emitted by the Data Source node. Contains complete OHLCV bar data for a given symbol, bar type, and timeframe. This is the raw feed that all indicator and pattern nodes consume. Can connect to indicator, pattern, ML, and filter input handles.
• VALUE: Emitted by Indicator and Pattern nodes. Contains a numeric array or categorical signal (depending on the output type — numeric, binary, zero_crossing, or percentage). Connects to condition inputs (left, right) and to filter indicator inputs.
• LEVEL: Emitted by Market Structure nodes (Fibonacci, Pivot Points, Price Levels, SMC). Contains price level data (support/resistance zones, pivot levels, Fib retracement/extensions). Connects to conditions for level-based logic (e.g., “price above S1 pivot”).
• SIGNAL: Emitted by ML model nodes (Classifier, Regressor, Strategy). Contains a probabilistic or categorical trading signal (e.g., 0.73 probability of upward movement). Connects to condition inputs for threshold-based decisions.
• RESULT: Emitted by Condition nodes. Contains a boolean (true/false) for whether the condition evaluated to true at each bar. Connects to logic gate inputs, signal gate inputs, and entry/exit node condition inputs (cond-0, cond-1, etc.).
• OUT: Emitted by Logic Gate and Signal Gate nodes. Contains a boolean representing the combined result of all input conditions after applying the gate logic (AND/OR/NOT). Connects to entry/exit node condition inputs.
• GATE: Emitted by Filter nodes (Trend, Volatility, Volume, Time, Regime). Contains a boolean — true when the filter conditions are met (trade allowed), false when they are not (trade blocked). Connects to the filter gate input on entry/exit nodes.

Let's build a complete SMA Crossover strategy — the classic “Hello World” of algorithmic trading. This will take about 5 minutes and will teach you the fundamental workflow: add nodes, configure them, connect them, and backtest.

Strategy: SMA(20) Crosses Above SMA(50) → Enter Long

The logic is simple: when the 20-period Simple Moving Average crosses above the 50-period Simple Moving Average, it signals an uptrend — enter a long position.

Step 1: Add a Data Source

From the Block Library (left panel), drag the Data Source block onto the canvas. Click the node to open the Inspector (right panel) and configure:

• Symbol: Search and select BTCUSDT.
• Bar Type: Select Spot.
• Timeframe: Select 1h (1-hour bars).
• MTF: Leave off for now.

The node now shows BTCUSDT | Spot | 1h in its body. It has a single output handle labeled data on its right edge.

Step 2: Add the Fast SMA (20-period)

Drag an Indicator block from the library onto the canvas. In the Inspector:

• Alias: Change from the auto-generated name to Fast SMA.
• Name: Select SMA from the dropdown.
• Params > period: Set to 20.
• Params > source: Set to close.
• Output: Keep sma (the only output for SMA).

Now connect the Data Source node: click and drag from the Data Source's data output handle to the Indicator node's input handle (on its left edge). A violet connection line appears. The Indicator node now reads BTCUSDT 1h bars and computes SMA(20) on close prices.

Step 3: Add the Slow SMA (50-period)

Drag another Indicator block onto the canvas. Configure it identically to Step 2, but with:

• Alias: Slow SMA.
• Params > period: 50.
• Output: sma.

Connect the Data Source's data handle to this second Indicator node as well. Data sources can fan out to multiple consumers.

Step 4: Add a Condition Node

Drag a Condition block from the library onto the canvas. In the Inspector:

• Alias: Crossover Signal.
• Left Side: When you connect the Fast SMA node's value output to the Condition's left input handle, the left side auto-populates to reference the Fast SMA indicator.
• Operator: Select crosses_above from the dropdown.
• Right Side: Select indicator as the source type, then pick Slow SMA from the dropdown. This tells the condition to compare Fast SMA against Slow SMA.

Connect the Fast SMA's value output to the Condition's left input. The Condition now evaluates: “SMA(20) crosses above SMA(50)” at every bar. When this is true, the Condition's result output becomes true.

Step 5: Add Entry and Exit Nodes

Drag an Entry Long block from the Execution category onto the canvas. Connect the Condition's result output to the Entry Long node's cond-0 input. When the condition is true, the strategy enters a long position.

Drag an Exit block (from the Execution category) onto the canvas. In the Inspector, configure risk management:

• Stop Loss: Set to 2%. The position will exit if the price drops 2% below entry.
• Take Profit: Set to 5%. The position will exit if the price rises 5% above entry.

The Exit node does not need to be connected to the Entry node directly — the backtest engine automatically applies exit rules to any open position from the same strategy.

Step 6: Run the Backtest

Click the Backtest button in the canvas toolbar. In the modal:

• Date Range: Select “Last 6 Months” or set custom start/end dates.
• Starting Balance: Set to $10,000.
• Commission: Keep the default (typically 0.1%, configurable).
• Slippage: Keep the default (typically 0.05%, configurable).
• Click Run.

Step 7: Review Results

The Backtest Panel slides up from the bottom. Review:

• Equity Curve: Is the equity line generally sloping upward? Are there long flat periods (no trades) or sharp drops (large losses)?
• Metrics: Focus on Sharpe Ratio (risk-adjusted return), Max Drawdown (worst peak-to-trough decline), Win Rate (% of profitable trades), and Profit Factor (gross profit / gross loss). A Sharpe above 1.0 is decent; above 2.0 is excellent (but be skeptical of unrealistically high values).
• Trade Ledger: Scan the individual trades. Are there many tiny wins and a few huge losses? That's a warning sign. Are there consistent profits and losses? That's more realistic. Look for patterns: do all losses occur during specific hours or days?
• Monthly Returns: Are returns consistent month-to-month, or does all the profit come from one outlier month? Consistent returns across months suggest robustness; a single outlier month suggests luck.

You've built your first strategy and understand the core concepts. Here is where to go next in the documentation to deepen your knowledge and expand your capabilities: