This isn't a hypothetical. It's a real, reproducible behavior in Interactive Brokers' platform, and it bit a live algorithmic trading operation hard enough that I spent the better part of a week root-causing it. Here's exactly what happens, why it happens, and what actually protects you against it.
The setup
A long position gets a protective stop order placed against it — a standard STP
or STP LMT sell order resting at the broker, waiting to trigger if the price
falls through a level. This is about as basic as risk management gets. Thousands of retail
and algorithmic traders rely on exactly this mechanism, every day, without a second thought.
The failure shows up specifically when that stop needs to be modified — trailed up as price moves favorably, or adjusted — while the position is being held through extended hours (pre-market or after-hours trading).
What actually happens
IBKR applies a price collar to orders placed or modified outside regular trading hours — a sanity check meant to protect against fat-finger orders and illiquid extended-hours pricing. Under certain conditions, when a trailing stop's modify request falls outside that collar's tolerance, IBKR's system rejects the modification — but the original resting stop doesn't survive the rejected modify attempt either. It gets cancelled in the process.
Here's the part that makes this genuinely dangerous rather than just annoying: there's no error callback, no rejection message, nothing surfaced through the API or the TWS interface that tells you the stop is gone. The position sits there, completely unprotected, looking from the outside exactly like a normal, healthy, stop-protected position.
The only way to discover it happened is to actively go check whether the order is still resting — and most systems, understandably, assume that once a protective stop is placed, it stays placed unless they cancel it.
How this was confirmed
This wasn't inferred from a support forum post or a changelog note — it was reproduced directly against a live account, correlating the exact timestamp of a trailing-stop modify attempt during extended hours against the moment the resting order disappeared from the broker's own open-orders list. No corresponding cancel event. No error in the application log. The order was simply gone.
Running multiple live algorithmic strategies simultaneously made this class of bug unusually visible — when you're managing dozens of positions across several independent systems, a single silently-unprotected position doesn't stay hidden forever. Eventually something closes out at a loss it shouldn't have been exposed to, and you go looking for why.
What this actually looks like, caught in the act
Between those two timestamps, a 100-share position sat completely unprotected. Nothing in TWS flagged it. Nothing in the API's error stream flagged it. The only reason it got caught at all is that something was actively polling, comparing what should be resting against what actually was.
What actually protects you
The honest answer is: nothing passive does. You cannot "set and forget" a protective stop and trust that it'll still be there later, specifically across extended-hours trailing updates. The only real defense is active, periodic verification — comparing what should be protected against what's actually resting at the broker, and re-arming immediately when they diverge.
That's a genuinely unglamorous engineering problem — polling on a schedule, tracking last-known state so you have something to compare against, and re-arming in a way that's safe to repeat without accidentally placing a duplicate order if a check runs again before the first fix is confirmed. It's exactly the kind of thing that's easy to skip, which is why it tends to get skipped.
If you want to check whether this has happened to you
Even if you never touch any tool for this: pull your account's open-orders list right now and cross-reference it against every position you believe has a protective stop. If a position doesn't have a matching resting order, and you didn't cancel it yourself, this is almost certainly why.
A related but different kind of silent failure: Task Scheduler Said It Was Running. It Wasn't. — a stale process squatting on a port long enough to block a real one from launching.
Stop Watchdog
A small, focused tool that does exactly this check — continuously — and re-arms a stop the moment it notices one has silently vanished. Free and open-source (MIT) to run yourself; a paid tier if you'd rather not run the infrastructure.