
{/* banner prompt: Cinematic realistic photograph, 16:9 wide banner composition: a laptop on a wooden desk showing blurred lines of code in a dark editor, beside it a second screen with an abstract heatmap of green and red blocks, a notebook with hand-drawn diagrams, warm desk lamp light at night. Muted teal and warm amber colour grade, soft natural light, shallow depth of field, high detail, photorealistic, no readable text, no numbers, no logos, no visible faces. */}

This is the final post in the order book craft track of the [ASX order book series](/blog/2026/10/12-reading-the-asx-order-book-how-intraday-traders-actually-find-edge/). The previous seven posts described what experienced intraday traders look at: [depth over charts](/blog/2026/10/13-why-the-best-intraday-traders-barely-look-at-charts/), [protection](/blog/2026/10/14-protection-the-liquidity-you-lean-on/), the [opening auction](/blog/2026/10/15-reading-the-asx-opening-auction/), [gap cause](/blog/2026/10/16-why-did-it-gap-mechanical-gaps-vs-information-gaps/), [cross-market leads](/blog/2026/10/17-cross-market-leads-and-the-indicative-open/), [fake and hidden size](/blog/2026/10/18-spoofs-icebergs-and-reloading-orders/) and [time-based exits](/blog/2026/10/19-when-the-tape-stops-confirming-time-stops-and-liquidity-exits/).

All of that is discretionary. A good trader does it by eye in a few seconds. But almost every piece of it can be expressed as a number, and once it's a number we can test whether it actually predicts anything. That's the job of this post.

As I've written before, [an indicator is a measurement, not a decision](/blog/2026/09/13-indicators-measure-strategies-decide-alpha-is-what-survives/). Everything below is measurement. Whether any of it becomes a strategy depends on what the testing says.

<KeyPoints>

- Python features for imbalance, microprice, protection, resistance, wall persistence and auction mispricing.
- Label with short forward horizons and evaluate per event or per day, after costs and latency.
- The likely edge is in narrow event setups, not in a continuous imbalance signal.

</KeyPoints>

## Getting depth data

You need order book snapshots: at a given timestamp, the price and volume at each of the top N levels on each side. For ASX stocks, options include your broker's API if it provides market depth (Interactive Brokers, for example, offers a market depth request, subject to data subscriptions), or a commercial data vendor. Depth data is bulky, so most people capture snapshots at a fixed interval or on every change for a short watchlist.

I'll assume a simple schema:

```python
# one row per snapshot
# ts, code, bid_px_1..N, bid_sz_1..N, ask_px_1..N, ask_sz_1..N
import numpy as np
import pandas as pd

N = 5
BID_PX = [f"bid_px_{i}" for i in range(1, N + 1)]
BID_SZ = [f"bid_sz_{i}" for i in range(1, N + 1)]
ASK_PX = [f"ask_px_{i}" for i in range(1, N + 1)]
ASK_SZ = [f"ask_sz_{i}" for i in range(1, N + 1)]
```

## Feature 1: order book imbalance

The classic measure: how lopsided is the visible depth near the touch?

```python
def imbalance(df: pd.DataFrame, levels: int = 3, decay: float = 0.5) -> pd.Series:
    """Weighted depth imbalance in [-1, 1]. Positive = more bid depth."""
    w = np.array([decay ** i for i in range(levels)])
    bids = df[BID_SZ[:levels]].to_numpy() @ w
    asks = df[ASK_SZ[:levels]].to_numpy() @ w
    return pd.Series((bids - asks) / (bids + asks), index=df.index)
```

The decay weights nearer levels more heavily, because size one tick away matters more than size five ticks away.

## Feature 2: microprice

The midpoint ignores size. The microprice tilts the mid toward the side with *less* depth, because that side is more likely to be consumed next.

```python
def microprice(df: pd.DataFrame) -> pd.Series:
    b, a = df["bid_px_1"], df["ask_px_1"]
    qb, qa = df["bid_sz_1"], df["ask_sz_1"]
    return (b * qa + a * qb) / (qa + qb)
```

Microprice minus mid, expressed in ticks, is a neat one-number summary of top-of-book pressure.

## Feature 3: protection ratio

This is the discretionary idea from the protection post, made explicit: depth behind an entry, relative to how much volume normally trades.

