Signal History: Self-Service Debugging for Systematic Traders

You set up your strategy. You connected your webhook. TradingView fired a signal at exactly the right moment; you can see it right there in the alert log. And then… nothing. No position. No fill. No error message. Just a closed candle and a trade you didn’t take.

If you’ve spent any time automating a trading strategy, you know this feeling. It’s one of the most frustrating experiences in systematic trading, and it’s made worse by the fact that there are so many places the breakdown could have happened. Did the webhook fire? Did it reach your automation platform? Was there a configuration issue with your bot? Did the broker reject the order? Without visibility into each step of that chain, you’re left guessing. Guessing is not a systematic process.

This is the problem Signal History in RelayDesk was built to solve.

The Black Box Problem

Webhook-based automation introduces many invisible moving parts between your chart and your broker. Most platforms treat this pipeline as a black box: signals go in, orders (hopefully) come out, and what happens in the middle is largely opaque. When something goes wrong, you’re left digging through logs, re-reading documentation, and trying to reconstruct what happened after the fact.

What systematic traders actually need is the same thing they demand from their strategies: transparency, repeatability, and the ability to diagnose failure modes without guesswork.

Signal History is built around that principle.

One Signal, Many Outcomes

Here’s something that trips up a lot of traders when they first get into automation: a single signal source can feed multiple bots simultaneously, and each of those bots can respond differently to the same signal.

Take a real example from RelayDesk. A QQQ strategy — “QQQ UT” — is connected to two bots: one for long entries (QQQ UT [LNG]) and one for short entries (QQQ UT [SHRT]). When a signal fires, both bots independently evaluate it against their own configurations. The result? The same entry signal can execute on one bot and be skipped on another, and the reasons can be completely different.

That’s not a bug, it’s the system working exactly as designed. But without visibility into what happened at each bot level, it looks like chaos.

Signal History surfaces this per-bot breakdown for every signal that comes through. When that QQQ entry signal fired at 15:54 ET, here’s what you’d see:

• QQQ UT (SHRT): Skipped — Bot is paused
• QQQ UT [LNG]: Skipped — Outside entry window: 09:35–15:45 ET (current: 15:54 ET)

Two bots, two different skip reasons, one clear picture. The short bot was manually paused. The long bot’s entry window had already closed for the day. Neither of these is a malfunction; both are the system enforcing rules you set. Signal History just makes those enforcement decisions visible.

This matters more than it might seem. When you’re running multiple strategies across multiple bots, the ability to instantly see why a signal didn’t execute, without digging through settings or re-reading configuration docs, is the difference between spending two minutes on a review and spending twenty.

When Signals Do Execute

The other side of Signal History is equally important: when a signal does result in a trade, you get a complete execution audit trail.

For every executed signal, RelayDesk records the full lifecycle of the position. Entry time, contract count, fill price, and every subsequent exit leg as it triggers. A typical options trade might look like this:

• ENTRY at 2:27 PM — 19 contracts @ $0.53
• TP1 at 2:30 PM — 10 contracts @ $0.59
• BREAKEVEN at 2:30 PM — 9 contracts @ $0.52

Alongside that execution timeline, you also get the bot’s strategy parameters at the time of the trade: position size, order type, max spread, stop-loss percentage, and stop-loss management type. The realized P&L is calculated and displayed. In this case, +$51.00 (+5.06%) on a fully closed position.

This isn’t just record-keeping. It’s the foundation of a feedback loop. When a trade performs differently than you expected, you can look at exactly how it was managed; which exits triggered, in what sequence, at what prices, and understand whether the strategy behaved correctly or whether something needs to be adjusted.

Debugging Should Be Systematic

Here’s the underlying philosophy: if you’re running a systematic strategy, your debugging process should be systematic too.

Staring at a broker statement and trying to work backwards to figure out why a signal didn’t turn into a trade is not a systematic process. Neither is sending support tickets asking why something happened three days ago.

Signal History puts that diagnostic capability directly in your hands. Every signal your source receives is logged. Every bot-level decision, whether executed or skipped, along with the precise reason, is recorded. Every trade executed carries a full audit trail of its management.

When something looks off, you open Signal History, find the signal in question, and you have your answer in seconds. Not because someone on the other end looked it up for you, but because the platform was built with the assumption that you’d need to know.

Systematic traders deserve systematic tools. That’s what we’re building.

RelayDesk connects TradingView alerts to broker execution with full visibility into every step of the process. Running a UT-based strategy this month? The March Bot Challenge is live now. UT Bot Alerts on 1-Minute SPX, best P&L wins.