
{/* banner prompt: Matte clay-render 3D illustration, 16:9, soft studio shadows, simple cream background. A small warm-lit theatre stage where a single sage-green clay robot performs a full juggling routine with tiny candlestick-chart cards, spotlit and mid-performance, facing rows of completely empty terracotta theatre seats. In the front row sits one solitary cream clay judge figure holding a clipboard and pencil, attentively taking notes. Heavy terracotta stage curtains at the sides, a soft single spotlight beam, warm muted palette of sage green, cream and terracotta, clean geometry, no text, gentle depth of field. */}

This is the third post in a series. The [first](/blog/2026/09/13-indicators-measure-strategies-decide-alpha-is-what-survives/) argued that indicators, strategies, and alpha are three different layers with three different jobs. The [second](/blog/2026/09/14-a-trading-system-in-three-layers-measure-decide-account/) turned the taxonomy into architecture, and made a claim I promised to back up: that the probation tier — a strategy running fully live while trading nothing — is the single highest-value feature in our codebase.

This post is the receipts.

## Fully live, trading nothing

Mechanically, signal-only deployment is almost embarrassingly small: one boolean on a deployed strategy. With the flag set, the policy runs the complete live path — real-time bars as they arrive, real multi-timeframe consultation, real entry decisions, real exit doctrine, real notifications pushed to my phone — and at the last possible moment, places no order.

The phrase to notice is *complete live path*. This is not paper trading in a separate simulator, and the distinction is the entire point. A separate simulator is a second implementation of your system, and a second implementation is a second set of bugs. The first post in this series called divergence between "the thing you validated" and "the thing you trade" a fraud you commit against yourself; a standalone paper-trading harness reintroduces that fraud through the back door, with better intentions. In probation, the code that decides is the code that will trade. The only difference between probation and production is one flag — which means everything probation proves, it proves about the real system.

A backtest answers *would this have worked?* Probation answers a different and humbler question: *does this actually work — this code, this data feed, this clock, this market, right now?* It is remarkable how often the answer to the first question is yes and the second is no. Every one of the following stories is a case where the backtest had no opinion and probation did.

## What probation catches that backtests cannot

**Stale inputs.** The previous post mentioned a monthly-timeframe series that had silently stopped updating for almost a year. Here is the part I left out: the way you *find* that fault, in practice, is probation. Nothing crashed and no monitor fired — the tell was **silence**. A policy that consults the monthly level and should fire occasionally had never fired at all, and signal-only deployment is what converts "it has never fired" from an unremarkable fact into a question that must be answered. When we chased the silence, we found the frozen series: the stale bar happened to read "trending," a state that particular policy could never align with, so it had been structurally dead since the day it was deployed. A backtest over the same period, using clean historical data, showed the policy firing happily. Backtests run on the data you *should* have. Probation runs on the data you *do* have.

**Code-path divergence.** While validating a new policy recently, we discovered that every backtest on one of our production servers had been quietly dying partway through the run — an exit-callback signature mismatch between two builds of the same portfolio library, so the first simulated position to close crashed the simulation. The live trading path was untouched; only the validation path was broken, and only on that machine. Sit with the irony: the tool whose job is to certify strategies was the thing that was wrong, and it failed in a way that produced clean-looking, quietly truncated results rather than an error. If your validation and your execution are different code — different builds count — then what you are validating is a fiction that resembles your system. The only durable defence is the one probation embodies: make the live path itself the thing that gets exercised, and treat any disagreement between the backtest and a live-path replay of the same history as a five-alarm bug, not a rounding curiosity.

**Data-feed reality.** Two smaller specimens from the same collection. One of our index CFD feeds only quotes the middle of the trading session — the official open and close, where the most dramatic bars print, simply do not exist on that feed. And on one server, a confirmation timeframe's history did not reach back far enough, so entry signals fired and then *expired unconfirmed* — not because the market rejected them, but because the bars needed to judge them were absent. Neither fact lives in any backtest dataset. Both change what a strategy actually experiences. The market data you backtest and the feed you trade are not the same object, and only one of them pays you.

