ThingsBoard

Most IoT projects start the same way: you wire up sensors, pick an MQTT broker, find a time-series database, bolt on Grafana, and write glue code to tie it all together. ThingsBoard rolls device management, data processing, dashboards, and alarm handling into a single platform, so you skip the integration work. It has been in active development since 2016, with 21K+ GitHub stars and 253 contributors.

Key features

• Multi-protocol device connectivity -- MQTT, CoAP, HTTP, SNMP, and LwM2M supported natively. An IoT Gateway component adds Modbus, OPC-UA, BACnet, BLE, and CAN bus for bridging legacy equipment.
• Rule engine -- drag-and-drop chains for filtering, transforming, and routing telemetry. Supports alarm creation, external API calls, and RPC commands to devices. No custom code required for common workflows.
• Multi-tenancy -- built-in tenant hierarchy with separate dashboards, devices, and users per customer. IoT service providers can white-label the platform (Professional Edition) and onboard clients without separate deployments.
• Dashboard builder -- 30+ configurable widget types including charts, maps, SCADA symbols, gauges, and control panels. Dashboards can be shared or embedded in external applications.
• ThingsBoard Edge -- runs locally at the network edge for environments with unreliable connectivity. Processes data on-site, stores it during outages, and syncs to the cloud server when connectivity returns. Handles up to 1,000 devices per instance.
• Alarm system -- v4.3 introduced Alarm Rules 2.0 with calculated fields, providing more flexible threshold-based and composite alarm logic.
• SCADA integration -- drag-and-drop SCADA symbol editor for creating HMI-style dashboards that map directly to physical equipment.

What ThingsBoard does

ThingsBoard is a Java-based monolith (single deployable) or microservices-based platform depending on scale. The architecture centers on three layers:

The transport layer accepts device telemetry over MQTT 3.1.1, CoAP, HTTP, SNMP, and LwM2M. Devices authenticate via tokens, X.509 certificates, or access keys. For legacy industrial equipment, ThingsBoard IoT Gateway (a separate Python-based service) translates protocols like Modbus TCP/RTU, OPC-UA, BACnet, and BLE into ThingsBoard's internal format.

The rule engine processes incoming telemetry through configurable chains of nodes: message filters, transformations, enrichments, and actions. You can create alarms, send notifications, push data to Kafka or RabbitMQ, call external REST APIs, or issue RPC commands back to devices. Version 4.2 (August 2025) added an AI Rule Node for inference within rule chains.

The application layer serves the web UI, REST API, and WebSocket subscriptions for real-time updates. Multi-tenancy is fundamental to the data model: every entity belongs to a tenant, and tenant admins manage their own devices, dashboards, and users independently.

For storage, ThingsBoard uses PostgreSQL for entities and metadata. For high-volume telemetry (above ~5,000 messages/second), it supports a hybrid mode with Cassandra or TimescaleDB handling time-series data.

Manufacturing context

ThingsBoard is a general-purpose IoT platform, not a manufacturing-specific tool. It lacks built-in MES concepts like work orders, bill of materials, or OEE calculations. But its protocol breadth and multi-tenancy make it useful in manufacturing scenarios where the primary need is device connectivity and monitoring rather than production execution.

Typical factory use cases: connecting temperature/humidity/vibration sensors via MQTT, building operator dashboards for line-of-sight monitoring, setting up threshold alarms for equipment parameters, and bridging legacy PLCs via the OPC-UA or Modbus gateway connectors. The SCADA symbol editor (added in recent versions) moves it closer to traditional HMI use, though it is not a replacement for purpose-built SCADA systems like Ignition.

For plants that already have a MING stack (Mosquitto + InfluxDB + Node-RED + Grafana), ThingsBoard represents a consolidation play: one platform instead of four. The trade-off is that each individual component in the MING stack is best-in-class at its specific job, while ThingsBoard is a generalist.

Why choose ThingsBoard

Self-hosted and free to start. Community Edition is Apache-2.0 licensed with no device limits. You can run it on a single VM with 4GB RAM and PostgreSQL, or scale to microservices on Kubernetes for millions of devices.

Multi-tenancy is native, not bolted on. If you are an IoT integrator or managed service provider serving multiple factory clients, the tenant model avoids running separate instances per customer.

Edge computing without a separate product. ThingsBoard Edge runs the same rule engine and dashboards locally, handles disconnected operation, and syncs automatically. Useful for remote factory sites or areas with unreliable connectivity.

Protocol gateway included. The IoT Gateway covers Modbus, OPC-UA, BACnet, BLE, CAN bus, and ODBC at no extra cost. For brownfield factories with legacy PLCs and sensors, this removes the need for a separate protocol translator.

Getting started

Community Edition installs via Docker, apt packages (Ubuntu/Debian/CentOS), or directly on a Raspberry Pi (4GB+ RAM). A single-node setup with PostgreSQL needs 2 CPU cores and 4GB RAM for testing; production with moderate load recommends 8 cores and 16GB RAM.

The learning curve is moderate. The dashboard builder and rule chain designer are visual, so basic monitoring setups work without writing code. However, complex rule chains, custom widgets, and multi-tenant configurations require reading the docs carefully. Community examples are thinner than you would find for Grafana or Node-RED, and some tutorial content is outdated.

Professional Edition adds white-labeling, advanced RBAC, platform integrations (Kafka, Kinesis, SQS), and CSV/scheduling features. Self-managed PE starts at $10/month for 10 devices (Maker plan), scaling to $99/month for 100 devices with white-labeling (Pilot). Managed cloud starts higher. There is a free PE trial plan for evaluating advanced features.

Technical specs

• Language: Java 17 (server), Angular (frontend)
• Database: PostgreSQL (required), optional Cassandra or TimescaleDB for high-volume time-series
• Deployment: Docker, Docker Compose, Kubernetes (Helm), Ubuntu/CentOS packages, Raspberry Pi, AWS Marketplace
• Architecture: Monolith (default) or microservices (for 1M+ devices, >5K msg/sec)
• API: REST API, WebSocket API for real-time subscriptions
• Latest version: 4.3 (January 2026), with Alarm Rules 2.0 and Calculated Fields

Limitations

• No manufacturing-specific features. No OEE, no work order management, no production scheduling. If you need MES-level functionality, you need a separate tool or a platform like United Manufacturing Hub that is purpose-built for manufacturing.
• Documentation and community examples are uneven. The official docs cover the basics but advanced use cases (complex rule chains, custom widgets, multi-tenant deployment patterns) often lack worked examples. Video tutorials have not kept pace with recent versions.
• Dashboard builder has a ceiling. The widget library covers common visualization needs, but building highly custom dashboards requires JavaScript widget development. The SCADA symbol editor is newer and less mature than dedicated HMI tools.
• Java resource footprint. A production single-node deployment wants 8+ cores and 16GB RAM. Compared to lighter tools like Mosquitto or Node-RED, ThingsBoard is heavier to run, especially on constrained edge hardware.
• Professional Edition features behind a paywall. White-labeling, advanced integrations (Kafka, Kinesis), CSV export, and some RBAC controls require the paid PE license. The CE-to-PE feature gap can surprise teams who prototype on CE and then discover they need PE features in production.