IoT on live streams.
Millions of small events a second, flaky networks, silent devices, and a fleet that spans regions. A pipeline that ingests the firehose, decides at the edge, and rolls the fleet up into one live picture.
Built for the firehose, not adapted to it
The native path — columnar batches, shard-per-core, io_uring storage — was designed for exactly this shape of load: huge volumes of small events. Devices and gateways publish over MQTT, HTTP or the Kafka wire; producer-side sequencing dedupes the retries lossy networks generate.
Decide at the edge, escalate to the cloud
Pulse runs embedded on a gateway-class box — the same engine, single process. Rule stages fire in microseconds on-site: shut the valve, flag the reading, drop the noise. Only aggregates and exceptions travel upstream, cutting backhaul and reaction time.
Your perimeter, end to end
Self-hosted everywhere: the edge node, the ingestion tier and the mesh all run on your infrastructure. TLS on the device-facing connectors, secrets kept out of configs via ${secret:…}, and an audit stream that records what flowed where.
Per-device state, fleet-wide picture
Keyed state per device tracks drift, battery, firmware and heartbeat. Keyed timers catch the device that went silent; windowed aggregates roll the fleet up by model, region or customer. An LLM stage can triage anomaly clusters into a readable morning report.
One engine, two altitudes
The edge node and the cloud mesh run the same app.
Embedded, on-site, autonomous
A single self-hosted process on gateway hardware. Local rules act in microseconds even when the uplink is down; state survives power cycles.
- •observe → decide → act, fully local
- •store-and-forward when offline
- •no cloud round-trip in the control path
The mesh that absorbs the fleet
When one node isn't enough: a quorum-replicated, multi-node event mesh ingests every site's stream, with central fleet operation and governance.
- •multi-node HA · RF=3 durability
- •multi-region replication
- •SSO/RBAC · fleet observability
same pulse.yaml →
What it looks like
A fleet watch is one file.
Telemetry in, per-device health out — with the silent devices surfaced, not forgotten.
1# pulse.yaml — fleet watch
2source:
3 kind: webhook # gateways post telemetry
4
5stages:
6 - name: health
7 engine: streaming
8 operators:
9 - window: 5m sliding
10 keyBy: device_id
11 aggregations:
12 readings: count
13 batt_min: min(battery)
14 rssi_avg: avg(rssi)
15
16 - name: flag
17 engine: rule-based
18 rules:
19 - "readings == 0 || batt_min < 15"
20
21 - name: act
22 engine: mcp
23 mcpTools: [ fleet.openTicket ]
24
25sink:
26 kind: webhook # NOC board
27 url: ${secret:NOC_WEBHOOK}
28- 1
Scaffold.
pulse new fleet --source webhook --stage streaming:health --stage rule-based:flag --stage mcp:act --sink webhook - 2
Run it at the edge.
Deploy the same file on the gateway box — local decisions stay local, exceptions escalate.
- 3
Watch the fleet.
pulse events tail --topic fleet.flag.outEvery weak battery and silent device, live.
- 4
Scale when it hurts.
Point the app at the enterprise mesh when one node stops being enough — the YAML doesn't change.
Ingest the firehose. Decide at the edge.
See device telemetry stream into per-device health in minutes — no install, no signup. Then self-host it on a gateway.
Pulse is free and self-hosted. Multi-node HA, geo-replication and governance come with StreamFlow Enterprise.