The five places a trade can die
The signal didn't work" is five different faults wearing one sentence. Each has its own screen, and checking them in order takes two minutes.
An automated strategy did not trade when you expected it to. You look at the chart, the setup was there, and nothing happened.
That is not one problem. It is five, and they look identical from the outside: in every case the screen shows no order. The difference is which stage the trade died at, and there is a specific place to look for each. Walking the chain in order is faster than guessing, and it is the single most useful diagnostic habit in automated trading.
The five stages, and what each failure looks like
1. The signal was never raised. The source did not fire. Your condition did not actually become true, or it became true on a bar that had not closed yet, or the study you are watching computes differently from how you read it. This is the most common cause and the least often suspected, because the chart looks right to a human eye.
The tell: no new entry at the source at all. Nothing downstream has anything to receive.
2. It was raised but not delivered. The signal exists at the source and this node never read it. Something in between — a queue, a subscription, a cursor that tracks how far this node has consumed — is stuck.
The tell: the source shows a new sequence number; the node's position has not moved. This is the failure that most resembles a dead system while every component reports itself healthy, because each one is fine and the link between them is not.
3. It was delivered but matched nothing. The node received the signal and had no instruction for it. The identifier did not correspond to a configured route, or the route exists and is disabled, or it points at a strategy that is no longer deployed.
The tell: a received signal with no corresponding action, and — crucially — this should be logged as a drop, not silently ignored. A system that discards unmatched signals without a record is a system where this failure mode is undiagnosable, which is why an unmatched signal deserves an entry of its own.
4. It matched but the engine chose not to trade. This is the one that is not a fault, and it is where the most time is wasted. The signal arrived, the route matched, and the engine evaluated it and declined: outside the permitted window, a risk limit reached, no margin, the instrument not tradeable, a position already open, the day's trade count exhausted.
The tell: a recorded decision with a reason. A good engine records why it declined. If yours does, read it and you are done. If yours does not, this stage is a black box and every investigation will stall here.
5. The engine acted but the order did not fill. An order was sent. It was rejected by the broker, or accepted and never filled, or partially filled. All three are different and all three show "no position".
The tell: an order record with a broker response. Read the response. A rejection carries a reason code, and a limit order that never filled is a different problem from one that was refused.
Why the order matters
Walking left to right eliminates possibilities. Guessing does not.
The common mistake is to start at the end — "the broker must have rejected it" — because that is where the visible absence is. But an order that was never sent cannot have been rejected, and half an hour can be spent reading a broker's rejection codes for an order that does not exist.
Starting at the left takes the same two minutes every time and ends with a specific answer. And it has a second benefit: you learn which stage your setup actually fails at. Most setups have a characteristic weak link, and after three or four investigations you will know yours.
A strategy has produced no orders for two days. The trader's first assumption is that the strategy logic is broken, and they spend an evening reading it.
The chain walk takes two minutes:
- Raised? Yes — 39 signals over two days, sequence numbers advancing.
- Delivered? Yes — the node's cursor is current.
- Routed? Yes — every one matched its strategy.
- Acted? Yes, and here is the answer: 39 recorded decisions, every one declining, every one with the same reason — a risk limit reached.
- Filled? Nothing reached this stage.
The strategy logic was never the problem. A risk limit was configured as 0, and zero is a perfectly valid limit meaning never trade, sitting in the field where the trader believed they had entered no limit. Thirty-nine signals, thirty-nine correct refusals, zero orders ever placed.
Every component behaved exactly as designed. The configuration said do not trade, and the system did not trade. The only thing that failed was the assumption that an empty-looking value means "unlimited" — and the only reason it took two minutes instead of two evenings is that stage four recorded a reason.
That example is worth sitting with, because it is the shape of most automation failures. Nothing crashed. Nothing logged an error. Every screen was green. The system did precisely what it was told, and what it was told was not what anyone intended.
Which is the theme of this whole module: in automated trading, the dangerous failures are not the ones that break. They are the ones that work correctly on the wrong instruction.
What to take from this chapter
- "The signal didn't work" is five distinct faults with one symptom. Walk the chain left to right and stop at the first stage with no record.
- Raised, delivered, routed, acted, filled. Each has its own place to look and its own tell.
- The most common cause is stage one — the signal never fired — and the least suspected, because the chart looks right.
- Stage two is the one that looks like a dead system while every component reports healthy: the components are fine, the link is not.
- An unmatched signal must be logged as a drop. Silently discarding it makes stage three undiagnosable.
- Stage four is usually not a fault at all. An engine that records why it declined turns a two-evening investigation into a two-minute one.
- A rejected order, an unfilled order and a partially filled order are three different problems that all look like "no position".
- The dangerous automation failures do not break. They execute the wrong instruction perfectly, with every screen green.