Staff Software Engineer (Onboard Services)

UFORCE exists to make aggression unaffordable.
Founded in Ukraine and headquartered in London, UFORCE is a defence-technology company with operations across Europe, the United States and Asia.
UFORCE builds uncrewed vessels, ground robotics and aircraft, autonomy software, and the command-and-control layer that operates them together. Each platform is deployable on its own, and stronger as part of the system. Its product lines include the MAGURA family of uncrewed surface vessels, the NEMESIS family of strike platforms, the LIUT family of ground robotic platforms, and counter-UAS systems.

About the role

The Staff Software Engineer (Onboard Services) will design, build, and operate the software services that run on UFORCE’s uncrewed vehicles — spanning video streaming, telemetry, autonomy integration, vehicle control, health monitoring, navigation, and device integrations.

You will turn independently evolved services into one secure, testable, and maintainable onboard platform. This is a hands-on software engineering role focused on production Python services, service architecture, messaging, and reliable operation on constrained Linux hardware, including Raspberry Pi, x86, and NVIDIA Jetson.

You will also own the boundary between the vehicle and the backend: clear, versioned contracts with cloud services, deployment systems, video infrastructure, and operator interfaces that work over intermittent, low-bandwidth links. Working with backend, autonomy, hardware, QA, and field teams, you will make releases predictable and catch failures on the bench, not in the field.

What you’ll do

• Define and evolve a unified onboard service architecture: service boundaries, messaging, configuration, startup ordering, readiness, watchdogs, and graceful degradation when dependencies or devices are unavailable.

• Build and migrate production services to shared patterns, using reusable libraries and a reference service template covering project structure, packaging, logging, health reporting, and lifecycle management.

• Standardise local service communication around NATS, with clear rules for integrating MAVLink, ZMQ IPC, and HTTP where appropriate.

• Design stable, versioned vehicle-to-backend contracts for telemetry, commands and acknowledgements, video metadata and control, configuration, health, and logs.

• Engineer for unreliable connectivity: buffering and store-and-forward, idempotent commands, explicit acknowledgements and timeouts, reconnection, back-off, and safe behaviour when the backend is unreachable.

• Implement secure-by-default services: least-privilege identities and messaging permissions, mutually authenticated and encrypted backend links, secure credential provisioning and rotation, sandboxed runtimes, and audit events for safety-critical commands.

• Strengthen automated testing across unit, contract, integration, simulation, and hardware-in-the-loop tests, with CI gates that catch regressions before release.

• Build safer release workflows with signed packages, dependency scanning, bench smoke and soak tests, staged fleet rollouts, and reliable rollback.

• Profile services and enforce practical CPU, memory, and latency budgets on target hardware.

• Improve field diagnostics through structured logs, metrics, standardised health reporting, post-mission log capture, and actionable runbooks.

• Document architectural decisions and service interfaces, communicate trade-offs clearly, and use AI coding tools to accelerate delivery without compromising quality.

What success looks like

• Actively developed onboard services converge on a shared architecture, supported Python runtime, messaging model, and service template.

• Engineers can take a new service from an empty repository to running on a bench vehicle in a day or less, with less duplicated infrastructure code.

• Vehicle-to-backend contracts remain compatible as cloud and vehicle software evolve at different speeds, preventing integration failures in the field.

• Authentication, least privilege, secret handling, runtime hardening, and supply-chain checks are consistently applied across the onboard stack.

• Automated tests and bench validation catch defects before deployment, reducing issues discovered in the field.

• Releases move predictably from bench validation to pilot vehicles and the wider fleet, with clear readiness gates and rollback procedures.

• Services stay within resource budgets and remain diagnosable under hardware constraints and degraded connectivity.

• Architecture documentation and runbooks help engineering, QA, and field teams integrate changes and resolve failures faster.

Required Qualifications

• 10+ years of professional experience in software engineering, delivering and operating production systems.

• 2+ years as a Tech Lead or Staff Engineer, owning architecture across multiple services or teams and establishing standards adopted by others.

• Expert Python — designs and ships production services (asyncio, packaging, testing, profiling, and performance); Node.js experience is a plus.

• Distributed / edge system architecture — has designed service architectures and messaging systems (e.g., NATS, MQTT, ZMQ, Kafka) with versioned contracts across system boundaries and unreliable networks.

• Web development and API experience — has built and evolved HTTP/WebSocket APIs and message-based integrations for multiple consumers.

• Security architecture — has led the design of authentication and authorisation, secrets and key management, secure updates, and supply-chain controls; security reviews or certification evidence are a strong plus.

• Quality engineering leadership — has established test strategies, CI gates, and staged release pipelines for a team or organisation; simulator or hardware-in-the-loop experience is a strong plus.

• Development with AI tools — uses AI coding assistants or agents daily and has introduced practices that help a team use them effectively and safely.

• C++, Rust, or Go experience is a plus.

• UxV, robotics, or embedded/edge Linux experience (e.g., MAVLink, GStreamer, serial/CAN devices, systemd services on constrained hardware) is a plus.

The nature of combat has changed.

Tomorrow’s battlefield success depends on autonomy, speed, and adaptability.

And UFORCE is ready.

Are You?