Senior Embedded Systems Engineer

The role

Our pods are living machines - Linux-based controllers, custom firmware, sensors, actuators, and cloud infrastructure all working together, deployed in the field, running unattended. When a customer is disappointed in their experience, that’s not acceptable to us.

We’re looking for a Senior Embedded Systems Engineer who has made interconnected hardware actually reliable - not just on the bench, but in the field, at scale, under conditions nobody planned for. You’ve debugged a production system from a laptop with a serial cable. You know the difference between a software bug and a ground loop.

You’re not afraid to pull out a scope or multimeter and figure out what’s happening. You understand that uptime isn’t a metric, it’s a promise - and that speed, consistency, and security are just as non-negotiable as reliability.

• In your first 30 days:
  • Get deep on the existing pod stack - understand every service, every interface, every failure mode. Ask hard questions. As you go, fill the gaps: if a system isn’t documented, document it. Leave everything in better shape than you found it.
  • Own at least one live reliability improvement from diagnosis through deployment.
  • Establish your local dev and debug workflow; get comfortable deploying to field hardware.
  • Spend time on-site during customer testing - work with our site hosts, watch real customers interact with the pods, and understand what’s actually at stake when the system works (or doesn’t).
• In your first 2–12 months:
  • Own firmware development and maintenance for microcontroller subsystems (STM
    32, ESP
    32, and others) - motor control, sensors, actuators, safety interlocks.
  • Design and maintain the embedded Linux control layer: inter-process communication, hardware abstraction, service reliability, watchdog strategies.
  • Improve and expand our OTA update pipeline - ensuring we can ship firmware and software changes to a distributed fleet confidently, with robust rollback and failure recovery.
  • Build and maintain internal tools and dashboards that give every member of the team - engineering, ops, and beyond - instant visibility into what the fleet is doing, fast paths to diagnosing issues, and clear workflows for resolving them.
  • Build out testing coverage across the stack: unit tests, integration tests, and hardware-in-the-loop validation; develop test procedures, diagnostic tools, and repeatable benchmarks that help us continuously improve our hardware, software, and operational processes - and ensure every customer gets a consistently excellent experience.
  • Design for performance: our customers expect a fast, predictable experience every time - latency and consistency matter as much as uptime.
  • Harden the system against real-world failure modes: power loss, thermal stress, connectivity drops, hardware wear - and against security threats, with secure communication, authenticated updates, and a minimal attack surface.
  • Design systems that preserve beverage quality and consistency - the software and hardware choices we make directly affect what ends up in the customer’s hands.
  • Establish observability practices - logging, telemetry, alerting - so we know what our pods are doing before our customers tell us.
  • Design for portability and consistency: systems that behave the same way regardless of where a pod is deployed.
• Ongoing:
  • Partner with mechanical and ops to close the loop between field failures and software fixes fast.
  • Define embedded architecture patterns and code standards as the team grows.
  • Own production reliability and performance KPIs - uptime, MTBF, service latency, time-to-detect, time-to-recover.
  • Be the person the team calls when something weird is happening in the field.

• 5+ years of embedded Linux development - you’ve owned a Linux-based hardware product through design, deployment, and sustained field operation.
• Strong Python and C/C++ - you know when to use each, and you write code other people can maintain at 6 am.
• Real hardware fluency: GPIO, SPI, I2C, UART, PWM - not just theoretical, but debug-with-a-scope fluency. You’re comfortable wiring things up, pulling out a multimeter, and figuring out what’s happening at the hardware…