Keyboard Shortcuts & Productivity

The Strategy Builder supports a comprehensive set of keyboard shortcuts designed to keep your hands on the keyboard and minimize mouse travel. Every shortcut listed below works on both Windows/Linux and macOS — macOS users should substitute Cmd for Ctrl and Option for Alt unless otherwise noted. Modifier-less keys (Delete, Escape, Space) are identical across all platforms.

Power users who internalize just the top 8 shortcuts (Undo, Redo, Copy, Paste, Delete, Select All, Fit View, Save) report building strategies 2-3x faster than relying on toolbar buttons and context menus. The full set of 18 shortcuts covers every common operation in the builder.

Editing & Clipboard

Selection

Canvas Navigation

Strategy Management

The Strategy Builder canvas is an infinite, zoomable, pannable workspace. Mastering navigation is the single biggest productivity unlock — when you can move around the canvas without conscious thought, you stay in a state of flow with your strategy logic instead of battling the viewport. This section covers all 4 pan methods, all 4 zoom methods, zoom limits, Fit View, Auto-Layout, and node dragging behavior.

Panning: 4 Methods

Each pan method has a different ergonomic profile. Pick the one that fits your hardware setup:

• Space + Drag: Hold the Space key, then click and drag with the left mouse button. The cursor changes to an open-hand grab icon. Release Space to return to normal editing mode. This is the most universal method — it works on every operating system with any mouse, and it is the safest because Space suppresses all node interaction (you cannot accidentally move a node while panning). Tap Space quickly without dragging to confirm you are in pan mode — the cursor change is your indicator.
• Middle Mouse Drag: Click and hold the scroll wheel (middle mouse button), then drag. No keyboard modifier needed — true one-hand panning. This is the fastest method if your mouse has a comfortable middle button. On some systems, middle-click may be mapped to other functions (e.g., autoscroll in browsers, or Mission Control on macOS). Check your system preferences or mouse driver settings if middle-click does not pan.
• Two-Finger Trackpad Drag: On laptops with precision trackpads (MacBook, Surface, ThinkPad X1), a two-finger drag gesture pans the canvas smoothly and continuously. This is the most natural method for laptop users and requires no modifier keys. Combined with pinch-to-zoom, trackpad navigation can rival or exceed a dedicated mouse for canvas manipulation efficiency.
• Scrollbars: Standard horizontal and vertical scrollbars appear at the canvas edges when content extends beyond the viewport (i.e., when zoomed in). Click and drag the scrollbar thumbs for coarse positioning. This is the slowest method but serves as a reliable fallback when other input methods are unavailable or when you need precise single-axis panning (e.g., sliding exactly horizontally to align two distant nodes).

Zooming: 4 Methods

• Scroll Wheel: Scroll up to zoom in, scroll down to zoom out. The zoom is centered on the cursor position — the point under your mouse stays fixed on screen while the canvas scales around it. This cursor-centric zooming means you can zoom into a specific node by hovering over it, or zoom out to see the full graph by moving the cursor to an empty area. Each scroll tick changes zoom by approximately 15%. The current zoom level (e.g., "83%") is displayed in the bottom-left corner of the canvas.
• Ctrl+Scroll / Cmd+Scroll: Fine zoom mode. Each scroll tick changes zoom by approximately 5% instead of 15%. Use when the default zoom step is too aggressive — for example, when trying to fit exactly 15 nodes in the viewport for a clean screenshot, or when aligning nodes to a precise visual grid. The smaller increment gives you pixel-level control.
• Pinch-to-Zoom: On trackpads, a two-finger pinch gesture controls zoom: spread fingers apart to zoom in, bring them together to zoom out. The zoom is smooth and continuous, not stepped like scroll-wheel zoom. The zoom center is the midpoint between your fingertips. Combine with two-finger drag for fluid, trackpad-only navigation.
• Toolbar Controls: The canvas toolbar includes a zoom-percentage display with + and - buttons. Each click steps the zoom by a fixed increment. Clicking the percentage number itself may reset zoom to 100%. These are the slowest controls but are always visible and accessible — useful when you need a known, repeatable zoom level (e.g., "set to exactly 100% for consistent screenshots").