```python
def protection_ratio(df: pd.DataFrame, side: int, recent_vol_per_min: pd.Series,
                     levels: int = 3) -> pd.Series:
    """side=+1 for a long (protection = bids), -1 for a short (protection = asks).
    recent_vol_per_min: rolling average traded volume per minute, aligned to df.
    """
    cols = BID_SZ[:levels] if side == 1 else ASK_SZ[:levels]
    depth = df[cols].sum(axis=1)
    return depth / recent_vol_per_min.replace(0, np.nan)
```

A ratio of 10 means it would take roughly ten minutes of normal trading to consume the protection. A ratio of 0.5 means it could be gone in thirty seconds.

## Feature 4: resistance ahead

The twin of protection: how much stands in the way of the move you want?

```python
def resistance_ratio(df: pd.DataFrame, side: int, levels: int = 3) -> pd.Series:
    """Depth ahead of the trade divided by depth behind it. Lower is better."""
    ahead = df[(ASK_SZ if side == 1 else BID_SZ)[:levels]].sum(axis=1)
    behind = df[(BID_SZ if side == 1 else ASK_SZ)[:levels]].sum(axis=1)
    return ahead / behind.replace(0, np.nan)
```

## Feature 5: wall persistence

To deal with spoofs, measure whether large orders survive. One simple approach: track the maximum single-level size near the touch, and how many consecutive snapshots a level above some size threshold has existed at the same price.

```python
def wall_persistence(df: pd.DataFrame, side: int, threshold: float) -> pd.Series:
    """Consecutive snapshots that a level >= threshold has existed at the same price."""
    px_cols, sz_cols = (BID_PX, BID_SZ) if side == 1 else (ASK_PX, ASK_SZ)
    wall_px = []
    for _, row in df.iterrows():
        big = [row[p] for p, s in zip(px_cols, sz_cols) if row[s] >= threshold]
        wall_px.append(big[0] if big else np.nan)
    wall_px = pd.Series(wall_px, index=df.index)
    same = wall_px.eq(wall_px.shift()) & wall_px.notna()
    return same.groupby((~same).cumsum()).cumsum()
```

A wall that has persisted, and especially one that has persisted while volume traded at its price, is more trustworthy than one that just appeared.

## Feature 6: auction mispricing

At the open, the most useful single feature from the earlier posts is how far the indicative gap deviates from what the overnight lead and sector peers imply.

```python
def auction_mispricing(indicative_gap: pd.Series, lead_move: pd.Series,
                       beta: pd.Series, peer_median_gap: pd.Series,
                       w_lead: float = 0.5) -> pd.Series:
    """Positive = indicated too high versus references (fade candidate)."""
    expected = w_lead * beta * lead_move + (1 - w_lead) * peer_median_gap
    return indicative_gap - expected
```

Combined with the auction surplus sign and a protection ratio from the pre-open book, this is a reasonable first attempt at encoding the "is the open mispriced?" judgement.

## Labelling: what are we predicting?

Features need a target. For scalping-style questions the natural targets are short horizons:

```python
def forward_return_ticks(mid: pd.Series, tick: float, horizon: str) -> pd.Series:
    """Mid-price change over a forward time horizon, in ticks."""
    fwd = mid.shift(freq=f"-{horizon}").reindex(mid.index, method="ffill")
    return (fwd - mid) / tick
```

Use several horizons (5 seconds, 30 seconds, 2 minutes). Different features tend to work at different horizons, and the time-stop post suggests that most of the edge in scalps shows up very early.

## Evaluating without fooling yourself

This is the part people skip. A few rules I apply:

<Table data={
    {
        headers: ['Pitfall', 'Guard'],
        rows: [
            ['Lookahead', 'Only use information available at the snapshot timestamp. Rolling volumes must be trailing.'],
            ['Mid-price fantasy', 'Mid moves are not tradeable. Re-test with entry at the touch you would actually pay.'],
            ['Costs', 'Subtract brokerage and the spread. Many imbalance signals vanish after costs.'],
            ['Latency', 'Add a realistic delay between signal and order. A one second delay changes a lot.'],
            ['Overlapping samples', 'Snapshots seconds apart are not independent. Evaluate per event or per day.'],
            ['Regime', 'Split by period and by market condition. A feature that only worked in one month is noise.'],
            ['Universe', 'Test on stocks you would actually trade, with similar liquidity and tick size.'],
        ]
    }
} />

A simple first evaluation is to bucket a feature into quantiles and look at the average forward return in each bucket, after costs, with confidence intervals computed per day rather than per snapshot.

