ThingsBoard vs Grafana: The Definitive IoT Platform Comparison

WZ-IT operates thingshost. Current hosting starts from €159.80 net/month; setup and service level follow the proposal. Former package prices, location lists and cost comparisons in this dated article describe the previous offer, not current WZ-IT terms. View current service scope.

ThingsBoard and Grafana are not direct competitors — they solve fundamentally different problems, yet their overlapping dashboard capabilities create genuine confusion for IoT teams. ThingsBoard is a full-stack IoT platform handling everything from device provisioning to rule-based automation to visualization. Grafana is a best-in-class observability and visualization layer that connects to external data stores but manages zero devices. The real question is not which one to pick — it's whether you need a complete IoT operating system (ThingsBoard), a world-class visualization engine atop your own data pipeline (Grafana), or both working together. This report covers every dimension of this decision with current data through March 2026.

Table of Contents

• Two Fundamentally Different Philosophies for IoT Data
• Dashboard Building and Visualization Compared Side by Side
• Data Ingestion and Storage: Built-in Versus Bring-Your-Own
• Device Management: ThingsBoard's Core Advantage
• Rule Engines and Alerting: Structured IoT Automation Versus Metric-Based Alerts
• LoRaWAN Integration with ChirpStack and The Things Stack
• Multi-Tenancy and White-Labeling for Service Providers
• Pricing Breakdown for 2025–2026
• Scaling for Large IoT Deployments
• Using ThingsBoard and Grafana Together
• Which Verticals Favor Which Platform
• How Node-RED and InfluxDB Complete the Architecture
• Recent Developments Reshaping the Landscape (2024–2026)
• Conclusion: A Framework for Choosing
• Sources

Two Fundamentally Different Philosophies for IoT Data

ThingsBoard was purpose-built as an end-to-end IoT platform. Written in Java (Spring Boot) with an Angular frontend, it handles device connectivity (MQTT, HTTP, CoAP, LwM2M), telemetry ingestion and storage, data processing via a visual rule engine, alarm management, and multi-tenant dashboards — all in a single deployable application. Its architecture supports both monolithic mode (as low as 256 MB RAM) and a microservices mode using Apache Kafka, Redis/Valkey, and ZooKeeper for horizontal scaling.

Grafana, by contrast, is a pure visualization and observability platform written in Go and TypeScript. It stores nothing except its own configuration — no telemetry, no device metadata, no time-series data. Instead, it connects to 80+ external data sources (InfluxDB, Prometheus, PostgreSQL, TimescaleDB, Elasticsearch, and many more) through a plugin architecture. Grafana earned Gartner's 2025 Magic Quadrant Leader position for Observability Platforms and serves 25 million+ users globally. Its philosophy is vendor-neutral data unification: visualize anything from anywhere.

The architectural implication is stark. ThingsBoard is a single platform that replaces an entire IoT stack. Grafana is one layer — the visualization layer — that requires you to assemble the rest: an MQTT broker, a time-series database, a data pipeline (Telegraf or Node-RED), and a separate device management system. For an IoT project, ThingsBoard gets you from sensor to dashboard with one tool. Grafana gets you the best dashboards in the industry, but you build everything else yourself.

For teams that want ThingsBoard's full power without operating the infrastructure, a managed ThingsBoard hosting service like thingshost eliminates the operational burden entirely — dedicated instance, fully managed, hosted in Germany.

Dashboard Building and Visualization Compared Side by Side

Both platforms offer drag-and-drop dashboard builders, but the experience and capabilities differ significantly.

ThingsBoard provides 20+ widget categories with 600+ customizable widgets specifically designed for IoT: analog and digital gauges, SCADA HMI symbols (added in v3.8), control widgets for sending RPC commands to devices, alarm tables, GPS tracking maps with geofencing, and environmental monitoring displays. Dashboards update in real time via WebSockets. The builder uses a grid layout with support for multiple dashboard states (multi-page navigation within a single dashboard) and responsive layouts for desktop, tablet, and mobile. Custom widgets can be developed using HTML, CSS, and JavaScript with a JSON Schema-based settings editor. The learning curve is moderate to steep — basic dashboards come together quickly, but advanced customization involving custom widgets, complex entity aliases, and SCADA layouts requires significant ThingsBoard-specific knowledge.

