Embedded DevOps, Engineered
Your firmware builds on your machine, on your day, with your cable plugged in. The project: build the machine that builds it, a real CI/CD pipeline around the occupancy-sensor product from Course 1 (supplied as a finished snapshot). A pinned Docker toolchain, a Jenkins pipeline that tests, signs and ships every commit, and a hardware-in-the-loop rig where CI touches real silicon. The guided lessons are the vehicle; the pipeline is what you keep.
Preview build: the full course is readable here; checkout opens at launch.
"Works on my machine" is not a build system
The usual way
- One senior engineer's laptop is the release process, and it just went on holiday
- "Which SDK version built this binary?": archaeology, every field failure
- Tests run when someone remembers; signing happens by hand, at midnight
- A broken commit is discovered at integration. Weeks after it landed
This course
- The toolchain is a pinned Docker image. The same bytes build everywhere, provably
- Every commit is built, tested and gated by a pipeline that lives with the product
- The pipeline signs what it ships, from a credential store, never a key on a laptop
- Releases assemble themselves from a git tag, manifest and checksums included
One product, one pipeline
The pipeline wraps the occupancy sensor from Zigbee, Engineered: the same nRF52840 firmware, the same signed OTA packages. You containerise its toolchain, stand up Jenkins in Docker, grow the pipeline stage by stage (build → test → sign → release), finish with hardware-in-the-loop flashing on a native agent, then translate the whole thing to GitHub Actions and compare the two homes honestly.
The pipeline takes shape
Checkout, containerised build, archived artifacts. (Chapter 5)
The test pyramid, on a chip
Host tests, gates, and what runs where. (Chapter 6)
CI touches real silicon
The HIL agent: flash, boot, assert over serial. (Chapter 10)
Real animations from inside the lessons
A pipeline is a thing that moves. Stages run, gates stop the line, image layers stack. The lessons animate those flows and hand you the controls. These three are the actual chapter animations, untouched: press play, or step through them frame by frame.
The pipeline flows, and a red stage stops the line
Layers: the stack is the cache
Sign in the pipeline; verify like an enemy
Chapter by chapter
Eleven chapters, one growing pipeline. Total: about 28 to 33 hours of building, depending on your pace. Chapter 1 starts with the ideas (what embedded DevOps is, what it buys an embedded team, and why learning it early compounds for a whole career), before any tooling appears.
Why embedded CI is different, and the baseline you will automate
What embedded DevOps actually is, what it buys an embedded team, and why learning it early compounds, then the manual baseline: one firmware build, done by hand and measured, that every later chapter automates.
Docker for embedded engineers
Docker from an embedded angle: images, containers, volumes and Compose, with the toolchain treated as a deliverable, not a workstation accident.
The pinned toolchain image, production grade
The pinned toolchain image, production grade: layered, reproducible, and byte-checked against the host build, including the honest +8-byte exception and how it was proven innocent.
Jenkins, standing it up the Docker way
Jenkins stood up the Docker way: a pinned controller, a frozen 70-plugin set, and configuration that survives restarts because it lives in files, not clicks.
Your first declarative pipeline: CI builds the firmware
Your first declarative pipeline: checkout, build inside the image, archive the artifacts, a Jenkinsfile that lives with the product and answers to code review.
The test pyramid on a chip: automated tests and gates
The test pyramid on a chip: refactor the LD2410 parser into a host-testable unit, Twister on native_sim/64, and quality gates that can actually stop a line.
Build matrix, versioning, and artifacts that mean something
Versioning that means something: one git truth stamped into BOTH version knobs, a build matrix, and a manifest that lists every artifact the run produced.
Secrets and signing: the pipeline signs what it ships
Secrets and signing: the product key lives in the credential store, the pipeline signs what it ships, and imgtool verification proves it. Wrong key and corrupt image included.
Release pipelines: tag it and it ships
Release pipelines: tag it and it ships. The bundle assembles itself (signed images, the .zigbee OTA package, manifest, checksums) behind an approval gate.
Hardware-in-the-loop: CI touches real silicon
Hardware-in-the-loop: a native Linux agent with real silicon. Flash, boot, and assert over the serial transcript. CI touches the product itself.
The same pipeline, in GitHub Actions
The same pipeline in GitHub Actions: the Jenkinsfile translated stage for stage, GHCR for the image, and an honest comparison of the two homes.
Everything is a deliverable
- 11 hands-on labs: every lab run and verified in the course's own build environment before publication, and the build log is quoted in the course. Steps that need physical hardware or a hosted account (the Chapter 10 flash, the Chapter 11 release publish) are written as exact desk procedures in the lessons, labeled as such, for your own desk pass
- 90 quiz questions with full answer keys: self-check cards, graded as you go
- 20 diagrams. Pipeline flows, the test pyramid, the HIL rig, the release path
- A real product repo: the Course 1 firmware, its Jenkinsfile, its tests and its release tooling, growing chapter by chapter
- Reproducibility, measured: byte-level comparisons of host vs container builds, including the one honest exception and why it happens
- Stretch exercises. Break the pipeline on purpose, extend it, prove you understood
- All 11 chapters, labs, quizzes and diagrams
- Lifetime access in the online player, nothing to install, read anywhere
- The full product + pipeline repo layout
- Email support from the instructor
- Free updates to the course
Placeholder price for this preview build. Secure checkout opens at launch; the refund policy (14 days, no questions) will apply from day one.
Before you start
You do not need Course 1 first: the product repo supplied with this course contains the finished Course 1 firmware snapshot, and the pipeline is built around that snapshot. Course 1 is recommended background; if you built the product yourself there, yours is the same code. You need a machine that runs Docker, and a free GitHub account for Chapter 11. Jenkins, Docker and every other tool in the course is free. The only paid item at launch is your own domain, if you want one.
What owners get
Buying the course is the start, not the whole deal. This is what's included with it, and the headline is a human being on the other end of an email.
Lifetime email support
Pipeline red at midnight, or a gate you don't trust? Email your question about the course to [email protected] and a working engineer answers, within 1 to 2 working days. Support covers questions about the course material and its labs. It is not general consulting, and it does not extend to debugging projects unrelated to the course. For as long as you own the course: no support tiers, no expiry, no ticket bot.
Animated diagrams
The moving parts (stages flowing, gates stopping the line, image layers stacking, a signature being checked), are taught as animations you play, pause and step through.
90 quiz questions, with answer keys
Every chapter ends in a self-check quiz with full answers, so you find the gaps while they're still cheap to fix.
The troubleshooting appendix
When it breaks. The field guide to the failures this build actually produces: symptom, cause, fix. Kept open beside the labs, it earns its place in the first week.
Exercise-by-exercise code
One real product repo (the firmware, its Jenkinsfile, its tests and its release tooling), growing a verified step at a time, chapter by chapter.
More perks on the way
Owning a course here will keep getting better. More owner perks are in the works, and when they land, owners get them, free.
Before you ask
Do I need Course 1 first?
No. The pipeline is built around the occupancy-sensor product, and a finished snapshot of that firmware is supplied in this course's own repo, so you can start here. Course 1 is recommended background: it explains how the firmware was built. The DevOps concepts themselves are taught from zero.
Which tools, exactly?
Docker and Docker Compose from Chapter 2, Jenkins 2.580.1 LTS (pinned, run in Docker) as the anchor, Twister for tests, imgtool for signing, and GitHub Actions + GHCR for the final translation. Everything is free tooling; no paid CI minutes are required to follow along.
Does the hardware-in-the-loop chapter need the desk kit?
Yes. Chapter 10 flashes a real nRF52840 DK from a Jenkins agent. Everything up to the physical flash is verified in the course's own build log; the flash itself is a desk step with exact expected output, like Course 1's hardware checks.
How long do I have access?
Access doesn't expire. Buy once, build at your pace, come back whenever, including course updates.