Most active traders run six tabs at once: TradingView for the chart, the broker platform for orders, a spreadsheet for daily PnL, the news feed in another window, Discord for alerts, and the bot's terminal output in a fifth pane. By the third trade of the day, the cognitive overhead is eating into the edge. We build custom trading dashboards that collapse all of it into a single branded panel — multi-timeframe candlestick chart with entry/exit markers, live equity curve, trade cards, order-flow widgets, capture-zone preview, and a stats strip showing trades, win rate, and net dollars. Built in Python + WebSocket + HTML5 Canvas, served on localhost, fully owned by you.
TradingView is the best general-purpose charting product in the world — and it is still the wrong centerpiece for a serious trader's daily workflow. The reason is structural: TradingView is a chart with indicator overlays. It cannot show you your live equity curve from your broker. It cannot render trade cards with realized P&L per fill. It cannot display your order-flow signal next to the chart. It cannot show your bot's adaptive mode or composite score. It cannot tell you your hourly win-rate breakdown for the last 30 days.
None of those things belong in a charting tool — they belong in a dashboard. A serious trader's dashboard is a different animal: it is a cockpit, not a chart. It pulls live data from the broker, the bot, the order-flow feed, and the indicator engine, and lays it out on a single screen so every decision can be made without alt-tabbing.
The reference dashboard we built for our own MNQ futures system is a single-file Python HTTP server on port 8080 that renders five timeframes, an outlier-filtered equity curve, trade cards with green/red borders by P&L, live position badge with $/pt P&L, capture-zone preview, and a real-time order-flow widget — all from one WebSocket-powered HTML page. We have built variants of it for futures traders, options traders, equity swing traders, and crypto desks. The skeleton stays the same. The data plumbing is what gets customized.
The dashboard is intentionally simple. A Python http.server stdlib HTTP server (no Flask, no Django, no FastAPI) reads four shared JSONL files written by the trade engine and exposes them through five JSON endpoints. The browser pulls those endpoints on a 1–2 second cadence and renders everything on HTML5 Canvas. Total dependencies in the dashboard layer: zero npm packages.
Why this stack? Because simplicity scales. A dashboard that depends on React, Vite, Webpack, and twenty npm packages will rot in 18 months. A single-file Python server reading JSONL has no upgrade treadmill, no breaking dependency changes, and no build step. You can copy the directory to a different machine and have it running in 30 seconds.
# dashboard.py — five JSON endpoints, zero frameworks
ENDPOINTS = {
"/data": # candles (5 TF) + markers + equity + live + stats + cards
"/analytics": # hourly breakdown, win-rate, dollar histogram
"/zone_preview": # JPEG of OCR capture region (1fps)
"/flow": # live order_flow.json passthrough
"/status": # OCR stats, candle counts, client count
}
# Each tab in the UI hits one endpoint, polls on a configurable interval.
# Browser does ALL rendering — server does zero HTML templating.Every dashboard we build customizes around the same six structural panels. The data sources change — futures, options, equities, crypto — but the panel set stays consistent because it maps directly to the cognitive task of trading.
5s / 1m / 5m / 15m / 1h candles all built from the same tick stream. Tab to switch, or 2×3 grid view to see all five at once. Resizable equity panel below.
Every entry, half-exit, and full-exit drawn directly on the chart with green/amber/red arrows. Hover shows contracts, points, and dollar P&L.
Cumulative dollar P&L plotted under the chart. Outlier filter excludes |pts| > 200 (OCR garbage). Color flips green/red based on net session result.
One visual card per trade with entry → half-exit (amber) → full exit, dollar P&L, and a green/red border by win/loss. Sorted newest-first, scrollable.
Live DOM imbalance bar, rolling tick delta, cumulative delta, VWAP, and a signal badge (BULLISH / BEARISH / NEUTRAL). Polls every 1s.
Single-row session vitals: Trades, Win%, W-L, Net Pts, Net $. Color-coded so a glance tells you whether the session is on or off pace.
On top of those six panels, the reference build adds three optional tabs — Analytics (hourly win-rate breakdown for bad-hour blocking), Zone (live OCR capture region preview, refreshed at 1fps as JPEG so you can confirm the engine is reading the right area), and Flow (raw order-flow JSON passthrough for power users). Every tab is one endpoint, one render function, one CSS file. Adding a seventh tab is twenty lines of code.
The most-stared-at piece of the dashboard is the live position badge. It sits in the upper-right corner of the header strip and shows: side (Long/Short), contract count (×N), live points P&L, and live dollar P&L, with a "½ OUT" tag if a half-exit has fired and the position is still partly open. Color flips green or red based on whether the trade is currently winning.
That badge is the thing a trader looks at every 4–6 seconds, the entire time a trade is open. Most charting tools force you to keep the broker DOM open in a separate window to see it. The custom dashboard puts it on the same screen as the chart.
Design note: The badge updates from the same WebSocket tick stream that builds the candles — not from a separate broker poll. So the moment the chart redraws, the dollar P&L is correct to the same tick. No latency mismatch between the chart and the position display.
The order-flow panel is the differentiator between a "nice dashboard" and a "tool that improves my edge." It pulls live DOM (depth-of-market) data, tick delta, and VWAP from the broker WebSocket, computes a composite imbalance score, and renders a real-time bar that visualizes whether buyers or sellers are aggressing right now.
The reference build computes a single signal score from three weighted inputs: DOM bid/ask imbalance (40%), rolling tick delta (35%), and price-vs-VWAP (15%). Score > 0.15 lights up BULLISH in green; < -0.15 lights up BEARISH in red; everything else is NEUTRAL. The bot reads the same score on entry and refuses long entries when the flow is bearish — the dashboard just shows the human side of that loop.
// Order flow widget refresh — 1s poll from /flow endpoint
async function refreshFlow() {
const r = await fetch('/flow');
const f = await r.json();
imbalanceBar.style.width = `${(f.imbalance * 100).toFixed(0)}%`;
deltaText.textContent = f.rolling_delta.toFixed(0);
vwapText.textContent = f.vwap.toFixed(2);
signalBadge.className = 'sig-' + f.signal.toLowerCase();
signalBadge.textContent = f.signal;
}
setInterval(refreshFlow, 1000);The Analytics tab is what turns the dashboard from a real-time tool into a learning tool. It buckets every closed trade by hour-of-day and renders win-rate, average dollar P&L, sample size, and a "bad-hour" flag (red badge) for any hour with ≥ 5 trades and a win-rate below 30%.
That single panel has rewritten more trading rules than any indicator in the system. Once a trader can see at a glance that 11:00–11:30 has been a 23% win-rate for the last six weeks, the natural response is to add that hour to the session blackout list — which the bot reads on the next start. The dashboard surfaces the pattern; the bot enforces it.
The mainstream platforms each give you a slice of what a dashboard does. None give you all of it on one screen, and none give you the freedom to add your own widget when you discover a new metric that matters to your edge.
| Capability | Custom Dashboard | NinjaTrader / Sierra / TradingView |
|---|---|---|
| Live equity curve from broker | Yes — same screen as chart | Separate broker window |
| Trade cards with $ P&L per fill | Yes — visual card per trade | Spreadsheet export only |
| Order-flow widget (DOM + delta + VWAP) | Composite signal in one panel | 3 separate windows or paid add-on |
| Hourly win-rate analytics | Built into Analytics tab | Manual export to Excel |
| Custom widgets (composite score, bot mode) | Add any field in one screen of code | Locked to vendor's widget set |
| Branding (your colors, your logo) | Pixel-perfect to your theme | Generic vendor chrome |
| Multi-monitor / kiosk mode | Browser fullscreen on any display | Vendor's window manager |
| Monthly cost | $0 — runs on your machine | $15–$200/mo platform + data fees |
| Code & data ownership | Full source delivered, you own everything | Vendor's IP, vendor's terms |
The dashboard ships with an /embed endpoint — a minimal version of the chart that drops into any iframe. We use this to publish a public-safe candlestick view of our trading bot's live performance on a separate website. Embedded chart shows price + entry/exit markers + equity curve only. Position size, account number, and broker credentials never leave the trading machine.
For private sharing — mentor sessions, trade-room alerts, etc. — we layer Cloudflare Tunnel + Cloudflare Access on top. The tunnel exposes the local dashboard at a custom subdomain, with email-verified access policies controlling who can connect. No router port-forwarding. No inbound exposure on your machine.
If you trade futures, options, equities, or crypto with a system — manual or fully automated — a custom dashboard is a 4–8 week build that pays for itself in the first month of clearer decision-making. We start from the reference architecture and customize the panels, the data plumbing, and the styling to match your workflow.
Multi-TF chart, live position badge, equity curve, trade cards, order flow, hourly analytics. Branded to your theme.
Live bot status, adaptive mode, composite score, zone preview, log tail, kill switch. The cockpit for an automated system.
Public-safe embed with chart + entry/exit markers + equity only. No account info exposed. Cloudflare Access gated.
Replay historical trades on the same dashboard with scrubber controls. See what each panel would have shown in real time.
One dashboard with tabs per strategy or per account. Compare equity curves side-by-side, allocate capital by performance.
Runs on a $40 Mac mini or any 4GB Linux box. Browser-based UI works on phone, tablet, second monitor, or kiosk display.
If you also want the trading engine itself built — OCR signal capture, adaptive thresholds, broker auto-execution — see the companion custom futures trading bot blog. The dashboard layer documented here sits on top of any engine, including ones you already have.
If you are running a serious manual or automated trading workflow and you are still alt-tabbing between TradingView, your broker, and a spreadsheet — a custom dashboard is the lowest-hanging upgrade you can make. Call or text Jacob at (320) 360-8285, or message DM HUNT through the contact form for a same-day reply.