Grafana offers fewer built-in panel types — roughly 20 core visualizations including time series, stat, gauge, bar chart, heatmap, geomap, histogram, candlestick, state timeline, and the completely rebuilt logs panel (v12.3, November 2025). But each visualization is polished to near-perfection. Grafana's template variables system allows a single dashboard to dynamically switch between thousands of devices, locations, or time ranges. The transformations pipeline applies client-side data operations (merge, filter, calculate, group by) that enable complex analytics without modifying queries. Grafana 12 introduced dynamic dashboards with tabs and conditional logic, Git Sync for version-controlled dashboard-as-code, and SQL Expressions to combine data from any source. Custom panel plugins are built with React and Go via the Grafana plugin SDK. The learning curve centers on mastering query languages (PromQL, Flux, SQL) rather than platform-specific concepts.

The trade-off is clear: ThingsBoard gives you IoT-specific widgets out of the box (device control buttons, SCADA symbols, fleet tracking maps), while Grafana gives you superior general-purpose visualization with unmatched data source flexibility. For customer-facing IoT dashboards where non-technical users interact with devices, ThingsBoard wins. For engineering teams running advanced analytics across multiple data sources, Grafana wins.

Data Ingestion and Storage: Built-in Versus Bring-Your-Own

ThingsBoard includes its own built-in time-series database with three deployment options. Pure PostgreSQL handles up to 20,000 data points per second and suits smaller deployments. PostgreSQL plus TimescaleDB improves time-series query performance using hypertable partitioning. The hybrid configuration pairing PostgreSQL (for entities and attributes) with Apache Cassandra (for telemetry) scales to 1 million data points per second — suitable for large enterprise deployments. Version 4.1 added Cassandra 5.0 support. The v4.0 Entity Data Query Service (EDQS) introduced an in-memory engine delivering dashboard queries in under 10 milliseconds, dramatically reducing database load.

Grafana stores no data. Its power lies in querying external stores through its plugin ecosystem. For IoT, the most relevant data sources are:

• InfluxDB — the most common pairing for IoT time-series data, with native Grafana support for both InfluxQL and Flux queries
• TimescaleDB — accessed via the PostgreSQL data source plugin, popular with teams already running PostgreSQL
• Prometheus/Mimir — Grafana Mimir has been tested to 1 billion active time series, making it viable for massive IoT metric aggregation
• MQTT plugin — an official Grafana Labs plugin that streams live MQTT data via WebSockets, but critically stores nothing and cannot query historical data
• Elasticsearch, ClickHouse, QuestDB — various options for specialized analytics

For most IoT deployments using Grafana, the standard pipeline is: devices → MQTT broker → Telegraf → InfluxDB → Grafana. InfluxDB 3.0, which reached GA in April 2025, was completely rewritten in Rust on the Apache Arrow/Parquet stack, delivering 100x faster queries than v2 with native SQL support. This makes the Grafana + InfluxDB 3.0 combination increasingly competitive for IoT time-series workloads.

Device Management: ThingsBoard's Core Advantage

This is the most decisive differentiator. ThingsBoard provides complete device lifecycle management; Grafana provides none.

ThingsBoard handles device provisioning (manual, auto-provisioning via provision keys, bulk CSV import), credential management (access tokens, X.509 certificates, MQTT basic auth), and device profiles that define transport configuration, alarm rules, and default rule chains per device type. Three attribute scopes — client (device-reported), server (platform-set), and shared (pushed to device) — enable rich bidirectional metadata exchange. Server-side and client-side RPC allow sending commands to devices and receiving responses. OTA firmware updates include package management with checksum verification and delivery tracking. Version 4.2 added version control for OTA packages.