Zoom Limits

Canvas zoom is clamped to prevent disorientation:

• Minimum: 0.25x (25%). At this level, a strategy with ~20 nodes occupies roughly a postage-stamp-sized area. Useful for getting a bird's-eye view of a very large graph (50+ nodes). Individual node labels become unreadable — you are seeing structure (clusters, rows, DAG depth), not details.
• Maximum: 4x (400%). At this level, a single node fills most of the screen. Useful for inspecting tiny handle labels, verifying exact connection endpoints, or achieving pixel-perfect node alignment. Most users operate in the 60%-150% range for everyday editing.

Fit View (Ctrl+0 / Cmd+0)

The Fit View command — accessible via Ctrl+0 or the toolbar button (expand/fit icon) — automatically calculates the bounding box of all nodes on the canvas, adds a 40px padding margin on every side, and sets the zoom level and pan offset so that bounding box exactly fills the viewport. This is the emergency recovery tool for when you are lost:

• After pasting nodes that landed far off-screen.
• After loading a strategy whose saved viewport does not match your current window size.
• After Auto-Layout rearranged everything — some nodes may have been pushed outside your view.
• After accidental excessive panning into empty canvas space.

If Fit View shows nothing at all, you may have accidentally deleted all nodes. Press Ctrl+Z immediately to restore them.

Auto-Layout Button

The Auto-Layout toolbar button (grid/organize icon) applies a Sugiyama-style layered graph drawing algorithm to arrange all nodes in a clean left-to-right hierarchical layout:

• Nodes are assigned to layers based on their depth in the DAG: data sources at layer 0, direct consumers at layer 1, and so on. Execution nodes occupy the rightmost layer.
• Within each layer, nodes are ordered to minimize edge crossings. The algorithm iteratively swaps node positions to untangle crossing edges.
• Nodes with no connections (orphans) are placed at the far right.
• Edge routing is recalculated to produce clean horizontal and vertical paths.

Auto-Layout is an undoable action — if the automatic arrangement is not to your liking, one Ctrl+Z restores your manual layout. If you have spent time carefully positioning nodes for visual clarity, save the strategy before running Auto-Layout so you can reload if needed.

Node Dragging Behavior

• Single node: Click and drag any node to reposition it. All incident edges (connections) reroute elastically to follow. Nodes snap to a 20px grid to help maintain alignment; hold Alt while dragging to override the snap for pixel-precise placement.
• Multiple selected nodes: Drag any selected node and the entire selection moves as a group. Relative positions between selected nodes are preserved exactly. Edges between selected nodes move with the group; edges to unselected nodes stretch elastically.
• Undo granularity: Each drag-release (mouse up) is recorded as a single undo step capturing the final position. Intermediate positions during the drag are not individually tracked. One Ctrl+Z returns the node(s) to their pre-drag position. This differs from some design tools that track every pixel — the Strategy Builder only records the endpoint.

As strategies grow in complexity — 20, 30, even 50+ nodes — manipulating nodes one at a time becomes a bottleneck. Multi-select lets you operate on groups of nodes as a single unit: move an entire signal chain, copy a subgraph for reuse, or delete a failed experiment in one keystroke. This section covers all 4 selection methods and what you can do with a multi-selection.

Selection Methods

Shift+Click — Add to Selection

Hold Shift and click any unselected node to add it to the current selection. If the node is already selected, Shift+Click removes it (toggle behavior). This is the most precise selection method: you explicitly choose every node in the group, one click at a time. Works on both nodes and edges.

Example: You have 8 indicators feeding into 3 conditions, and you want to reposition all 8 indicators 100px to the left. Click the first indicator, Shift+Click the remaining 7, then drag any one of them. All 8 move as a group while the 3 conditions stay put.

