ThingsBoard alternatives in 2026: picking an IoT platform for a small industrial fleet

By the Synacl team. Originally published at synacl.com.

ThingsBoard is the platform most people find first when they search for an open-source IoT dashboard, and for good reason: it's mature, self-hostable and can do almost anything. It's also a lot of platform for a plant with forty meters and one electrician.

This guide compares the realistic alternatives for a small industrial fleet (tens to a few hundred devices, mostly Modbus, RS485 and simple sensors) on the things that actually decide the outcome: who hosts it, how devices get in, what the pricing model does as you grow, whether commercial use is allowed on the cheap tiers, and how much engineering you need on staff.

Prices below were checked in September 2026 against each vendor's public pricing page, and ThingsBoard's again on 8 October 2026 after its licence change. They change often, so treat them as the shape of the offer, not a quote. Synacl is our product, so the last section is ours to argue; the rest is written to be fair.

What ThingsBoard is good at, and where it gets heavy

ThingsBoard comes in two forms:

• Self-managed ThingsBoard. Since version 4.4 (September 2026) the old Community and Professional editions are one product under the Business Source License 1.1. Production use is free for commercial use up to 100 devices on one server (1,000 devices for non-commercial use), as long as the ThingsBoard branding stays visible and you use a free licence key. Beyond that, self-managed subscriptions run from $99 to $499 a month, and a perpetual licence starts at $4,999. Versions before 4.4 stay Apache 2.0, and each new release becomes Apache 2.0 four years after it ships.
• ThingsBoard Cloud is the hosted version. It's billed by plan, and each plan caps both devices and data points, where one data point is one telemetry value. The free tier covers 5 devices and 1 million data points a month. Paid tiers are Prototype ($49 a month, 50 devices, 10 million data points), Pilot ($149, 100 devices, 100 million), Startup ($399, 500 devices) and Business ($749, 1,000 devices), with extra devices at about $0.30 each.
• There's also ThingsBoard Edge, a local instance that runs on site and syncs with the cloud.

You get device management, a rule engine, a large widget library and a dashboard builder, and you pay in servers and attention.

Where ThingsBoard shines: you need a rule engine you can program in depth, you want to own the stack, or you're integrating a dozen protocols through the separate ThingsBoard IoT Gateway, a Python service you install on an edge box.

Where it gets heavy:

• The gateway is a second product to deploy and keep alive.
• Modbus devices are configured in the gateway's connector config rather than in the platform.
• Self-hosting at scale means PostgreSQL or Cassandra plus Kafka.
• On Cloud, the data-point caps punish sensors that report often: 50 devices reporting four values every 10 seconds come to about 52 million data points a month, five times the Prototype allowance.

If your team has a developer who enjoys this, ThingsBoard is a fine choice. If your team is an installer with a laptop, it's a project.

For the two side by side, feature by feature, see ThingsBoard vs Synacl.

The hosted alternatives, one by one

ThingSpeak

ThingSpeak is MathWorks' IoT analytics service, and it comes up in almost every "ThingsBoard vs ThingSpeak" search. Its strength is MATLAB: you can run MATLAB analysis and visualisations on channel data without leaving the browser.

The free tier allows about 3 million messages a year, 4 channels and one update every 15 seconds, and it's for non-commercial use only. Paid licences are sold per unit of messages per year and priced by country rather than published. The device side is your own firmware posting over HTTP or MQTT.

Best for: research, teaching and data analysis projects, especially if you already use MATLAB. It isn't built for fleet operations, alerting or multi-user access.

Blynk

Blynk grew up as the app builder for makers and has moved towards businesses. Its strength is the phone app: drag a few widgets, connect an ESP32 with the Blynk library, and you're done.

The free plan covers 5 devices for exploration. Paid plans start at Starter ($29 a month for 10 devices), then Prototype ($99 for 50) and Production tiers from $199 for 100 devices. Modbus and RS485 aren't first-class: you write the firmware that reads the bus and publishes values.

Best for: a product team building a consumer or light-commercial device that ships with its own firmware and needs a branded mobile app.

Datacake

Datacake is a low-code platform with unusually good LoRaWAN support. The first 5 devices are free, and paid plans are bundles priced in euros: Hobby is €25 a month for up to 25 devices, and the next step, Light, is €159 a month for 50.