The entity model extends beyond devices: assets represent logical entities (buildings, floors, zones), entity relations define hierarchies, and entity views expose subsets of device data to specific users. This entire device management layer — provisioning, credentials, attributes, RPC, OTA, asset hierarchies — simply does not exist in Grafana. Any Grafana-based IoT deployment must build or integrate these capabilities externally.

With a managed ThingsBoard instance from thingshost, you get this full device management stack without operating the underlying infrastructure — including database backups, security patches, and 24/7 monitoring.

Rule Engines and Alerting: Structured IoT Automation Versus Metric-Based Alerts

ThingsBoard's rule engine is built on an actor-based model with 50+ built-in rule node types organized into categories: filter, enrichment, transformation, action, external integration, and flow control. Rule chains are configured visually — drag nodes onto a canvas, connect them with success/failure paths, and define processing logic using TBEL (ThingsBoard Expression Language) or JavaScript. Common IoT workflows include threshold-based alarms, device inactivity detection (built into device profiles), telemetry aggregation across related entities, data enrichment from parent assets, and forwarding to external systems via REST, MQTT, Kafka, or cloud services (AWS SNS/SQS, Azure IoT Hub, GCP Pub/Sub).

Version 4.0 introduced Calculated Fields for server-side derived values, reducing the need for rule chains in simple math operations. Version 4.2 added the AI Request Rule Node with native LLM integration (OpenAI, Azure OpenAI, Ollama, Google Gemini, GitHub Models) for AI-powered anomaly detection and intelligent alarm generation. Version 4.3 brought Alarm Rules 2.0 with a more flexible alarming model.

Grafana's Unified Alerting system (default since v9) handles threshold alerts and No Data detection competently. Alert rules can query any backend data source, combine multiple queries with math expressions, and route notifications through contact points (email, Slack, PagerDuty, webhooks, Telegram, and more) via a notification policy routing tree. For IoT, Grafana can detect device inactivity through No Data alerts and set static thresholds on any metric.

However, Grafana alerting has significant IoT limitations. It has no concept of "device" as a first-class entity — alerts are metric/query-based. There are no rule chains for complex workflows (e.g., "if temperature high AND humidity low, send command to actuator"). No bidirectional device control from alerts. No sophisticated alarm lifecycle management (acknowledge, escalate, reassign). Managing thousands of per-device alert rules becomes unwieldy. Dynamic per-device thresholds require extensive workarounds. For IoT-specific automation, ThingsBoard's rule engine is categorically more capable.

LoRaWAN Integration with ChirpStack and The Things Stack

For companies building on LoRaWAN with ChirpStack, the integration story differs substantially between the two platforms.

ThingsBoard PE offers a native ChirpStack integration type in its Integrations Center. Configuration involves creating an HTTP integration in ChirpStack pointing to a ThingsBoard-generated endpoint URL. Uplink and downlink converters (TBEL or JavaScript) handle payload transformation. Devices are auto-created on first uplink based on DevEUI. ThingsBoard v4.0+ includes a built-in converter library with 100+ device decoders supporting six LoRaWAN network servers including ChirpStack. The PE integration also supports downlink messages via the Integration Downlink rule node. Similarly, The Things Stack Community and Industries editions have native MQTT-based integrations in ThingsBoard PE.

ThingsBoard CE lacks the Platform Integrations feature entirely, but two workarounds exist. ChirpStack's own built-in ThingsBoard integration can send data via ThingsBoard's HTTP API using per-device access tokens stored as ChirpStack device variables. Alternatively, the ThingsBoard IoT Gateway can bridge ChirpStack MQTT topics to ThingsBoard CE.

Grafana has no native LoRaWAN integration capability. The standard approach uses ChirpStack's native InfluxDB integration, which writes decoded device payloads directly to InfluxDB with measurements like device_frmpayload_data_<field_name> plus metadata tags (device EUI, application name, RSSI, SNR). Grafana then queries InfluxDB using Flux or InfluxQL. An alternative path runs ChirpStack MQTT → Telegraf mqtt_consumer plugin → InfluxDB → Grafana, which offers more control over data transformation.

Multi-Tenancy and White-Labeling for Service Providers