Ctrl+Click / Cmd+Click — Toggle Selection

Hold Ctrl (Windows/Linux) or Cmd (macOS) and click a node to toggle its selection state. If currently selected, it is removed; if unselected, it is added. This is the correction tool — if you accidentally included a node in a Shift+Click or rectangle select, Ctrl+Click it to remove it without losing the rest of your carefully built selection group.

Rectangle Select — Click+Drag on Empty Canvas

Click on an empty area of the canvas (not on any node) and drag to draw a blue dashed selection rectangle. On mouse release, every node whose bounding box is fully enclosed by the rectangle is selected. Nodes that are only partially inside are NOT selected — you must completely surround them. This is the fastest method for selecting large, visually clustered groups.

Holding Shift while drawing the rectangle adds the enclosed nodes to any existing selection (union). Without Shift, the rectangle replaces the previous selection.

Ctrl+A / Cmd+A — Select All

Selects every node on the canvas in a single keystroke. Edges are not selected (edges must be clicked individually or Shift+Clicked). Typical use cases: copy an entire strategy to paste as a backup before risky edits; delete everything to start fresh; or run Auto-Layout on the full graph.

Bulk Operations on Multi-Selection

Once multiple nodes are selected, these operations apply to the entire group:

• Move Together: Click and drag any selected node — the entire group moves as one unit. Relative positions between selected nodes are preserved. Connections between selected nodes move with them; connections to unselected nodes stretch.
• Copy (Ctrl+C): All selected nodes — with their full configuration, aliases, parameters, and internal connections — are serialized to the clipboard. Connections to nodes outside the selection are discarded.
• Cut (Ctrl+X): Copies to clipboard AND deletes from canvas in one atomic undo step. Equivalent to Copy followed by Delete, but tracked as a single action.
• Delete (Delete/Backspace): Removes all selected nodes and every incident edge. All nodes are deleted in one undo step — a single Ctrl+Z restores the entire group.

Selection Ring Visual

Selected nodes display a blue glow border (selection ring) around their entire body. This ring is visually distinct from the node's category-color header bar, making selected nodes instantly identifiable even in a dense graph. When a single node is selected via normal click (no modifier), any previous selection is automatically deselected — only the clicked node shows the ring. The Inspector shows the last-clicked node's configuration, even when multiple nodes are selected, allowing you to inspect details while preparing for a bulk operation.

Edge Selection

Edges can be selected and operated on independently of nodes:

• Click an edge: Click directly on a connection line to select it. The edge highlights (thicker stroke, brighter color) and both its source and target nodes show subtle highlights. Selecting a second edge normally deselects the first unless Shift is held.
• Shift+Click for multi-edge: Hold Shift while clicking edges to select several simultaneously. Then press Delete to remove all selected edges at once. This is invaluable when refactoring — delete a batch of wrong connections in one action, then draw the correct ones.
• Edge deletion: Removing an edge does NOT delete either connected node. The target node's input handle becomes empty, which may trigger a yellow validation warning badge.

The Strategy Builder has a dedicated internal clipboard system that stores serialized node data in the browser's localStorage. This is NOT the operating system clipboard — it is a structured, JSON-based clipboard that preserves every parameter, connection, and alias of your copied nodes. Understanding exactly how it works lets you leverage it for everything from quick node duplication to cross-session subgraph reuse.

How Copy Works (Ctrl+C / Cmd+C)

1. Select one or more nodes using any method from Step 2.
2. Press Ctrl+C. A toast notification confirms: "Copied N nodes."
3. Each selected node is serialized into a JSON object containing: node type, position (x, y), alias, all parameter values, all input/output handle configurations, and all MTF override settings.
4. Internal connections preserved: Edges where both the source AND target nodes are within the selected set are included in the serialized data. These connections are restored exactly when pasted.
5. External connections discarded: Edges to nodes outside the selection are NOT copied. If you select an Indicator node and a Condition node but NOT the Entry node they feed into, the Condition-to-Entry edge is dropped. You must manually reconnect after pasting.
6. The JSON blob is stored in localStorage under a dedicated key. This overwrites any previous clipboard contents — there is only one clipboard slot.

