Senior C++ - Low Latency

Role Overview :
1. The Mission (Pure Backend Focus)

• You will architect the high-performance C++ Backend of our robotics software 

•   The Engine: Your mission is to build the "invisible engine" that processes 50 Mbps of raw scientific data and feeds it efficiently to the UI layer. 

• Ownership: You own the threads, the data structures, and the logic. 

2. Critical Outcomes (The First 4 Months) 

• Architect the Data Ingestion Layer: Design a C++ backend capable of ingesting 100 Mbps of live sensor data (from embedded hardware) without dropping packets or consuming excessive CPU 

• Decouple Backend from UI: Implement Ring Buffers and Lock-Free Queues to separate high-speed data acquisition threads from the main Qt Event Loop, ensuring the backend never freezes the UI. 

• Crash-Proof Concurrency: Refactor the threading model to eliminate Race Conditions and Deadlocks using proper synchronization (Mutexes/Semaphores) or lock-free designs. 

• Efficient IPC Implementation: Establish robust Inter-Process Communication (Shared Memory/Sockets) to allow the C++ backend to exchange data with other Linux processes instantly. 

3 . Strategic Outcomes (Months 5 Onward) 
As the product matures, your focus will shift from "Building the Engine" to "Hardening and Scaling the Ecosystem." 

• R obust OTA & Redundancy: Implement Linux A/B Partitioning strategies. You will 
  design the fallback mechanism where the system uses atomic updates to revert to the last known good configuration in case of an update failure, ensuring high availability in remote offshore locations. 

• Containerized Deployment: Move from manual builds to automated deployment. You will containerize the application (Docker/Podman) and integrate it with Jenkins/GitLab CI to enable seamless remote deployment to the robot fleet. 

• Remote Diagnostics Engine: Build the internal logic to capture, compress, and transmit critical system logs and core dumps securely to the cloud without saturating the robot's bandwidth. 

• Fleet Monitoring Infrastructure: distinct from simple logging, you will architect the heartbeat and telemetry protocols that allow our central command to monitor the health of robots deployed in railways and chemical plants in real-time. 

4. Competencies (Must-Haves) 

• High-Performance C++: You handle data at the byte level, preferring Circular Buffers (Ring Buffers) over standard vectors for streams. 

• Concurrency Mastery: You know when to use Lock-Free programming to avoid thread contention and can manage interactions between Data Acquisition and Processing threads without bottlenecks. 

• Design Patterns: Competence in Producer-Consumer (for streams), Singleton (hardware managers), and Factory patterns. 

• Linux System Programming: Comfortable with IPC (Shared Memory, Unix Domain Sockets) and optimizing process priorities. 

• DevOps for Embedded. Proven experience with containerization on edge devices and managing remote, high-availability deployments in disconnected environments. 

• DevOps for Embedded. Proven experience with containerization on edge devices and managing remote, high-availability deployments in disconnected environments. 
  
  

5. The "Squad" (Your Team) 

• Embedded Engineers: They push the raw 50 Mbps stream to the OS; you write the drivers to catch it. 

• UI/Frontend Developers: They handle QML/UX; you provide the data APIs they need. 

• Robotics (ROS) Engineers: You ensure their heavy algorithms don't starve your data acquisition threads. 

• Testers: You ensure your code stands up to their stress testing. 
  
  

6. Why This Role Defines Your Career 

• Deep Backend Engineering: Escape the "button styling" trap. This is 100% logic, memory management, and architecture. 

• Real Engineering Problems: Solve race conditions, memory leaks, and high-velocity data streams. 

• Architectural Autonomy: You decide how the data moves and choose the patterns. You own the "Engine Room".