ThingsBoard was architected for multi-tenancy from the ground up. The hierarchy runs System Administrator → Tenant Administrator → Customer → Customer User, with each level having isolated data and permissions. PE extends this with nested customer hierarchies (sub-customers), advanced RBAC with custom granular roles, and entity groups for batch operations. White-labeling in PE is configurable at system, tenant, and customer levels — custom logos, color schemes, favicons, login pages, domains, and translations — without coding or server restarts. This makes ThingsBoard PE the natural choice for managed service providers (MSPs) who need to brand the platform differently for each client, manage multi-level customer hierarchies, and maintain strict data isolation.

Grafana offers organizations and teams with basic Admin/Editor/Viewer roles in the OSS version. Enterprise/Cloud adds RBAC with granular permissions, LBAC (Label-Based Access Control) for data isolation, SCIM for user sync, and multi-stack isolation on Grafana Cloud. White-labeling is Enterprise-only via grafana.ini configuration — covering app title, login page branding, logos, and footer links, but with less flexibility than ThingsBoard PE's multi-level approach. For IoT MSPs specifically, Grafana lacks the tenant-customer-device hierarchy, customer onboarding workflows, and per-customer branding inheritance that ThingsBoard provides natively.

Pricing Breakdown for 2025–2026

ThingsBoard Community Edition is free under Apache 2.0 with no device limits — including device management, rule engine, dashboards, multi-tenancy, clustering, and OTA updates. The key exclusions are white-labeling, advanced RBAC, platform integrations (ChirpStack, TTN), entity groups, scheduler, reporting, and analytics rule nodes.

ThingsBoard PE self-managed ranges from $10/month (Maker: 10 devices) through $99/month (Pilot: 100 devices, most popular) to $499/month (Business: 1,000 devices at $0.10 per additional device). All plans include unlimited customers, dashboards, integrations, API calls, and data points. ThingsBoard Cloud ranges from free (5 devices, 1M data points/month) through $149/month (Pilot: 100 devices, 100M data points) to $749/month (Business: 1,000 devices). Private Cloud starts at $1,349/month (Launch: 5,000 devices) with Enterprise pricing available on request for 100,000+ devices.

Grafana OSS is free under AGPL v3, which requires releasing modifications if you provide Grafana as a network service. Grafana Cloud offers a generous free tier (10K metric series, 50GB logs, 3 users, 14-day retention). The Pro tier starts at $19/month plus usage-based billing — metrics cost $8 per 1,000 active series (standard) or $16 per 1,000 (high-resolution/15s). For IoT scale: 1,000 devices sending 10 metrics at 15-second intervals would cost roughly $160/month for metrics alone on Grafana Cloud, scaling to approximately $16,000/month for 100,000 devices — excluding the underlying time-series database costs if self-hosted. Grafana Enterprise (self-hosted) starts at approximately $25,000/year minimum commitment.

The total cost comparison depends heavily on architecture. ThingsBoard bundles storage and device management into one price. A Grafana-based IoT stack requires separately pricing the MQTT broker, time-series database (InfluxDB, TimescaleDB), any device management system, and Grafana itself. With the thingshost flat rate for ThingsBoard hosting, managed ThingsBoard hosting starts from €149.90/month as a flat rate — no per-device fees, no infrastructure management, GDPR-compliant hosting in Germany.

Scaling for Large IoT Deployments

ThingsBoard scales through its microservices architecture: separate services for transport (MQTT, HTTP, CoAP, LwM2M), rule engine, core, web UI, and JS executors, communicating via Kafka. Entity-based partitioning distributes load using consistent hashing of entity IDs. Official benchmarks cite a single-node deployment handling 300,000 devices at 10,000 messages/second for approximately $100/month in infrastructure. Medium deployments (1M devices) use the PostgreSQL + Cassandra hybrid with estimated infrastructure costs of $1,770/month. Large deployments (1M+ devices) require 15+ TB storage nodes and dedicated Kafka clusters at approximately $13,790/month. Kubernetes deployment is supported with official Helm charts.

