Documentation Integrations

What is Vesbite?

Vesbite is an IoT integration platform that bridges the gap between commercial IoT devices and the business systems your organization already relies on. Instead of writing and maintaining custom integration code, you adopt devices into Vesbite, build visual workflows on a drag-and-drop canvas, and let the platform handle connectivity, execution, and scaling.

The Problem

Commercial IoT devices – RFID readers, barcode scanners, sensors, label printers – generate valuable operational data every second. But turning that raw data into business outcomes is harder than it should be.

A typical integration project requires:

  • Server infrastructure to receive and process device data in real time
  • Custom integration code for every destination system (ERP, spreadsheet, CRM, database)
  • Device-specific knowledge to handle each vendor’s protocols and data formats
  • Ongoing maintenance as device firmware, cloud APIs, and business requirements change

For most organizations, this creates a barrier that delays or prevents IoT adoption entirely. Teams that do build custom integrations find themselves maintaining fragile, hand-coded pipelines that break whenever an API changes or a new device model is introduced.

The Solution

Vesbite removes the integration burden so you can focus on what matters: the business logic that connects device data to outcomes.

The platform works in three steps:

1. Adopt a Device

Install the Vesbite agent on your device and enter the adoption code in the dashboard. Within seconds, Vesbite discovers the device’s capabilities – what events it can publish, what actions it accepts, what settings it exposes – and makes them all available through a consistent interface.

No firmware modification. No protocol expertise. No server setup.

2. Build a Flow

Open the visual Flow builder, drag a trigger onto the canvas (such as “Device Event”), add the actions you need (send an HTTP request, create a record, branch on a condition), and wire them together. Expressions let you pass data between nodes using a simple {{ }} syntax.

3. Connect Services

Add integration nodes to your Flow for the services your business already uses – Airtable, SendGrid, Salesforce, PostgreSQL, or any HTTP API. Authenticate once, and Vesbite manages the connection going forward.

How It Works at a High Level

┌─────────────┐     ┌─────────────┐     ┌─────────────┐
│   Devices   │────>│   Vesbite   │────>│  Services   │
│             │<────│   Platform  │<────│             │
└─────────────┘     └─────────────┘     └─────────────┘
     │                    │                    │
  Events &            Workflows            APIs &
  Actions              Engine            Integrations

Devices communicate with Vesbite through a lightweight agent that handles secure connectivity, event publishing, action execution, and settings management. The agent uses a message bus (NATS) for real-time, bidirectional communication.

The Platform provides the device registry, workflow engine, integration connectors, and multi-tenant isolation. Workflows run in the cloud with durable execution – they survive restarts, scale to thousands of concurrent instances, and handle errors gracefully.

Services receive data and commands through pre-built integration actions, HTTP webhooks, or direct API calls. Because integrations are just workflow nodes, you can mix and match them freely.

Key Concepts

Devices

A device in Vesbite is any IoT hardware that runs the Vesbite agent. Each device type defines its own schema – the events it generates, the actions it accepts, and the settings it exposes. This schema-driven design means the platform adapts to the device, not the other way around.

Learn more about devices -->

Flows

A Flow is a visual automation that connects a trigger to a sequence of actions. Flows are defined on a canvas as a directed graph of nodes and connections. When a trigger fires (a device event arrives, a timer expires, a webhook is received), the Flow engine executes each action in order, following branches and handling errors along the way.

Learn more about workflows -->

Integrations

Integrations are pre-built connectors to third-party services. Each integration exposes one or more actions that you can drop into a Flow. Authentication is handled once per connection, and Vesbite manages token refresh and credential storage.

Expressions

Expressions are the glue that passes data between workflow nodes. Written in Vex (a Scriban-based template language), they let you reference trigger data, previous node outputs, and workflow variables using a simple {{ }} syntax.

Learn more about expressions -->

Multi-Tenant Architecture

Vesbite is designed for organizations. Each organization gets its own tenant – an isolated workspace where devices, workflows, integrations, and credentials are completely separate from other tenants.

This isolation means:

  • Separate device registries – your devices are only visible to your team
  • Independent workflows – one tenant’s automation load does not affect another’s
  • Private credentials – integration tokens and API keys are never shared across tenants
  • Team-based access control – invite members and manage permissions within your organization

Tenants are enforced at the database level. There is no configuration that can accidentally expose one tenant’s data to another.

Use Cases

Vesbite works best when you need to connect commercial IoT devices to business systems without writing custom code.

Inventory tracking – RFID readers scan tagged items as they move through a warehouse. Vesbite Flows automatically update inventory records in Airtable, trigger reorder alerts in Slack, and log movements to a database.

Asset management – Track high-value equipment across facilities. When a reader detects an asset in an unexpected location, a Flow sends a notification, updates the asset record, and creates an incident ticket.

Automated alerts – Sensor readings that cross a threshold trigger Flows that send SMS alerts, email notifications, or webhook calls to on-call systems.

Data logging – Every device event is processed by a Flow that normalizes the data, enriches it with metadata, and writes it to a PostgreSQL database or Google Sheet for reporting.

Print automation – When a Flow processes an incoming scan, it can send a print action to a label printer with dynamically generated content – no manual intervention required.

When to Use Vesbite

Good fit:

  • Commercial IoT devices that need to connect to business systems
  • Organizations without dedicated IoT engineering teams
  • Use cases requiring rapid iteration and visual development
  • Multi-device deployments needing centralized management and monitoring

Consider alternatives if:

  • You need sub-millisecond latency at the edge (Vesbite workflows execute in the cloud)
  • You are building a consumer IoT product with millions of devices
  • Your use case requires deeply custom firmware behavior

Next Steps