```python
def bucket_report(feature: pd.Series, fwd: pd.Series, q: int = 5) -> pd.DataFrame:
    df = pd.concat({"f": feature, "y": fwd}, axis=1).dropna()
    df["bucket"] = pd.qcut(df["f"], q, labels=False, duplicates="drop")
    return df.groupby("bucket")["y"].agg(["count", "mean", "std"])
```

If the top and bottom buckets don't separate clearly after costs, the feature isn't useful at that horizon, however intuitive it looked.

## What I expect to find

I'll be honest about priors. Raw top-of-book imbalance is one of the most studied microstructure signals there is, and most of its edge goes to participants who are much faster than any human or retail system. I don't expect it to survive costs on its own.

What I'm more interested in is the *combination* the discretionary traders used, at the specific moments they used it: a mispriced auction, plus protection that is large relative to volume, plus little resistance ahead, plus a fast time stop. That's a narrow, event-driven setup, not a continuous signal, and it's where human depth readers seem to have found their edge. Whether it holds up in data is exactly the kind of question I'll be testing in our own systems.

That wraps up the order book craft track. Next, we move to the business side of trading, starting with the most misunderstood pair of numbers in any trading journal.

<SeriesNav series="asx-order-book" />

<Disclaimer />


49212afc165b75b602da1f5391f84e71862eff13bc3db9741fba959ae94bb105

Python examples for computing order book imbalance, microprice, protection ratio and auction mispricing from market depth snapshots, and how to backtest them.

Turning discretionary depth reading into numbers you can test. Python code for order book imbalance, microprice, a protection ratio, a resistance score and an auction mispricing feature, plus how to label and evaluate them honestly without fooling yourself.

Measuring Order Book Imbalance in Code


{/* 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, due to 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, and 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.*


7238d44865de0336f6911e034a844525e4c86c0b06f0d57fd31c013269808de5

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" or 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, or 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, where the higher timeframes decide direction and regime and 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, to skip the policy and 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, but 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 and 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, but 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 and 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.*


7cb03a1779212b89d4e3e267e92ad7f6347d4866377692d125d2bd258dba13d0

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.

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


{/* banner prompt: Matte clay-render 3D illustration, 16:9, soft studio shadows, simple cream background. Three tidy workbench stations left to right: first a sage-green measuring instrument station with calipers, a thermometer and a small candlestick chart being measured; second a terracotta decision station with a branching flowchart of chunky clay arrows choosing between paths; third a minimal scale weighing one small glowing golden nugget against a heap of dull grey pebbles. Clean geometry, warm muted palette of sage green, cream and terracotta, no text, no people, gentle depth of field. */}

Ask ten traders what the difference is between an indicator and a strategy and you'll get ten variations of "the strategy is the indicator plus some rules." Ask where the alpha is and most will point back at the indicator: a better MACD setting, a smarter RSI threshold, the right moving average pair.

After years of building and, more importantly, *measuring* trading systems, I've come to a different model. The three words name three different layers, with three different jobs, and three different failure modes. Most losing systems aren't built from bad indicators. They're built from a confusion about which layer is supposed to be doing which job.

## An indicator is a measurement instrument

RSI doesn't have an opinion about your trade. It's a ratio of recent up-moves to down-moves, compressed into 0–100. MACD is the distance between two moving averages, and the momentum of that distance. Parabolic SAR is a trailing curve that accelerates under a trend. Bollinger Bands are a rolling mean with a volatility envelope.

That's all they are: **measurements**. A thermometer, not a doctor.

This framing sounds obvious, but it has two consequences people skip.

**First: a measurement instrument must be *correct*, and you should verify it the way you'd verify a thermometer, against a reference.** Indicators have canonical definitions, and real implementations drift from them more often than anyone admits. Wilder's Parabolic SAR is a good example, because it's deceptively fiddly: the update rule clamps the stop against the *prior two* bars' extremes, freezes the acceleration on the reversal bar, and seeds the flip at the old extreme point. Miss one of those details and you still get a plausible-looking dotted line on the chart that hugs trends and flips at pullbacks, but it disagrees with the canonical value on a large fraction of bars and, crucially, it *flips at different times*. Every strategy sitting on top inherits that error silently. We once traced a chronically underperforming trend system to exactly this: not a bad idea, a mis-measuring instrument. The fix wasn't a new strategy; it was making the thermometer read the true temperature.

