DEV Community

Cover image for 20 ESP32s Burn ThingsBoard's Free Tier in 28 Hours. Here's What Hosting Actually Costs
Mounir
Mounir

Posted on

20 ESP32s Burn ThingsBoard's Free Tier in 28 Hours. Here's What Hosting Actually Costs

Disclosure: This post contains affiliate links (ThingsBoard and RackNerd), meaning I may earn a commission at no extra cost to you. I also co-founded AskSensors, included below as a managed alternative. Prices verified Nov 17, 2026.

ThingsBoard 4.4 merged its Community and Professional editions under a source-available license (BUSL 1.1) on September 29. Since then, I wanted to check what a modest ESP32 fleet actually costs on Managed Cloud compared to running it on your own box, or skipping ThingsBoard altogether.

Take a normal setup: 20 ESP32 boards, 5 sensor readings each, sending one MQTT payload every 10 seconds.

On ThingsBoard Cloud's Free plan, that setup burns through the monthly quota in about 28 hours. You don't even make it through the weekend. Past that, your real 24-month bill depends mostly on how much Linux maintenance you feel like doing:

  • ThingsBoard Cloud lands at $69 to $79/month with top-up packs ($1,656 to $1,896 over two years), not automatically $149/month like a lot of guides assume.
  • An 8 GB KVM VPS costs $240 to $878 over two years, as long as you are fine updating Docker and PostgreSQL yourself.
  • A flat-rate managed alternative (AskSensors PRO) works out to $380 to $456 over two years, with no server to manage if you don't need ThingsBoard's Rule Engine.

Quick verdict

  • Go with ThingsBoard Cloud if you want their Rule Engine without touching Linux, Java, or database backups. Even better if your sensors can report every 30 seconds instead of 10, which drops the bill to $49/month.
  • Grab an 8 GB RackNerd KVM VPS if you need 10-second updates, want a full year of raw telemetry on your own disk for around $10/month (on annual promos), and don't mind spending time in a terminal.
  • Try AskSensors PRO if you just need dashboards, alerts, and 24-month retention for 20 to 25 devices at $15.83 to $19/month, without maintaining a server or counting data points.

Why 20 ESP32s burn the free tier in 28 hours

On ThingsBoard Cloud, you aren't just billed per MQTT message. Every numeric key inside your payload counts as one billable data point. With 20 boards sending temperature, humidity, battery voltage, RSSI, and uptime every 10 seconds over a 30-day month:

  • Messages: 20 x (2,592,000 / 10) = 5.184 million / month
  • Data points: 5.184M x 5 = 25.92 million / month (10 points per second)

Here is how each ThingsBoard Cloud tier handles that load:

Cloud Plan Base Limits At 25.92M points/mo Monthly Bill
Free 5 devices, 1M points Over device cap; 1M points gone in ~27.8h $0 (unusable)
Prototype 50 devices, 5M msg, 10M points Hits 10M cap on Day 12 unless topped up $69/mo (4 Traffic Packs, 30d TTL)
Prototype (60d default TTL) 1B storage point-days included 25.92M x 60d = 1.555B point-days $79/mo (4 Traffic + 1 Storage Pack)
Pilot 100 devices, 50M msg, 100M points Fits out of the box (needed above 50 devices) $149/mo

You don't actually have to jump straight from $49 Prototype to $149 Pilot. Prototype lets you buy $5 Traffic Packs (+2.5M messages and +5M data points each). Four packs add $20/month, cover the load, and put you at $69/month.

Watch the default retention setting, though. Prototype keeps raw telemetry for 60 days out of the box. At 10 points per second, that adds up to 1.555 billion point-days, which crosses the 1B included limit and triggers an extra $10 Storage Pack. Trim your rule chain down to 30 days right away, or you end up paying $79/month without noticing why.

24-month math: Cloud vs. RackNerd 8 GB KVM

Under ThingsBoard 4.4's Free License (BUSL 1.1), commercial self-hosting costs $0 up to 100 devices on one production server, provided you leave ThingsBoard branding visible.

For hardware sizing, ThingsBoard's PostgreSQL estimate (~14 MB per point-per-second per day) comes out to roughly 51 GB per year just for raw telemetry at 10 points/sec. Add Java 25, PostgreSQL, and Docker containers, and an 8 GB RAM / 150+ GB SSD server gives you comfortable headroom.

Looking at RackNerd, there are two realistic ways to rent 8 GB KVM:

  1. Annual 8 GB KVM special: around $119.99/year (~$10.00/mo), locked recurring rate, 150 GB SSD.
  2. Standard monthly 8 GB KVM: $36.59/month, 6 vCPU, 220 GB RAID-10 SSD, no annual lock-in.
Timeframe Cloud Prototype ($69/mo, 30d TTL) Cloud Pilot ($149/mo, >50 dev) RackNerd 8 GB (Annual ~$10/mo) RackNerd 8 GB (Monthly $36.59/mo)
12 Months $828 $1,788 $120 $439
24 Months $1,656 $3,576 $240 $878
Year 3+ Rate $69/mo $149/mo $10/mo (locked) $36.59/mo

