Backtesting vs live trading: the gap where systems die

A backtest runs your strategy against a market that holds perfectly still and answers every order the instant you send it, at exactly the price you wanted. Live trading hands the same logic to a market that keeps moving while you think — one that fills you late, fills you halfway, or sometimes just doesn't fill you at all. The strategy never changed. The conditions did. And the space between those two worlds is where the edge you were promised quietly goes missing.

You can't trade without backtesting, and it's also the most over-trusted number in the business. A backtest tells you whether the idea has any merit at all. What it won't tell you is whether the system running that idea survives contact with a real venue. Those are two different questions. I've watched people confuse them more times than I can count, and it's exactly how a strategy that printed money on history quietly bleeds it in production.

What the backtest quietly assumes

Every backtest sits on a stack of assumptions the historical data quietly lets you get away with. You don't notice them because the data never charges you for them:

• You execute at the price you saw. Nothing happens between the decision and the fill.
• Your order doesn't move the market. Liquidity is infinite and you leave no footprint.
• Every order fills, in full, the instant you send it. No partials, no rejections, no waiting in a queue.
• The venue never goes down. No disconnects, no rate limits, no stale prices.

Live trading breaks all four. On their own they each shave off a few basis points, which feels harmless. But stack them on a strategy whose edge was thin to begin with and they'll flip a positive expectancy into a losing one. And you don't get the warning until you've got real capital on the line.

Slippage is the tax on the gap

Slippage is just the difference between the price you expected and the price you actually got, and it's the cleanest way to measure how far apart your backtest and reality have drifted. It shows up from a few directions at once: the lag between deciding and executing, how thin the order book happens to be when your order lands, and the market drifting away in the milliseconds it took you to act.

A backtest with zero slippage isn't optimistic. It's fiction. The question worth asking isn't "what does the strategy make" — it's "what's left after the market charges you for the privilege of trading in it." If a system doesn't model slippage, it's reporting a number from a world that doesn't exist, and in my experience that's the number people fall in love with right before they get hurt.

The gap is an architecture problem, not a strategy problem

Here's the part almost everyone misses. When live results come in under the backtest, the reflex is to blame the strategy and go re-fit it. But the loss usually isn't in the signal at all. It's hiding in everything between the signal and the fill — the part the backtest never simulated, the part that's the architecture's job. I've seen weeks burned re-tuning a perfectly good model when the real culprit was an order path that fell apart under load.

How fast does the order actually leave? What happens on a partial fill? What does the system do when the venue rejects you? Does your position state still line up when a fill lands late? None of those are strategy questions — they're system questions, and they decide how much of the backtested edge ever reaches your account. The strategy sets the ceiling. The execution architecture decides how far below it you end up.

Closing the gap

You'll never fully close the distance between backtest and live. What you can do is shrink it, measure it, and stop pretending it's zero:

• Model execution honestly — put latency, slippage, partial fills, and fees into the backtest, even when it makes the headline number look worse. Especially then.
• Paper trade against the live feed — run the real system against the real market with no money on it, then check whether its fills match what the backtest assumed.
• Measure live slippage continuously — the gap between expected and realized price should be a number on a dashboard, not a nasty surprise at month-end.
• Treat the execution path as the product — it's the part that decides whether the edge is real.

A backtest tells you the strategy could work. Only the system tells you whether it does.

The gap between backtest and live isn't a flaw to be embarrassed about. It's just the normal weather of trading real markets — it's always there. The systems that last are built by people who respect that. They assume the market is going to fight back, and they design the execution layer to give up as little of the edge as possible on the way to the fill.

Ignacio Montoya is a systems architect specializing in algorithmic trading infrastructure, financial systems, and digital asset platforms. He builds the execution architecture that determines how much of a backtested edge survives in live markets.