Strategy Lifecycle

The toolbar sits above the canvas and provides one-click access to every lifecycle operation. Each button has a distinct icon (described below), a keyboard shortcut where applicable, and clear enabled/disabled states. When a button is unavailable (e.g., Redo when there is nothing to redo, Backtest when the DAG has validation errors), it appears grayed out. This is your command center — learn what each button does so you can reach for it without thinking.

The toolbar is divided into two logical groups. The left group (New, Save, Load, Undo, Redo, Auto-Layout, Fit View) covers editing and file management. The right group (Backtest, Optimize) covers analysis and validation. This grouping reflects the natural workflow: build on the left, test on the right.

Strategies are saved to your BitPredict user account and accessible from any device where you are logged in. There is no auto-save — you must save manually. This is by design: auto-save would record every intermediate state (including broken experiments), cluttering your strategy library and making it hard to identify meaningful versions.

The Save Dialog (First Save)

When saving a strategy that has never been saved (fresh canvas or loaded template):

• Strategy Name (required): A text field accepting up to 100 characters. This is your primary identifier in the Load dialog, in backtest reports, and on optimization results pages. Choose something descriptive: include the symbol, primary timeframe, strategy type, and key differentiator. Good: "BTCUSDT 1h SMA20/50 Crossover + RSI Filter + 2% SL." Bad: "test", "strategy 7", "final v2 really final."
• Overwrite Warning: If the strategy name matches an existing saved strategy, the dialog warns: "A strategy with this name already exists. Overwrite it?" The previous version is permanently replaced — there is no server-side version history. Use naming conventions like "v1", "v2" to maintain your own history via separate saves.

Quick Save (Ctrl+S / Cmd+S)

If the strategy was previously loaded from your account or has been saved at least once, pressing Ctrl+S (or clicking the Save toolbar button) immediately overwrites the existing version on the server. No dialog opens. The toolbar Save button shows a brief checkmark confirmation animation. This makes saving a reflex action — one keystroke, no interruption.

To create a copy under a different name (branching your strategy development), load the strategy, modify it, and use the "Save As New" option if available, or save from a fresh canvas by copy-pasting the entire graph and saving as a new name.

What Gets Saved

• All nodes: type, alias, position (x, y), every parameter value, every handle configuration, all MTF override settings.
• All edges: source node ID, source handle type, target node ID, target handle type.
• Canvas viewport: pan position and zoom level at time of save.
• Strategy metadata: created date, last modified date, version number (auto-incremented on each save).

What Does NOT Get Saved

• Backtest results: These are transient and tied to a specific backtest configuration (date range, balance, fees). After loading a strategy, re-run the backtest to see results.
• Optimization configurations: Each optimization run has its own configuration (parameter ranges, pipeline settings, objective). These are stored with the optimization job on the server, not as part of the strategy definition.
• Undo history: The undo stack starts fresh when you load a strategy. Your session's undo history is not persisted to the server.
• Clipboard contents: The internal clipboard (localStorage) is independent of strategy save/load and is not included in the saved strategy definition.

DAG Validation on Save

Clicking Save (or pressing Ctrl+S) triggers validateDag() before persisting to the server:

• Errors (red badges) block save: If the DAG has structural issues — cycles detected, incompatible handle type connections, missing required data sources — the save is blocked and errors are displayed. Fix all errors before saving. Common errors: cycle detected (node feeds back into itself), type mismatch (DATA handle connected to SIGNAL input), missing data source (no Data Source node on canvas).
• Warnings (yellow badges) do NOT block save: Unconnected input handles, indicators with no manual input selected, conditions comparing against empty inputs, orphaned nodes — these generate warnings but do not prevent saving. The strategy saves successfully and you can fix warnings later.

The Load dialog displays all strategies saved to your account. Strategies are private to your account — only you can see and load them. There is no shared, public, or team strategy library.

Load Dialog Interface