If you prepay the $119.99 annual VPS, you break even against $69/mo Cloud in Month 2 ($119.99 spent once vs. $138 cumulative Cloud). Pick the $36.59 monthly VPS instead and you are $32.41/mo cheaper from Month 1, with zero upfront commitment.

Your own time isn't free, of course. Saving $59/month (annual VPS vs. $69 Cloud) pays you $50/hour as long as server upkeep stays under roughly 70 minutes a month after initial setup. If you spend a Saturday night every other month debugging a broken Docker upgrade, that math stops looking quite so good.

The easiest fix before you buy anything

Before pulling out a card, ask yourself if your hallway thermometer really needs to phone home every 10 seconds.

Change your ESP32 send interval from 10 seconds to 30 seconds.

20 x 5 / 30 s = 8.64M points/month. That sits comfortably under Prototype's 10M limit and drops your Cloud bill from $69 or $79/month down to $49/month (the exact cutoff in a 30-day month is 26 seconds). For room temperature, humidity, or battery voltage, 30 seconds is plenty.

Where both options can bite you

On ThingsBoard Cloud:

  • Default 60-day retention: Leave the default TTL untouched and you pay an extra $10/month Storage Pack for history you might not care about.
  • 51-device cliff: Device #51 forces a jump to Pilot ($149/month), even if your boards barely send any data.
  • Hosting location: Telemetry lives on the vendor's AWS tenant rather than your own disk.

On RackNerd (Self-Hosted):

  • Unmanaged Linux: RackNerd gives you a bare VPS, not a one-click ThingsBoard dashboard. You install Docker, configure TLS with Caddy or Nginx, and handle OS, Java 25, and PostgreSQL updates yourself.
  • Backups are your problem: Provider snapshots aren't tested restores. Set up automated off-server pg_dump backups and database retention pruning, or telemetry will eventually fill your disk.
  • BUSL 1.1 limits: The free license covers 100 devices on one production server with ThingsBoard branding. Running a separate staging instance in production, white-labeling, or passing 100 devices requires a paid license.
  • Promo stock: Annual 8 GB specials (~$119.99/yr) depend on active stock. Outside promos, standard monthly 8 GB KVM pricing is $36.59/month.

A third option: skipping ThingsBoard altogether

Look, ThingsBoard is tough to beat if you actually need its Rule Engine, digital twins, or white-label customer portals. A lot of ESP32 projects just don't need any of that.

If you only want MQTT or HTTP ingestion, live graphs, email alerts, and CSV/JSON exports without paying $69 to $79/month or babysitting PostgreSQL on weekends, there is a simpler middle ground.

Full transparency here: I co-founded AskSensors. Because we charge per device instead of metering data points, 20 ESP32 boards pushing 5 readings every 10 seconds fit on our PRO plan (up to 25 devices):

  • AskSensors PRO (Monthly): $19/month ($228/year, $456 over 24 months)
  • AskSensors PRO (Annual): $190/year (~$15.83/month, $380 over 24 months)
  • Included: Unlimited data storage, 24 months of retention (versus 30 or 60 days on ThingsBoard Prototype), 1-second graph refresh, up to 25 custom dashboards and 300 shareable widgets, plus CSV/JSON export.
  • Past 50 devices: Where ThingsBoard Cloud jumps to $149/month at device #51, our GURU plan covers up to 60 devices with 30 months of retention for $29/month (or $290/year).

Here is how all five setups compare over 24 months:

24-Month Hosting Cost Comparison for 20 ESP32s at 10-Second Intervals

Option 12 Months 24 Months Operations Key Trade-off
ThingsBoard Cloud (30d TTL) $828 $1,656 Managed Expensive at 10s intervals; $149/mo above 50 devices
RackNerd 8 GB (Monthly) $439 $878 Unmanaged No lock-in, but you handle Linux, Docker & Postgres
AskSensors PRO (Monthly) $228 $456 Managed Simpler feature set (no TB Rule Engine or white-labeling)
AskSensors PRO (Annual) $190 $380 Managed 24-month retention included; 25-device cap (Guru is $290/yr for 60)
RackNerd 8 GB (Annual promo) $120 $240 Unmanaged Lowest raw cost, zero managed support

I am not going to pretend it replaces ThingsBoard's Rule Engine. If you need heavy server-side processing or want full control over the stack, self-hosting on a $119.99/year VPS is still the cheapest way to go. If you just want a managed dashboard for 20 to 60 ESP32s without paying $69 to $149/month, AskSensors works out to roughly 4x cheaper than ThingsBoard Cloud over two years.

Run your own numbers

I put the ThingsBoard Cloud vs. RackNerd math into a small static calculator (no signup, no tracking) where you can adjust device count, metrics, send interval, retention days, and both RackNerd plans:

How many devices are you running right now, and what send interval did you settle on? Drop your numbers in the comments and I will check which tier they land on.

(Links used in this comparison: ThingsBoard Cloud / 4.4 Free License, RackNerd 8 GB KVM VPS, and AskSensors Pricing.)

Top comments (0)