Source Node
Self-hosted Sources — File/SMB watcher, MQTT, and self-hosted webhook — run on your own machine through a single piece of software: the Source Node. You install it once, and that one service runs every self-hosted source your tenant uses. New source types arrive by updating the node — never by installing new software.
The node connects outbound to the Hub like a sink agent: no inbound firewall rules are required, except for the self-hosted webhook engine, which listens locally on your machine.
How the Source Node Works
Section titled “How the Source Node Works”When you start the node it:
- Authenticates with the Hub using the credentials of the node you created on the Nodes screen (see the Nodes reference — installers take
CLIENT_ID/CLIENT_SECRETfrom there) - Registers itself as the
SOURCE_NODEnode type - Opens a persistent outbound stream to the Hub
- Receives the flows attached to the node — for each attached flow, the node runs one supervised worker process (file watcher, MQTT client, webhook receiver, or schedule engine) and forwards the events it produces to the Hub
Each flow runs in its own worker: one failing flow never takes down another. The node’s configuration and per-flow cursors live on the node’s host; secrets never touch disk.
Deployment Options
Section titled “Deployment Options”| Platform | Guide | Notes |
|---|---|---|
| Windows | Install on Windows | Runs as a Windows Service; supports self-updating |
| Linux | Install on Linux | Runs as a systemd unit; supports self-updating |
Updating the Node
Section titled “Updating the Node”New source types are released in engine packs — batches of engines shipped in a new node version. When your platform enables the update, the Hub drains your node’s workers and the node updates itself automatically (the same self-update flow sink agents use). Keep the service updated: a source whose engine is missing from your node version shows an ERROR status telling you an update is required.
Source Status
Section titled “Source Status”Once the node is connected, its flows appear on the Sources screen. See the Sources guide for the status values, including the ERROR states the node reports.
Offline Behavior
Section titled “Offline Behavior”When the node goes offline, its attached flows stop producing events — they are never moved to the platform. The Nodes screen shows the node as Offline, and the flows are flagged until the node returns. The one exception is schedule sources: they are location-independent, so the platform redistributes them to another available source node (see below).
What Runs Where
Section titled “What Runs Where”| Source | Where it runs |
|---|---|
| Webhook, Scheduler, Azure EventGrid, MCP | Platform — nothing to install |
| File/SMB watcher, MQTT, self-hosted webhook | Your machine, via the Source Node — as a system service or as a container |
The Containerized Source Node
Section titled “The Containerized Source Node”The same engines ship as a container image with a Helm sub-chart: one image runs the generic source node — webhook serving included, through its unified webhook engine — supervised with per-flow worker isolation. Deploy it as a tenant Kubernetes node (create a source node on the Nodes screen, hand the chart its credentials, enable the webhook ingress) or as a platform node — the image is the same.
Scaling is one knob: a replicable row (replicaCount greater than 1).
Every pod registers with the same node credentials, webhook flows fan out to
every pod (any pod serves any flow’s POST), and the hub delivers each
schedule/file/MQTT flow to exactly one pod at a time — re-assigning within a
sync interval when a pod disappears. Adding pods adds capacity for every
source kind; there is no placement rule to manage.
Platform deployment is plan-gated: the platform placement is offered when your plan carries platform capacity, and the New Source slide-over otherwise defaults to a pinned node. Your plan also caps how many sources and how many self-hosted source nodes you can attach — see Billing & Subscription for your tier’s allowances.
Schedule sources are location-independent: when the node hosting them goes offline, they redistribute to another available source node of the same tenant (location-bound sources keep their pin). A schedule source fires on exactly one node — placement plus the hub’s per-instance delivery keep multiple container nodes from ever double-firing.
Deployment steps (credentials, ingress, scaling) live in the chart’s README under helm/nexomatic/charts/source-node/.