Embedded Linux and Fleet Engineer

SunAlgo; United States; Remote; USD 120,000 - 160,000; Full time

Job summary

Volt IoT is our own device platform. This role owns the device end, focusing on identity, telemetry, and updates that must not brick devices. You will build Yocto images, maintain the on-device supervisor, and drive the update lifecycle from the factory to the device.

You will implement A/B updates with RAUC, ship onboarding paths, integrate kiosk software and peripherals, and develop fleet tooling. A strong shell/Python background and hardware-tested debugging are valued.

Qualifications

• Build and maintain a custom Linux image with Yocto/Buildroot or equivalent.
• Understand boot path details: bootloader, partitions, root fs, init.
• Run an update system in the field and ensure safe rollback capability.
• Develop on-device services in Node and Python; script provisioning flows.
• Debug devices remotely using limited telemetry and logs.

Responsibilities

• Build and maintain Yocto images for Raspberry Pi and other SBCs.
• Develop the on-device supervisor service and its telemetry interfaces.
• A/B updates with RAUC and automatic rollback to avoid bricks.
• Handle device onboarding: credentials, zero-touch codes, discovery.
• Integrate kiosk software and peripheral devices (USB HID, readers, displays).
• Develop fleet ops tooling for releases, staged rollouts, health checks.
• Create hardware-in-the-loop tests for candidate releases.
• Own device-facing control plane: identity, queues, telemetry ingest via API.

Skills

Custom Linux image, Yocto/Buildroot

Boot path knowledge

Update systems & safe rollback

On-device services (Node/Python)

Shell scripting

Tools

RAUC/Mender/swupdate

Secure boot & provisioning

MQTT

Container runtimes on constrained hardware

Ansible or similar CM tools

Fleet management tooling

Job description

Volt IoT is our own device platform. It's a Yocto-based Linux device OS with a Node supervisor, A/B over-the-air updates with automatic rollback, several onboarding paths, and a multi-tenant control plane. We built it, and we run it for the clients whose devices ship on it.

This role owns the device end of that. Once units are installed the work becomes identity, telemetry, and updates that can't brick anything, and the difference between a good and a bad update system gets measured in site visits.

What you would work on:

• Build and maintain custom Yocto images for Raspberry Pi and other single-board computers, including the layers, the recipes, and the automation that produces a release image.
• Work on the on-device supervisor, a Node service that reports telemetry, accepts commands, and drives the update lifecycle.
• A/B updates with RAUC and automatic rollback, so a bad release costs a reboot instead of a site visit.
• Device onboarding. We ship several paths already, from pre-issued credentials and config dropped onto the boot media through to zero-touch claim codes and discovery for hardware we didn't build.
• Kiosk software on Linux and the peripheral integration around it, including USB HID devices, card readers, and displays.
• Fleet operations tooling. OS image releases, staged rollouts, device health, and working out why one unit in a warehouse stopped reporting last Tuesday.
• Hardware-in-the-loop rigs that run a candidate release against real devices before anyone ships it.
• The device-facing half of the control plane, where device identity, command queues, and telemetry ingest meet the API.

What we look for:

• You've built a custom Linux image with Yocto, Buildroot, or something comparable, and maintained it past its first release.
• You understand the boot path in detail, including bootloader, partitions, root filesystem, and init, and what happens when one of them is half written.
• You've run an update system on devices in the field and know what makes one safe to roll back.
• You're comfortable writing the on-device service in whatever the job needs, Node and Python in our case, and fluent enough in shell to script a provisioning flow.
• You've debugged a device you couldn't physically reach, using only what it was willing to tell you.

Nice to have:

• RAUC, Mender, swupdate, or another A/B update framework.
• Secure boot, device identity, and provisioning at manufacturing time.
• MQTT and the message shapes that survive a flaky link.
• Container runtimes on constrained hardware.
• Ansible or another configuration management tool.
• Experience with fleets in the thousands, on links ranging from cellular to wired.