• Strategy List: A scrollable, vertically-stacked list of strategy entries. Each entry displays: strategy name (bold, primary text), last modified date (relative: "2 hours ago", "3 days ago", "Jan 15, 2026"), node count (e.g., "12 nodes" as a complexity indicator), and symbol/timeframe extracted from the data source node (e.g., "BTCUSDT | 1h"). If you have no saved strategies, the list shows an empty state: "No saved strategies yet. Build and save your first strategy."
• Search: A text input at the top of the dialog. Type to filter the list by strategy name. Filtering is case-insensitive and matches substrings, not just prefixes — searching "btc" finds "BTC 1h SMA Crossover" and "ETH-BTC Arbitrage." Results update as you type (no need to press Enter).
• Sort: A dropdown to order the list by Name (alphabetical, A-Z or Z-A), Date Created (newest or oldest first), or Date Modified (newest or oldest first). Default sort: Date Modified (newest first), so your most recently worked-on strategies appear at the top.
• Delete: Each strategy row has a trash icon on the right. Clicking it opens a confirmation dialog: "Delete [Strategy Name]? This action cannot be undone." This is permanent — deleted strategies are removed from the server and cannot be recovered. There is no trash bin, recycle bin, or undo for deletion.

Load Behavior

Clicking a strategy entry (or its Load button) triggers this sequence:

• Unsaved Changes Check: If the current canvas has unsaved modifications, a confirmation dialog appears: "You have unsaved changes. Discard them and load [Strategy Name]?" Options: "Discard and Load" (loses current canvas state) or "Cancel" (stays on current canvas).
• Full Replacement: Loading is a wholesale replacement, not a merge. All existing nodes, edges, and canvas state are cleared and replaced with the loaded strategy. You cannot load a strategy and have it combine additively with the current canvas.
• Viewport Restored: The canvas pans and zooms to the saved viewport position. If the saved viewport was at 87% zoom centered on a specific subgraph, you see that exact view.
• Undo History Cleared: The undo stack starts fresh. The Undo toolbar button is grayed out after loading. You cannot undo the load to return to the pre-load state.
• Clipboard Preserved: Your internal clipboard (localStorage) is NOT cleared by loading. Any nodes you copied before loading can still be pasted into the loaded strategy.

Strategy Privacy

All strategies are private to your BitPredict account. Other users cannot see, load, copy, or reference your strategies. If you want to share a strategy with another user, you would need to manually export the JSON definition (if an export feature is available) and have them import it. A strategy marketplace or sharing feature is a potential future enhancement.

Starting from a blank canvas. Follow this step-by-step checklist to build a strategy methodically — each step builds on the previous one, and testing at each stage catches errors before they compound into an undebuggable 30-node graph.

Starting Fresh

1. Click New in the toolbar, or press Ctrl+Shift+N (Cmd+Shift+N on Mac).
2. If there are unsaved changes on the current canvas, a confirmation dialog appears: "You have unsaved changes. Discard them and create a new strategy?" Click Discard to proceed or Cancel to go back and save first.
3. The canvas clears completely: all nodes, edges, viewport position, and undo history are reset. The clipboard is NOT cleared — any previously copied nodes remain available to paste.
4. The Node Inspector closes. The canvas toolbar buttons reset to default states (Undo/Redo grayed out).

Build Checklist: 12 Steps from Data Source to Save

