Cellular connectivity is the cost that scales with success. Every new sensor adds a SIM, a monthly fee, and a stream of bytes you pay for twice: once in airtime, and once in the engineering time spent watching overage alerts.

The good news is that most of those bytes are boring. A temperature that hasn't moved. A battery voltage reported to two decimal places every thirty seconds. A JSON payload whose field names are longer than the values inside them. Move the decisions to the device and a surprising amount of that traffic simply stops existing.

Start With a Data Budget, Not a Guess

Before you change a line of firmware, capture what one device actually sends in a normal day. Point it at a test broker, or log bytes at the modem, and total it up. Then add the traffic your application logs never show: TLS handshakes, MQTT keepalives, DNS lookups, TCP retransmissions on weak signal, failed publishes that get retried, and the occasional firmware check.

A 200-byte payload every thirty seconds is already roughly half a megabyte a day before any of that overhead. Multiply by a few hundred units and the monthly figure gets uncomfortable quickly. Hardware and plan details vary, so verify against your own logs rather than this arithmetic — but the order of magnitude is the point. Write the number down. Every change from here gets measured against it.

Filter at the Source With a Deadband

The simplest and most effective cut is to stop publishing values that carry no information. A deadband — sometimes called change-of-value reporting — holds readings until the measurement has moved by a meaningful amount: half a degree, two percent of full scale, three ADC counts, whatever matches the sensor's real noise floor.

Pair the deadband with a heartbeat. If the value never moves, you still want proof the device is alive. One message every six or twelve hours is usually enough for a monitored asset, and it keeps the SIM registered.

Set the threshold from data, not taste. Collect a few days of raw readings from a representative site, plot them, and look at the noise band. Tighter than the sensor's own jitter produces constant traffic. Looser than the process variation you care about hides real events.

Publish on Events, Not Schedules

Scheduled reporting is easy to build and expensive to run. Event-driven reporting flips the logic: the device decides locally whether anything worth transmitting has happened, and stays quiet when nothing has.

That decision can be simple or surprisingly capable. A pump monitor can run a small state machine across normal, warn, and alarm bands and transmit only on a transition, plus a daily digest. A vibration sensor can compute an RMS value in a window and send one number instead of thousands of samples. A cold-chain logger often needs nothing more than a threshold crossing and a periodic position report.

Keep the raw data, send the summary

The reasonable fear with edge filtering is losing evidence you need later. Keep a ring buffer of raw samples on the device — a few days' worth is cheap in flash — and add a command that backfills it on demand. Small bills in normal operation, full resolution when something goes wrong.

Batch, Compress, and Store for Later

If you do need a stream of readings, send them as one message rather than fifty. A single publish containing a minute of samples, or a compressed block covering an hour, costs far less than the same data split across individual messages, because connection and protocol overhead are paid once.

Batching trades latency for cost, so keep the alarm path separate. Alarms go out immediately on a short message; routine telemetry rides the batch.

Use store-and-forward for outages, but cap the queue by size and age, and compress it. An uncapped queue on a device sitting in a dead zone turns a coverage problem into a bill the day the signal returns.

Trim the Payload and the Protocol

Bytes are cheap to remove in firmware and expensive to remove after a fleet is deployed. Quick wins:

  • Use binary encoding such as CBOR or Protocol Buffers for telemetry instead of JSON. Field names disappear entirely.
  • Send values at the precision the sensor actually supports. Two decimal places on a battery voltage is decoration.
  • Drop redundant fields. Device identity belongs in the topic or header, not repeated in every payload.
  • Send deltas or indexes where data is monotonic, and timestamps as compact epoch values rather than formatted strings.
  • Keep topic names short. They are transmitted, not just typed.
  • Choose a sensible quality of service. Retrying every message forever on a marginal link generates more traffic than the message itself.
  • Reuse connections and enable TLS session resumption rather than reconnecting and renegotiating for each publish.

Tune the Radio, Then the Plan

Weak signal is a data cost. Retransmissions, failed attaches, and reconnects all burn airtime, and a device at the edge of coverage can spend more bytes on overhead than on payload. Antenna placement, enclosure, and mounting height often matter more than anything else in this article.

On low-power wide-area modules, power-saving features such as PSM and eDRX let the device sleep while staying reachable, which cuts both current draw and connection churn. Check which radio access technology your module actually selects — a fallback set to the wrong band wastes time and megabytes on every attempt.

Only then revisit the tariff. Match the plan to the traffic profile you have created: pooled data across a fleet, suspended lines for seasonal assets, or a private APN if you need fixed addressing. A well-filtered device on a modest plan beats a chatty one on a large plan you keep renegotiating.

A Practical Rollout

You do not need a redesign to start. Work through these in order:

  1. Measure a week of real per-device traffic, overhead included.
  2. Add a deadband and a heartbeat, and deploy to a pilot group first.
  3. Compare pilot traffic and data quality against the baseline before touching the fleet.
  4. Batch routine telemetry; keep alarms on a separate immediate path.
  5. Move telemetry to a compact encoding and cap the store-and-forward queue.
  6. Make thresholds remotely configurable so tuning never requires a site visit.
  7. Alert on per-device usage anomalies — a stuck retry loop or a misbehaving SIM shows up as a spike long before the invoice does.

Edge processing is not about sending less for its own sake. It is about deciding, where the data is created, which bytes are worth paying for. Do that well and cellular stops being the line item that grows faster than the fleet.

Photo: Giant Asparagus / Pexels