Edge vs Cloud IoT

The three tiers

What stays on the device

• Immediate control loops (motor control, safety interlocks).
• Sensor sampling and filtering.
• Local UI (button press, indicator light).
• Simple state machines (door open / closed, alarm armed / disarmed).
• Pre-buffering before transmit (queue 1 hour of readings, send periodically).

The constraint is the device's compute capacity. A microcontroller can do simple thresholding; a Raspberry Pi-class device can run ML inference; constrained sensor nodes can do just enough to sleep most of the time.

What stays at the gateway

• Aggregation across multiple devices (sum readings, compute averages).
• Local anomaly detection (warn before sending alerts upstream).
• Protocol translation (Modbus to MQTT, BLE to MQTT, LoRaWAN to HTTPS).
• Local storage during cloud outages (buffer and replay later).
• Local rules (if temperature spikes, alert maintenance immediately — don't wait for cloud).
• Video analytics that reduce a stream to events ("motion detected at door 3").

The gateway is what makes the deployment resilient to cloud outages. If everything depended on the cloud, every internet hiccup would be a service outage.

What stays in the cloud

• Cross-site analytics ("how does building A compare to building B?").
• Long-term storage and historical queries.
• Machine learning model training (devices run inference; cloud handles training).
• Dashboards and reporting.
• Integration with other systems (ERP, ticketing, billing).
• Software / firmware update orchestration.
• Fleet management — provisioning, configuration, monitoring.

Bandwidth: the strongest edge driver

Consider a security camera installation:

• Raw 1080p H.264 stream: ~4 Mbps per camera. 50 cameras = 200 Mbps continuous.
• Most uplinks can't sustain that. Cellular backhaul certainly can't.
• Edge processing detects motion, only uploads relevant clips: ~1% of raw data on average.
• Bandwidth bill drops 100x.

Similar math for vibration sensors, audio monitoring, LiDAR, and any workload where the raw stream is large but the events of interest are sparse.

Latency: the second driver

Cloud round-trip is 50-200 ms typically. For some IoT workloads that's fine; for others it's unacceptable:

• Industrial control loops: microseconds to milliseconds. Must be on-device.
• Safety interlocks: milliseconds. Must be on-device.
• Voice assistant wake-word detection: tens of milliseconds. On-device.
• Voice assistant intent classification: hundreds of milliseconds OK. Edge or cloud.
• Smart home automation: seconds. Cloud is fine.

Offline operation

"What happens when the internet is out?" is the question that distinguishes well-designed deployments. Examples:

• Factory floor: production lines must continue during ISP outages. Edge is essential.
• Retail point of sale: must complete transactions even if cloud is unreachable. Edge with later sync.
• Smart home: light switches must keep working when the broadband router reboots. Local control over Thread/Matter is the answer.
• Vehicle fleets: must function between cellular cells. Edge plus eventually-consistent cloud sync.

Privacy and data residency

Some data shouldn't leave the local network:

• Medical device data subject to HIPAA-like regulations.
• Industrial process data treated as trade secret.
• Camera footage with PII.
• Voice recordings.

Edge processing extracts what's needed (event detection, anonymized metadata) and discards or locally-archives the rest. The cloud sees only what's policy-approved.

The cost shape comparison

At high volume, edge wins on cost. At low volume or for bursty workloads, cloud wins. Hybrid combines the best of both — predictable cost on the steady portion, elastic cloud for spikes and analytics.

The standard architecture pattern

1. Devices sense, do local control, send compact summaries to gateway.
2. Gateway aggregates per-site, runs local rules and analytics, forwards to cloud.
3. Cloud stores history, runs fleet-wide analytics, ships data to dashboards and integrations.
4. Downstream commands flow the reverse direction — cloud to gateway to device.

Each tier does what only it can do. Devices have intimate access to sensors and actuators. Gateways aggregate locally and survive outages. Cloud sees the whole picture and never runs out of compute or storage.

Frequently Asked Questions

What is edge IoT?

Processing IoT data close to where it's generated — on the device itself or on a nearby gateway — rather than sending everything to the cloud. Edge processing reduces latency, bandwidth, and cloud cost, and enables operation even when cloud connectivity fails. It complements rather than replaces cloud — most production systems run both.

When should I process on the device vs at the edge gateway?

Process on the device when the function is simple, latency-critical, or must work without any external dependency (button press lights up an LED). Process at the gateway when the function needs more compute than the device has, when aggregating data from multiple devices, or when running shared logic across a local fleet (anomaly detection on a building's sensors).

What stays in the cloud?

Fleet-wide analytics, long-term storage, machine learning training, dashboards, alerting, integrations with other systems, and any decision that requires data from many distributed locations. The cloud is the right place for the things only the cloud can do — aggregation across the entire fleet and operations that benefit from elastic compute and storage.

Why does bandwidth push toward edge processing?

Some IoT workloads generate huge amounts of raw data — security cameras at 30 fps, vibration sensors at kilohertz sample rates, lidar scans. Sending all of it to the cloud is expensive and often unnecessary. Edge processing extracts the useful events (motion detected, anomaly score above threshold) and sends summaries; the raw data either stays local or is discarded.

What about offline operation?

Many IoT scenarios must continue functioning when cloud connectivity is lost — factory floors during ISP outages, vehicles between cellular cells, remote sensors. Edge processing is the only way: the local logic must be self-sufficient. The cloud catches up later when connectivity returns, but the immediate function never depended on it.