13 November 2026
The IoT backend in four bricks
A temperature sensor in a greenhouse does one small thing: it measures, and it sends a number. Everything that makes that number useful happens somewhere else. That somewhere is the IoT backend.
Take a greenhouse with a thousand sensors, each sending a reading every 30 seconds. That is about 33 messages per second, a load any laptop shrugs off. (This is plain arithmetic, not a benchmark.)
Now the power goes out for a minute. When it returns, all thousand sensors reconnect in the same second, and each one has readings waiting to be sent. The average load was 33 messages per second. The load that matters is the one in that second, and the grower is counting on the system to keep every reading, because a frost that happened during the outage is exactly what they need to know about.
An IoT backend is judged by its worst minute, not its average one. Four bricks, each with one job, are how you survive it.
1. The broker: receive from everyone, reliably
Devices do not call your servers. They connect to a message broker and publish messages on topics, such as
greenhouse/3/temperature. Whoever is interested subscribes. The choice is a broker in the middle, not every
device talking to every consumer.
The price: the broker is now the one place everything passes through. It has to accept a thousand connections at once, cut a byte stream into packets correctly, and refuse a broken device without falling over. This is where MQTT lives. Why MQTT?
2. Ingestion: turn messages into events
A message is bytes on a topic. Before you can trust it you must parse it, validate it, stamp it and drop duplicates. The result is an event: a small, immutable fact with a device, a time and a value. The choice is to validate at the door, not downstream.
The price: ingestion now has to be fast enough to absorb the reconnect burst, or acknowledge late and remember what it has not finished. What is an event?
3. The time-series database: remember in time order
Sensor data is written once, in time order, and read by time window ("the last hour", "per day for a month"). A time-series database is built for exactly that access pattern, not a plain table that treats the last second like any other row.
The price: you give up general-purpose flexibility, and you must prove it survives a crash in the middle of a write. Why not a plain table?
4. The gateway: push to the people watching
A dashboard should not poll every second. A gateway streams new events to browsers as they happen, with Server-Sent Events, not repeated requests. The price: it must cope with a browser that is slow or gone. From database to screen
What this series has not measured
The scenario is illustrative: a greenhouse of a thousand sensors is a design target, not a deployment. The course tests each brick against its own stage tests, and the reference solution passes them. It does not claim production capacity for a thousand real devices.
Why build them yourself
You can rent each brick. But the day a dashboard shows a wrong value, you will need to know which brick lied: the device, the broker, the parser, the database or the stream. Building each one once, small and tested, is the fastest way to learn where an IoT system can break.
The first brick is the broker. Stage 1 is free and runs on your own machine: accept a connection.