From manual bench testing to real hardware-in-the-loop CI
We help embedded teams get their firmware tested automatically on every commit, hardware-in-the-loop, the same way software teams take CI for granted.
Still testing firmware by hand at a bench? Or have CI on the software side but nothing for the hardware? That's the gap we work in.
Short demo: flash, test, and debug a real target from CI.
What we do
We build your hardware-in-the-loop test setup
From a custom fixture for your board to the CI wiring around it, whatever your DUT needs to be properly exercised on every commit.
Custom HIL test fixtures
A test rig built for your specific board, so the setup fits your hardware, not the other way around.
Precision analog & sensor sim
Precision analog I/O, sensor simulation, and logic analysis, whatever your DUT needs to be properly exercised.
FPGA protocol mocking
FPGA-based protocol mocking where it helps, on an open iCE40 / Yosys toolchain.
Test orchestration firmware
STM32 + FreeRTOS firmware to orchestrate tests and control DUT power, so runs are hands-off.
Wired into your CI
Hooked into the CI you already run, GitHub Actions, Jenkins, or any runner, triggered on every commit.
Secure by default
Security controls like OIDC, so credentials never sit in the pipeline.
Works with any MCU or SoC. No Linux required on the target.
What a finished pipeline looks like
Once it's wired up, every commit runs the same flow against real hardware: build, flash, boot, test, and debug artifacts when something fails.
Code
Push source refs and the validation flow for your target.
Build
Compile firmware and images in isolated runners.
Flash / Boot
The device flashes firmware and power-cycles the target.
Test
Run pytest against real hardware: GPIO, UART, analog signals, and current draw.
Debug
Serial, logs, and remote access when something fails.
Code
Push source refs and the validation flow for your target.
Build
Compile firmware and images in isolated runners.
Flash / Boot
The device flashes firmware and power-cycles the target.
Test
Run pytest against real hardware: GPIO, UART, analog signals, and current draw.
Debug
Serial, logs, and remote access when something fails.
Sound familiar?
If you’ve shipped embedded products, you’ve hit these walls. EmbeddedCI turns your lab into software-defined test infrastructure.
Before
- CI stops at build. The firmware regressions ship.
- Hardware testing is manual, slow, and easy to skip under pressure.
- Debugging needs a bench, cables, and someone in the lab.
- Flaky boards and environment drift break “it works on my machine.”
- Signal regressions like a changed current profile or wrong ADC threshold stay hidden until a field return.
- Scaling to many board variants or branches is painful without automation.
After
- CI catches hardware regressions on every commit, across power, signal, and behavior.
- Schedules and triggers keep devices busy, not people.
- The device captures current profiles, analog waveforms, and bus traces per run.
- Pipelines are versioned and repeatable per branch or product line.
The device behind it
BenchPod: a bench in a box for teams serious about CI
A lot of this work runs on BenchPod, one board that folds sensor simulation, CAN, analog I/O, power control, a logic analyzer, and an FPGA into a single network-attached instrument, with a Python SDK and pytest integration. It's not a prerequisite for working with us, but if you're serious about hardware CI, it's a supporting device anyone can build on.
Why EmbeddedCI
We connect your CI pipeline directly to your hardware, so “build passed” means the firmware booted, the current profile looks right, and the signal behavior matches the last known-good run.
✓
Real hardware CIruns on the real device, not an emulator.✓
Software-defined testsstimulus, capture, and asserts in pytest.✓
Automated device controlflash, power, and orchestration built in.✓
Remote debuggingUART and signal capture per run.✓
Reproducible pipelinessame config, same hardware, every run.
Become a design partner
We're putting our hardware into the hands of a small number of teams before general availability.
If you're running CI that stops at the build step, or duct-taping a Raspberry Pi into your test rig, this is for you.
Design partners get:
- Early hardware access at partner pricing
- Direct line to the team for setup and firmware support
- Priority access to new features
- Preferential pricing
We're onboarding 5–10 embedded teams right now.