The three shapes a FlowFuse app takes when it runs on a device.
Hardware apps — start here
The three shapes a FlowFuse app takes when it runs on a device. Pick by how much varies per site: nothing (Packaged App), a few settings (Configurable App), or you assemble it yourself (Edge Building Block).
Deploy · sealed
Sealed product on a Remote Instance, identical on every device.
Built once
Pipeline snapshot
sealed · built once
deploy · sealed
Devices · nothing to configure
Remote Instance
identical
Remote Instance
identical
Remote Instance
identical
Sealed · nothing to configure
A sealed product that ships on a piece of hardware and is identical everywhere — buy it, it runs on its device, nothing to configure.
Use it when
The app ships with a known partner device and the data it reads is fixed by that hardware.
How it works
Built and promoted through a pipeline (dev → staging → prod), then deployed to a Remote Instance as a snapshot. Everything is baked in; only fixed env vars vary at deploy.
Major components
Pipeline snapshot — the app built once, promoted to the device
Team Broker (MQTT) — carries the app's events to subscribers
FlowFuse Tables — stores the rows the app writes
Where config & data live
Config — baked into the snapshot; only fixed env vars at deploy, nothing per-site.
Data — events to the Team Broker, records to FlowFuse Tables.
Same build, per-site config
Same build on a Remote Instance, tuned by a per-site config file that lives on the device.
Built once
Pipeline snapshot
same build
same build
Per-site config
Per-site config
tags · broker · site
loads its own config
Devices · each tuned to its site
Remote Instance
Site A
Remote Instance
Site B
Remote Instance
Site C
The same shelf product, plus a few knobs — tag names, broker address, site name — that differ per site and live on the Remote Instance.
Use it when
The flows are the same everywhere but the values they use differ per install and may change over time.
How it works
Same pipeline delivery to a Remote Instance; the runtime loads a per-site config from a file on the device. Back that file up to the database, so a device swap restores the config — the device is the source of truth, the DB is the safety net.
Major components
Pipeline snapshot — the same build promoted to every device
Remote Instance (edge device) — runs the app and loads its own per-site config
Per-site config (tags · broker · site) — a file on the device, backed up to the DB
Team Broker / FlowFuse Tables — event egress + records
Where config & data live
Config — a per-site file on the device (tags, broker address, site name), backed up to FlowFuse Tables so a swap restores it.
Data — Team Broker + FlowFuse Tables.
A reusable edge block
A reusable edge block you wire into your own upstream flows.
Equipment
Equipment
signals / PLC
reads
Edge Building Block on a Remote Instance
Remote Instance
edge device
publishes
Upstream
Team Broker
MQTT
Not a finished app — one hardware-facing block plus example flows, running on a Remote Instance. You assemble everything upstream of it yourself.
Use it when
The hardware-facing piece is reusable, but everything before it differs so much per site that no finished app would fit.
How it works
Blocks are published as subflows to the Team Library with an example flow. Consumers drop them onto a Remote Instance and wire them up.
Major components
Equipment (signals / PLC) — the source hardware the block reads
Remote Instance (edge device) — runs the edge building block at the line
Team Broker (MQTT) — publishes the normalized data upstream
Team Library — where the block is published as an installable subflow
Where config & data live
Config — lives in the consuming flow you build around the block (env / context).
FlowFuse Application Guide