How Paste Works (Ctrl+V / Cmd+V)

1. Ensure the canvas has focus (click it if you have been in the Inspector or a dialog).
2. Press Ctrl+V. Pasted nodes appear offset by 50px down and 50px right from their original positions. The first paste offsets by 50px; the second paste offsets by 100px; and so on. This prevents nodes from stacking directly on top of each other during repeated pastes.
3. Alias Auto-Rename: To maintain uniqueness (required for DAG validation), pasted node aliases are automatically renamed. "SMA #1" becomes "SMA #1 (copy 1)". A second paste becomes "SMA #1 (copy 2)". The system scans existing node aliases and pastes in the current paste batch to find the next available name.
4. Internal connections restored: Edges between nodes within the paste batch are recreated identically to the original. If you copied an Indicator → Condition chain, the pasted versions are connected the same way.
5. Paste is undoable: The entire paste operation (all nodes, all connections) is one undo step. Ctrl+Z immediately after pasting removes everything that was just pasted.

Cut = Copy + Delete (Ctrl+X / Cmd+X)

Cut is logically equivalent to Copy followed by Delete, but executed atomically as a single undo step. The nodes are placed on the clipboard AND removed from the canvas. Pressing Ctrl+Z after a Cut restores both the nodes AND the previous clipboard contents (the system saves a backup). You never lose data from a cut — the nodes are either on the canvas or on the clipboard.

Cross-Session Persistence

Because the clipboard uses localStorage, it has specific persistence characteristics:

• Survives: Page refresh, navigation to other Strategy Builder sub-pages, closing and reopening the browser tab, and full browser restarts (assuming your browser preserves localStorage, which all major browsers do by default).
• Does NOT survive: Switching browsers (Chrome to Firefox), switching devices (desktop to laptop), or running in incognito/private mode (localStorage is isolated per session). The clipboard is NOT synchronized across devices or accounts — it is local to your current browser on your current machine.

Clipboard Limits

• Single entry only: Each new Copy/Cut overwrites the previous clipboard contents. There is no clipboard history, no multiple slots, no paste-from-history. If you need to preserve multiple subgraphs, save them as separate strategies.
• Size limit (~5MB): Modern browsers allocate approximately 5-10MB of localStorage per origin. A single node serializes to roughly 2-5KB of JSON. Even selecting 100 nodes produces only 200-500KB. However, other parts of the application may also use localStorage, so be aware of the shared quota. If the quota is exceeded, the copy may fail silently.
• No cross-tab coordination: localStorage is shared per origin, meaning two Strategy Builder tabs in the same browser share one clipboard. If you copy nodes in Tab A, then copy different nodes in Tab B, Tab A's clipboard is overwritten. Finish work in one tab before switching.

Practical Patterns

• Duplicate and modify: Copy an SMA(20) node, paste it, change the period to 50. You now have a fast and slow SMA configured identically except for the period — much faster than dragging and configuring from scratch.
• Reuse proven subgraphs: Build a "Trend + Momentum Confirmation" subgraph (EMA + ADX + 2 Conditions + AND gate), verify it works, then copy and paste it into every strategy that needs trend filtering. Consistent subgraphs mean consistent behavior.
• Backup before risky edits: Before making a major change, Ctrl+A, Ctrl+C to snapshot everything. If the change fails, Ctrl+A, Delete, Ctrl+V to restore. This is faster than undo if you have made many incremental changes and only want to revert to the snapshot.

Every modification to the DAG — adding, deleting, moving, connecting, or configuring nodes — is recorded as an atomic step in a linear undo history with a 50-step capacity. Understanding exactly what gets tracked and what does not is the difference between using undo confidently and hesitating before every action.

