Staff Embedded Firmware Engineer — Platform Controller (Zephyr RTOS

Role Overview

We are building the firmware that runs on our platform management controller: a Zephyr-based system responsible for power sequencing, rail telemetry, board health, and secure boot on next-generation silicon. As a Staff Embedded Firmware Engineer you will own firmware from pre-silicon bring-up through production release, working shoulder-to-shoulder with design, DV, and systems teams.

You will spend your time on real hardware. Expect bus analyzers, scopes, JTAG, and trace captures alongside your editor. We are also folding machine learning into the controller — anomaly detection on power and thermal telemetry, predictive fault signaling — so we want someone who can reason about both a register map and a quantized model.

What you do

• Design, implement, and maintain Zephyr RTOS firmware for platform management controller, including device drivers, subsystem integration, and application-level services.
• Write and upstream-quality-review drivers against Zephyr's driver model — devicetree bindings, Kconfig, init levels and priorities, struct device APIs.
• Deploy and maintain lightweight ML inference on-target for anomaly detection and predictive fault analysis; own the path from trained model to running firmware.
• Perform post-silicon bring-up: first-boot debug, clock and reset validation, bus enumeration, triage of RTL-versus-firmware ambiguity with design teams.
• Contribute to pre-silicon validation on FPGA and emulation platforms; write firmware that exercises IP before tapeout.
• Debug hard problems using JTAG/SWD, ETM/ITM trace, protocol analyzers, and logic analyzers — including intermittent, timing-dependent, and multi-master bus failures.
• Build and extend CI: unit tests, Twister test suites, hardware-in-the-loop regression, static analysis gates.
• Write the documentation your teammates and customers will actually rely on — design docs, bring-up guides, register-level notes, release notes.
• Mentor mid-level engineers and set the code-review bar for the team.

Required qualifications

• 8–10 years of professional embedded firmware development in C, with meaningful exposure to modern C++ or Rust.
• Deep, hands-on RTOS experience on 32-bit microcontrollers (Arm Cortex-M or RISCV) — scheduling, priority assignment, ISR design, synchronization primitives, and the failure modes each one produces.
• Proven driver development experience against a formal driver model, including bus drivers and interrupt-driven peripherals.
• Strong grasp of serial protocols at the wire level: I2C, SPI, UART — arbitration, clock stretching, timing parameters, and how they break.
• Demonstrated ability to read a hardware specification or register map and translate it into correct, testable firmware without hand-holding.
• Practical debugging skill with JTAG/SWD debuggers, oscilloscopes, logic analyzers, and protocol decoders.
• Comfort with the toolchain: Git, GCC/Clang, CMake, Python scripting, and CI systems.
• Applied AI/ML knowledge — at minimum, a working understanding of model training and deployment workflows, quantization and its accuracy cost, inference latency and memory budgeting on constrained targets, and honest judgment about when ML is and is not the right tool for a control problem.
• BS or MS in Electrical Engineering, Computer Engineering, Computer Science, or equivalent practical experience.

Preferred qualifications

Strong candidates will have direct experience with several of the following. We do not expect all of them.

RTOS and platform

• Zephyr RTOS in production: devicetree, Kconfig, west workspaces, SYS_INIT and device init ordering, Twister, upstream contribution history.
• Bare-metal and boot-path firmware, including boot ROM code, secure boot chains, and ROM-to-application handoff.
• On-chip bus fabric familiarity — AMBA APB / AHB — and what a fabric-level stall or misconfigured bridge looks like from the firmware side.

Peripherals and subsystems

• PMBus and SMBus — command sets, PEC, ALERT handling, multi-master and bus-recovery behavior.
• QSPI flash: XIP, DMA-driven transfers, dual/quad modes, flash programming and update paths.
• GPIO expanders and pin multiplexing; PWM and PIT/timer peripherals for control loops and precise sequencing.
• Watchdog design — windowed watchdogs, task-level petting strategies, and failure-mode analysis.
• Interrupt controller configuration nested and prioritized interrupts, latency measurement and reduction.
• Telemetry subsystem design: ADC sampling strategy, calibration, scaling, and out-of-band reporting.
• Debug and trace infrastructure — ETM/ITM, SWO, coresight, trace-based performance and timing analysis.

AI/ML

• TinyML or edge inference frameworks on microcontrollers.
• Time-series anomaly detection applied to sensor or telemetry data.
• Model compression: quantization, pruning, operator fusion, and validating that accuracy survived it.
• NPU or hardware accelerator integration and driver work.
• Building the data pipeline — capture, labeling, and retraining loops sourced from fielded hardware.
• Effective use of AI coding assistants in a firmware workflow, with sound judgment about reviewing generated code.

Silicon and process

• Pre-silicon firmware development on FPGA prototypes or emulation.
• Post-silicon bring-up on first articles, and working directly with design and DV teams on errata.
• Board-level hardware debug and schematic literacy.
• Coding standards and safety-critical process: MISRA C, static analysis, functional safety, or security certification programs.
• Secure development practice: cryptographic key handling, attestation, firmware signing, and threat modeling.

What tells us you are a strong fit

• You have shipped firmware that runs unattended for months and have the scar tissue to prove it.
• You can explain a bug's root cause, not just the change that made it go away.
• You are skeptical of adding ML where a threshold and a good sensor would do — and you can articulate the cases where it genuinely wins.
• You write things down.