Heavy Manufacturer Achieves 99.999% Uptime with Rust-Based Edge Orchestrator That Eliminated Gateway Crashes

Before writing any Rust, we needed to understand exactly why the existing middleware was failing. Our team analyzed crash logs, memory profiles, and GC pause distributions from the Java and C++ components.

The patterns were clear: memory leaks in the C++ protocol handlers accumulated over 3-5 days until the system ran out of heap. The Java orchestration layer added unpredictable GC pauses – sometimes exceeding 200ms – which caused timeouts on latency-sensitive OT connections. We documented these failure modes to ensure the Rust replacement would address each one.

Software reliability was only half the equation. The client also needed deterministic networking for safety-critical machine controls – something standard Ethernet couldn’t guarantee.

We selected NXP’s Layerscape LS1028A processor for its integrated Time-Sensitive Networking support. TSN provides bounded latency for critical traffic while allowing best-effort delivery for bulk telemetry – exactly what’s needed to bridge OT reliability requirements with IT cloud connectivity.

Rust was the only language choice that satisfied all requirements: memory safety without garbage collection, fearless concurrency for handling thousands of protocol connections, and bare-metal performance for real-time data processing.

We built the orchestrator on the tokio async runtime, enabling efficient handling of concurrent Modbus, Profinet, and OPC UA connections without thread-per-connection overhead. Protocol adapters were implemented as modular crates, making it straightforward to add new OT protocols as the client’s needs evolve.

Replacing middleware on a live factory floor requires careful orchestration. We ran the Rust system in shadow mode for three weeks, processing the same sensor streams as the legacy middleware and comparing outputs.

Once we confirmed 100% data parity and stable performance, we cut over zone by zone during scheduled maintenance windows. The transition was invisible to upstream systems – cloud integrations continued without interruption. Since deployment, the Rust orchestrator has achieved 99.999% uptime with zero memory-related crashes.