The test is cheap: implement the indicator twice, once your way and once as a line-for-line port of the reference definition, then run both over a few thousand bars, and demand zero disagreement. If you can't be bothered, at least diff your values against a charting platform's. A strategy built on an unverified indicator is a building inspection performed with a broken level.

**Second: an indicator fires on every event, including the false ones, by design.** RSI crosses 70 in every strong trend, repeatedly, all the way up. MACD crosses its signal line dozens of times in a ranging week. A Bollinger breakout bar looks identical whether it's the start of a 5% move or a one-bar fakeout. The instrument's job is to report the event, not to judge it. If you find yourself trying to tune an indicator until it "stops giving false signals," you're asking the thermometer to prescribe the medicine. Judgment is the next layer's job.

## A strategy is a policy

A strategy consumes measurements and produces decisions, and the decisions are the whole game. The same MACD crossover event can anchor a dozen different strategies depending on the policy wrapped around it:

- **Context**: do we act on a bullish crossover in any regime, or only when a higher timeframe agrees? A crossover on the hourly *against* a falling daily trend is a different trade from the same crossover *with* it. In our measurements, this single conditioning decision routinely swings a signal population from net-negative to net-positive, with the indicator untouched.
- **Timing versus deciding**: fast timeframes are excellent at *timing* an entry and terrible at *deciding* its direction. A policy that lets a 15-minute signal pick the direction while the 4-hour trend disagrees is letting the second hand of the watch overrule the calendar.
- **Exits**: two strategies with identical entries and different exits are different strategies, usually *more* different than two strategies with different entries and the same exits. An exit policy that snaps shut on every one-bar wobble will bleed a trend-following entry dry; an exit that only responds to its own thesis breaking will hold through noise and give back tails. Neither is "right"; each belongs to a different kind of trade, and mixing them up is one of the most expensive silent errors in system design.
- **Proportion**: where is the stop, relative to the structure that justified the entry? If a breakout bar is so extended that the logical stop sits several ATRs away, the signal may be "valid" and the trade still unacceptable. A policy has to be allowed to refuse a true signal.

Notice that none of these decisions live inside MACD. You cannot fix a policy problem by re-tuning a measurement, and almost every "indicator graveyard" thread you've read is a catalogue of policy problems misdiagnosed as indicator problems.

## Alpha is what survives honest accounting

So where's the alpha? Not in the indicator; everyone has RSI. Not in the strategy skeleton; crossover-plus-filter is public knowledge. Alpha lives in the *mapping* between what you measure and what you do, and it only counts if it survives honest measurement.

The clearest public evidence for that claim comes, ironically, from the place that industrialised the word: WorldQuant's famous *101 Formulaic Alphas* paper, which published a hundred and one real production alpha expressions. Look at two of the simplest:

```txt
Alpha#101:  (close - open) / ((high - low) + 0.001)

Alpha#6:    -1 * correlation(open, volume, 10)
```

Alpha#101 is just "where in its daily range did the stock close," a normalized candle-body. Alpha#6 is the ten-day correlation between opening price and volume, negated. Squint and these are *indicators*: small, honest measurements, no more mystical than RSI. Nobody at a chart-trading forum would call them edges.

What makes them alphas is everything wrapped around the formula, which the paper's framework standardises so thoroughly it barely mentions it: each expression is computed **cross-sectionally** across thousands of stocks, converted to a rank, traded as a dollar-neutral portfolio (long the top of the rank, short the bottom) and rebalanced on a fixed schedule with costs accounted. The formula is layer one. The rank-long-short-rebalance contract is layer two, *fixed and identical for every alpha*. And because layer two never varies, layer three, the honest accounting, becomes an assembly line: thousands of candidate expressions can be measured the same way, kept if they survive, discarded or watched as they decay when the crowd finds them. WorldQuant's real invention wasn't any formula in that paper. It was freezing the policy layer so that measurement could be mass-produced.

That's the same lesson in institutional form: the expression is cheap; the mapping and the accounting are the asset. The same point shows up at retail scale with any charting indicator, and the best illustration I can offer is a study we ran on the classic Bollinger squeeze, the folklore that a breakout from unusually narrow bands is more likely to be "real." It's chart-reading orthodoxy, and every trader's eyes confirm it. We labelled about 12,000 historical band breakouts as real or failed (did the move travel a couple of ATRs before giving the break back?) and conditioned on how narrow the bands were at the break, measured properly as a z-score against recent history.

The result, in precision/recall terms:

