Table of Contents
This interview features David Bergstrom on the Desire To Trade podcast, where he breaks down how a quant mindset can turn scattered ideas into a dependable trading process. David is the creator of Build Alpha and a veteran of a high-frequency trading desk, so he’s lived the difference between hand-drawn chart lines and rigorously tested edges. If you’re curious about algorithmic trading but want plain-English, beginner-friendly explanations that you can apply whether you automate or not, you’re in the right place.
In this piece, you’ll learn the clean, repeatable workflow David uses to find and vet a strategy: mine ideas, pressure-test them for robustness, then walk them live with clear expectations. We’ll cover why “test everything” is his north star, how to use Monte Carlo bands to set realistic drawdown and return ranges, and when to bench a system that drifts out of bounds. You’ll also see how he builds portfolios that mix trend, mean-reversion, and pattern setups while watching correlations and hidden dependencies—plus the mindset shifts that keep you from over-promising a backtest and under-delivering in real time.
David Bergstrom Playbook & Strategy: How He Actually Trades
Core philosophy: edges first, stories second
David Bergstrom builds systems by testing ideas like a scientist, not by telling market stories. The goal is to prove an edge survives pressure, then express it in rules simple enough to execute without doubt. Expect fewer opinions and more evidence-driven decisions.
- Define every idea as rules you could hand to a computer; no discretionary overrides.
- Favor signals you can explain in one sentence (e.g., “buy strength that pulls back to rising average”).
- Keep rules count low (≤5 total conditions) to reduce curve-fit risk.
- Require that the logic be market-agnostic (works on multiple symbols or regimes), not just a single chart.
Idea mining: from concepts to testable setups
He starts wide, turning common concepts into precise, testable statements. Each concept must be measurable (entry, exit, risk, timeframe) so it can be validated quickly and fairly.
- Convert a concept to a hypothesis with exact parameters (e.g., “trend if price > 200-SMA and 20-day breakout”).
- Pre-define entry, stop, time exit, and profit exit before any backtest.
- Use at least 10+ liquid markets or 20+ years of data (whichever yields ≥500 trades at the intended timeframe).
- Reject ideas with a <52% win rate and a payoff ratio <1.2, unless they diversify the portfolio meaningfully.
Signal construction: keep it simple and robust
Signals are built with simple, interpretable components that tend to generalize: trend, momentum, mean reversion, seasonality, or pattern filters. He avoids exotic math unless it clearly improves robustness.
- Use a maximum of one trend filter, one timing trigger, and one market-regime filter.
- Prefer SMAs/EMAs, Donchian channels, RSI(2–5), ATR-based filters, or day-of-week/seasonal flags.
- Ban overlapping rules that say the same thing (e.g., RSI<30 plus %B<0 often duplicates).
- Cap lookback windows between 5 and 250 bars; avoid micro-optimizations like 17 vs. 18.
Parameter sweeps: search broadly, choose conservatively
Rather than picking the “best” setting, he sweeps ranges and selects middle-of-the-pack parameters that remain strong across neighbors. The aim is stability, not the single top curve.
- Grid-search each parameter over wide, sensible ranges (e.g., SMA 50–250 in steps of 10).
- Rank by median performance across neighbors, not the single best node.
- Lock parameters inside a “safety box” where ±20% changes don’t wreck results.
- If the best node outperforms the median by >2x, treat it as a red flag for curve-fit.
Robustness testing: abuse the system before the market does
Everything must survive tests designed to break fragile edges. David stresses noise, slippage, data shifts, and sub-sampling to ensure results are not lucky artifacts.
- Add slippage/fees at 1.5–2.0× your broker’s typical cost in the backtest.
- Randomize entry/exit by ±1–3 bars and require the edge to remain positive.
- Perform Monte Carlo reshuffles (≥1,000 paths) and record the worst-10% drawdown/return.
- Accept only systems whose worst-decile Monte Carlo equity is still viable at your risk.
In-sample / out-of-sample & walk-forward
He separates development from validation and then simulates “retraining” with walk-forward to mimic how rules age in live markets.
- Split data chronologically: ≥60% in-sample (IS), 40% out-of-sample (OOS).
- Demand OOS CAR/MDD of at least 70% of IS and Sharpe ≥0.8 OOS.
- Run 3–5 fold walk-forward; accept only if the majority of folds beat a naive benchmark (e.g., buy-and-hold or flat).
- Freeze the final rule set after validation; no touching parameters before going live.
Position sizing: volatility-based, risk first
Sizing is set by volatility and worst-case scenarios, not by hope. He uses ATR-based stops and pre-computed loss bands from Monte Carlo to keep drawdowns tolerable.
- Risk is a fixed fraction per trade (0.25–0.75% of equity) based on system quality and correlation.
- Place initial stop at 1.5–2.5× ATR from entry; size shares so stop equals the chosen % risk (1R).
- For trend systems, trail at 2.5–3.5× ATR; for mean reversion, use time-based exits (e.g., 5–10 bars).
- If live drawdown hits the Monte Carlo 90% worst-case path, immediately halve risk until recovery.
Portfolio construction: edges that don’t rhyme
Multiple uncorrelated systems beat any single “perfect” system. David mixes trend, mean-reversion, and pattern edges across symbols and timeframes to flatten the equity curve.
- Target ≤0.6 pairwise correlation between systems’ daily returns.
- Cap exposure per asset class at 30–40% of total risk; per single symbol at 10–15%.
- Run at least one long-bias and one short-capable system in the same portfolio.
- Stagger timeframes (intraday, swing, position) so not all signals fire together.
Execution discipline: rules to avoid slippage and doubts
He emphasizes clean, mechanical execution. Entries and exits are fully specified so the operator can follow them without second-guessing.
- Use market or stop orders for breakouts; limit orders only for mean-reversion entries with strict no-fill rules.
- Place all orders after the signal bar closes to avoid peeking bias.
- If a gap blows past the intended entry, skip the trade unless the plan explicitly allows a re-pricing rule.
- Log every trade with timestamp, fill, slippage vs. model, and reason code.
Live monitoring: bands, alerts, and decisions
Before going live, he defines acceptable performance bands. If the system drifts outside those bands, pre-agreed actions kick in automatically.
- Calculate expected CAGR and max DD bands from Monte Carlo; publish green/amber/red thresholds.
- If rolling 6-month Sharpe <0 for a trend system and below the amber band, cut size by 50%.
- If two independent health checks fail (e.g., hit ratio and average trade), pause new entries; manage open trades per plan.
- Re-evaluate monthly; only restore full size after two consecutive green-band months.
Change control: when to tweak, when to kill
David’s bias is to protect capital first. Systems get retired when the data says the edge faded, not when emotions flare.
- No parameter changes mid-flight unless a documented “emergency rule” triggers (e.g., structural fee hike).
- Kill criteria: 1) live DD worse than Monte Carlo 99% band, 2) two full walk-forward windows underperform cash, 3) structural market change invalidates premise.
- If killed, archive with notes; do not resurrect without fresh IS/OOS and walk-forward.
- Replace retired risk with the next validated, uncorrelated system—never by doubling another system.
Record-keeping & review: let data coach you
He treats the post-trade journal as a system component. The review loop prevents small leaks from becoming big problems.
- Maintain a dashboard: rolling Sharpe, CAR/MDD, win rate, avg trade, heat maps of slippage and timing.
- Tag each trade by regime (vol up/down, trend/sideways) to see where the edge truly lives.
- Quarterly, re-test with blind OOS appended; if stability worsens, reduce capital or retire.
- Keep a living “anti-rules” list (what not to do); add any mistake that costs≥0.25R and make it enforceable.
Size Every Trade by ATR; protect equity first, always.
David Bergstrom keeps risk mechanical by letting volatility dictate position size. Instead of guessing how “big” a setup feels, he translates the chart’s noise into dollars using ATR so every trade risks a consistent fraction of equity. That way, a slow, quiet market doesn’t get oversized, and a wild, spiky market doesn’t blow you out. The outcome is a smoother equity curve where one freak move can’t torpedo months of progress.
Here’s the gist: define your stop at a multiple of ATR, then back into shares so the distance to that stop equals your chosen risk per trade. David Bergstrom typically frames entries, knowing the exact 1R he’s putting on the line, which keeps emotions out when price wiggles. The rule scales naturally across symbols and timeframes because ATR adapts to each market’s personality. Protect equity first, and the compounding takes care of itself.
Build Simple Rule Sets; test broadly, choose middle-of-pack parameters.
David Bergstrom keeps systems brutally simple so they’re easy to execute and hard to break. He limits each strategy to a small handful of conditions that anyone could explain in one breath. Simple rules generalize across markets and regimes, which means fewer nasty surprises when volatility shifts. If a rule is hard to justify in plain English, he cuts it before it cuts his equity curve.
When it comes to parameters, David Bergstrom sweeps wide ranges and studies how performance behaves across the neighborhood. He avoids the “best” setting and picks a sturdy middle that stays strong when you nudge it up or down. This prevents one lucky backtest from becoming a disappointing live system. The final step is locking those choices inside a safety box so live trading sticks to robust, repeatable behavior.
Diversify By Strategy, Market, And Timeframe To Flatten Drawdowns.
David Bergstrom doesn’t hunt for one perfect system; he stacks several good ones that don’t move together. He mixes trend, mean reversion, and pattern setups so each shines in different regimes. By spreading across equities, futures, FX, and crypto, he avoids letting one asset class dictate the entire equity curve. The goal is simple: when one engine sputters, the others keep the portfolio cruising.
To make it work in practice, David Bergstrom watches correlations like a hawk and trims any pair that starts “rhyming” too much. He staggers timeframes—intraday, swing, and position—so signals fire at different rhythms instead of all at once. He keeps both long-bias and short-capable systems online to handle bull runs, chop, and panics without retooling. Capital is allocated by risk, not excitement, and he rebalances when one sleeve dominates so the whole machine stays smooth.
Replace Predictions With Mechanics: walk-forward testing, monitor Monte Carlo bands.
David Bergstrom replaces market “calls” with repeatable checklists that either fire or don’t. Instead of forecasting, he validates rules through walk-forward testing that mimics how a live system evolves. Each fold forces the strategy to prove it can adapt without hand-waving or hindsight edits. That mindset turns trading from opinion-based to process-driven.
Once live, David Bergstrom watches Monte Carlo performance bands like a dashboard. He compares rolling returns and drawdowns to the simulated ranges and reacts when the equity curve slips into the danger zone. If results hit amber or red bands, he cuts size or pauses entries per the prewritten plan. The system doesn’t argue with the market; it follows mechanics that protect capital first.
Predefine Stops, Exits, And Kill-Switches To Enforce Process Discipline.
David Bergstrom treats risk rules like a pre-flight checklist—non-negotiable and done before the engine starts. He writes the initial stop, profit exit, and time exit into the playbook so there’s nothing to “decide” mid-trade. The stop is placed where the edge is invalidated, not where it “feels safe,” and size is set so that loss equals a fixed R. Profit taking is conditional and specific—trail for trends, scale out or time out for mean reversion. By scripting the path to both loss and gain, he removes the impulse to tinker when emotions spike.
Kill-switches are defined in advance so the system protects itself when conditions deteriorate. David Bergstrom uses rolling performance checks—like hit rate, average trade, or Sharpe—against precomputed thresholds to cut size or pause entries. If a drawdown breaches a worst-case band, he halves the risk or stands down until metrics recover. The trade log and dashboard make the decision obvious, turning “Should I stop?” into “The rules say stop.” That’s how discipline becomes automatic instead of heroic.
David Bergstrom’s core message is disarmingly simple: trade what you can prove, size what you can survive. He strips every idea down to rules you can hand to a machine, keeps parameters in the sturdy middle of the range, and lets ATR set position size so one wild day can’t wreck the account. Walk-forward testing replaces gut calls, and Monte Carlo bands set hard expectations for returns and drawdowns before a single live order goes out. When the equity curve drifts into the danger zone, the playbook already tells you whether to cut size, pause entries, or retire the system—no debates required.
Just as important, David Bergstrom spreads risk across edges that don’t rhyme: trend, mean reversion, and pattern systems running on different markets and timeframes. He caps correlations, staggers signals, and enforces stops, time exits, and kill-switches so discipline isn’t left to how you feel that day. The big takeaway for traders is a repeatable loop: define the rules, torture-test them, allocate by volatility, monitor against pre-published bands, and let the data decide the next move. Do that consistently and you’ll spend less time predicting and more time compounding.
Related posts:
- Paul Langham Trader Strategy: Price Action that Actually Makes Sense
- Kevin Davey Trader Strategy: How an Algo Pro Really Builds & Trades Systems
- Sovit Manjani Trader Strategy: Build Doable Systems, Not Just Profitable Ones
- Laurens Bensdorp Trader Strategy: Simple Rules, Many Systems, Real Edge
- Troy Bombardia Trader Strategy: Systems Thinking for Real-World Edge
- Trader Strategy Through Adversity: What David Opar’s Journey Teaches
- Pavel Kycek Trader Strategy: Data-First Systems for Real-World Crypto & Stocks
- Jason Graystone Trader Strategy: High-Timeframe Systems, Smooth Risk, Real Wealth
- Glitch Trader Strategy: How David Hale Turns Market Inefficiencies Into Edge
- David Moadel’s Trader Strategy: How He Analyzes Markets and Builds a Winning Portfolio
- SMC Trap Trader Strategy: Luca’s Data-Driven FX Edge
- Aatu Kokkila Trader Strategy: Event-Driven FX That Actually Scales