1. Add Data Source: Drag from the Block Library (Data Source category). Configure: Symbol (e.g., BTCUSDT), Bar Type (Spot, Perpetual, Futures), Timeframe (1m, 5m, 15m, 1h, 4h, 1d). Decide: single timeframe or enable MTF for multi-timeframe analysis. If MTF, individual nodes can override their timeframe later. This node produces a DATA-type output handle — the root of your DAG.
2. Add Indicators / Patterns: Drag Indicator or Pattern blocks from the library. Configure: indicator name (SMA, EMA, RSI, MACD, etc.) or pattern name (Engulfing, Doji, Hammer, etc.), parameters (period, source price, output type). Connect the Data Source's data handle to the indicator's input. Rename the alias to something meaningful: "Fast MA 20" instead of "SMA #1."
3. Add Conditions: Drag Condition blocks. Connect indicator value outputs to the condition's left or right inputs. Set the operator: crosses_above, crosses_below, greater_than, less_than, equals, between, etc. Set the right side: another indicator, a fixed numeric value, a pattern signal, or a price level. The condition produces a RESULT-type boolean output.
4. Add Logic Gates (optional): Drag AND, OR, NOT, or XOR gate blocks. Connect condition result outputs to gate inputs. AND requires all inputs true; OR requires at least one; NOT inverts; XOR requires exactly one. Gates combine multiple signals into one clean wire — prefer them over chaining conditions in series.
5. Add Signal Gates (optional): Drag Signal Gate blocks for timing-based signal modification: Hold (sustain a signal for N bars), Delay (wait N bars before passing), Cooldown (block re-entry for N bars after a trade closes), Pulse (emit a one-bar signal).
6. Add Filters (optional): Drag filter blocks: Trend Filter (ADX-based — only trade above/below trend threshold), Volatility Filter (ATR or BB-width — only trade within volatility range), Volume Filter (only trade above volume threshold), Time Filter (only trade during specific hours/days), Regime Filter (only trade in bull/bear/ranging). Filters produce a GATE-type boolean output.
7. Add Entry Node(s): Drag Entry Long (green) and/or Entry Short (red) blocks from the Execution category. Connect condition/logic result outputs to entry condition inputs (cond-0 through cond-4). Connect filter gate outputs to entry filter inputs (filter-0 through filter-4). Configure: combination mode (how multiple cond-N inputs combine), position sizing.
8. Add Exit Node(s): Drag Exit blocks. Configure exit types: Signal Exit (connect a condition result to trigger exit on a signal) and/or Risk Management Exit (stop-loss %, take-profit %, trailing stop %, time-based exit in bars). Set "applies_to" to specify which entry nodes this exit covers. Always add at minimum a Risk Management exit with a stop loss.
9. Connect Everything: Verify the data flow: Data Source → Indicators/Patterns → Conditions → Logic Gates → Entry. Plus: Filters → Entry (filter inputs). Plus: Conditions → Exit (signal). Every node's input handle should be connected or have a manual value. Yellow warning badges indicate unconnected handles.
10. Validate: DAG validation runs automatically. Check for red badges (blocking errors — cycles, type mismatches) and yellow badges (warnings — unconnected inputs, missing configurations). Fix all red errors. Investigate all yellow warnings.
11. Backtest: Click Backtest, configure the date range/balance/fees, and run. Review the equity curve, metrics, and trade ledger. If zero trades: check condition operators and thresholds. If poor results: iterate on parameters and logic. Build incrementally — test after every 2-3 new nodes.
12. Save: When satisfied (or at a logical checkpoint), save with a descriptive name: "BTCUSDT 1h SMA20/50 Crossover + RSI Filter + 2% SL." The strategy is now in your library, ready to load, modify, backtest, or optimize later.

Template Strategies (If Available)

The Load dialog may include template/example strategies — pre-built, validated strategies demonstrating common patterns: SMA Crossover, RSI Mean Reversion, MACD Signal Line Crossover, Bollinger Band Breakout, MTF Trend Confirmation. These are read-only on the server (you cannot overwrite them). Loading a template and modifying it is often faster than building from scratch: the connections, parameters, and DAG structure are already correct. You simply adapt the specifics to your trading idea and save as a new strategy under your account.

Backtesting runs your strategy against historical price data to simulate how it would have performed in the past. The backtest engine executes on BitPredict's servers — not in your browser — so it can handle multi-year date ranges, 1-minute bar granularity, and complex DAGs with dozens of indicators without freezing your tab.

Backtest Configuration Modal

Click the Backtest toolbar button to open. Every field is validated before submission. Here is each field in detail:

Validation Rules

• Start Date is not before the minimum available data date for the symbol/timeframe.
• End Date is not in the future.
• End Date is strictly after Start Date.
• Starting Balance is at least 100.
• Leverage is at least 1.
• Slippage is at least 0.
• Transaction Fee is at least 0.
• The DAG passes validation (no blocking errors).

Failed validation highlights the offending field in red with a specific error message. The Run button remains disabled until all errors are resolved.

The Backtest Panel

After submitting, the backtest runs on BitPredict's servers. A loading spinner indicates progress. When complete, the Backtest Panel slides up from the bottom. It contains four sections:

1. Equity Curve (Interactive Chart)

• Line chart of cumulative account value over time. X-axis: dates. Y-axis: USDT value.
• Drawdown shading: Regions below the previous equity peak are shaded in red/pink — visually highlights all drawdown periods.
• Interactive: zoom (drag to select region), pan (drag chart), hover (tooltip with exact date and value).
• Optional benchmark line: dashed gray buy-and-hold line for comparison. If your strategy underperforms buy-and-hold, ask whether active trading adds value.

2. Metrics Table

