Skip to content
use-cases / a-live-metrics-dashboard-no-backend / hero
PIPE · SSE · NO BACKEND

A live dashboard with no metrics backend

Twenty agents push their metrics to one pipe URL with curl -T. Your dashboard reads the same URL with ?progress and renders the SSE stream straight into the page. No InfluxDB, no Prometheus, no scrape interval. Just a wire.

Read the pipe docs
use-cases / a-live-metrics-dashboard-no-backend / mechanism

One URL, two sides

Every agent curls its line into the same pipe path. The dashboard's browser opens an EventSource on that path with ?progress. The Hoody Pipe server holds nothing — bytes that arrive on one side leave on the other.

agent · monitor.sh
PUT · sender
#!/bin/sh
# Agent monitor loop — one line per second.
while true; do
  cpu=$(top -bn1 | awk '/Cpu/ [print $2]')
  mem=$(free | awk '/Mem:/ [printf "%.0f", $3/$2*100]')
  line="cpu=$cpu mem=$mem qps=$(cat /tmp/qps) ts=$(date +%s)"
  echo "$line" | curl -T - https://pipe.hoody.com/api/v1/pipe/metrics-$AGENT_ID
  sleep 1
done
the wire holds nothing
dashboard.html · in your browser
GET ?progress · reader
// One <script> in one HTML file. No backend.
const tiles = document.querySelectorAll('[data-agent]');

tiles.forEach((tile) => [
  const id = tile.dataset.agent;
  // ?progress turns the pipe path into an SSE stream.
  const sse = new EventSource(
    `https://pipe.hoody.com/api/v1/pipe/metrics-$[id]?progress`,
  );

  sse.addEventListener('metric', (e) => [
    const [ cpu, mem, qps ] = JSON.parse(e.data);
    tile.querySelector('.cpu').textContent = `$[cpu]%`;
    tile.querySelector('.mem').textContent = `$[mem]%`;
    tile.querySelector('.qps').textContent = qps;
  ]);
]);

Agents curl. The browser EventSources. The pipe forwards. There is nothing in between to scale, restart, or pay for. Close the dashboard and the streams end. Open it again and you see live data within the second.

use-cases / a-live-metrics-dashboard-no-backend / powers

Three powers of an evaporating dashboard

What you give up by deleting the backend, you get back as something simpler.

LATENCY

Sub-second by construction

There is no scrape interval to wait for. The agent's last write is the dashboard's current frame. The pipe forwards directly — no intermediate flush.

OPERATIONS

Nothing to retain, nothing to fail

No retention policy because there is no storage. No disk to fill, no compaction window, no time-series index to corrupt. The metric exists while a reader is watching.

ECONOMICS

One static HTML file ships it

The dashboard is an HTML file you can host anywhere — or open from disk. There is no agent to install, no daemon to run, no DataDog seat to provision. The pipe URL is the entire stack.

use-cases / a-live-metrics-dashboard-no-backend / evaporates

What evaporates

The standard agent-to-dashboard stack has four moving parts. The pipe model has zero. Same wire, half a screen of curl.

BEFORE · FOUR PARTS TO BABYSITthe typical stack
  • statsd / telegraf
  • InfluxDB / TimescaleDB
  • Grafana / Datadog
  • scrape config files
four configs · four upgrades · four bills
AFTER · ONE WIREtwo curl commands
# Each agent: one line per metric.echo "cpu=64 mem=42" | curl -T - https://pipe.hoody.com/api/v1/pipe/metrics-$ID# Each viewer: one curl, or new EventSource() in HTML.curl -N https://pipe.hoody.com/api/v1/pipe/metrics-$ID?progress
no storage · no scraper · no daemon

When you skip the database, the things you used to manage stop existing. There is no retention policy on a wire.

use-cases / a-live-metrics-dashboard-no-backend / capacity

What the pipe gives you

A pipe path is small but real infrastructure. Numbers come from the Hoody Pipe API guarantees, not from invented benchmarks.

  1. RECEIVERS PER PATH256

    Up to 256 dashboards or curl tails can subscribe to the same path with ?n. The slowest reader applies backpressure but never blocks the others.

  2. PROGRESS SPECTATORS50

    Up to 50 ?progress SSE viewers per path. They don't consume a receiver slot — your dashboard tabs and your terminal can watch in parallel.

  3. STORAGE LATENCY0 ms

    The server doesn't write to disk. Bytes that arrive on the sender side leave on the reader side. There is no flush window between them.

Limits per the Hoody Pipe API: receiver count 1–256, progress spectators capped at 50 per path, 30-minute progress connection TTL, 30-second post-transfer linger.

use-cases / a-live-metrics-dashboard-no-backend / punchline

The dashboard didn't query a database. The bytes just arrived.

watched live · fridayevaporated · saturday
WHAT THE OLD ARCHITECTURE LOOKED LIKEagent → statsd → InfluxDB → Grafanafour moving parts · four config files · four bills
WHAT IT LOOKS LIKE NOWecho $line | curl -T - pipe/metricsone line — and the dashboard is just an HTML file
use-cases / a-live-metrics-dashboard-no-backend / replaces

What this replaces

The standard reach-for-it tools when you want a metrics dashboard. Each one charges you a database and a daemon. The pipe charges you neither.

  • AWS Lambda + CloudWatchPer-invocation billing for what is just curl
  • custom routing servicesA whole microservice to forward bytes that already had a URL
  • Prometheus + Grafana stackTwo daemons, a scrape loop, and a dashboard you must self-host
  • InfluxDB + TelegrafA time-series database for data you don't keep past the screen
  • DataDog metric collectionPer-host pricing for a number you wanted to see once
  • custom metric ingest pipelinesKafka + consumer + sink for a value the agent could just push
use-cases / a-live-metrics-dashboard-no-backend / cta

Stop scraping. Stop storing. Watch the wire — and when you stop watching, the wire is empty.

Read the pipe docs
use-cases / a-live-metrics-dashboard-no-backend / related

Read the others