**The refusal machinery, proven live.** The freshest story, and my favourite kind: days after we deployed a new trend-drift policy signal-only on the indices, it fired a live long trigger — and then its higher-timeframe confirmation rolled over and killed the signal before it graduated into a would-be trade. That is not a failure report. A signal that fires and then gets refused *for the right reason* is probation gold: it exercises the entry logic, the confirmation logic, and the refusal path, end to end, on live data, and it costs nothing. You cannot buy that certainty from a backtest, because the backtest runs the same code with the same assumptions baked into both sides of the test.

## The funnel is the report card

While a policy is on probation, we grade it on a funnel: every decision it makes falls through four stages, and each stage answers a different question.

![The probation funnel: signals in, most refused for measured reasons, graduates out](https://storage.googleapis.com/www-tyolab-com-blog-assets/images/blog/2026/09/trade-nothing-prove-everything-the-signal-only-probation-tier/funnel.png)

<Table data={
    {
        headers: ['Funnel stage', 'Question it answers', 'A bad number usually means'],
        rows: [
            ['Signals fired', 'Does the policy fire at all on live data?', 'A dead or stale input, an impossible condition, or a thesis whose setup never occurs'],
            ['Confirmed', "Do signals survive the policy's own checks?", 'Confirmation data missing or short, or checks tuned so tight nothing passes'],
            ['Expired / refused', 'Does the refusal machinery reject for market reasons?', 'Refusals tracing to broken inputs rather than to the market'],
            ['Hypothetical outcome', 'Would the confirmed signals have paid?', "The honest no - recorded in the ledger, and no capital paid for the lesson"],
        ]
    }
} />

The discipline is that every stage gets *explained*, not just counted. Zero signals is fine if the market offered no setups; it is a defect if it traces to a frozen series. A pile of expired signals is fine if the confirmations genuinely failed; it is a defect if the confirmation bars were simply missing. The funnel does not tell you whether the policy is good. It tells you whether the policy is *real* — and only a real policy deserves the question of goodness.

## Graduation: the actual criteria

The bar a policy must clear before the flag comes off is unglamorous, and that is deliberate. Ours is:

- **A sample floor, counted in signals, not months.** A quiet policy that fires four times a quarter needs more wall-clock than an active one; eight live signals validate nothing — the sample-size theatre warning from the first post applies to probation too.
- **Live/backtest parity.** Replaying history *through the live path* must reproduce the backtest's episodes — same events, same windows. Where they disagree, one of them is lying, and probation exists to find out which.
- **Every silence explained.** Any gap where the policy did not fire must trace to "no qualifying setups," never to "an input was broken and nobody noticed."
- **An A/B against the incumbent.** A new policy does not merely have to work; it has to beat, or usefully complement, whatever currently owns its scope — measured on the same bars.
- **Graduate narrow.** This is the one people resist. When our trailing-stop policy earned real capital, it earned it on exactly one symbol, at one timeframe, in one direction — the single scope where a corrected-implementation A/B proved it — and it remains signal-only everywhere else to this day. The instinct after a good probation is to switch everything on. The correct move is to scale *scope* before you scale *size*: one market, one timeframe, one direction, then earn the next scope the same way the first was earned.

Notice what is *not* on the list: conviction, elegance, how good the equity curve looked in the backtest, or how much I personally like the idea. The first two posts were about building a court that can kill your favourite idea. Graduation criteria are that court's sentencing guidelines, written down *before* the trial.

## The door swings both ways

The part that makes probation a tier rather than a gate: demotion uses the same doorway. When a live policy decays — and edges decay; that is what being an edge means — it does not get deleted. It goes back to signal-only, where it keeps running the full live path, keeps generating evidence about itself, and costs nothing while it does. Sometimes the decay is the market moving on, and the ledger gets a dated entry saying so. Sometimes the "decay" turns out to be a broken input, and the policy comes back. Either way the answer is data, not memory.

A strategy in our system is therefore never really "in" or "out." It occupies a scope: trading real capital where it has earned it, on probation everywhere else, demotable at any time, re-promotable only by the same criteria as before. The shelf of policies from the last post is really a shelf of probation records.

## The price is patience

Signal-only deployment converts opinion into data at exactly zero financial risk. That sentence sounds like a free lunch, so let me name the real cost: time. A probation takes weeks where a backtest takes minutes, and the discipline it demands is the least fashionable one in trading — waiting, while a thing you believe in trades nothing, until the ledger agrees with you or does not.

Every mechanism in this series points the same direction: the system's job is to move belief out of the trader's head and into a place where it can be counted. The backtest counts the past. Probation counts the present. Capital is what you allocate to the intersection.

*Next in this series: how edges decay — what a dying policy actually looks like in the ledger, how long we let it bleed before demotion, and why "it stopped working" is a measurement, not a mood.*


dfb4e0fa8acd0e045b28f48a6d5206fcf68ff5f36ae6d63b0d677c34a8c27a38

How a signal-only probation tier validates trading strategies on live data at zero risk, and the graduation criteria that let a policy trade real capital.

Backtests are rehearsals. Before a strategy touches real capital in our system, it runs fully live and trades nothing. What the signal-only probation tier catches that backtests structurally cannot, the funnel we grade it on, and the graduation criteria we actually use.

Trade Nothing, Prove Everything: The Signal-Only Probation Tier


{/* banner prompt: Matte clay-render 3D illustration, 16:9, soft studio shadows, simple cream background. A tidy miniature factory line in three connected stations, left to right: first a sage-green measuring station with calipers, dials and a small candlestick chart on an easel; second a terracotta sorting station where chunky clay arms route little rounded blocks through branching gates onto different tracks; third a cream accounting station with a small balance scale and two bins, one holding a few glowing golden blocks and one holding many dull grey blocks. A thin conveyor belt links all three stations. Clean geometry, warm muted palette of sage green, cream and terracotta, no text, no people, gentle depth of field. */}

In [the last post](/blog/2026/09/13-indicators-measure-strategies-decide-alpha-is-what-survives/) I argued that *indicator*, *strategy*, and *alpha* are not three words for the same thing but three different layers with three different jobs: indicators measure, strategies decide, alpha is what survives honest accounting. Several readers asked the natural follow-up: fine as a taxonomy — but what does a trading *system* built that way actually look like?

This post is the answer. The claim is stronger than "layers are a nice way to think." The claim is that the layering is an **architecture**, that each layer has a concrete set of components and a rule it must never break, and that the rate at which your whole operation finds real edges depends less on the brilliance of any one idea than on how cleanly the layers are separated. Edges are not found; they are *farmed* — and the three layers are the farm.

![The three layers of a trading system: measurement, decision, accounting](https://storage.googleapis.com/www-tyolab-com-blog-assets/images/blog/2026/09/a-trading-system-in-three-layers-measure-decide-account/layers.png)

## Layer 1: the measurement layer

**What it consists of:** the data pipeline (bars at every timeframe you consult, gap-checked and freshness-checked), and the indicator library — every instrument computed on every bar of every series, all the time, whether or not anything downstream is listening. Moving averages, bands, oscillators, trailing stops, plus whatever house instruments you have built. In our system this layer runs from the 15-minute series up through hourly, daily, weekly and monthly, for every symbol, continuously.

**Its function:** report events. Never judge them.

**The rule it must never break:** an indicator is not allowed to know whether its event worked out. The moment you let outcome-awareness leak into an instrument — tuning it to "avoid false signals," suppressing a crossover because the last three lost — you have destroyed the layer boundary, and everything downstream is now measuring a mixture of the market and your opinions. The false signals are not a defect. They are the raw material the next layer exists to judge, and the layer after that exists to count.

Because the components are boring, the failure modes at this layer are boring too — and that is exactly what makes them dangerous. Two dominate:

- **Silently wrong.** An indicator implementation that drifts from its canonical definition still draws a plausible line on the chart. The last post covered this one: verify each instrument against the reference once, like calibrating a thermometer, then leave it alone.
- **Silently stale.** This is the system-level version, and it bites harder. We recently discovered that a monthly-timeframe series on one of our servers had quietly stopped updating almost a year earlier. Nothing crashed. Nothing warned. Every policy that consulted the monthly level was voting with a ten-month-old opinion — and one class of policies that required monthly agreement had been silently dead the whole time, because the frozen bar happened to read "trending," a state those policies could never align with. A measurement layer needs freshness monitoring the way a lab needs calibration stickers: every series carries an implicit "last verified current" date, and a policy consulting a stale series should be told, not humoured.

**Where a trader should focus here:** correctness and coverage, *once each*, plus a standing freshness check. This layer rewards diligence, not creativity. If you find yourself spending your evenings retuning indicator parameters, you are farming the wrong field.

## Layer 2: the decision layer

**What it consists of:** a portfolio of small policies — strategies — each one a single hypothesis about how to map measurements to actions. Each policy owns its entry conditions, its exit doctrine, its stop placement, and its right of refusal. Critically, each policy is *small*: one idea, one file, one name in the ledger.

**Its function:** judgment. This is the only layer where an opinion about the market is allowed to exist.

**The rule it must never break:** a policy consumes measurements; it never re-measures, and it never grades its own homework. Timeframes have a contract — the higher timeframes decide direction and regime, the lower timeframes time the entry — and a policy that lets a 15-minute signal overrule a daily trend has broken it.

The payoff of keeping policies small and separate is that the *same instruments* can serve contradictory hypotheses simultaneously, and the system does not have to pick a winner in advance. A worked example from our own book, using nothing more exotic than Bollinger Bands and Parabolic SAR:

Our workhorse band policy trades the cycle a band system sees: expansion, trend, exhaustion, reversion. It is structurally good at that shape — and structurally blind to one specific, expensive shape: the failed breakdown that V-reverses and melts up. Price breaks the lower band, looks like a crash, snaps back through the middle band within a few bars, and then trends for months without ever offering the pullback the policy waits for. We measured thousands of these events, and the numbers were blunt: at the moment the band policy would first consider the recovered trend tradeable, price sat a couple of ATRs beyond anything it would chase, and a quarter of the resulting runs never revisited the middle band at all. No parameter setting fixes that. It is not a tuning problem; it is the wrong hypothesis for that shape.

The instructive part is what the fix was *not*. We did not touch the bands, and we did not bolt a "melt-up exception" onto the band policy — that would have been two hypotheses wearing one name, unjudgeable at the accounting layer. Instead: a different instrument already in the measurement layer (Parabolic SAR, which flips on the recovery bar essentially every time, precisely *because* it judges nothing) and a new, separate policy that consumes the same measurements at higher timeframes and rides the calm drift the band cycle reads as "nothing happening." Two policies, one instrument bench, each individually accountable.

And the tempting shortcut — skip the policy, just buy every failed breakdown, since the pattern looks so obviously bullish on a chart? We measured that too, across nine hundred-plus events: 24% win rate, zero expectancy under every conditioning we tried. The pattern is real; the naive trade on it is worthless. Which brings us to the layer that told us so.

**Where a trader should focus here:** this is where creative effort belongs — but creativity expressed as *separable hypotheses*, not as features accreted onto one ever-growing strategy. The question "what would a policy for this market shape look like?" is productive. The question "how do I make my main strategy also handle this?" usually is not.

## Layer 3: the accounting layer

**What it consists of:** four components, in escalating order of realism.

- **The backtest through the live code path.** Not a separate vectorized approximation of your strategy — the actual policy code, fed historical bars the way live bars arrive. Any divergence between "backtest logic" and "live logic" is a fraud you are committing against yourself, and it will be discovered at the worst possible price.
- **A probation tier: signal-only deployment.** Every new policy in our system carries a flag that lets it run fully live — consuming real-time measurements, forming real decisions, logging real signals — while trading nothing. It is the single highest-value feature in the codebase. Backtests answer "would it have worked?"; probation answers "does it actually fire, on live data, when the code, the data feed, and the market are all being themselves?" The new drift policy above went out signal-only; it will earn capital or it will not, and either way the answer will be data.
- **Ground-truth labels.** For recurring patterns, a store of hand-labelled or rule-labelled outcomes ("was this breakout real?") that candidate policies can be scored against without waiting months of wall-clock time.
- **The negative-results ledger.** When an idea fails measurement, the result gets recorded where the code lives. The cheapest experiment is the one you do not re-run, and the most expensive opinion is the one you re-believe six months later.

**Its function:** decide what survives — and, just as importantly, notice what has stopped surviving. Edges decay. A layer that can only admit policies and never expel them is a museum, not an accounting department.

**The rule it must never break:** it must be *able to kill your favourite idea*, and it must apply the same test to every candidate. The moment a beloved policy gets a friendlier backtest window or a waived probation period, the layer stops producing information.

**Where a trader should focus here:** skepticism. Not the performative kind — the procedural kind, where the test is fixed before the idea is loved.

## Why the separation is what finds the edges

Here is the part that took me longest to internalise. The layering is usually sold as hygiene — nice, clean engineering. But the real payoff is economic: **separation collapses the cost of running experiments, and edge-finding is an experiment-count game.**

- **Fixed layer 1 + uniform layer 3 = cheap layer 2.** When measurement is shared and accounting is standardised, a new hypothesis costs one small policy file — not a new system. This is precisely the WorldQuant lesson from the last post, scaled to a retail codebase: they froze the policy contract so that thousands of alpha expressions could be measured on an assembly line. You freeze the instrument bench and the courtroom so that dozens of policies can be.
- **Failures become attributable.** When a layered system loses, you can say *which layer* failed: a stale series (measurement), a broken thesis (policy), or a correct decision that lost anyway (variance — the only acceptable kind of loss). An unlayered system offers only "the strategy lost," which is unactionable, so the trader responds the only way the architecture allows: retuning indicator parameters. That is the indicator graveyard, explained structurally.
- **Probation converts opinion into data at zero risk.** A signal-only tier means the gap between "I believe this" and "the ledger says this" is a few weeks of patience instead of a few percent of the account.
- **The edge becomes a portfolio property.** No single policy has to be brilliant. A shelf of small, separately-accountable policies, each with a modest measured edge and each individually killable, is more robust than one grand unified strategy — because when the market changes shape, you retire a policy, not a system.

## Where the effort goes

<Table data={
    {
        headers: ['Layer', 'Consists of', 'Function', 'Your effort'],
        rows: [
            ['1. Measurement', 'Data pipeline, indicator library, freshness checks', 'Report every event, judge nothing', 'Diligence: verify once, monitor staleness forever'],
            ['2. Decision', 'A portfolio of small, separable policies with their own exits and refusal rights', 'Judgment: map measurements to actions', 'Creativity: one hypothesis per policy'],
            ['3. Accounting', 'Live-path backtests, signal-only probation, ground-truth labels, negative-results ledger', 'Decide what survives and what has stopped surviving', 'Skepticism: fix the test before you love the idea'],
        ]
    }
} />

Most traders allocate effort in almost exactly the wrong proportions: the vast majority at layer 1 (cycling indicators and settings), a little at layer 2 (rules copied from the indicator's folklore), and none at layer 3. A working allocation is closer to the inverse — measurement verified once and then trusted, decisions where the imagination goes, accounting where most of the discipline and a surprising amount of the time goes.

The edge, when it comes, will not look like a secret indicator. It will look like a small, slightly boring policy — sitting on instruments everyone has, judged by a court you built yourself — that keeps surviving the count while its siblings get retired around it. The system that can notice that, cheaply and repeatedly, *is* the edge.

*Next in this series: what the probation tier looks like in practice — how a signal-only policy earns its way to real capital, and the graduation criteria we actually use.*


26fe9688db1d22f9378865fd7386cca8e8aa2638befa3d9b34996ce6268cb4f2

How to architect an algo trading system in three layers - measurement, decision, accounting - and why the separation is what makes edges findable.

Our last post named the three layers: indicators measure, strategies decide, alpha is what survives. This one is about building an algo trading system around them - what each layer contains, what it must never do, and why the separation itself is what makes edges findable.

Tag: System Design

Tag: System Design

Trade Nothing, Prove Everything: The Signal-Only Probation Tier

A Trading System in Three Layers: Measure, Decide, Account