Comprehensive performance statistics with concrete interpretation thresholds:

3. Trade Ledger

A paginated, sortable table of every individual trade. Columns: Entry Time, Exit Time, Direction (Long/Short), Entry Price, Exit Price, P&L (USDT), P&L %, Bars Held, Exit Reason (Signal Exit, Stop Loss, Take Profit, Trailing Stop, Time Stop, Forced Close). Click column headers to sort. Scan for anomalies: trades with unrealistic holding periods, exit reasons mismatched with your configuration, or P&L values inconsistent with price movements.

4. Signal Components (Per-Node Contribution)

Shows what each node computed at every bar and which trades it contributed to. If a Condition node shows "0 trades triggered" over the entire backtest, it is either misconfigured or too restrictive. This per-node traceability lets you trace any trade back through the DAG to see exactly which conditions fired — the debugging superpower of the visual approach.

Optimization uses Tree-structured Parzen Estimator (TPE) — a Bayesian optimization algorithm — to systematically search your strategy's parameter space for the combination that maximizes your chosen objective metric. Instead of manually testing RSI periods of 10, 12, 14, 16, 18, and 20 (and every combination with SMA lengths, ADX thresholds, etc.), you define ranges, and the optimizer intelligently explores the most promising regions of the parameter space.

Access & Prerequisites

• Click Optimize in the toolbar.
• Prerequisites: (1) DAG validation passes (no blocking errors). (2) Strategy has at least one optimizable parameter (numeric indicator periods, threshold values, etc. — fixed fields like symbol or bar type are not optimizable). (3) Your account has sufficient credits.
• The Backtest Configuration modal opens first — set your evaluation conditions (same fields as Step 4).
• After confirming, the Optimization modal opens with two tabs.

Tab 1 — Parameter Optimization

• Search Breadth Presets:
  • Low (75-125%): Narrow search around current values. For fine-tuning an already-good strategy. Example: RSI period 14 → explores 10-18. Fastest, cheapest.
  • Medium (50-150%): Balanced. Good default for most optimizations. RSI period 14 → explores 7-21.
  • High (0-200%): Wide exploratory search. RSI period 14 → explores 1-28. Slowest, most credits.
• Node Parameters: All optimizable parameters grouped by category (Indicators, Classifiers, Conditions, Entries, Filters, Risk Management). Each parameter row shows: name, current value, a dual-handle range slider (drag min/max), a step size input (e.g., step=2 tests 10, 12, 14...), and an enable/disable toggle. Only enabled parameters are optimized; disabled ones stay fixed.
• Live Combination Count: Updated in real time as ranges and step sizes change. Shows estimated unique combinations (e.g., "~2,500 combinations"). The actual number of trials evaluated is capped by the n_trials setting in Tab 2, regardless of how many theoretical combinations exist.

Tab 2 — Pipeline Config (11 Validation Phases)

Each phase can be independently enabled/disabled. Disabling phases reduces credit cost but also reduces robustness — you are trading thoroughness for speed.

