Table of Contents
In this YouTube interview, software entrepreneur and systematic trader Matt DeLong breaks down how he took his trading automation in-house and built a multi-strategy engine that runs day and swing systems across stocks, options, and ETFs. He matters because he’s not theorizing—he’s shipping live code that allocates capital, routes orders, and manages trades in real time, with the kind of practical constraints most retail traders never consider (APIs, data gaps, throttling, scaling). If you’ve wondered what it really takes to go from “idea on paper” to an always-on trading stack, Matt is your guy.
In this piece, you’ll learn Matt DeLong’s blueprint for building and running automated strategies: documenting the rules before coding, separating strategy logic from trade management, and designing for both intraday and end-of-day flows. You’ll also see how he treats data hygiene, backtests vs. live execution, broker API limits, risk caps per trade and per account, and when to favor pyramiding or multiple accounts. It’s a clear, beginner-friendly look at the real moving parts behind a working automated trader—and how to structure your own system so it actually gets filled, scales, and survives beyond the backtest.
Matt DeLong Playbook & Strategy: How He Actually Trades
Architecture: the engine that runs every trade
A clean structure keeps the strategy logic simple and the execution reliable. Matt separates the “what to trade” from the “how to route and manage orders,” so new ideas can be added without breaking the machine.
- Build a three-layer stack: scanner/strategy logic → trade manager → broker adapter. No strategy code talks to the broker directly.
- Standardize inputs: all strategies consume the same bar format (timestamp, O/H/L/C, volume) and emit the same signals (entry, stop, target).
- Use 5-minute bars for intraday systems and EOD bars for swing; never mix bar types inside a single strategy.
- Keep a state machine for each order: planned → submitted → working → filled/partial → managed → closed/expired.
- Isolate brokers behind an adapter so you can switch (or add a second broker) without editing strategy code.
Setups first, code second.
He writes the trading setup like a recipe before a single line of code. Each setup prints its entry, stop, targets, and conditions so any trader can sanity-check it.
- Define a “setup” object with required fields: entry rule, stop rule, target1/target2, time-in-force, and instrument filters.
- Force every setup to explain itself in plain text at runtime (e.g., “enter if 5m close > prior high; stop = prior swing low”).
- No variable names in rules—use human numbers (e.g., “stop 0.50 below entry,” not “stop = entry – X”).
- A setup must be testable on historical data and executable live with the same parameters.
- If the setup can’t specify where it exits when wrong, it’s not ready.
Data hygiene that survives reality
Live trading breaks when data is messy. He treats data like a production dependency with checks, fallbacks, and clear failure states.
- Maintain a daily ingest for all tradables you might touch (full US equities + options if you trade them).
- Before scans, run health checks: stale bar detection, missing symbols, split/dividend adjustments, API heartbeat.
- Backtests fail fast: if a gap or split is detected mid-series, skip that symbol/day and log it.
- Version your data and your code: each file references a data snapshot + code version for post-mortems.
- Keep real-time and historical data calls separate; throttle each to its own limits.
Intraday vs swing: two playbooks, two clocks
Day systems demand precision and low latency; swing systems demand breadth and clean EOD processing. He runs both—just not with the same assumptions.
- Intraday: evaluate on 5-minute close only; no tick-based decisions; throttle decisions to ≤2 reads/sec per symbol family.
- Swing: run scanners pre-market off prior day’s close; generate a next-session plan with entries/stops/targets stamped.
- Day systems must include a time stop (e.g., flat by 15:55 ET).
- Swing systems must include a gap protocol (skip late fills if open > planned slippage threshold).
- Never let a swing setup leak into intraday rules—separate queues and separate risk budgets.
Position sizing that respects dollars, not vibes
Matt budgets risk in hard dollars per trade and per account. The sizing rule lives outside the strategy, so every setup inherits the same guardrails.
- Set a max $ risk per trade (e.g., $2,500) and compute quantity from stop distance and expected slippage.
- Cap aggregate open risk (e.g., total risk ≤ 6 × per-trade risk) to prevent signal pile-ups.
- Use laddered targets (e.g., take ½ at T1, move stop to breakeven; trail remainder to T2 rule).
- Reject any order that would push maintenance or BP beyond a threshold; size down automatically.
- Round quantities to broker-safe lots; for options, enforce min OI and max spread width.
Order routing that actually fills
Pretty charts don’t matter if you can’t get filled. He codifies broker realities—latency, throttles, rejects—into the trade manager.
- Pre-submit checks: buying power, price bands, halt status, shortability/locate for shorts, option chain sanity.
- Use limit-at-market logic: limit = last ± slip buffer; if unfilled after N bars, cancel or re-price once, then abandon.
- Consolidate all API calls through a single queue with rate-limit guards (e.g., ≤2 requests/sec endpoint).
- On partial fills, recompute stop and target for filled quantity and leave the remainder working or cancel by rule.
- Every broker response is logged verbatim (request, response, latency) to a durable store for later audits.
Portfolio allocation and correlation control
Running the same idea everywhere feels good—until it doesn’t. He intentionally diversifies by account, strategy, and instrument to avoid synchronized drawdowns.
- Tag strategies by regime and edge (trend-follow, mean-revert, breakout) and spread them across accounts.
- Hard rule: never run the same strategy in every account; enforce diversification at the account-strategy matrix.
- Cap sector and factor exposure (e.g., tech weight, high-beta weight) at the portfolio level.
- Prefer independent clocks (day vs swing) to reduce correlation of exits on volatile sessions.
- If two setups conflict on the same symbol, apply priority rules (higher expectancy or earlier timestamp wins).
Pyramiding and scale rules
Adding to winners is powerful when scripted and dangerous when emotional. He allows ads only in a strict context.
- Permit adds only above breakeven and after lock-in (stop ≥ entry on core).
- Each add must tighten the stop on the composite so worst-case loss never exceeds the initial risk.
- Max adds per trade (e.g., two), and max total size caps prevent runaway leverage.
- No pyramids in the final N bars of the session for day systems.
- Disable adds on news/halting symbols, or if the spread widens beyond a defined threshold.
Monitoring, logs, and “message of the day”
Operations beats inspiration. He treats observability as a feature, not a chore.
- Dashboard shows open risk, P&L by strategy, API health, queue depth, and error count.
- Morning banner (“message of the day”) prints maintenance, throttle windows, and known vendor issues before scans run.
- Every trade has a timeline (signal → order → fill → management → exit) with timestamps for post-trade review.
- If any dependency is degraded, block new entries and allow only exits/management.
- Set pager rules for exceptions (reject storms, data gaps, latency spikes) with human-readable messages.
Daily runbook that keeps humans in the loop
Even with automation, humans set the rules and review the outcomes. The day is structured to keep discretion out and discipline in.
- Pre-market: run swing scans from prior close; approve plan; publish risk budgets and any symbol bans.
- Open to midday: intraday engine active; trader monitors exceptions only; no manual overrides except kill-switch.
- Last hour: tighten time stops; block new day entries; ensure swing orders are staged for next session.
- After close: reconcile fills vs. plan; diff logs; tag anomalies; schedule replays for any strategy that misbehaved.
- Weekly: re-estimate slippage/commissions, refresh universe lists, and re-balance risk caps by strategy.
Option-specific guardrails
Equities and options share the engine, but options need extra safety rails for liquidity and execution.
- Minimum open interest and maximum bid-ask %; skip if violated at submit time.
- Use limit-only for options; never send market orders; auto-cancel if mid-price drifts beyond allowed delta.
- Restrict to the first two monthly cycles unless the setup requires more time; block weeklies on news weeks.
- Size by dollar risk, not contracts; validate assignment risk and exercise cutoffs in the trade plan.
- Disable option entries if the underlying halts or exceeds intraday ATR × K spike.
Backtest to live: one rulebook, two modes.
The secret to consistent execution is making sure live trading and backtests speak the same language.
- Use the same setup objects and parameter files in backtest and live; forbid “test-only” hacks.
- Bake in slippage and latency assumptions that match real broker stats; re-fit monthly.
- Reject any live trade whose backtest scenario is missing (e.g., symbol history too short or adjusted incorrectly).
- Compare expected vs actual (entry, slip, time-in-trade) on every trade; alert if variance exceeds threshold.
- Freeze code during market hours; deploy only in a post-close window with automatic rollback.
Capital scaling without breaking risk
More capital should increase profits—not operational risk. He scales via parallel accounts and safer order flow, not bigger bets everywhere.
- Increase the number of concurrent strategies, not per-trade risk, when stepping up size.
- Spread orders across multiple accounts/brokers to reduce throttle and rejection clusters.
- Enforce per-account drawdown stops (e.g., pause new entries if equity ↓ X% from high-water mark).
- Recompute position size ceilings after deposit/withdrawal events; never assume prior limits.
- Keep a paper “shadow account” mirroring new strategies for 20 sessions before going live.
Size Every Trade in Dollars, Not Confidence or Hopes
Matt DeLong is blunt about this: position size is a math problem, not a mood. He fixes risk per trade in dollars first, then backs into quantity from entry and stop—no exceptions. That shift kills the “I feel good about this one” impulse that wrecks accounts. When every setup risks the same dollars, losses are survivable, and wins compound without drama.
Practically, Matt DeLong sets a hard cap per trade and lets volatility dictate size, not the other way around. If the stop is wider, he takes fewer shares; if it’s tighter, he takes more—still the same dollars at risk. He tracks aggregate open risk, so multiple signals don’t quietly exceed the budget. With size decided by dollars, not conviction, the strategy stays consistent on hot streaks and cold snaps alike.
Separate Strategy Logic From Execution Mechanics To Scale Safely
Matt DeLong keeps the “what” and the “how” living in different rooms. Strategies decide entries, stops, and targets; a separate trade manager handles routing, throttles, and error recovery. This separation lets him add or retire setups without touching broker code. It also prevents a small tweak to a rule from accidentally breaking live execution.
Matt DeLong’s execution layer treats brokers like interchangeable parts behind a clean adapter. Orders pass through preflight checks—buying power, halts, price bands—before they ever hit the street. If a broker chokes or rate-limits, the manager retries, re-prices by rule, or stands down gracefully. Because logic and mechanics don’t mingle, he scales accounts, adds assets, and survives API weirdness without rewriting the strategy playbook.
Diversify By Strategy, Underlying, and Timeframe To Cut Drawdowns
Matt DeLong spreads risk across uncorrelated edges instead of doubling down on one “best” idea. He runs trend-follow and mean-revert side by side, so one can carry the other through regime shifts. Different underlyings—large caps, mids, ETFs, and selective options—keep any single sector blow-up from dictating the day. Timeframe diversification matters too: intraday systems flatten shocks fast, while swing systems harvest broader moves.
He also prevents hidden correlation by limiting how many positions share the same factor or sector heat. If two strategies want the same symbol at the same time, priority rules decide which one wins to avoid overexposure. Independent risk budgets per strategy and per account stop a hot hand from quietly dominating portfolio variance. This is how Matt DeLong keeps the curve smooth: many small, independent engines—not one big bet—pulling in the same direction over time.
Use Volatility-Based Position Sizing And Laddered Targets For Consistency
Matt DeLong sizes trades to the market’s mood instead of his own. When volatility is high, he cuts position size so the same dollar risk survives wider swings; when it’s calm, size can step up without breaking the risk cap. An ATR or standard-deviation stop defines distance; quantity is just math from that distance back to a fixed dollar loss. This keeps losers uniform and stops the “big-loss, small-win” spiral that ruins equity curves.
Matt DeLong also locks in progress with laddered targets instead of swinging for one perfect exit. He takes a first scale at T1 to book risk-off, then bumps stops to breakeven so the trade can’t turn green to red. The remainder trails to T2 or a rules-based exit, letting outliers pay the bills while routine winners still contribute. In choppy sessions, the scales protect the day; in trends, the runner captures the move without second-guessing. Over time, this combo—vol-adjusted size plus staged profit-taking—bakes consistency into results and keeps emotions out of the driver’s seat.
Choose Defined Rules Over Predictions, Automate Process Discipline Daily
Matt DeLong doesn’t care about calling tops or bottoms—he cares that the same rule fires the same way every time. Entries, exits, and stop logic are written down first, coded second, and followed even when it feels wrong in the moment. That removes the “maybe this time is different” temptation that usually arrives right before a large loss. When the bell rings, rules run; opinions sit.
To keep it honest, Matt DeLong automates the routines that humans love to skip: preflight checks, time stops, gap protocols, and post-trade reviews. The system blocks new entries during degraded data or broker hiccups and only allows management—no hero trades. Every trade is tagged with why it happened, how it was managed, and whether it matched the playbook, so daily reviews are fast and blunt. Over weeks, this turns discipline into muscle memory: rules make the money, the automation keeps you from breaking them.
Matt DeLong’s core lesson is to treat trading like production software: write the rules in plain English first, then code them, and keep strategy logic separate from the plumbing that routes and manages orders. He runs intraday ideas on 5-minute bars and swing ideas off the prior close, with distinct queues, budgets, and time stops (flat by the end of the day for day systems). Entries are stop-limit in the trade’s direction, exits are pre-declared (T1, T2, and a hard stop), and quantity is just math from a fixed dollar risk per trade—never a feeling. Backtest and live share the same setup objects and parameters, with slippage, latency, and broker quirks baked in so results rhyme across modes.
He builds resilience with guardrails and observability. Preflight checks catch bad data, halts, buying-power issues, and price bands before an order leaves the house; rate-limited queues and retries absorb broker API noise; dashboards and logs stamp every trade with code version, data snapshot, and timing so post-mortems are fast and honest. Portfolio-level controls cap total open risk, restrict correlated exposure, and enforce priority when two strategies want the same symbol. Scaling means adding independent strategies and accounts—not juicing per-trade risk—and staging new ideas in a shadow account before they go live. Even collaborations, like his gap work with Jeremy Newsome, enter the machine as explicit setups with entry, stop, targets, gap protocols, and sizing rules, so discretion can’t sneak in. Net-net: define risk in dollars, encode behavior in rules, separate “what” from “how,” and automate the discipline that humans forget—then let the engine run.