History Capacity: 50 Steps

The undo stack holds a maximum of 50 atomic actions. When the 51st action is recorded, the oldest action (step 1) is permanently evicted and unrecoverable. Fifty steps covers roughly 20-40 minutes of active editing at a moderate pace. Rapid parameter tweaking (each field change in the Inspector is one step) fills the history faster. There is no on-screen indicator of remaining undo depth — if you attempt to undo past the oldest recorded state, nothing happens (silent, no error). If you need to preserve a specific state beyond 50 steps, save the strategy.

What IS Tracked (Each Creates One Undo Step)

• Add Node: Adding a single node via drag-from-library or double-click.
• Delete Node(s): Deleting one or more nodes in a single operation (select + Delete). Even if you delete 20 nodes at once, it is one undo step — all 20 are restored together, along with their incident edges.
• Move Node(s): Each drag release (mouse up) creates one undo step, capturing the final position(s). Only the endpoint matters — intermediate positions during the drag are not recorded.
• Parameter Change: Every field change in the Node Inspector — changing a period from 20 to 50, toggling a checkbox, selecting a different indicator from a dropdown. Each field is tracked independently. Changing 3 parameters creates 3 undo steps.
• Connection Create: Drawing a new edge between two nodes.
• Connection Delete: Removing an edge (select + Delete, or right-click delete).
• Auto-Layout: The entire auto-layout operation is one step. Undoing it restores every node to its previous manual position.
• Paste: Pasting any number of nodes from the clipboard is one step, regardless of how many were pasted.
• Cut: One undo step (atomically replaces Copy + Delete — you don't get two separate steps).

What Is NOT Tracked

These actions are intentionally excluded from undo history because tracking them would add noise without preserving meaningful strategy state:

• Viewport Changes: Panning, zooming, and Fit View. These affect your view, not your strategy logic.
• Selection Changes: Clicking nodes, Shift+Click, rectangle select, Ctrl+A. Selection is UI state.
• Inspector Open/Close: Toggling the Node Inspector panel visibility.
• Dialog Opens: Opening Save, Load, Backtest Config, or Optimize modals. Only actions within those modals that modify DAG state (e.g., Save overwrite) are tracked.
• Library Search / Panel Resize: Searching the Block Library or resizing panels is purely UI state.

Undo After Save

Undo operates on the local canvas state, not the server-saved strategy. This distinction is critical:

• You make changes, press Ctrl+S. The server now has the updated strategy.
• You make 5 more changes, then press Ctrl+Z 5 times. The canvas reverts to the saved state — but the server STILL has the version before you undid.
• To sync the undone state to the server, press Ctrl+S again.
• To return to the most recent local state (discarding the undos), press Ctrl+Shift+Z (Redo).

This means undo is safe: you can always restore the server version via the Load dialog even if you have undone past the save point and then made new changes that cleared the redo stack.

Redo Clears on New Action

The redo stack is linear and ephemeral. If you undo 5 steps and then perform any new action (add node, change parameter, delete, etc.), the redo history is immediately cleared. Those 5 undone steps are permanently gone — replaced by the new action at the top of the undo stack. This is standard behavior across all editing software (text editors, IDEs, design tools) and prevents branching histories.

Example: You delete a node. Undo brings it back. Instead of redoing the delete, you change the node's period from 20 to 50. The redo stack (which contained "delete node") is cleared. "Change period" is now the top of the undo stack. The toolbar Redo button becomes disabled (grayed out) at this point.

Right-clicking on different canvas elements reveals context-sensitive menus that put the most common operations directly at your cursor. The menu content adapts based on what you clicked — empty canvas, a node, or an edge. This section documents every option across all three variants.

Right-Click on Empty Canvas

• Paste: Available only when the clipboard is non-empty. Pastes at the cursor position (where you right-clicked), giving you precise placement control. This is more accurate than Ctrl+V which uses a fixed offset from original positions.
• Select All: Same as Ctrl+A — selects every node on the canvas.
• Fit View: Same as Ctrl+0 — pans and zooms to show all nodes.
• Add Node (submenu): Expands into a nested menu organized by the same 9 categories as the Block Library: Data Source, Indicators, Patterns, ML Models, Strategies, Logic, Filters, Market Structure, Execution. Hovering over a category reveals its individual node types. Click one to add it at the cursor position. This is useful when the Block Library is collapsed or when you want to add a node without moving your mouse to the left edge of the screen — keep your focus on the canvas.

Right-Click on a Node

If multiple nodes are selected when you right-click, the menu options apply to the entire selection, not just the right-clicked node:

• Copy: Copy selected node(s) to the clipboard. Shortcut: Ctrl+C.
• Cut: Copy to clipboard and delete from canvas. Shortcut: Ctrl+X.
• Delete: Remove the node(s) and all incident edges. Shortcut: Delete/Backspace.
• Duplicate: Creates an exact copy of the selected node(s) offset by 50px diagonally. Unlike Copy+Paste, Duplicate does NOT use the clipboard — your clipboard contents are preserved. Duplicate is a single action (one undo step) and is often the fastest path: you don't need to Ctrl+C then Ctrl+V. Aliases are auto-renamed ("SMA #1" → "SMA #1 (copy 1)"). Internal connections between duplicated nodes are preserved; connections to non-duplicated nodes are NOT recreated.
• Select Connected: Expands the selection to include all nodes directly connected to the right-clicked node — both upstream (providers) and downstream (consumers). Does NOT follow connections recursively — only one hop. Use this to quickly isolate a signal chain: right-click the Entry node, choose Select Connected, and every node that contributes to that entry is selected. You can then copy, move, or delete the entire chain as a group.
• Toggle Inspector: Opens the Node Inspector panel (if closed) or closes it (if open). Same as clicking the node, then clicking the toggle.

Right-Click on an Edge

• Delete Edge: Removes only this connection. Both connected nodes remain on the canvas, but data flow between them is severed. The target node's input handle becomes empty, which may trigger a yellow validation warning. Shortcut: Delete (when edge is selected).
• Select Edge: Selects this edge, highlighting it with a thicker/brighter stroke and showing subtle highlights on its source and target nodes. From here you can Shift+Click additional edges for multi-select deletion.

These tips come from experienced strategy developers who use the Strategy Builder daily. They go beyond the mechanics of the interface into the craft of efficient strategy development — how to organize your canvas, structure your logic, debug systematically, manage performance, and maintain good saving habits.

Naming & Organization

• Use meaningful aliases: Replace auto-generated names like "SMA #1", "Condition #3", and "Indicator #7" with role-descriptive names: "Fast MA (20)", "Crossover Signal", "Vol Filter (ATR)", "Entry Trigger". When you come back to this strategy in two weeks, meaningful aliases let you understand the graph at a glance without clicking a single Inspector. This is the single highest-leverage habit you can adopt. A good naming convention: [Type] [Key Param] [Role]. Examples: "SMA 20 Fast", "RSI 14 Oversold", "ADX 25 Trend Gate", "AND Entry Confirm".
• Group related conditions with Logic Gates: Instead of chaining 5 conditions in series (making it hard to tell which one failed), run them in parallel through an AND gate. The AND gate makes the logical relationship explicit: "all of these must be true to enter." Use OR gates for alternative entry signals. Use NOT gates to invert a condition. Gates self-document your strategy logic.
• Use vertical spacing for readability: Arrange independent signal paths at different vertical positions. Put your trend-following signal chain in the upper half and your mean-reversion chain in the lower half. Leave at least 80-100px of vertical space between rows to give edges room to route cleanly. Vertical "lanes" make complex strategies scannable.

Iterative Development

• Start simple, iterate: Build the core signal first — one data source, one indicator, one condition, one entry. Backtest. Get a baseline metric. THEN add complexity: a filter node, a second condition, a volatility check. Backtest after every addition. A complex strategy built all at once is nearly impossible to debug because you cannot isolate which component is driving performance.
• Test each addition: After adding a new node, run a quick backtest. Does the equity curve improve? Does Sharpe increase? Does max drawdown decrease? If adding a filter worsens performance, the filter may be too restrictive or the market regime may not align with your assumptions. Remove or tune it before adding more.

Graph Architecture

• Keep the DAG shallow: Favor wide, parallel structures over deep, serial chains. A strategy with 8 indicators feeding into 1 condition through an AND gate is easier to understand and debug than one with 2 indicators feeding into 4 chained conditions. Deep chains amplify parameter sensitivity and make signal tracing tedious. Wide structures let you see all signal components at a glance.
• Use Strategy Reference for modularity: If you find yourself building the same subgraph repeatedly (e.g., a "Trend + Momentum Confirmation" block), build it once as a standalone strategy, save it, and reference it from other strategies via the Strategy node. This is the DAG equivalent of extracting a reusable function. Changes to the referenced strategy propagate to all consumers.

Performance Awareness

• MTF timeframes cost API calls: Each unique symbol/timeframe combination requires a separate data fetch from the exchange. A strategy using BTCUSDT on 1h, 4h, and 1d makes 3 data requests per backtest. Keep MTF usage deliberate — do not add a timeframe "just in case" if no node uses it. Check your nodes' MTF override settings and remove unused overrides.
• Long lookbacks increase computation: A 200-period SMA on 1-minute bars over a 2-year backtest computes roughly 700,000 rolling averages. An EMA is more efficient (recursive O(1) per bar vs. O(n) for SMA). Prefer EMA over SMA for long lookbacks. Bollinger Bands (which compute SMA + standard deviation internally) are doubly expensive — use only when you need the band width information.
• Patterns are heavy: Candlestick pattern recognition runs per-bar logic with multiple sub-conditions (body/range ratios, trend context, confirmation candles). A strategy with 10 pattern nodes backtests noticeably slower than one with 10 indicator nodes. Use patterns selectively — and only enable the 2-3 patterns you actually need.

Debugging

• Isolate chains: If a complex strategy produces unexpected results, copy the suspicious subgraph (select nodes, Ctrl+C), create a new blank canvas (Ctrl+Shift+N), paste it, add just a data source and an entry node, and backtest in isolation. The simplified graph makes it much easier to see what each component contributes.
• Inspect signal components: In the Backtest Panel, the Signal Components tab shows per-node contribution. If a Condition shows "0 trades triggered", click it on the canvas — is the operator correct? Are the left/right sources connected? Is the threshold realistic?
• Read validation warnings: Yellow warning badges are not blocking errors, but they indicate potential issues: a node with no incoming data, an indicator with no source selected, a condition with asymmetric inputs. Investigate warnings — they often explain unexpected backtest results.

Save Discipline

• Save early and often: Ctrl+S is a single keystroke. Use it after every meaningful change. There is NO auto-save. A browser crash or accidental tab close loses all unsaved work. Make Ctrl+S a reflex — the same way you instinctively save documents in any other application.
• Use descriptive strategy names: Include symbol, timeframe, strategy type, and key differentiator. Examples: "BTCUSDT 1h SMA20/50 Crossover + RSI Filter + 2% SL", "ETHUSDT 4h Mean Reversion — BB(20,2) + RSI(14) < 30". When you have 50 saved strategies, descriptive names let you find the right one in seconds instead of loading 10 wrong ones.
• Version your strategies: Append v1, v2, v3: "BTC 1h Trend Follow v1 — baseline", "BTC 1h Trend Follow v2 — added vol filter", "BTC 1h Trend Follow v3 — optimized params". This gives you a clear development history and lets you compare performance across versions.