Grafana itself is lightweight as a query/visualization layer and scales horizontally behind load balancers. The real scaling challenge is the underlying data store. Grafana Mimir, designed for Prometheus-compatible metrics, has been tested to 1 billion active time series. Mimir 3.0 (late 2025) introduced a decoupled read/write architecture reducing peak memory by up to 92%. For IoT specifically, InfluxDB 3.0's Rust-based columnar engine handles millions of data points per second ingestion. TimescaleDB leverages PostgreSQL's mature scaling capabilities with time-based partitioning. The Grafana + InfluxDB/TimescaleDB stack can match ThingsBoard's throughput for pure telemetry storage, but scaling device management, rule processing, and alarm handling must be addressed separately.

Using ThingsBoard and Grafana Together

The most sophisticated IoT deployments use both platforms with a clear separation of responsibilities. ThingsBoard handles device management, data collection, rule processing, customer-facing dashboards, and alarms. Grafana handles operations monitoring, cross-system analytics, and engineering dashboards.

The most common integration patterns are:

• ThingsBoard → PostgreSQL/TimescaleDB → Grafana: Grafana connects directly to ThingsBoard's database using a read-only PostgreSQL user, querying the same telemetry data for advanced analytics without data duplication
• ThingsBoard → Kafka → InfluxDB → Grafana: In microservices deployments, Kafka topics are consumed by Telegraf or custom consumers writing to a dedicated InfluxDB instance that Grafana queries
• ThingsBoard → MQTT rule node → Telegraf → InfluxDB → Grafana: The rule engine forwards processed data via MQTT for independent storage and visualization
• ThingsBoard Prometheus metrics → Grafana: ThingsBoard exposes actuator/prometheus metrics, and its Edge cluster deployment includes built-in Grafana + Prometheus monitoring — Grafana monitors the health of the ThingsBoard infrastructure itself

Which Verticals Favor Which Platform

Smart city and fleet tracking favor ThingsBoard strongly — built-in geofencing, map widgets, device provisioning at scale, and multi-tenant customer management align directly with municipal and logistics requirements. Schwarz Group (Lidl/Kaufland) runs ThingsBoard PE across 13,000+ retail stores.

Energy monitoring sees both platforms used extensively. ThingsBoard offers dedicated smart metering solution templates. Grafana's time-series visualization excellence makes it natural for energy dashboards — Flexcity, Energinet, Utilita, and SYSO are documented Grafana energy success stories.

Industrial IoT splits based on needs. ThingsBoard provides SCADA capabilities (v3.8+), OPC-UA via its IoT Gateway, and Modbus integration. Grafana is widely used as the visualization layer in industrial settings atop Prometheus or InfluxDB, particularly when IT/OT convergence requires monitoring both factory equipment and IT infrastructure in one view.

Agriculture favors ThingsBoard for commercial deployments (device management critical for remote LoRaWAN sensors in fields), while Grafana serves hobbyist and research weather station projects well.

How Node-RED and InfluxDB Complete the Architecture

Node-RED serves as versatile middleware in both ThingsBoard and Grafana architectures. Between ChirpStack and ThingsBoard CE, it subscribes to ChirpStack MQTT topics, transforms payloads, and publishes to ThingsBoard's MQTT API. In the MING stack (Mosquitto, InfluxDB, Node-RED, Grafana), Node-RED handles all data routing and transformation. Compared to ThingsBoard's rule engine, Node-RED offers a lower learning curve, 5,000+ community nodes for protocol support (Modbus, OPC-UA, BACnet, serial), and greater flexibility for custom integrations. ThingsBoard's rule engine offers tighter platform integration, tenant-aware processing, and horizontal scalability. Many deployments use both: Node-RED for edge protocol bridging and ThingsBoard's rule engine for centralized IoT logic.

InfluxDB is the most common time-series database in Grafana-based IoT stacks. ChirpStack has a native InfluxDB integration. Telegraf's 300+ input plugins (including mqtt_consumer) provide universal data collection. InfluxDB 3.0's architecture makes it increasingly viable as a high-performance alternative to ThingsBoard's built-in storage, though it requires separate device management.