Device data is decoded with JavaScript payload decoders you maintain per device type. Modbus reaches Datacake through third-party RS485-to-LoRaWAN converters.

Best for: LoRaWAN sensor fleets, and anyone whose devices already speak MQTT or HTTP with a payload they can decode in a few lines.

Ubidots

Ubidots offers polished dashboards, an events engine and white-label options on higher tiers. The free STEM plan covers 3 devices for non-commercial use. The Professional plan is $99 a month for 50 devices, plus about $2 per extra device, and the Industrial and Enterprise tiers are priced on request.

As with Blynk and Datacake, the device side is your problem: Ubidots ingests MQTT and HTTP, and Modbus comes in through a third-party gateway.

Best for: teams that want a clean, presentable dashboard product on top of devices they already control.

TagoIO

TagoIO is a developer-friendly platform with serverless "analysis" scripts, a dashboard builder and network integrations for LoRaWAN and similar radios. The free tier covers 5 devices. Starter is $49 a month for up to 100 devices with a monthly data allowance, and usage beyond it is pay-as-you-go. A dedicated or on-premise deployment is available at a much higher price.

Like most hosted platforms it expects devices, or a third-party gateway, to deliver data over HTTP or MQTT.

Best for: developers who want to script their own processing in JavaScript and don't mind usage-based billing.

Arduino Cloud

If your hardware is Arduino-branded, or ESP32 boards flashed with Arduino sketches, Arduino Cloud is the path of least resistance: the IDE, device provisioning and dashboards are one product. Read the licence terms carefully, though.

The free plan and the Maker plan ($72 a year for 25 "Things") are for personal use only. Commercial use starts at the Team plan, $1,000 a year for 100 Things. Industrial protocols, fleet operations and alerting are thin.

Best for: classrooms, prototypes and personal projects.

AWS IoT Core and Azure IoT Hub

These are building blocks, not platforms. You get a secure MQTT broker at any scale and pay per message and per connection minute. Then you assemble storage, dashboards, alerting, device provisioning and OTA from other services.

That assembly isn't stable, either. Google shut Cloud IoT Core down in 2023, and AWS has since retired IoT Analytics and IoT Events, so a stack built on those had to be rebuilt.

The hyperscalers are superb when you have a cloud team and unusual requirements, and expensive in engineering time when you don't.

Best for: software companies building their own IoT product on top.

Two other names come up in enterprise shortlists. Losant is now part of SUSE and prices by quote. Azure IoT Central is still available, despite a 2024 retirement notice that Microsoft withdrew. Both are aimed at larger deployments than this guide covers.

If you need to self-host

Self-hosting is the main reason people choose ThingsBoard in the first place. If it's a hard requirement (data residency, an air-gapped site, company policy), the realistic options are:

• Self-managed ThingsBoard. The most complete self-hostable platform, and the heaviest to run. Since 4.4 it is source-available rather than open source: free for commercial use up to 100 devices on one server.
• Thinger.io. Lighter, with open-source (MIT) client libraries and a hosted service priced per instance rather than per device: a free Maker tier with 2 devices, and paid instances from about €29 a month. Private on-premise instances are also offered.
• Node-RED + InfluxDB + Grafana + Mosquitto. The DIY stack. It's all free software and endlessly flexible, and Node-RED's Modbus nodes are excellent. The cost is ownership: backups, upgrades, TLS, user management, and the knowledge living in one person's head.

Be honest about whether self-hosting is a requirement or a preference. A preference usually evaporates the first time an upgrade breaks at 2 a.m. and the only person who understands the stack is on holiday.

Comparison at a glance

