Documentation and onboarding so your team owns it
The last deliverable of every engagement is a team that can run the firmware without us. Handover ends when your engineer ships a release while we watch.
Key characteristics
- Documents
- Architecture, release runbook, key and recovery procedures
- Sessions
- Recorded walkthroughs and pairing on real work
- Finish line
- A release your team ships while we watch
- Signed off with
- The 15-item handover checklist
Firmware written by an outside team has a failure mode that has nothing to do with the code: the knowledge leaves when the contract ends. The person who knew why the watchdog timeout has the value it has, how to reach the signing service and what to do when a rollout halts is gone, and the first release your own team attempts turns into an investigation. We write and teach the firmware so that does not happen, starting in the first week rather than the last.
Documentation and onboarding sits next to the firmware review among our services because it is the other bookend of an engagement. The review is how we learn your product; the handover is how your team learns our work.
What we write
| Document | What it answers |
|---|---|
| Architecture overview | Tasks or threads, drivers, memory map, flash layout, boot flow and power states, and why each choice was made |
| Build and flash guide | How to get from a fresh checkout to a flashed board, with pinned toolchain versions |
| Release runbook | From tag to CI build, test gates, signed image, staged rollout and release report |
| Key procedures | Who can sign, how the signing service is reached, how keys are rotated, and what to do if a key is lost or leaked |
| Recovery runbook | What to do when a rollout halts: stop, diagnose, roll back, tell the people who need to know |
| Hardware notes | Pin map, clock tree, known board issues and their firmware workarounds |
| Open issues | Known bugs and planned work, ranked |
Documents live in your repository beside the code, as plain text that changes in the same commits as the code it describes, so it drifts less. A runbook counts as finished only when someone who did not write it has followed it step by step and got the expected result.
Recorded walkthroughs
We record walkthrough sessions of the code base, the build, the release process and the update pipeline, using your own repository and boards rather than slides. New engineers watch them in their first week. They stay useful long after: when someone has to change the bootloader configuration two years from now, the reasoning is on record, next to the document that describes the result.
Pairing with your first firmware hire
Many hardware startups hire their first firmware engineer once the product is real. That person inherits code they did not write, under pressure to ship. We pair with them on real work from the backlog, with them at the keyboard and us beside them. The order is deliberate: first a bug fix, then a small feature, then a clean build and flash on their own machine from the written instructions, then a release candidate through CI, and finally a release through the staged rollout. By the end, every step they will need alone has been done once with help.
The handover checklist
Handover is not a meeting. It is a checklist of 15 items in four groups, signed off by both sides. The free handover checklist is the same list.
- Code and builds. Repository transferred or access granted with full history; a clean build from a fresh checkout using the written instructions; CI running under your account; toolchain versions pinned and documented.
- Documents. Architecture overview; release procedure from tag to signed image to rollout; hardware notes; open issues and planned work, ranked.
- Keys and accounts. Signing keys and update server accounts owned by you; contractor access removed from every system; the recovery procedure for a lost signing key reviewed; cloud and device provisioning credentials rotated.
- People. Walkthrough sessions recorded; your engineer has built, flashed and released one version unaided; a named contact for questions during the agreed follow-up period.
You receive the source code, build instructions, signing setup and documentation. Ownership and licensing terms are set out in each agreement.
The supervised release
The checklist item that matters most is the release. Before handover is signed off, your engineer runs a real release from start to finish: tags the commit, lets CI build and test it, has it signed in the signing service, writes the release notes, plans the waves and ships it to your fleet. We watch, and step in only if something would put devices at risk. If they get stuck, the runbook was wrong, and we fix the runbook before we sign off. The firmware release checklist is the list they follow.
Example (fictional). Loamwick starts as two founders and one contract hardware engineer. Near the end of the engagement they hire their first firmware engineer, who pairs with us on the release process using the LW-1 code base, the Rev C and Rev D boards and the staged waves through the gateways. Before the handover checklist is signed, the new engineer ships a release to the pilot fleet while we watch, and the engagement ends with a team handover. See the example project.
Documentation that lasts
Documentation is also something regulators expect to exist and to last. Under the EU Cyber Resilience Act, whose main obligations apply from December 11, 2027, manufacturers of products in its scope must keep the technical documentation for at least ten years after the product is placed on the market, or for the support period if that is longer. Writing it during the work, rather than reconstructing it later, is far cheaper. This is not legal advice; see firmware security for the wider picture.
Where to start
Documentation is written during every engagement, not bolted on at the end. A team handover can also be a fixed-scope engagement on its own: for firmware we wrote, or, after a firmware review, for firmware someone else left behind. If you would rather we keep shipping releases until your team is ready, see sustaining releases. Request a firmware review, or read more in the firmware architecture section of Field Update.
Send us your board and your plan.
A firmware review reads your schematics, code, flash layout and update plan, and ends with a written plan: what to build first, what could go wrong in the field and how updates will reach your devices.
Or email sales@fumbar.com, or call (720) 675-4202.