5+ years of experience in embedded/firmware development, specifically bare-metal and/or RTOS, using C/C++ and/or Rust.
Proficient in motor and motion control, including PWM, timers, DMA, and control loops.
Deep understanding of microcontroller architecture, particularly ARM Cortex-M, including interrupts and peripherals.
Experience with safety-critical systems where failure has significant consequences, such as in medical or automotive applications.
Skilled in designing state machines with a focus on transitions and fault edges.
Responsibilities
Own the motor control firmware for the dispensing mechanism, ensuring precise and safe actuation.
Manage the PreScript firmware interface, including the wire protocol and failure behavior during dispensing.
Oversee sensor acquisition and cross-checking to confirm accurate dispense operations.
Implement on-firmware safety measures, ensuring that actuations only occur under verified conditions.
Enhance firmware observability through structured logging and diagnostic reporting for fleet monitoring.
Conduct hardware bring-up and debugging, utilizing tools like scopes and logic analyzers.
Benefits
Early-stage equity in a pioneering automated pharmacy dispensing company.
Opportunity for direct impact on patient safety through firmware development.
Work in a small, agile team with minimal bureaucracy and high trust.
Engage with challenging problems in safety-critical firmware and real-time hardware integration.
Full Job Description
About the Role
You own the firmware that physically moves the medication. This is the bare-metal / RTOS software on the motor-control microcontroller inside the robot - the layer below the edge agent, where a command becomes motion, a sensor becomes a decision, and a safety interlock is the difference between the right dose and a patient-safety event.
You own the firmware side of the PreScript interface - the wire protocol the edge agent (Rust, on Jetson-class hardware) uses to drive the dispense mechanism - and everything below it: motor control loops, sensor acquisition and cross-checking, timing-critical actuation, and the on-device safety gates that make an unsafe dispense structurally impossible rather than merely unlikely.
This posting covers Senior and Staff levels. Which one you land at is set by scope and impact - a Senior engineer owns hard subsystems end-to-end; a Staff engineer's work changes how the whole team operates. You work directly with Josh (CTO) on the motor-control and hardware interface, and report to the Head of Software Engineering on architecture and cross-boundary integration with the edge agent.
What You'll Own
Motor control - Closed-loop actuation of the dispensing mechanism: PWM/DMA drive, current sensing, stall detection, and the timing budgets that keep motion precise and safe.
The PreScript firmware interface - The firmware side of the wire protocol with the edge agent. You own the contract, the framing, and the failure behavior when the link drops mid-dispense.
Sensor acquisition & cross-check - Read, filter, and independently cross-check the signals that confirm a dispense happened correctly. No critical signal is trusted on a single source.
On-firmware safety - Interlocks and state machines that fail closed: the code path to actuate does not exist without confirmed, verified state. Watchdogs, brown-out behavior, safe-state on fault.
Firmware observability - Structured logging to nonvolatile memory that survives a reset, health/diagnostic reporting the fleet can read, and the firmware-level signals that feed fleet KPIs. If the device can't prove it behaved correctly, it didn't.
Hardware bring-up & debugging - Board bring-up, driver work, and the kind of debugging that needs a scope and a logic analyzer - including chasing silicon errata to ground truth when the bug could be on either side of the wire.
First 90 Days
Day 30: Understand the motor-control firmware and the PreScript interface. First PR to a driver or a safety state machine. Paired with the CTO on the hardware interface. You can explain the dispense lifecycle and the firmware safety invariants.
Day 60: Own a subsystem end-to-end (motor control, or sensor acquisition + cross-check). Firmware observability improved - a field failure produces enough evidence to diagnose it remotely. Hardware-in-loop tests expanded.
Day 90: A full dispense driven through your firmware on real hardware, with the safety interlocks and cross-checks proven under fault injection. Every critical signal is cross-checked; every fault has a defined safe state and a runbook.
What We're Looking For
Must-Have
5+ years embedded / firmware - bare-metal and/or RTOS, in C/C++ and/or Rust, shipped to production hardware.
Motor / motion control - PWM, timers, DMA, current sensing, control loops. You reason in timing budgets, not just function calls.
Microcontroller depth - ARM Cortex-M (STM32 or similar): interrupts, DMA, clock trees, peripherals. You've read a datasheet and an errata sheet to ground truth.
Safety-critical systems - you've built firmware where failure has physical consequences (medical, automotive, avionics, robotics, industrial). Fail-closed is a reflex, not a checklist.
State machines - you design in states and transitions and can reason about every edge, including the fault edges.
Firmware observability - logging that survives a reset, remote diagnostics, fault forensics from the field.
Nice-to-Have
Power electronics / gate-driver debugging.
Jetson / embedded Linux adjacency.
Robotics: sensor fusion, motion planning, control theory.
Healthcare or other regulated / audited industry experience.
How We Hire
Recruiter Screen (30 min)
Technical Interview (90 min) - a take-home walkthrough plus a live design exercise; we fix and improve together and talk through operational and safety thinking.
Design Interview (60 min) - we go deeper on a control/observability subsystem: how it fails, how you'd know, and how you make the bad state impossible.
Leadership Interview (60 min) - culture, mission, and long-term fit.
What We Offer
Early-stage equity in automated pharmacy dispensing at scale
Direct impact - your firmware physically, safely moves medication for real patients
Small team, zero bureaucracy, high trust
Hard problems: safety-critical firmware, real-time hardware integration, regulatory compliance