• Data Splits: Train/Val/Holdout ratios (default 70/15/15). Data is split chronologically, not randomly, to respect temporal order. The holdout data is NEVER seen during training — it is the ultimate honesty check.
• TPE Search: n_trials (typically 50-500), optional timeout, and objective mode: Single Metric (e.g., maximize Sharpe), Weighted Multi-Metric (e.g., 50% Sharpe + 30% Profit Factor + 20% -Max DD), or Multi-Objective with NSGA-II (Pareto frontier — find solutions where no metric can improve without worsening another).
• Multiple Testing Correction: Adjusts for the statistical reality that testing many parameter combinations increases the chance of finding a "good" result by random chance. Methods: Deflated Sharpe Ratio (recommended), Bonferroni (conservative), Benjamini-Hochberg (controls false discovery rate).
• Sensitivity Analysis: Perturbs each optimized parameter slightly (e.g., +/- 5-10%) and re-evaluates. A robust strategy should maintain performance under small perturbations. If changing RSI period from 14 to 15 cuts Sharpe in half, the optimization found a fragile local peak, not a robust solution.
• Noise Injection: Adds small multiplicative noise to price data to simulate market microstructure randomness. Tests whether the strategy's edge comes from genuine patterns or from fitting to noise. If 0.1% noise crashes performance, the strategy is likely overfitting to exact historical ticks.
• Regime Consistency: Partitions the backtest into market regimes (Bull, Bear, Range-bound, Transition) and checks performance in each. A strategy that only works in bull markets is a bull market detector — not a robust trading system.
• Synthetic Data Testing: Generates synthetic price series with similar statistical properties (returns distribution, volatility clustering) via block or stationary bootstrap. If the strategy finds "patterns" in random synthetic data, it is fitting to noise.
• Temporal Stability: Evaluates on sliding time windows. Consistent Sharpe/Max DD across windows = temporally stable. Erratic performance, with great results in some windows and terrible in others = likely overfit to specific periods.
• Walk-Forward Validation: The gold standard. Trains on older data, validates on the next contiguous out-of-sample window. Uses purging (removing overlapping data) and embargoing (inserting gap between train/test) to prevent data leakage. Multiple windows show the distribution of out-of-sample performance.
• Monte Carlo Simulation: Reshuffles trade sequences thousands of times. If 95%+ of random trade orderings are profitable, the edge is likely real. If only 40% are profitable, performance may be a fluke of fortunate trade ordering.
• Holdout Test: Final evaluation on completely unseen data. Define gates: minimum Sharpe, minimum trades, maximum drawdown on holdout. Trials that fail the holdout are rejected regardless of how good they looked on training data. Pass = evidence of genuine out-of-sample predictive power.

Credits Estimator

A live estimate at the bottom of the Optimization modal shows:

• Estimated Time: Computed from date range (number of bars) x number of TPE trials x enabled pipeline phases x MTF complexity factor. Example: "Estimated: 12 minutes."
• Credits Required: 1 credit per 3 minutes of estimated computation time, rounded up, minimum 1. Example: 12 minutes = 4 credits. A wide search (High breadth, 200 trials, 7 phases) on 2 years of 1h data may cost 15-30 credits. A narrow search (Low breadth, 50 trials, 3 phases) on 6 months of 4h data may cost 2-5 credits.
• Your Balance: Current credit balance. If insufficient, the Run button is disabled and a message directs you to acquire more credits.

Submitting & Viewing Results

Click Run Optimization to submit. The job is queued on BitPredict's servers. You do NOT need to keep the browser open. Monitor from the Optimizations page (/optimizations):

• See all optimization jobs with status (Queued, Running, Completed, Failed), progress (N/M trials), elapsed time, and credits consumed.
• View all trials ranked by the objective metric, each with pass/reject status for every pipeline phase (green checkmark = passed, red X = rejected).
• Drill into any trial for full analytics: equity curve, trade ledger, signal components, sensitivity surface (how performance varies with each parameter), Monte Carlo distribution histogram, regime breakdown pie chart, walk-forward window performance table.
• View the exact configuration that produced each trial (parameter values, backtest settings, pipeline settings) via the Configs modal.
• Apply the best trial's parameters directly to your canvas (updates all node parameters to the optimized values).
• Save ML models (Classifier/Regressor nodes) for reuse in other strategies.

The journey from a strategy concept to live trading with real capital is a structured, 5-phase process. Each phase progressively de-risks the strategy. Skipping phases is the most common reason algorithmic traders lose money — backtests are optimistic by nature, and only live execution reveals the true performance gap.

Phase 1: Development

Strategy Builder — Build, Backtest, Iterate

• Build the strategy DAG in the visual editor.
• Run quick backtests with short date ranges (1-3 months) to validate the core idea.
• Iterate rapidly: change a parameter, backtest, review. The tight feedback loop is your advantage.
• Once the concept shows promise (positive Sharpe on training data, >30 trades), move to Phase 2.
• Goal: A plausible strategy with positive expected value on historical data — not optimized, not validated, just "this idea has merit."

Phase 2: Validation

Optimization Pipeline — Optimize, Walk-Forward, Monte Carlo, Holdout

• Run hyperparameter optimization to find the best parameter set.
• Review walk-forward: does the strategy work consistently out-of-sample across multiple time windows?
• Check Monte Carlo: if 95%+ of random trade-sequence reshuffles are profitable, the edge is likely real.
• Verify holdout: the strategy MUST pass the final unseen data test. If it fails, iterate on the concept or accept the idea does not work.
• Examine regime consistency: a strategy that only works in 2023's bull market is fragile.
• Check sensitivity: small parameter perturbations should not crash performance.
• Goal: A robust, validated strategy with evidence of out-of-sample predictive power and acceptable risk metrics.