Platform Hosting Free tier Commercial use on the cheapest paid plan Pricing model Modbus / RS485 path ThingsBoard (self-managed) Self-hosted 100 devices on one server (1,000 non-commercial) Yes, within the free licence Free to 100 devices, then subscriptions from $99/month Separate IoT Gateway service ThingsBoard Cloud Hosted 5 devices, 1M data points/month Yes Plan caps devices + data points Same gateway, hosted platform ThingSpeak Hosted 3M messages/year, non-commercial Yes, on a Standard licence Per unit of messages/year, priced by country Your firmware Blynk Hosted 5 devices, exploration Yes Per plan by device count Your firmware Datacake Hosted 5 devices Yes Device bundles, in EUR Third-party LoRaWAN converters Ubidots Hosted 3 devices, non-commercial Yes Plan + per extra device Third-party gateway TagoIO Hosted 5 devices Yes Plan + pay-as-you-go data Third-party gateway Arduino Cloud Hosted 2 Things, personal No, only from the Team plan Per plan Your sketch Thinger.io Hosted or private 2 devices Yes Per instance size Plugins / third-party gateway Node-RED + Influx + Grafana Self-hosted Free software Yes Your time Node-RED Modbus nodes AWS IoT / Azure IoT Hub Cloud building blocks Small credits Yes Per message and connection minute Build it Synacl Hosted 5 devices Yes Per plan by device count Built-in ESP32 gateway, browser-flashed

How to choose in ten minutes

Answer five questions and most of the table disappears.

1. Do your devices already speak MQTT or HTTP with firmware you control? If they do, every hosted platform works and you're choosing on dashboards and price. If they're Modbus meters, RS485 probes or 4-20 mA transmitters on a PLC, you need a gateway, and the question becomes who provides and maintains it.
2. Is self-hosting a requirement or a preference? A requirement points at the self-hosting section above. A preference usually doesn't survive contact with the upgrade schedule.
3. How often do sensors report? Data-point and message caps are fine at one reading a minute and painful at one a second. Per-device pricing doesn't care.
4. Is this commercial? Several free and entry tiers (ThingSpeak, Ubidots STEM, Arduino Cloud up to Team) rule out commercial use. Check before you build a customer's install on one.
5. Who will run it day to day? If the answer is an electrician, an installer or a plant manager, the platform has to handle provisioning, firmware updates and diagnostics from a browser. Otherwise the work lands back on whoever set it up.

Moving off ThingsBoard

If you already run ThingsBoard and it's become more platform than you need, migration is less work than it looks, because the part worth keeping is small:

• Devices and register maps. Export them from the IoT Gateway's Modbus connector config: slave IDs, register addresses, function codes, scaling. This is the knowledge that took time to collect, and it transfers to any platform as-is.
• Rules. Most small-fleet rule chains are thresholds and offline alerts. Write them down as plain sentences ("alert if tank level < 20% for 5 minutes") and rebuild them, rather than trying to translate rule-chain JSON.
• Dashboards. These don't move between platforms. Rebuild the few that people actually open, and skip the rest.
• History. Export telemetry you need for compliance or reports to CSV before you switch off. Few platforms import another's time-series history, so plan on keeping the export as an archive.

Run the two systems side by side for a week on a handful of devices before you move the rest. Double-reading is harmless if both platforms read the bus, but not if one of them writes.

Where Synacl fits, and where it doesn't

Synacl was built for the case the table leaves half-served: industrial-ish hardware, a small fleet, and no software team. The gateway is part of the platform, not a separate product. It's an ESP32 you flash from the browser, provision over USB, and update over the air with its settings kept.

Modbus RTU and RS485 devices are configured in the platform, register by register, with scaling and units on each tag. Common meters and sensors start from a device catalog with the register map already filled in, and on paid plans a fleet of identical meters can be added in one go with auto-numbered names and Modbus IDs. GPIO, I²C, 1-Wire, SPI, UART and CAN devices hang off the same gateway, and devices that already speak MQTT or HTTPS connect directly without one.

On top of the devices you get:

• live dashboards with SCADA-style widgets and P&ID mimics
• threshold and event rules with email, webhook and MQTT actions
• gateway-local macros that keep running when the internet doesn't
• uptime history with probe and heartbeat monitors
• a white-label portal for installers who run fleets for several customers
• an MCP connection, so an AI assistant can set up devices and dashboards on your behalf

The free browser tools (a Modbus RTU tester, a CRC calculator, a register decoder, a slave simulator and a serial monitor) need no account at all.

Pricing is per plan by device count, with no per-message or per-data-point billing. The first five devices are free, commercial use included, and the paid tiers are on the pricing page. It's a host