An end-to-end
algorithmic trading
system.
From raw market data to live broker orders — a self-built platform that finds breakout setups across the US market, filters them with machine learning, sizes each trade by expected value, and executes through Interactive Brokers, fully automated and risk-first.
Six layers, one source of truth
Every layer reads from and writes to a single Postgres / Supabase database — no component hands trade data to another in memory, so any piece can fail, be skipped, or be re-run on its own.
Find the breakout. Let ML decide the bet.
The strategy hunts one repeatable shape, then turns a chart pattern into a probabilistic, risk-sized decision.
A momentum-scored rally, a tight base that rests at least 1.5× as long, then a confirmed breakout sets the entry, stop and target straight from the candle.
Higher expected value earns a bigger slice of account risk. Negative-EV setups are skipped entirely — size is computed, never guessed.
Where the stop and targets come from
Nothing is hand-placed. The breakout sets the entry; the stop and every target are derived from the pattern's own geometry — the size of the move and the stock's recent volatility — so each signal arrives with a known risk and reward before a cent is committed. The short side is the mirror image: a selloff, a base, then a breakdown.
When the model bets against the breakout
A rejected signal isn't always a non-event. When the model is confident a breakout will fail, the system takes the other side — a mean-reversion trade. It waits for the failing breakout to run most of the way to its target, then fades it back.
Take a long breakout the model expects to fail. Rather than buy it, the opposing book waits for price to climb 75% of the way to the primary's target — where the breakout looks “successful” — and shorts it there, betting on the snap-back.
- ▸Gated by a 2-bar reversal alert — no alert, no opposing trade
- ▸Stop sits at the 50% (target-50) line; the take-profit targets the original signal's stop — a mean-reversion bracket
- ▸Dual entry: a reference 75%-to-target limit plus the alert level; one entry is live at a time
- ▸Each leg sized to 1R off its own fill
Real results from the system's own backtest_opposing_entry.py, replayed on 1-hour bars over the held-out test set, on the flipped population (primaries the model scored below 0.50). The backtest models the original-entry + alert legs (its current product); live execution layers the 75% leg on top. Expectancy in R, before costs.
Training methodology
Every closed trade becomes a labelled example. Two models, two objectives, one discipline: nothing is ever scored on data it trained on.
Every training run is logged as an experiment (long model reached exp 155 across ~27 tracked runs; short reached exp 147 across ~20). A model is only promoted to production after it clears the held-out test set — the same deterministic split every time. Once live, the active model IDs are written to ACTIVE_MODELS.json so the pipeline and the auto-trader always serve the current version without a code change.
Two side-aware models,
measured out of sample
Long and short setups are scored by separate models — promoted only after clearing a held-out test set the model never saw in training. These are the production evaluation metrics of the two models trading today: not curve-fit training scores, but honest out-of-sample performance on unseen trades.
The short model leans toward recall (0.682) — it casts a wider net to catch more breakdowns — while the long model is balanced near 0.61 across the board. AUC above 0.5 confirms both rank true setups ahead of false ones; that ranking is exactly what the EV and risk-tier layer above turns into position size.
Different inputs for long and short
The two models don't share a feature set. The long model reads 44 SQL-built features — adding VIX moves, weekly sector-relative returns, market-cap ratios and finer volume detail. The short model trades on a leaner 20, plus its own pattern_score input. 19 features are common to both. Toggle to compare.
How much each feature contributes
Gain-based importance shows how much each feature improved the model's splits. The two models could hardly be more different: the long model spreads its conviction across dozens of weak signals (nothing tops ~4%), while the short model leans hard on a few — the size of the prior rally alone drives 11.7%. Hover a name for what it measures.
Gain-based importance from the production model (20 features, bars on a shared 0–12% scale). consol_duration lands at 0% — basic_tightness already encodes the base length, so the tree never needs it.
Does a confidence of 0.6 really win 60%?
A score is only useful if it means what it says. These reliability curves plot predicted confidence against the win rate actually realised, across the full confidence range on each model's held-out test set — every point on the dashed line is perfectly calibrated. Both models track the diagonal closely: a 0.6 really does mean roughly 60%.
Win rate measured on the production models' own held-out test sets — 700 unseen trades for the long model (exp 155), 498 for the short (exp 147) — bucketed by predicted confidence. Points are sized by sample count, so the sparse tails (very low or very high confidence, where few setups land) carry visibly less weight than the dense middle. Hover any point to see how many trades fall in that bucket. Live trading only acts on the calibrated ≥ 0.50 range.
Is it actually profitable?
Results are in R — multiples of the risk taken on each trade (R = |entry − stop|). A stop-out is −1R; a winner pays its reward-to-risk. On its own the breakout scanner has a negative expectancy; the machine-learning filter is what turns it positive. Move the confidence filter to see the quality-vs-quantity tradeoff. Every figure is from each model's held-out test set — trades it never saw — equal-weighted, before costs.
Raising the bar trades quantity for quality: win rate and per-trade expectancy climb, but fewer signals clear the gate — so total R can actually fall as the book thins out. Production runs the ≥0.50 gate to keep enough trades working while staying clearly positive.
The control above is the actual production lever: signals must score at or above 0.50 confidence to be traded — that single gate is the entire difference between the “scanner only” and “scanner + ML” columns. Live, the same score then feeds the regime filter and EV-based risk tiers that size each position.
The filter rejects ~52% of raw signals — but the lowest-confidence ones aren't discarded. When the model is confident a setup will fail, the system flips to the contrarian side (the opposing book). Backtested over the held-out set, those flips earn +0.23R (opposing short) and +0.39R per trade — a real second edge from the model's negative conviction. Full mechanics in the Strategy section.
Held-out test sets: 700 trades (long, exp 155), 498 (short, exp 147). Returns in R-multiples (loss = −1R, win = its reward-to-risk), booked at the scanner's primary 50% target (up to 200% on strong-breakout “adjusted” entries) — the 75% and 100% partials are tracked but not counted here. Equal-weighted, before commissions and slippage. Test-set performance is not a guarantee of live results.
How a trade scales in and out
Every position starts at a defined 1R and is managed from there — risk comes off fast, size is added only on confirmation, and the exit is one trailed bracket, never a discretionary guess.
| Primary (breakout) | Opposing (fade) | |
|---|---|---|
| Initial stop | entry − 2 × ATR | the 50% (target-50) line |
| Add-on price | Day+2 close | signal entry price |
| Resize toward | 1.5 × original $ risk | 1.0 × original $ risk |
| Trail stop to | low/high of 2 pre-entry bars | ⅓ of the original risk |
| Take-profit | 100% target longs · 75% shorts (→1.5×R after add) | toward the original stop (1×R) |
One honest detail: the book scales in on strength, but it exits as a single managed bracket — a trailed stop and one take-profit — not in tranches. The 75% and 100% targets are tracked for context and feed the Day-2 resize, but the live exit is one order. Rules from move_stops_to_breakeven.py and day2_stop_trail.py.
One command runs the whole day
A single orchestrator walks the market from data to executed trades — logged, re-runnable, and human-approved by default. Click any step to see what it runs and which tables it touches.
What makes it hold up
Where it goes from here
The stock book is live; the next frontier is expressing the same signals as defined-risk options, then tightening the loop between live results and the models.
Defined-risk options overlay
The same ML signals can be expressed as IBKR debit spreads — buy a call near the 50% target, sell one near the 100% target. The net debit paid is the entire risk: the position can't lose more than it cost, by construction.
- ▸Long ~ target 50% · short ~ target 100% (vertical debit spread)
- ▸Net debit = maximum loss — risk capped up front
- ▸Auto-planned from the live IBKR option chain, sized ~1% of account
- ▸One combo order in; GTC conditional close at the side's target — long at 100%, short at 75%
- ▸Running in IBKR paper now — same kill-switch + approval safety as the stock book
The stack
Every layer of the system built from scratch — from SQL feature jobs to live IBKR bracket orders.