A practical system design breakdown for processing spatial telemetry for predictive material flow
tags: architecture, iot, edgecomputing, softwareengineering
When it comes to processing real-time location system (RTLS) data in shop floors, the raw telemetry ingestion poses a classic distributed system design problem; how to ingest tens of thousands of spatial coordinates per second from hybrid hardware protocols while keeping the inference latency under 100ms
Delayed location updates in high-velocity assembly plants mean missed pick/pack events, inaccurate asset dwell-time calculations and broken digital twins
In this article, we'll be discussing battle-tested system architecture for ingesting UWB, BLE, and Passive RFID telemetry, filtering signal noise at the edge and streaming structured events into enterprise MES/WMS platforms
System Architecture: The Multi-Sensor Data Pipeline
The biggest challenge in spatial IIoT is heterogeneity. Ultra-Wideband (UWB) gives sub-meter precision using Time-Difference-of-Arrival (TDOA), Bluetooth Low Energy (BLE) offers RSSI proximity telemetry, and UHF RFID offers deterministic portal checkpoints
Step 1: Signal Ingestion & Protocol Standardization
As raw hardware payloads come in different formats, edge gateways translate raw packets into a combined Protobuf schema
Here is a sample schema for standardizing spatial telemetry across different hardware protocols:
Protocol Buffers
syntax = "proto3";
package telemetry;
enum SensorType {
UWB = 0;
BLE = 1;
RFID = 2;
}
message SpatialPoint {
string asset_id = 1;
SensorType sensor_type = 2;
double x_coord = 3;
double y_coord = 4;
double z_coord = 5;
float confidence_score = 6;
int64 timestamp_ms = 7;
}
By standardizing at the gateway level, your downstream inference service only deals with clean SpatialPoint structures irrespective of the hardware vendor being Decawave, Zebra or Nordic Semi
Step 2: Edge Filtering & Noise Reduction
Raw RSSI and TDOA signals fluctuate due to multipath reflections off metal machinery on the shop floor. Processing unfiltered coordinates directly will result in false geofence triggers
Applying a lightweight Extended Kalman Filter (EKF) or moving-average sliding window at the edge service strips out high-frequency noise before publishing to the main message queue:
Python
Simple Sliding-Window Moving Average for Coordinate Smoothing
from collections import deque
import numpy as np
class PositionSmoother:
def init(self, window_size=5):
self.x_history = deque(maxlen=window_size)
self.y_history = deque(maxlen=window_size)
def smooth(self, raw_x: float, raw_y: float) -> tuple[float, float]:
self.x_history.append(raw_x)
self.y_history.append(raw_y)
Calculate moving average across window
smoothed_x = float(np.mean(self.x_history))
smoothed_y = float(np.mean(self.y_history))
return smoothed_x, smoothed_y
Step 3: Geofence Detection & Event Dispatching
Once spatial telemetry is smoothed, edge inference engine evaluates coordinate points against defined polygonal zones (e.g. Kitting Bay Alpha, Assembly Line 4, Buffer Staging)
When a work-in-progress (WIP) cart enters or exits a polygon, a state transition event is published:
JSON
{
"event_type": "GEOFENCE_TRANSITION",
"asset_id": "WIP-CART-884",
"zone_id": "STAGING_BAY_2",
"action": "ENTER",
"dwell_time_seconds": 0,
"timestamp": "2026-10-07T14:32:00Z"
}
These transition events feed directly into predictive Kanban algorithms to calculate material consumption velocity and trigger dynamic replenishment dispatches
Key Performance Benchmarks To Aim For
While evaluating your edge tracking pipeline under full production load, consider aiming for these latency and throughput benchmarks:
Ingestion Throughput: ≥ 10,000 telemetry packets/sec per edge gateway instance.
Pipeline Processing Latency: ≤ 15ms from gateway reception to geofence evaluation.
Network Overhead: Protobuf serialization reduces payload footprint by ~65% compared to raw JSON over MQTT.
Developers looking to design complete industrial edge processing pipelines can refer to detailed integration topologies in this guide on AIoT powered in-plant logistics solutions
Conclusion & Tech Stack Recommendations
Building a resilient, real-time spatial pipeline requires choosing the right lightweight tools:
Edge Broker: EMQX or Eclipse Mosquitto (MQTT 5.0)
High-Throughput Pipeline: Rust or Go microservices for low-memory, zero-GC edge inference.
Message Streaming: NATS JetStream or Apache Kafka for enterprise integration.
What protocols or message brokers are you using in your IIoT telemetry stacks? Let's discuss system design choices and edge trade-offs in the comments below!
Top comments (0)