We Built a Mechanical Breakout Bot. Then One API Call Cut Its Drawdown in Half.

The setup: a purely mechanical breakout strategy

We run a Smart Money Concepts (SMC) prop-trading engine - the kind of strategy that lives and dies on structure, not sentiment. It watches daily candles for a clear trend approaching a significant zone, then drops to hourly candles waiting for a Break of Structure (BOS) in that direction. No discretion, no AI judgment call, no "vibes" - just rules: detect the trend, detect the break, build the trade.

We back-tested it the honest way: a genuine hour-by-hour walk-forward simulation (not a vectorized shortcut) over the maximum history we could pull - 2.3 years of real hourly OHLCV data (July 2024 → October 2026) across the top 5 crypto tickers by market cap: BTC, ETH, BNB, XRP, and SOL. Every one of the 765 signals the strategy fired got walked forward candle-by-candle until its stop or target was actually touched. No look-ahead, no cherry-picking.

Here's what a purely structural, no-frills breakout strategy actually looks like in the real world:

That's... fine? Positive on average, but look closer: two of five tickers are net losers, and every ticker is dragging a drawdown north of 10% - three of them over 17%. The strategy has a real structural edge (a 2.5:1 reward-to-risk setup carrying a sub-35% win rate to a positive outcome is nothing to sneeze at), but it has no idea which of its own signals are the strong ones and which are the weak ones. It treats every Break of Structure identically, whether that break is the start of a genuine trend move or a half-hearted fakeout that reverts straight into the stop.

That's exactly the kind of problem more data should be able to solve.

The question: is there a signal we're ignoring?

A plain OHLCV breakout detector only ever looks at price. But we weren't only pulling price - our data vendor, DefiTheOdds, already attaches a set of pre-computed ML classifier outputs to every single candle, for free, in the same API call:

• expansion_probability - P(volatility expands next bar)
• tail_risk / tail_risk_conf - P(next bar's move exceeds the rolling 90th percentile)
• high_vol / high_vol_conf - P(next bar is in a high-volatility regime)
• regime_change / regime_change_conf - P(a low→high volatility transition is starting)
• regime_emergence / regime_emergence_conf - P(a 10-bar volatility spike vs. the 30-bar median)
• breakout / breakout_conf - an independent ML classifier's own breakout probability

We'd been fetching all of this the whole time and using none of it. So we asked a very simple question: does any of this actually separate our winning signals from our losing ones?

Not "does this sound plausible." Does it, empirically, on our own 760 real resolved trades.

The answer: mostly no. One field, clearly yes.

We checked the mean and median value of every field above, split by whether the trade that fired at that moment went on to win or lose. Most of them were a wash - high_vol, regime_change, and regime_emergence showed essentially zero separation between winners and losers. Even breakout_conf, the field that sounds like it should obviously matter for a breakout strategy, barely moved the needle (0.62 vs. 0.60).

One field stood out immediately:

It makes sense in hindsight: a Break of Structure that the model also expects to be followed by expanding volatility is more likely a genuine, energetic move with real follow-through. A break with low predicted expansion is more likely a weak, low-conviction poke that reverts straight back into your stop. The structure said "break" either way - the ML layer is the thing that can tell you whether anyone actually showed up to push it.

Wiring it in: one line, one threshold

We didn't change the strategy's logic at all. We just added a pre-trade gate: before any detected BOS is allowed to become a real trade, check that hour's expansion_probability reading. Below 0.6 ("the model doesn't expect this move to have real energy behind it"), skip it - leave the opportunity on the watchlist, retry next hour.

Then we ran the exact same 2.3-year, 765-signal backtest again with that one gate switched on.

The results

Read that drawdown column again. Average max drawdown across the five tickers roughly halved - 17.12% down to 9.20% - while average return stayed essentially identical. We didn't trade our edge away to reduce risk; we simply stopped taking the half of our signals that the data told us were the weak ones. BTC and SOL - the two tickers that were net losers in the raw strategy - both flip to solidly positive. ETH's drawdown drops by more than half. XRP's return/drawdown ratio goes from "already good" (5.44) to "excellent" (8.73).

One ticker, BNB, is the honest exception - still net positive, but its risk-adjusted ratio actually gets slightly worse. We're reporting that too, because a strategy writeup that only shows you the wins isn't a backtest, it's an advertisement. (We also tried gating on tail_risk_conf looking for a similar win - it didn't have one. Win and loss means were statistically indistinguishable, and max drawdown barely moved at any threshold we tried. Not every pre-computed signal is going to be the one that matters for your specific strategy, and knowing which one is only comes from actually testing against your own outcomes.)

Why this matters

We didn't build a volatility-expansion classifier. We didn't train a model, label a dataset, or stand up any ML infrastructure. We made the same API call we were already making, read one more field out of the response we were already getting, and added a four-line threshold check. The entire "data science" here was: pull a vendor's pre-computed model outputs, check them against our own real outcomes, keep the one that worked, discard the four that didn't.

That's the actual value of a data provider that ships ML outputs alongside raw price data instead of making you build the modeling layer yourself: you get to spend your time testing hypotheses against your own strategy instead of building and maintaining volatility/tail-risk/regime classifiers from scratch. We tested six different signals in an afternoon. Building even one of them in-house - labeling historical volatility expansions, training a classifier, validating it, keeping it fresh - is a project, not an afternoon.

Try it on your own strategy

You don't need our SMC engine to run this test - the only requirement is a strategy you already have and a signal you're pulling from an API call you're probably already making. Pull expansion_probability (or any of the other five fields above) alongside your normal OHLCV request, split your own historical trades by that field, and see whether it separates your winners from your losers the way it separated ours.

Grab a free API key at defitheodds.xyz/register - the free tier covers BTC and ETH, which is enough to run this exact comparison against your own backtest. Full field definitions and published accuracy numbers (expansion_probability carries a published ROC-AUC of 0.84) are on the methodology page.

If you're running any kind of systematic strategy on crypto (or planning to), the fields are already there, attached to candles you're probably already pulling. The only real question is the one we asked ourselves: does this one actually help, for your strategy, on your own outcomes? We'd encourage you to go find out for yourself.

Methodology note: all figures above come from a genuine hour-by-hour walk-forward simulation (not vectorized/look-ahead), using the maximum hourly history available (2024-07-08 → 2026-10-26, ~20,000 candles/ticker), reusing the exact same detection code that runs in production rather than a parallel research copy. Returns assume 1% account risk per trade, compounding, with each ticker treated as its own independent account.