IoT & device telemetry

The problem

IoT is a volume problem. Thousands of devices each send small payloads at regular intervals. JSON encoding wastes bandwidth on those payloads. A sensor reading of a few bytes in binary can become many times larger in JSON. At scale, that difference is a bandwidth cost and a parse overhead on each edge node.

Connection-based prices do not work for IoT. A fleet of 5,000 open sensor connections must not cost the same as 5,000 active users who send messages. Most platforms bill you the same way.

Sensors can spike, for example in a fleet event, a weather anomaly, or a coordinated trigger. Then the ingress volume can hit your database before your workers are ready to process it.

How Celeris solves it

With a binary-first transport, you control the encoding of each sensor payload. Compact binary and plain JSON both work. MessagePack encodes a {deviceId, reading, ts} struct in a fraction of the bytes that JSON requires. Less bandwidth per device makes the economics of a large fleet work.

Metered billing follows your usage. You pay for the messages you send and the minutes your devices stay connected, not for a peak connection tier. A sensor that sends one reading per minute does not have the same price as a user in an active chat.

BYOD data export, available soon, will let sensor data flow directly to your Kafka cluster, RabbitMQ queue, or S3 bucket. The export is write-only and occurs after acceptance, and it does not touch your primary database. A fleet event that spikes the ingress volume does not touch your database. Your workers consume from your queue at their own speed.

Connect a device

const client = createClient({ credentialProvider });
const channel = client.channel(`fleet-${region}`);

const device = channel.segment(`device-${deviceId}`);
device.onMessage((payload) => {
  handleCommand(readJson(payload)); // downstream commands
});
device.subscribe();

await channel.connect();

// Publish a sensor reading on a timer
setInterval(async () => {
  await device.publish({
    payload: jsonPayload({ deviceId, temp: sensor.read(), ts: Date.now() }),
  });
}, 60_000);

Relevant features

• Binary-first messaging: smaller payloads, less bandwidth, and less parse overhead per device
• BYOD data export (coming soon): telemetry flows to your own infrastructure, and your database stays off the spike path
• Metered billing: you pay for messages and connection minutes, not for a peak connection tier
• Channels and segments: one segment per device for command-and-control patterns