Recent Developments Reshaping the Landscape (2024–2026)

ThingsBoard's trajectory from v3.7 (June 2024) through v4.3.1 (March 2026, current LTS) has been transformative. Version 4.0 introduced Calculated Fields and EDQS for sub-10ms dashboard queries. Version 4.2 added the AI Request Rule Node for native LLM integration directly in rule chains — enabling AI-powered anomaly detection and intelligent alarm generation using OpenAI, Ollama, or Google Gemini. Version 4.3 brought Alarm Rules 2.0. The platform also launched ThingsBoard MCP 2.0 (November 2025) for natural language interaction via Claude Desktop or other LLM tools.

Grafana's evolution through v12.3 (November 2025, latest) focused on platform maturity. Version 12 brought the App Platform with versioned APIs, Git Sync for dashboard-as-code, SQL Expressions, dynamic dashboards with tabs and conditional logic, and blazing-fast geomap rendering. The Grafana Assistant — an agentic LLM embedded in Grafana Cloud — enables natural language querying of observability data, AI-assisted dashboard creation, and multi-step incident investigation. It saw 10x user growth within 90 days of launch. Grafana ML provides forecasting and anomaly detection for Cloud users.

Both platforms are converging on AI capabilities, but from different directions: ThingsBoard integrates AI into IoT-specific rule processing (analyze telemetry, generate alarms), while Grafana applies AI to observability workflows (explore data, build dashboards, investigate incidents).

Conclusion: A Framework for Choosing

The decision reduces to three scenarios. Choose ThingsBoard alone when you need a complete IoT platform with device management, multi-tenancy, customer-facing dashboards, and integrated data processing — typical for MSPs, smart city deployments, fleet tracking, and commercial agriculture. The Community Edition is remarkably capable for free; PE adds white-labeling, LoRaWAN integrations, and advanced RBAC starting at $99/month for 100 devices. For teams that prefer managed infrastructure, thingshost provides dedicated ThingsBoard instances starting from €149.90/month — GDPR-compliant, hosted in Germany, with 24/7 monitoring and support.

Choose Grafana alone when you already have device management handled externally, need best-in-class visualization across multiple data sources, or are extending an existing IT monitoring stack into IoT territory. This path requires assembling a full data pipeline (MQTT broker + Telegraf + InfluxDB/TimescaleDB) but rewards you with unmatched analytical flexibility.

Choose both together — and this is the pattern used by experienced IoT teams — when you want ThingsBoard's device management and rule engine handling the operational IoT layer while Grafana provides advanced analytics, infrastructure monitoring, and engineering dashboards on the same data. The integration is straightforward via shared PostgreSQL/TimescaleDB databases or Kafka-based data streaming. This combined architecture delivers the best of both worlds: a purpose-built IoT platform for operations and the industry's best visualization tool for analytics.

Sources

1. ThingsBoard — Dashboards Documentation — Widget categories, dashboard features
2. ThingsBoard — Architecture Reference — System architecture, data storage options
3. ThingsBoard — Rule Engine Overview — Rule node types, visual configuration
4. ThingsBoard — Deployment Scenarios & Benchmarks — Scaling data, infrastructure costs
5. ThingsBoard — Pricing — CE/PE/Cloud pricing models
6. ThingsBoard — v4.0 Release Blog — EDQS, Calculated Fields, Maps
7. ThingsBoard — v4.2 Release Blog — AI Rule Node, Reporting 2.0
8. ThingsBoard PE — ChirpStack Integration — LoRaWAN integration setup
9. ThingsBoard GitHub Repository — Source code, community stats
10. Grafana 12 Release Blog — v12 features, Git Sync, SQL Expressions
11. Grafana — Pricing — Free/Pro/Enterprise pricing
12. Grafana MQTT Datasource (GitHub) — MQTT plugin capabilities
13. ChirpStack — ThingsBoard Integration Guide — ChirpStack v4 → ThingsBoard
14. InfluxData — InfluxDB 3.0 GA Announcement — InfluxDB 3.0 performance data