<Table data={
    {
        headers: ['Question', 'Answer from ~12,000 breakouts'],
        rows: [
            ['Are narrow-band breakouts more likely to succeed?', 'No. Success rate was flat (~44%) at every narrowness threshold.'],
            ['Do narrow-band breakouts travel further in absolute terms?', 'No. Wide-band regimes are volatile regimes; they move more points.'],
            ['Do narrow-band breakouts travel further relative to their own bands?', 'Yes, strongly and monotonically. Deep squeezes travelled about 1.1 band-widths; bloated bands about 0.4.'],
        ]
    }
} />

Read that carefully, because it explains the folklore *and* the losing trades. On a chart, a squeeze breakout looks dramatic, since the move dwarfs the coil that preceded it, and that relative drama is real and measurable. But a squeezed band-width is small in absolute points, so the probability of profit and the size of profit are no better. The eye is measuring in band-widths; the account is denominated in dollars.

Here's the layer lesson: the indicator (band-width) contained genuine information. Consumed as an **entry filter**, meaning "only trade narrow-band breakouts," it produced *zero* alpha; we swept every threshold and the precision never lifted. Consumed as **geometry**, sizing targets and stops in band-widths conditioned on the squeeze, the same measurement became useful. Same instrument, same numbers; the alpha appeared or vanished depending entirely on the mapping. And even then, the first mechanical implementation of the "useful" version lost money, because a target placed at the *median* expected travel amputates the right tail, and in trend trading the right tail pays for everything. The measurement was right, the first policy consuming it was wrong, and only measurement told us which was which.

## The accounting has to be honest

That phrase, *what survives honest accounting*, is doing a lot of work, so let me name the two frauds we catch ourselves committing most often.

**Lookahead by timeframe.** When a strategy consults a higher timeframe, the daily bar your backtest sees at 2 pm *includes 2 pm's price action*. Live, the completed daily bar you can actually consult is yesterday's. We once validated a higher-timeframe filter retrodictively, and it separated winners from losers almost perfectly, then re-tested it with only the bars a live system could have seen. It not only stopped working; it deleted the best trade in the sample and made everything worse. The filter's "predictive power" was the trade's own outcome leaking backwards through an in-progress bar. Anything that looks like a perfect discriminator deserves suspicion in proportion to its perfection.

**Sample-size theatre.** Eight trades cannot validate a rule; they can only inspire one. The discipline that saved us more than once: when a small sample suggests a rule, implement it, run it against the *full* history through the live-path simulator, and be genuinely prepared for the answer to be no. Roughly half the time, it is no, and every "no" is a strategy you didn't bleed out on live.

There's a quieter corollary worth stating: when your test says a mechanism doesn't work, *record the negative result where the code lives*. Six months later, someone, probably you, will have the same clever idea, and the cheapest experiment is the one you don't re-run.

## The working model

If you want the whole post in four lines:

<Table data={
    {
        headers: ['Layer', 'Job', 'Failure mode'],
        rows: [
            ['Indicator', 'Measure one thing correctly, on every bar, fakeouts included', 'Silently wrong implementation; tuned to "avoid false signals"'],
            ['Strategy', 'Policy: context, timing vs deciding, exits, proportion, refusal', 'Policy problems misdiagnosed as indicator problems'],
            ['Alpha', 'The edge left after honest, lookahead-free, adequately-sampled measurement', 'Retrodictive perfection; median targets amputating the tail; eight-trade proofs'],
        ]
    }
} />

The practical upshot is a change in where you spend effort. Most people spend it at layer one, cycling through indicators and settings. The measured reality is almost exactly inverted: verify layer one *once* against the canon and then leave it alone; spend your creative effort at layer two, where context and exits live; and spend your *skeptical* effort at layer three, where every idea, especially the beautiful ones, goes to be counted.

RSI is not your edge. What you do the third time RSI crosses 70 in a strong uptrend, and whether you ever actually measured it, might be.


7d31149cbfbd3ab6028953cae15a93929ea4dd0db7a5c71e7a98ea2035da2fe5

The working relationship between indicators, strategies, and alpha, illustrated with MACD, RSI, PSAR and Bollinger Bands.

Traders use indicator, strategy, and alpha almost interchangeably. They are three different layers, and most losing systems come from confusing them. A field guide with MACD, RSI, PSAR, Bollinger Bands and two of WorldQuant's 101 formulaic alphas.

Tag: Quant

Tag: Quant

Measuring Order Book Imbalance in Code

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

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

Indicators Measure, Strategies Decide, Alpha Is What Survives