Embedded Software Engineer

GRAM; El Segundo (CA); On-site; USD 165,000 - 205,000; Full time

Job summary

GRAM in El Segundo is seeking a senior embedded software engineer to own the firmware across microcontrollers, Linux runtime, and hardware bring-up. You will develop deterministic real-time software, build drivers, and ensure observable, recoverable behavior on a fixed hardware configuration.

This on-site role emphasizes bench work with hardware, testing, and release evidence, including boot paths, telemetry, and fault response.

Qualifications

• Shipped C or C++ software on a custom electromechanical product with RTOS/embedded Linux.
• Experience with hardware bring-up and field failure resolution.
• Implemented device drivers, interrupts, DMA, and serial interfaces.
• Real-time systems work with latency, jitter, bandwidth measurements.
• Closed hardware–software defects with instrumentation and automated tests.

Responsibilities

• Design and implement C/C++ firmware and drivers for robot-runtime components.
• Define timing, bandwidth, state-machine, calibration, and fault contracts across subsystems.
• Bring up new boards and embedded compute with debuggers and test equipment.
• Build boot, provisioning, update, rollback, and recovery paths with versioning.
• Develop simulation, HIL, SIL, fault-injection, and automated tests.
• Measure latency, jitter, resource use, and reliability under load.
• Investigate failures across firmware, Linux, networking, and controls; release evidence.

Skills

C/C++ firmware

Real-time systems

Hardware bring-up

Diagnostics & fault response

Measurement & testing

Education

Bachelor’s degree in CS/CE/EE or equivalent

Tools

CAN

EtherCAT

Ethernet

SPI

I2C

UART

Debugging tools

Job description

The Mission

GRAM is a self-replication company creating machine labor for the physical economy.

Our first research frontier is self-preservation: the base case of physical self-replication. We are building a new class of machines called insectoids that can survive, coordinate, and recover without humans. We believe scalable machine labor requires more than single-agent task generality or machines shaped in our image.

About the role

You will own embedded software from microcontrollers and real-time control support through the Linux robot runtime. You will bring up new electronics; build drivers, deterministic communications, timing, health monitoring, calibration, logging, and fault response; and expose stable interfaces to higher-level autonomy.

Success means versioned embedded software produces known behavior on a known hardware configuration and remains observable, recoverable, and testable through degraded conditions.

What you will do

• Design and implement C and C++ firmware, device drivers, hardware abstraction, real-time services, communication protocols, and robot-runtime components.


• Define timing, bandwidth, lifecycle, state-machine, calibration, diagnostic, and fault-response contracts across sensors, actuators, power electronics, compute, and autonomy.


• Bring up new boards and embedded compute using debuggers, oscilloscopes, logic analyzers, bus analyzers, kernel traces, and structured telemetry.


• Build boot, provisioning, parameter, configuration, software-update, rollback, and recovery paths with explicit failure behavior and version compatibility.


• Develop simulation, software-in-the-loop, hardware-in-the-loop, fault-injection, and regression tests that run automatically and gate releases.


• Measure and improve latency, jitter, resource use, startup time, communication reliability, logging completeness, and recovery under load.


• Investigate integrated-machine failures across firmware, Linux, networking, electronics, controls, and autonomy, then carry corrections through reproducible tests and release evidence.

Minimum qualifications

• Bachelor’s degree in computer science, computer engineering, electrical engineering, or a related field, or equivalent practical experience.


• Shipped C or C++ software on a custom electromechanical product using an RTOS, embedded Linux, or both, including direct responsibility for hardware bring-up or field failure resolution.


• Implemented and debugged device drivers, interrupts, DMA, concurrency, memory ownership, and at least one physical interface such as CAN, EtherCAT, Ethernet, SPI, I2C, or UART.


• Demonstrated real-time systems work with measured latency, jitter, bandwidth, CPU or memory use, and behavior under overload or component failure.


• Closed a hardware-software defect using instrumentation and captured evidence, then added an automated test, monitor, or fault response that prevented recurrence.

Preferred experience

• Robotics, autonomous vehicles, aerospace, industrial controls, or other distributed real-time machines.


• Bootloaders, secure boot, over-the-air updates, Yocto, kernel or device-tree development, time synchronization, or deterministic networking.


• Hardware-in-the-loop infrastructure, safety-related embedded systems, fleet configuration, or production programming and calibration.

Compensation

The annual base salary range for this El Segundo position is $165,000–$205,000. An offer within this range will reflect the position’s approved scope and the candidate’s demonstrated role-relevant skills and experience.

Working at GRAM

This role is based on-site in El Segundo and is inseparable from physical hardware. You will work at the bench and on the machine, and software changes will be evaluated against instrumented behavior, not only code-level tests.

Interview Process

After submitting your application, we review your portfolio and any exceptional work you’ve shipped. If your application demonstrates the caliber we seek, you’ll enter our interview process, which is designed for speed and substance. We aim to complete it within one week from start to finish.

Trust in the Process

GRAM expects deep trust and ownership from its people, and we begin by extending the same to candidates. We treat your information, prior work, and conversations with discretion.