A field-by-field walkthrough of the Meridian OFI Dashboard — the Order Flow Intelligence layer built on top of Meridian Engine v2. Every panel, every label, and every button, explained once, with the special color format that maps each order-flow read to its own shape and color.
The engine is a confirmation filter, not a signal generator. You read it in this order — Regime → 3-Gate → Lattice → Order Flow → Liquidity → Signal — and it only prints a trade when all the gates line up on one side. Most bars will show grade — and no signal. That's the engine honestly saying "no aligned setup", not a bug.
The dashboard is a vertical stack of seven readouts plus the top bar. Read top-to-bottom — the top bar first, then the engine, then the signal surface. Use the chapter pills to jump.
The two prices are deliberately split. They are not the same thing.
| Label | Meaning |
|---|---|
| tape $771.21 ●LIVE | Live Alpaca quote (IEX). ●LIVE = fresh (<5 min); ○stale = market closed / no fresh tape. |
| bar $772.04 | The engine's last delayed Polygon candle close — what the engine actually computes on. |
They can differ ~1% (raw IEX last vs Polygon adjusted close) — that's two different things, which is exactly why they're split. Also in the top bar: bias chip (BULL/BEAR/FLAT), LIVE·DELAYED / SIMULATION (real vs synthetic data), and the broker badge (PAPER · connected, SIMULATED · no key, etc.).
What kind of market you are in — every downstream read leans on it.
| Field | Meaning |
|---|---|
| TREND / RANGE / TRANSITION | ADX(14) ≥ 25 + aligned ribbon = TREND; ADX < 20 + mixed ribbon = RANGE; else TRANSITION. |
| ADX | Trend strength. >25 = trend, <20 = no trend. |
| ATR RS | ATR ÷ its 100-bar average — volatility expanding vs contracting. |
| Ribbon | BULL (EMA9>21>50) / BEAR / MIXED — medium-term direction. |
| RR | Target R:R — TP2 is priced at (base preset ± regime adjustment). |
| Timeframe → preset | 5m/15m→Intraday, 1h/4h→Swing, 1d→Position — each changes stop distance and base R:R. |
A signal must clear all three gates on one side only.
| Gate | Field | Meaning |
|---|---|---|
| 1 · Bias | gate1_long / gate1_short | Regime-aware direction (ribbon/cloud in TREND; extremes in RANGE). |
| 2 · Armed | bull_armed / bear_armed + armed_type | A trigger fired: sweep (liquidity grab), vwap (reclaim), or choch (change of character). Expires after a few bars. |
| 3 · Zone | in_bull_zone / in_bear_zone | Price retested an unmitigated FVG zone. |
| Filter | grade_ok_l / grade_ok_s | Lattice grade clears your min grade. |
How many distinct event types cluster near price — density becomes a grade.
| Grade | Density |
|---|---|
| — | < 2 |
| WATCH | 2 |
| PRIME | 3 |
| ELITE | 4 |
| SINGULAR | 5+ |
Events counted: sweep · CHoCH · BOS · VWAP reclaim · band touch · FVG · absorption · imbalance · stacked imbalance. Distinct types, not total events (two sweeps = one type). A nearby liquidity magnet can bump grade +1.
Four order-flow reads — each with its own special color format.
| Field | Meaning |
|---|---|
| CVD slope | Net buying/selling over last 3 bars (rising/falling/flat) — drawn as a line. |
| absorption ↑ / ↓ | Sellers/buyers hit a level but price didn't move — the other side is absorbing. Reversal hint (circle). |
| imbalance ↑ / ↓ | Strong one-sided delta with structure confirm. Continuation hint (diamond). |
| stacked imbalance ↑ / ↓ | ≥3 consecutive strong-delta bars. Rarest, most aggressive (bar). |
| source ·px | Stacked uses the CVD proxy (native footprint unavailable from OHLCV). |
Where the magnets are — and where TP3 gets aimed.
Pools form on liquidity sweeps and stacked imbalances. Each has a magnet that decays ×0.92/bar and re-charges on reaction. Top magnet = strongest active pool — that's where TP3 gets aimed. Price is pulled toward these.
Read it directionally, not literally: the map shows where opposing liquidity is sitting relative to price, so you know the most likely magnet the engine is aiming TP3 at.
When it prints: side, levels, and what happened after.
When a signal prints: side, entry (bar close), SL (swept low/high, padded 0.35 × stopATR × ATR), TP1 (1R), TP2 (RR × risk), TP3 (nearest opposing pool), RR, grade.
| Path integrity | Meaning |
|---|---|
| OPEN | Unresolved — signal fired, waiting on TP1 or stop. |
| CONFIRM | TP1 touched first = +1R. |
| BREAK | Stop crossed first = −1R. |
The context pane — bands, moving averages, and day-scoped flow.
Close + VWAP ±1σ/±2σ bands + EMA 9/21/50, with day-scoped CVD below. The VWAP zone (+2σ … fair value … −2σ) feeds the RANGE bias.
The dashboard wires to Alpaca for paper bracket orders. One-time setup, then a one-click execute from the signal surface.
Key once, click per signal.
One-time: ALPACA_API_KEY / ALPACA_SECRET_KEY in backend/.env (already wired locally with paper keys). Badge reads PAPER · connected.
| Step | What happens |
|---|---|
| 1 · Signal | Wait for a signal → the Signal panel shows ▶ Execute paper bracket. |
| 2 · Click | Places an Alpaca bracket: market entry + TP1 limit + SL stop as an OCO. |
| 3 · Result | Shows order id + both legs + live-anchored or delayed (market closed). |
| 4 · Positions | Positions button → Positions tab (close buttons) + Orders tab (bracket legs with live status). |
| 5 · Cancel | Cancel via the link under a just-placed order. |
Sizing: default $5,000 notional (qty = $5k ÷ entry); override via API qty/notional. Live re-anchoring: when tape is ●LIVE, entry/SL/TP1 re-anchor to the live mid, preserving R:R distances; when closed it uses delayed levels and says so.
Going live (real money): two gates, both required — ALPACA_LIVE=1 in env and confirm="LIVE" in the request. No accidental real orders. TP2/TP3 are never auto-executed — journal-only scale targets.
Bell button → settings. Alerts fire the instant the engine prints BUY/SELL (same trigger as journal capture), deduped per signal — so you don't get spammed when the WS re-broadcasts a stale state.
Master switch, browser popups, and a webhook.
| Setting | What it does |
|---|---|
| Alerts enabled | Master switch. Off = nothing fires, anywhere. |
| Min grade | Only fire on PRIME+ by default. Set to WATCH for noisy symbols you want every read on; SINGULAR to silence everything except rare setups. |
| Browser notification | Requests OS permission on first toggle, then desktop popups fire on each new signal. |
| Webhook URL | Discord / Slack / any endpoint that accepts POST application/json. Body is { content, signal } — see payload below. |
| Per-symbol | Comma-separated allow-list (e.g. NVDA,SPY,QQQ). Empty = all symbols. |
| Cooldown | Per-symbol cooldown in seconds (default 60). Prevents the same symbol alerting twice on back-to-back bars. |
| Send test alert | Fires one now to verify the webhook + browser permission. Doesn't count against the cooldown. |
# Content — Discord/Slack-style human-readable summary content: ":zap: **BUY NVDA · 5m** — PRIME · TREND · E 123.45 SL 122.10 TP1 124.80 (RR 2.0)" # signal — structured payload, parse on your side signal: { side: "BUY", symbol: "NVDA", timeframe: "5m", grade: "PRIME", # WATCH · PRIME · ELITE · SINGULAR regime: "TREND", entry: 123.45, sl: 122.10, tp1: 124.80, tp2: 126.15, # journal-only target tp3: 128.40, # journal-only target, aimed at top magnet rr: 2.0, bias: "bull", stacked: true, # stacked imbalance fired this bar source: "px", # stacked source: "px" (CVD proxy) or "FP" (footprint, when wired) ts: 1727728400000 }
Five steps, in order. Each step is short-circuitable — if any fails, the alert just doesn't fire. There's no retry queue.
lastSignalId map. Re-broadcasts from the WS that match the last signal within cooldown are dropped.Honest caveats: alerts are frontend-side (the tab must be open), ~10s latency floor (WS 3s + cache + browser wakeup), not bar-by-bar like native Pine alert(). For at-the-bell execution on every signal, wire a backend-side alert dispatcher (a future capability, not in scope today). Don't point an alert at a destination that requires a guarantee — alerts are best-effort, not contractual.
The Journal button captures every signal forward-only and scores it CONFIRM/BREAK as it resolves. The Watchlist button pins the symbols you keep coming back to. Both live entirely in your browser — nothing leaves unless you export it.
Every signal is captured the moment it prints. You can only score it — never edit it.
| Column | What it shows |
|---|---|
| Time | When the signal printed (bar close timestamp). |
| Symbol / TF | What you were watching at the moment of the signal. |
| Side | BUY or SELL — the direction the engine committed to. |
| Grade | WATCH / PRIME / ELITE / SINGULAR at the time of the signal. Not updated retroactively when the grade changes later. |
| Entry / SL / TP1 | Engine-priced levels at signal time. Locked — they don't drift even if you change timeframe. |
| Path | OPEN until TP1 or stop is hit; then CONFIRM or BREAK. Updated live as the path resolves. |
| R | Result in R-multiples. TP1 hit = +1R (the bracket's take-profit). SL hit = -1R (the stop distance you accepted). |
| Notes | Free text you can add — your own read on the setup. The engine never sees this. |
Two numbers summarize every signal on the symbol:
Forward-only is the point. The journal will not let you delete, edit, or "re-grade" a captured signal — that's the whole honesty guarantee. If you don't like a result, your only option is to add a note explaining why, or to stop trading the symbol. The CSV/JSON export keeps the same schema, so what you see is what you ship.
Local-only. ☆ on the top bar saves the symbol; chips jump to it; × removes it.
| Action | What it does |
|---|---|
| ☆ (top bar) | Adds the current symbol to your watchlist. Re-clicking removes it. |
| Chip click | Switches the dashboard to that symbol — same timeframe, same min-grade. Restores the saved settings for that ticker. |
| × on a chip | Removes the symbol from the watchlist. No confirmation — undo by re-typing the symbol and ☆-ing again. |
| Drag (if enabled) | Reorder. Order is purely cosmetic — no implied priority or sorting weight. |
| Storage | localStorage under sn-watchlist. Survives refreshes, tab close, browser restart. Not synced across devices — each browser has its own list. |
The two buttons are designed to chain together — watch a symbol, let the engine grade it, trade the paper bracket when it aligns, then read the journal to see if the path confirmed or broke.
Privacy by design. Your watchlist, journal, and alerts settings all live in your browser's localStorage. Nothing is sent to any backend until you trigger an explicit action (place a trade, send a webhook, export the journal). Closing the tab, switching browsers, or using a different device starts a fresh empty state — that's intentional, not a bug.
Stated plainly, so you can calibrate your trust.
Delayed data — Polygon OHLCV is delayed; the tape (IEX) is fresher but still not tick-perfect.
Stacked imbalance = the ·px proxy — native diagonal footprint isn't available from OHLCV aggregates.
HTF bias omitted — the higher-timeframe context flag is off.
VWAP daily-anchored — no exchange-session feed, so it anchors to the day.
Stocks only — futures need a separate Polygon entitlement.
Paper account = $100k / $400k buying power — not real capital.
During market hours, load NVDA on the 5m with a minimum grade of WATCH. The denser bars will cluster enough event types to print a grade.
Most bars show a grade and no signal. PRIME+ and actual signals are rare on quiet bars — that's the filter doing its job, not a bug.
The full loop: wait for a signal, click ▶ Execute paper bracket, watch the legs in the Orders tab, then close from Positions.
Two engines share the dashboard. The Vol-Arb engine prices volatility — it screens options for IV vs RV mispricings and emits delta-neutral structures. The OFI engine prices direction — it reads Smart Money Concepts, VWAP, and Order Flow on top of OHLCV bars as a confirmation filter. Same dashboard, fundamentally different jobs.
Strike-level IV is smile premium — tail-insurance pricing, a market structure, not mispricing. Using it to rank signals would systematically over-rank deep-OTM puts. Only ATM IV vs the matching-tenor realized-vol forecast counts.
# backend/app/engines.py — SignalEngine.compute() edge = round(atm_iv - rv_i, 2) # vol points (apples-to-apples) z = edge / cls.SIGMA_SPREAD # SIGMA_SPREAD = 2.5 vol pts side = "SELL VOL" if edge > 0 else "BUY VOL" confidence = "high" if |z| ≥ 1.5 else ("medium" if |z| ≥ 1.0 else "low") edge_cost = round(|edge| × VEGA_PER_LOT - ROUND_TRIP_COST, 2) # VEGA_PER_LOT = $40/vol-pt · ROUND_TRIP_COST = $8/contract
A signal with |edge| < 0.01 vol points is dropped — that's "no real edge in this expiry," and the engine returns empty rather than fabricating a fill. The ranking is edge first, then ATM-first, then nearest-to-money — explicitly pushing deep-OTM put skew to the bottom of the list (it's expensive for a reason, not mispriced).
The four OFI types are not arbitrary names — they form a clean matrix. Two axes: price-vs-delta agreement and structural confirmation.
A single bar of strong delta is common. A run of 3+ consecutive bars where the delta is both large (1.5× its 20-bar SMA of |delta|) and persistent (no bar in the run is allowed to fail the test) is statistically unusual. Random walks produce 3-bar runs around 12% of the time; the magnitude+persistence combo cuts that much further.
# backend/app/meridian.py — stacked imbalance (CVD proxy fallback, source="px") depth = min(min_stack_rows + 2, 8) # walk back 5-8 bars for k in range(depth): idx = i - k d = delta[idx] avg = avg_abs_delta[idx] if avg > 0 and d > avg * ofi_delta_mult: run_buy += 1; run_sell = 0 elif avg > 0 and d < -avg * ofi_delta_mult: run_sell += 1; run_buy = 0 else: break # any failed bar ends the run if run_buy ≥ min_stack_rows: stack_bull = True # default min = 3 if run_sell ≥ min_stack_rows: stack_bear = True
Stacked also pushes a liquidity magnet: when it fires, the engine runs push_pool(l, 1, count × 1.5 × vol_ratio) — the swing extreme of the stacked run becomes a magnet that decays ×0.92 per bar, exactly like a sweep-pool. A self-reinforcing loop: the signal that fires hardest also creates the target TP3 will later aim at.
Two engines, two strategies. Vol-arb is continuous-position, multi-leg, delta-neutral, held days-to-weeks. OFI is event-driven, single bracket per signal, minutes-to-hours. What pays for vol-arb is theta + IV mean-reversion; for OFI, it's momentum or mean-reversion confirmed by structure + flow. Don't conflate them — they share a dashboard but neither shares the other's logic.
Symptom → root cause → fix → how to prevent it. Each card is one known issue with the smallest honest path to a working dashboard. If your symptom isn't listed, GET /api/meta tells you provider / simulation / data — that's the first thing to capture.
WATCH.min grade to WATCH in the top bar. If still nothing, try NVDA · 5m during market hours — denser bars cluster more event types. A blank dashboard on every symbol and timeframe means the engine is genuinely saying "no aligned setup anywhere" — that's the filter doing its job.min grade = WATCH by default; bump up to PRIME only after you've calibrated your read on a symbol.ofi_delta_mult is too low. Default is 1.5× the 20-bar SMA of |delta|. Lower values fire the strong-delta condition too easily, so the 3-bar run threshold is met by random walk alone.ofi_delta_mult to 2.0 or 2.5 in meridian.py (line 136), or pass it in the engine config. Re-test on the same symbol — stacked should become rare (a few per session, not every bar).SIMULATED · no key, Execute button disabledbackend/.env is missing ALPACA_API_KEY / ALPACA_SECRET_KEY, or the broker can't reach Alpaca's paper endpoint. The dashboard runs without a broker — but you can't place orders.backend/.env.example → backend/.env, paste your paper keys (get them at alpaca.markets → Paper Account), restart the backend. The badge should flip to PAPER · connected.POST /api/broker/order○stale · live indicator greyALPACA_API_KEY is the paper key (live keys don't work for paper, paper keys work for paper). After-hours, ○stale is correct.SIMULATION permanentlyMERIDIAN_LIVE=1 isn't set in the backend environment, or the Polygon key is missing/invalid. The SimulatedProvider is honest — it tells you it's running on synthetic OHLCV.MERIDIAN_LIVE=1 and add a valid POLYGON_API_KEY to backend/.env. Restart the backend. GET /api/meta should now report simulation: false, data: "delayed".WATCWATC = WATCH. Same for PRIM, ELIT, SING.top_magnet.magnet over time — if it's not decaying, the pool is the active level, not a stale one. The top magnet is what TP3 aims at; if it's stuck, you're in a consolidation.source="px" in the meta so you can distinguish the CVD proxy from a real footprint (when wired).If your symptom isn't here, capture this first: GET /api/meta (provider, simulation flag, data source, symbol, timeframe, preset, footprint capability), GET /api/health (provider + engine status), and the last 3 bars from the chart's CVD series. With those three things, the underlying issue is usually one curl away from identified.
Four points the rest of the guide doesn't cover in plain English. The §1 / §3 / §8 sections already explain the alert pipeline, the settings table, and the 3-gate test — this section is the things that sit underneath those, especially the conditions that prevent a signal from firing and the realistic signal frequency you should expect.
The 3-gate test (covered in §1 mod-gates) is necessary but not sufficient. On top of the three gates, the engine runs three additional vetoes per side. A signal can have all three gates clear and still not print, because one of these vetoes vetoed it. They're the most common "the gates were all green, why didn't it fire?" answer.
How to read the panel. When a signal doesn't print and the gates all look green, scroll to the bottom of the gates panel and check the per-side veto indicators. Each one has a small dot: green = vetoed false (OK to print), amber = vetoed true (the side is suppressed). The dashboard surfaces all six states (3 vetoes × 2 sides) on every bar. If a side is "all green" and still no signal, the issue is downstream — chase_ok or the grade filter, not the gate.
It's possible for the engine to compute buy_raw = true AND sell_raw = true on the same bar. This happens in tight ranges where ribbon bias is mixed, both sides have FVG zones near price, and the OFI read is ambiguous. When both raw signals are true, the engine doesn't print either — it would be guessing.
The full tiebreaker rule, in priority order:
What to do on a phantom bar. Wait. The next bar (or two) will usually resolve the ambiguity one way or the other as the OFI read firms up. If you force a trade on a phantom bar, you're betting against the engine's tiebreaker — sometimes right, often wrong. The phantom is information: the market hasn't picked a side yet, and the trade isn't there.
When a trigger fires (sweep, VWAP reclaim, or CHoCH), the engine marks the bar as bull_armed or bear_armed. The "armed" state expires after a number of bars — the armed window. A long signal has to print while the side is still armed, otherwise the gate fails on the timing alone.
The armed window is not a constant. It's automatically derived from the active preset:
# meridian.py:146 — auto-derives from the preset's sweep length armed_bars = max(3, self.sweep_len // 2) # preset -> sweep_len -> armed window Scalp: sweep_len=6 → armed window = 3 bars (5m, 15m) Intraday: sweep_len=10 → armed window = 5 bars (5m, 15m, 30m) Swing: sweep_len=12 → armed window = 6 bars (1h, 4h) Position: sweep_len=15 → armed window = 7 bars (1d)
Why this matters: on a 5m Scalp preset, a trigger fires and the engine has 3 bars to confirm the signal before the armed state expires. On a 1d Position preset, you have 7 bars — which on daily is 7 trading days. A trigger that fires on Monday has until the following Monday to be confirmed. Same trigger, radically different windows.
The max(3, ...) floor exists so even the shortest preset gives the signal a real chance to set up. A 1-bar armed window would mean "trigger and confirm on the same bar" — which collapses the gate into noise. Three bars is the minimum the engine considers a valid setup window.
The honest expectation for a liquid US equity (SPY, NVDA, QQQ, AAPL) on a 5m chart, with the default PRIME grade floor, in a normal US-session day:
Six panels, in the order the engine evaluates them. The final frame shows what the dashboard looks like the moment the BUY signal prints with TP1, TP2, and TP3 all visible — entry at bar close, SL at the swept low padded by 0.35·stopATR·ATR, TP1 at 1R, TP2 at the regime-adjusted R:R, TP3 aimed at the top magnet.
These are realistic, not aspirational. If you're seeing 10+ PRIME+ per symbol per session on 5m, the grade floor is too loose, the symbol is in a strong regime, or something is misconfigured (a non-default value for min_grade dropping to WATCH). The engine deliberately underfires — the goal is signal quality over signal count.
In a typical US session, you'll see roughly 1.5-2× more BUY signals than SELL signals on 5m SPY/NVDA charts. The asymmetry comes from two compounding factors:
up_vol, and the equity market trends to have more flat-to-up bars than flat-to-down over time.If you're trading both sides and the ratio is significantly off (say, 4-5× more of one side), check the regime chip. TRANSITION regime is structurally harder for the engine to commit to a side; most phantom bars (the tiebreaker case above) cluster in TRANSITION, and the engine will print fewer of either side as a result.
Don't lower the bar to get more signals. The grade filter is the dial. If you want more signals, drop to WATCH and expect roughly 3-5× more prints — but at the cost of grade quality. The Confirm % on the journal will reflect this: WATCH-grade signals have a lower hit rate than PRIME+. If your Confirm % drops after lowering the floor, that's the data telling you the lower-grade signals weren't edge. Raise the floor again.