Request a firmware review
Menu
Founders and CTOs planning firmware work with an outside team

Five stages, one lead and a written status every week

Every engagement follows the same five stages and is run by one technical account lead, who writes down what was done, what was measured and what comes next.

Key characteristics

Stages
Review, bring-up, build, ship, sustain
Your contact
One technical account lead
Every week
Written status: done, measured, blocked, next
Every release
A signed image and a release report
Decisions
Logged in your repository with the reason

Firmware projects rarely fail on hard engineering problems. They fail because nobody wrote down which board revision the code was tested on, who decided to skip the update path, or why the battery numbers changed. Our method is built to prevent that. It has five stages, one person who is accountable for them, and a written record at every step that your team can read without us in the room.

Not every engagement runs all five stages. A firmware review may be all you need, or you may bring us in at Ship because your product firmware already works. The stages stay the same either way, so you always know where the work stands.

The five stages

Stage What happens You provide You receive
1 Review We read the board, the code and the update plan Schematics, boards, repository access, goals A written plan with ranked risks and the order of work
2 Bring-up First boards powered, clocked, debugged and measured Boards, layout files, time with your hardware engineer Bring-up log, drivers in your repository, hardware issue list
3 Build Product firmware written and tested Requirements, a decision owner, priorities Firmware in your repository, tests in CI, release candidates
4 Ship Signed releases, update pipeline, factory programming, first rollout Key custody decision, update service choice, test devices Signing setup, update path, rollout plan, test evidence
5 Sustain Maintenance releases, release reports, handover Priorities, release approvals, fleet data access Scheduled releases, reports, documentation, a trained team

1 Review

A short, fixed-scope look at your schematics, your current code if there is any, your flash layout and your update plan. You get a written plan: what we found, the risks ranked by what they would cost you, a flash and update budget, and the order we would do the work in. The plan is yours whether or not we do the next stage.

2 Bring-up

New boards are powered up against a checklist: every supply rail measured, debug access confirmed, clocks measured rather than assumed, every peripheral exercised once. Hardware problems go to your hardware engineer with measurements attached. The board bring-up checklist is the free version of the list we use.

3 Build

The application firmware: drivers, state machines, the radio link, power management and tests. Scope is agreed milestone by milestone. Code goes into your repository from the first day, not into ours to be handed over later.

4 Ship

The parts that let you release safely: a bootloader that checks signatures, image signing with keys held in your own account, the update agent, a staged rollout plan, factory programming and the first rollout to real devices. See over-the-air updates and security for the detail.

5 Sustain

Scheduled maintenance releases, dependency and vulnerability reviews, and the handover that lets your own engineers run releases. See sustaining releases and documentation and onboarding.

One technical account lead

Every client has one named technical lead. That person does engineering work on your project, knows the state of every board and branch, and is the one you write to. You do not get a project manager relaying messages to engineers you never meet. If other engineers work on your firmware, the lead reviews their changes and reports on them.

The weekly written status

Every week the lead sends a short status in plain English. It always has the same four parts, so a founder can read it in two minutes and an investor update can quote it.

  • Done: what was finished, with links to the commits or documents.
  • Measured: numbers taken on real hardware this week, with the conditions.
  • Blocked: what is waiting, and on whom.
  • Next: what the lead plans to do in the coming week.

Example (fictional). Week 5 status for Loamwick’s LW-1 soil probe. Done: probes on Rev C boards send moisture and temperature readings to the gateway every 5 minutes; MCUboot builds with two 448 KB image slots. Measured: 4 µA sleep current on five Rev C boards. Blocked: the signing service account in Loamwick’s cloud is not created yet; a Loamwick founder needs to create it, because Loamwick holds the key. Next: the first signed image through the gateway, then the power-cut tests. The whole story is on the example project page.

Release reports

After every release the lead writes a release report for people who are not firmware engineers. It says what changed and why, which devices got the release in which wave, how many updated, how many rolled back or went silent, what the test results were, and which risks are still open. Release notes for support teams and customers come from the same facts; our release notes builder shows the format.

Decisions and changes

Technical decisions are recorded in a decision log in your repository: the date, the options we looked at, what we chose and why. Six months later, when someone asks why the second image slot lives in internal flash, the answer is there.

We separate two kinds of decision. Engineering choices inside the agreed scope (a driver structure, a test approach) are made by the lead and logged. Product choices (what the device does, what your customers see, who gets an update and when) are yours, and we bring them to you with options and a recommendation. No release goes to customer devices without approval from the people you name.

When the scope needs to change, because a board revision slips or a new requirement appears, the lead writes a short change note: what changes, what it does to the plan and the cost, and what it pushes back. Work on the change starts after you approve it in writing.

How we report results

We report what we measured and how, and we do not promise outcomes we cannot control. A battery life figure depends on the cells, the temperature and how your customers use the device, so we give you measured currents and an estimate with its assumptions stated, not a number of years on a box.

What we report How it is measured
Sleep and average current On several boards, with the firmware version and conditions recorded
Battery life estimate From measured currents, with the assumptions listed, as in the battery life calculator
Update success and rollbacks Counted per wave from what devices report after each update
Test results Unit, hardware-in-the-loop and interrupted-update tests, per release
Flash and memory use Per build, against the budget agreed in the review
Open defects Count and severity, from the issue tracker in your repository

Where to start

Most engagements start with a firmware review, because it puts the risks and the order of work on paper before anyone commits to a schedule. Read about the six engagement types, see the whole method applied in the example project, or request a firmware review.

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.

Request a firmware review

Or email sales@fumbar.com, or call (720) 675-4202.