TradeBricksDocsOpen the Lab →
The Lab

The Lab

The Lab is the canvas where a trading idea becomes a graph of typed bricks. This page covers the canvas, the toolbox, how wiring works, where params live, running, and the results drawer.

The canvas

The canvas is an infinite, pannable workspace. Drag the background to move around, scroll to zoom, and use the on-canvas controls (bottom-left) to fit the whole graph in view. Bricks are cards you can drag anywhere; wires re-route automatically. A minimap shows where you are in a large strategy.

Reading direction is left-to-right: data on the left, your terminal exit on the right. Because every wire is colored by the data type flowing through it, you can read the shape of a strategy without reading a single label.

The toolbox

The toolbox lists every brick the engine offers, grouped into six categories. Each category has its own color and icon, used consistently on the canvas, in the toolbox, and throughout these docs.

data
Market feeds — price bars and option chains. Every graph starts here.
alt-data
Live and alternative data — Congress disclosures, SEC filings, option greeks, dealer gamma, IV, and flow. Only active when a provider that supplies the data is connected.
market-data
indicator
Transforms over a series: moving averages, oscillators, bands, and a free-form math brick.
logic
Comparisons and boolean glue that turn numbers into true/false signals.
entry
Decide when and how a position opens, given a signal and the bars.
exit
risk
Close the trade. The exit is terminal — it produces the backtest result.
order
The alt-data category is gated

The alt-data bricks (Congress, SEC, option greeks, dealer gamma, IV, flow) only light up when a provider that supplies their data is connected — Congress and SEC are built in, options data needs Schwab. Everything that gating means, and a brick-by-brick reference, lives in Live & alt-data.

Across all eight categories the engine ships roughly 63 bricks today — price, indicators, logic, entries and exits, order bricks for spreads, plus live market-data and 7 alt-data feeds. For the complete, always-current list — pulled live from the engine — see the Brick reference. Not sure which bricks an idea needs? Describe it to the AI assistant and let it wire a first draft for you.

Wiring bricks: typed, color-coded ports

Each brick has input ports on its left and output ports on its right. Every port carries a type, and the type has a color. The rule is simple:

Matching colors connect

You can only wire an output to an input of the same type. The colors are the type. If two ports share a color, they snap together; if they don’t, the wire is rejected. This makes invalid graphs impossible to draw.

The port types

barsseriessignalscalarchainentriesresult
  • bars — a full OHLCV candle stream. Indicators that need highs/lows, and entries/exits that need timing, take this.
  • series — a single number per bar (e.g. close, an SMA, an RSI). The workhorse type.
  • signal — a per-bar true/false condition produced by logic bricks.
  • scalar — a single constant value, broadcast to every bar.
  • chain — an option-chain snapshot per bar, from the options feed.
  • entries — the set of bars where a position opens.
  • result — the terminal backtest output. Only the exit brick produces it.
Series vs. scalar

A scalar is just a constant. Many logic bricks expect two series, so a constant flows in as a series that’s the same value on every bar — that’s how you compare RSI to a fixed level like 30.

Params: depth on click

Click any brick to open its params in the inspector. This is where the depth lives — lengths, thresholds, directions, stop and target sizes. Defaults are sensible, so a brick works the moment you drop it; you only open params when you want to tune.

example: a brick's params
Stop / target exit
  stop_atr    1.5     ← stop placed 1.5 ATR from entry
  target_atr  2.0     ← target placed 2.0 ATR from entry
  horizon     36      ← give up after 36 bars
  cost_atr    0.05    ← round-trip cost, charged every trade

Params are saved with the strategy and travel with it when you publish or fork. The Brick reference lists every param and its default for every brick.

Running

Hit Run and the Lab compiles your visual graph into a strategy spec and sends it to the engine. A valid graph needs exactly one terminal exit brick downstream of an entry; if something’s unwired or mismatched, the engine returns a clear error instead of a bogus result.

One exit, one result

The Stop / target exit is the terminal brick — it’s the only thing that turns a graph into a backtest. Every runnable strategy ends in exactly one.

The results drawer

Results slide up in a drawer at the bottom of the Lab so your graph stays visible. It shows the headline verdict, the per-slice stats table (All / Dev / Holdout), and a trade list. You can keep tweaking the graph above and re-run without losing your place.

  • Verdict — the engine’s plain-English call on the strategy.
  • Stats table — n, win, rr, and expectancy across the three slices.
  • Trades — each trade’s entry, exit, direction, and result, flagged by whether it fell in Dev or Holdout.

The drawer is deliberately blunt: a beautiful equity curve on Dev means nothing if Holdout is flat. The full story of how to interpret it — and the overfitting guards behind the verdict — is in Backtesting & overfitting.

Where to go next