Phase 3: Paper Trading

Virtual Accounts — Live Data, Simulated Capital

• Deploy the optimized strategy to a virtual (paper trading) account.
• Runs on live market data with simulated capital — real prices, real latency, simulated fills, no financial risk.
• Run for a minimum of 2-4 weeks. Less than 2 weeks cannot capture different market conditions (weekday vs weekend, high vs low volatility, news events).
• Compare live paper performance against backtest: Is live Sharpe within 30-50% of backtest? Is win rate similar? Is drawdown consistent? Are trades firing at expected frequency?
• Watch for red flags: slippage worse than configured, signals at wrong times (timestamp issues), regime drift from backtest period.
• Goal: Real-world confirmation the strategy behaves as expected on live data with real-world execution constraints.

Phase 4: Small Live (Recommended)

Minimal Capital — Verify Execution

• Deploy to a real exchange account with minimal position sizes — the smallest the exchange allows (e.g., 0.001 BTC). The goal is execution verification, not profit.
• Run for 1-2 weeks.
• Verify: fill rates (are limit orders filling?), actual vs expected slippage (compare executed prices to signal prices), latency (delay between signal and order submission), exchange downtime (any missed trades?).
• Compare small live vs paper trading — any discrepancies? Paper trading often shows optimistic fills because it ignores order book depth.
• Goal: Proof the strategy operates correctly with real money, fees, and liquidity — at a scale where losing everything costs pocket change.

Phase 5: Full Live

Production — Scale Up, Monitor, Maintain

• Scale up to full position sizes gradually — double size every few days as confidence builds.
• Enable alerts (Telegram, Discord, Slack) for trade notifications, error conditions, and drawdown thresholds.
• Define a kill switch before deploying: Write down objective criteria for pausing/stopping:
  • Drawdown exceeds 20% from peak (or 2x backtest max drawdown).
  • Win rate over last 20 trades drops below 25%.
  • 5-7 consecutive losing trades.
  • Rolling 30-day Sharpe drops below 0.5.
  • Exchange reports abnormal conditions (maintenance, extreme volatility).
  The time to decide these is BEFORE you are staring at a -30% drawdown. Emotional decisions during drawdowns are almost always wrong.
• Monitor daily (not obsessively): P&L, drawdown, trade frequency, error logs.
• Keep a trading journal: note observations, manual interventions, anomalies.
• Re-optimize every 3-6 months with latest data. Do NOT re-optimize after every losing week — that is curve-fitting to noise.

Critical Caveats

• Regime Changes Are Inevitable: Markets are non-stationary — the statistical properties that held in 2023 may not hold in 2025. A breakout strategy that worked in a trending market gets chopped in a range-bound one. The Regime Consistency phase tests for this, but only on historical regimes. Be mentally prepared to pause or retire strategies when market conditions change.
• Position Sizing Matters: Backtests assume infinite liquidity at the signal price. In live trading, position size is limited by: available margin (exchange margin requirements), max order limits, and market depth. A $500,000 BTC trade is trivial; the same size in a low-cap altcoin may move the price 5-10%. For large positions, use TWAP execution (split across multiple smaller orders over time).
• Always Use a Stop Loss: Even with sophisticated exit logic, always have a hard stop loss via the Risk Management exit node. This is insurance against black swans, flash crashes, and exchange outages. A stop loss is not a trading strategy — it is a safety net. Set it at 1.5-2x the Average True Range (ATR) of your timeframe as a starting point.
• Correlation Risk: Running multiple strategies on correlated assets (BTCUSDT, ETHUSDT, SOLUSDT) multiplies exposure to market-wide drawdowns. When BTC drops 20%, correlated altcoins often drop 25-30%. Diversify across genuinely uncorrelated assets and strategy types (trend-following + mean-reversion + options-based).
• Costs Compound Relentlessly: Slippage (0.05%) + fee (0.1%) = 0.15% per side, 0.3% round-trip. A strategy making 5 trades per day pays ~1.5% daily in costs. Over 250 trading days: 375% annual cost drag. Calculate your expected annual costs: trades_per_year x round_trip_cost_pct. If this exceeds your expected annual return, the strategy cannot survive.