Request a firmware review
Menu
About 25 minutes to read

What it takes to ship firmware you can safely update

Reader question: What has to be in place, from bootloader and signing keys to factory programming and rollout, before a startup can safely update devices in the field?

Micrograph-style illustration of a dragonfly wing's fine net of veins and cells, with a few cells near the wing tip tinted amber.

Before a startup can safely update devices in the field, it needs eight things in place. The device needs flash with room for two firmware images, a bootloader that verifies every image and reverts a bad one, and signing keys kept off build machines. It needs an update agent that checks each image before installing it, and a factory step that gives every unit its own identity and locks it. The company needs one repeatable release process, rollouts in waves that stop when fleet health drops, and a support period it can keep.

Most guides to OTA firmware update best practices come from companies that sell one link of this chain, an update platform or a device management service, so each starts and stops at its own product. This one walks the whole chain in the order a hardware startup meets it, says what each link protects against, and points to the Field Update article that goes deeper on each step.

Four of the eight links (the flash layout, the bootloader, the key the bootloader trusts and the factory settings) are fixed in the first units you ship. They have to be designed before the first production run, not after the first bug report.

Fumbar is a Denver firm that writes embedded firmware for hardware startups and builds the over-the-air update path that keeps it improving after devices ship. Everything below rests on public standards and project documentation, linked where each fact is used.

A field update is safe only when every link holds: the image is authentic, it is stored without touching the running version, it is tried and then kept or undone, and it reaches a few devices before it reaches all of them. The IETF’s firmware update architecture, RFC 9019 (April 2021), puts the stakes in one line: “An update is essentially authorized remote code execution.” If the authorization is weak, the update path becomes an attacker’s delivery system.

RFC 9019 also names the parts. The manifest is protected metadata about an image. The status tracker announces new versions, collects device versions and hardware details, and can trigger an update. The firmware consumer on the device fetches and stores the image, and the bootloader, the code that runs first after every reset, decides which image runs.

Figure 1 lays the chain out in the order a startup meets it, grouped by when each link is decided. The first three are settled on prototype boards; the last three repeat or last for the life of the product.

Design Build Factory Each release Product life 1 Flash with room for two images Without it: no last good copy to fall back on 2 A bootloader that verifies and reverts Without it: a power cut or bad image can brick units 3 Signing keys off build machines Without it: one stolen laptop can sign for every unit 4 An update agent that checks first Without it: wrong images, wasted battery and data 5 Identity and lockdown at the factory Without it: shared secrets and open debug ports 6 One release process for every version Without it: nobody can say what a device runs 7 Waves gated on fleet health Without it: one bad release reaches every device 8 A support period you can keep Without it: promises and legal duties you cannot meet Each link has its own chapter below
Figure 1. The eight links of a safe field update, grouped by when each is decided. Fumbar's synthesis of the roles in IETF RFC 9019 and the protect, detect and recover principles of NIST SP 800-193, checked November 2026.

Why the update path has to exist before the first unit ships

You cannot add an update path to units already in the field, because the code that installs updates is the code you would need to replace. A device that ships without a bootloader able to verify and revert images will, in practice, never safely gain one.

RFC 9019 says so directly: “it is assumed that the bootloader itself, or a minimal part of it, will not be updated since a failed update of the bootloader poses a reliability risk.” Espressif’s ESP-IDF OTA documentation makes the same point for its chips. It lists the bootloader and the partition table under an “unsafe update mode”, where “a power interruption during the update can cause issues that prevent the current application from loading.”

So the flash layout, the signature check, the public key (or key hash) the bootloader trusts and the recovery logic ship in the first unit and stay for the life of the product. Application firmware can change every month. The first code that runs after reset effectively cannot. If your current firmware grew out of vendor examples, prototype firmware to production covers what to keep and what to rewrite before the update path goes in.

RFC 9019 also sets the bar for everything else: “Devices must not fail when a disruption, such as a power failure or network interruption, occurs during the update process.” It allows exactly two ways to recover from an invalid image. The bootloader either selects a different, valid image already on the device, or it obtains a new valid image, for example through a small recovery image that can run the update again over serial, USB or a radio.

NIST’s SP 800-193 (May 2018) was written for the firmware of computer platforms, but its three principles fit a small device well: protect against unauthorized changes, detect the changes that happen, and recover “rapidly and securely”. Here is how they land on a microcontroller product:

Principle On a microcontroller device Links in the chain
Protect Only images signed with your production key are accepted; the debug port is locked; the signing key lives in a service, not on a laptop Signing keys, factory
Detect The bootloader checks the hash and signature before running an image; the new image runs a self-test before it is confirmed Bootloader, update agent
Recover A spare slot keeps the last good image; the bootloader reverts an image that never confirms; a halt rule stops the rollout Flash layout, bootloader, rollout

Some products cannot carry an update path because of a constraint their use case imposes. The European consumer IoT baseline, ETSI EN 303 645 V3.1.3, anticipates this. Its provision 5.3-14 recommends that makers of devices that cannot be updated publish the reason, and the period and method of hardware replacement support. If replacing hardware is not a plan you want to publish, the device needs an update path.

Choose a platform and flash layout with room for two images

Plan flash for two complete application images, a bootloader, settings and logs, plus room for the image to grow, before you commit to a microcontroller. If two images will not fit in internal flash with that growth, decide now between a bigger part, an external flash chip for the second slot, or an update method with weaker recovery.

The second copy is what makes recovery possible. The new image downloads into a spare slot while the running image stays untouched, so a dropped connection or a power cut costs only a retry.

Example (fictional). Loamwick’s LW-1 soil probe uses a Bluetooth LE microcontroller with 1 MB of internal flash. The layout in Figure 2 gives the MCUboot bootloader 48 KB, two image slots of 448 KB each, 32 KB to settings and 48 KB to logs. The 412 KB application image fills 92.8% of the 444 KB a slot can hold once the image header and trailer are counted. The flash budget calculator shows that 25% growth would make the image 515 KB, 71 KB too big for a slot, so Loamwick’s plan moves the second slot to an external flash chip on the next board revision.

1 MB internal flash (1,024 KB) Image 412 KB 92.8% of the slot Empty until an update new image is stored here Bootloader 48 KB Slot 1: running image, 448 KB Slot 2: download and test, 448 KB Settings 32 KB Logs 48 KB 25% growth makes the image 515 KB: 71 KB more than a slot holds
Figure 2. Flash layout of the fictional Loamwick LW-1 probe, drawn to scale. Fictional example data for illustration, computed with Fumbar's flash budget calculator; slot behavior per the MCUboot design documentation, checked November 2026.

The exact space a slot gives you also depends on how the bootloader swaps images. MCUboot’s design documentation shows that swap-using-move needs one spare sector in the primary slot and swap-using-offset one in the secondary slot, so check the formula for your method before you trust a fit calculation down to the last sector.

The platform decides how much of the update path you build yourself:

  • Zephyr. Its Device Firmware Upgrade documentation says Zephyr is “directly compatible with the open source, cross-RTOS MCUboot boot loader”. The management subsystem uses MCUmgr’s Simple Management Protocol over transports that include Bluetooth LE, UART and UDP.
  • ESP-IDF. Over-the-air updates are built in. The partition table needs at least two OTA app slots and an OTA data partition, and app rollback is a configuration option.
  • FreeRTOS or bare metal. The bootloader is a separate choice. MCUboot lists ports for Zephyr, Apache Mynewt, Apache NuttX, RIOT (as a boot target only), Mbed OS, Espressif and Cypress/Infineon. Anywhere else you port one or write your own, and it becomes a security component you maintain.
  • Embedded Linux. The same idea applies to whole file systems: Mender documents a dual redundant (A/B) scheme, and RAUC supports symmetric A and B root file systems or a recovery and normal pair.

Check the platform’s support window against the support period you plan to promise. As of November 2026, Zephyr supports stable releases for about one year and long-term support (LTS) releases for about five; LTS3 (3.7.0) reaches end of life on July 27, 2029, and the next LTS, 4.6, is planned for April 2027 (Zephyr releases). FreeRTOS LTS libraries receive security updates and critical bug fixes for two years (FreeRTOS LTS).

The EU Cyber Resilience Act sets a support period of at least five years unless the product is expected to be in use for less. A five-year promise on a two-year LTS means at least one platform upgrade shipped over the air to the whole fleet, which is one more reason the update path has to work well. For the platform decision itself, see Zephyr, FreeRTOS or bare metal and how to choose a microcontroller.

Pick a bootloader mode that survives power loss and reverts bad images

Use a bootloader that checks every image’s signature before running it, keeps the previous image until the new one confirms itself, and can resume a half-finished install after a power cut. On microcontrollers the common open-source choice is MCUboot, and its documented modes show the trade-offs any bootloader has to make.

MCUboot normally runs images only from the primary slot. To run a new image it either swaps the two slots or overwrites the primary one, a choice made when the bootloader is built. Two further modes treat the slots as equals.

Mode How the new image comes to run Extra space If the new image fails
Swap using scratch Sectors are exchanged through a scratch area A scratch area at least as large as the largest sector swapped Swapped back at the next reset unless it confirmed
Swap using offset Sectors move through one spare sector in the secondary slot One sector Swapped back unless it confirmed
Swap using move The primary slot shifts up one sector, then the swap runs One sector plus swap status Swapped back unless it confirmed
Overwrite only The new image is copied over the old one None The old image is gone, so there is nothing to return to
Direct-XIP Runs in place from either slot; the highest valid version wins None, but each image is built for the slot it runs from Optional revert erases an unconfirmed image and boots the other
RAM load The newest image is copied into RAM and run there Enough RAM for the image Optional revert, as in direct-XIP

For new designs, note that swap-using-scratch “may be removed in the coming future”, and swap-using-offset “is preferred over swap-using-move except when building for existing products already using the latter.”

Test, then confirm

The swap modes support a two-step install. MCUboot performs a “test” swap and boots the new image, which can then mark itself “OK”; only then does the swap become permanent. If the device resets first, for example because the new image crashes on start, MCUboot swaps the old image back at the next boot.

ESP-IDF follows the same pattern with a pending-verify state. The new app runs diagnostics and either marks itself valid or requests a rollback, and with rollback enabled, a reset before either call also returns the device to the previous app.

The confirm step is only as good as the self-test behind it. A sound rule is to confirm only after the new image has shown it can do its job and receive the next update: sensors read in range, the radio reached its gateway or server, and the watchdog stayed quiet for a set time. An image that boots, confirms and then cannot download a fix is the one failure a revert will not catch.

Wear, boot time and the two meanings of rollback

Swapping wears flash. MCUboot’s documentation works an example for swap-using-scratch: with 10,000 erase cycles, a 150 KB image and a 4 KB scratch area, a device can take about 267 upgrades before the scratch sector goes out of spec, and a 16 KB scratch area raises that to about 1,067. Count bench and development updates too, not only field releases.

Checking signatures costs time. MCUboot notes that validation at boot can take about 1 to 2 seconds on a low-performance Arm Cortex-M0, and offers an option to validate once and cache the result, which it says reduces security.

“Rollback” also means two opposite things, and you need both. Recovery rollback returns a device to its last good image after a failed update. Anti-rollback, which MCUboot calls downgrade prevention, refuses older images that may still carry vulnerabilities you fixed. In MCUboot, version-based downgrade prevention works only with overwrite-only upgrades; the hardware-based kind compares a security counter kept in trusted non-volatile storage, which does not have to rise with every release. ESP-IDF keeps its security version in eFuse.

The slot layouts are compared in depth in A/B or single-slot updates, and the version policy in rollback versus anti-rollback.

Keep signing keys off build machines and laptops

The private key that signs production images is the most valuable secret your product has: whoever holds it can install code on every device you ship. Keep it in a signing service or a hardware security module (HSM, a device that signs without ever exporting the key), separate from development keys, and let only named people trigger a production signature.

Start by removing the default. MCUboot ships a development key for testing, and its imgtool documentation is blunt: “Since this private key is widely distributed, it should never be used for production.” A production bootloader must embed your own public key. With MCUboot’s hardware-key option, the device instead holds a hash of the public key, provisioned separately from the bootloader build.

imgtool supports RSA-2048, RSA-3072, ECDSA P-256 and Ed25519 keys, and the key type must match what the bootloader was built to verify. For signing away from the build machine, imgtool can write out the payload or its digest instead of a signed image. The build server prepares the image, and a separate service that holds the key produces the signature.

Storage alone is not enough. The IETF’s manifest information model, RFC 9124 (January 2022), describes the threat: if signing runs on a server connected to the internet, “an attacker may compromise the server and then be able to sign manifests, even if the keys for manifest signing are held in an HSM that is accessed by the server.” Who can ask for a signature matters as much as where the key lives.

Decide four things before the first production key exists:

  1. Custody. Where the key is generated and stored, and which people and systems can use it.
  2. Approval. How many people must agree before a production image is signed. The update policy worksheet records the rule in one line, for example two named people, with the key never leaving the signing service.
  3. Separation. Development keys sign bench builds only, and production units refuse anything they sign.
  4. Loss and leaks. Whether the bootloader can hold more than one public key, how a replacement key reaches devices, and what happens to units that are offline when it does.

RFC 9019 adds a longer horizon: for bootloader code in ROM, which can never change, it recommends “post-quantum secure signature schemes such as hash-based signatures”.

Custody, rotation and revocation get a full treatment in firmware signing key management. The secure boot checklist lists the tests that prove the keys are wired correctly, and our security page describes how we handle client keys and code.

Build an update agent that checks before it installs

The update agent is the code on the device that learns about a release, downloads it into the spare slot and reports what happened. It should reject an image meant for another device before spending battery and airtime on it, survive interrupted downloads, and tell your server its version and update state.

Before and during a download, the agent should check:

  • Hardware match. RFC 9124 lists “mismatched firmware” as a threat: a valid image for the wrong type of device, signed by someone allowed to update both types, which for very different devices “is likely to render devices inoperable.” Carry the device class and hardware revision in the image metadata. imgtool, for example, accepts vendor and image class identifiers.
  • Version. Refuse older images early. ESP-IDF recommends reading the new app’s security version from the first package of a download, to avoid the download and erase overhead of an image the bootloader will refuse anyway.
  • Size. The image must fit the slot, header and trailer included.
  • Integrity. Check the hash of the stored image before asking the bootloader to test it, and never mark a partial image for test.
  • Power. RFC 9019 notes that radio traffic and flash writes make an update “an energy-intensive task”, so check the battery before a long transfer.

The agent is also the client half of RFC 9019’s status tracker: it hears about new versions, reports the installed version and free flash, and accepts a trigger to update. Your fleet dashboard is the server half.

Transport changes time and cost, not the rules

Over Bluetooth LE, the phone or gateway decides much of the speed. The default example in the Bluetooth LE update time calculator, a 412 KB image with 244-byte payloads, three packets per connection event and a 30 ms connection interval, transfers in about 21.6 seconds. With 20-byte payloads the same image takes about 4.4 minutes. The levers on both ends are in faster Bluetooth LE firmware updates.

Over cellular, the cost is data. The default example in the over-the-air data cost calculator assumes a hypothetical fleet of 5,000 devices, a data price of $0.40 per MB, 8% protocol overhead and 5% of devices downloading twice. One rollout of a 412 KB full image costs about $913, and a delta image at 30% of that size about $274.

A delta image carries only the differences from the installed version. RFC 9019 notes that a differential update needs a dependency resolution step, because what the update depends on, here the version it was built against, must be present before installation. Whether that is worth the added work is the subject of delta firmware updates.

Give each device its identity and lock it at the factory

The factory line is where the update path becomes real. Each unit receives the bootloader, the key it will trust, a signed first image, its own identity and a locked debug port, and the line records all of it against the serial number. Mistakes here are expensive: a unit that leaves with a shared secret or an open debug port stays that way until someone handles it.

RFC 9019 calls the party that installs trust anchors (the public keys a device trusts) the Trust Provisioning Authority. It expects them to be installed “in an out-of-band fashion prior to the firmware update process.” For most startups, that out-of-band channel is a programming station at the contract manufacturer.

A minimal factory sequence for an updatable device:

  1. Program the production bootloader with the production public key or its hash, and a signed shipping image.
  2. Give the unit its identity. A unique serial number and, if it talks to a cloud service, its own key pair or certificate. Never a fleet-wide password: ETSI EN 303 645 provision 5.1-1 requires passwords to be “unique per device or defined by the user”, and the UK PSTI regime rules out passwords based on incremental counters, and passwords derived from serial numbers unless an accepted encryption method or keyed hash is used.
  3. Test, then remove the test door. Run the factory test, then make sure test and factory commands cannot run in shipping firmware.
  4. Lock the debug port and enable readout protection where the chip offers it. An open debug port lets anyone with a probe read the firmware or write a new image, which goes around image signing entirely.
  5. Record everything. Serial number, hardware revision, bootloader and firmware versions, public identity and test results. The update server needs the hardware revision to offer each unit the right image.

Order matters: lock the debug port only after the unit passes test, and write the record last, so a unit without a record counts as not built.

Who generates device keys, and whether the contract manufacturer ever sees them, has three common answers with different costs. They are compared in factory provisioning and device identity. The PVT gate in the production readiness checklist lists the same items as pass or fail checks, and manufacturing firmware describes the factory programming and test firmware we build.

Release every version the same way

Every release should be built by CI from a tagged commit, carry a version the bootloader can compare, be signed through the same service, ship with notes and a software bill of materials, and pass the same failure tests. When a device in the field reports “1.1.0”, you should be able to say exactly which source, keys and tests produced it.

Versions the bootloader can compare

MCUboot’s image header stores the version as four numbers: major, minor, revision and build number. In direct-XIP mode the bootloader selects the image with the highest version. Labels such as “rc2” therefore belong in release names, not in anything a bootloader compares. imgtool can stamp a separate security counter with its -s option, or derive it from the version with auto.

The version scheme builder turns one release into a semantic version for people, an image version for the header and a file name for the signed image. The release notes builder groups changes under Security, Added, Changed and Fixed, and states the rollout plan and what happens if the update fails.

A bill of materials and a security branch

The CRA asks manufacturers to draw up a software bill of materials (SBOM, a list of the components in the firmware) “in a commonly used and machine-readable format covering at the very least the top-level dependencies.” Generate it from the same build that produced the image, not by hand afterwards; SBOMs for embedded firmware covers vendor SDKs and binary blobs.

The CRA also says that “where technically feasible, new security updates shall be provided separately from functionality updates.” In practice that means keeping a release branch you can patch and ship without pulling in half-finished features.

Tests that break the update path on purpose

An update path is not finished because one update worked on a desk. Each release should pass, on real hardware:

  • An update from the oldest version still in the field, not only from the last release.
  • Power pulled during the download, during the swap and during the first boot of the new image.
  • A self-test forced to fail, to watch the device revert.
  • An image signed with a development key, an older version and an image built for another hardware revision, each of which must be refused.
  • A slow or dropping link, to confirm the download resumes or restarts cleanly.

The firmware release checklist carries these tests, and firmware testing with CI and hardware-in-the-loop rigs explains how to run them on every build.

Roll out in waves and stop on fleet health

Offer each release to a small group first, wait a fixed soak time, compare health signals with a halt rule written before the rollout starts, and only then widen the audience. A staged rollout limits how many devices a bad release can reach before anyone notices.

The default example in the staged rollout planner uses a hypothetical fleet of 12,000 devices with cumulative waves of 1%, 10%, 50% and 100%, 48 hours of soak and an expected failure rate of 0.2%. Wave 1 is 120 devices, and the halt rule of more than 1% failures trips at more than 1 rollback among them. The whole fleet is offered the release on day 6, and about 24 devices would be expected to roll back along the way.

Signals worth gating on, each compared with the previous version on the same hardware:

  • Confirmed updates. Devices that installed and confirmed the new image, against devices offered it.
  • Rollbacks. Devices that reverted to the previous image.
  • Silent devices. Devices that stopped reporting after the update, the most serious signal because they cannot tell you why.
  • Resets and crash reports per device per day.
  • Battery and connection behavior, such as drain rate and reconnect counts.

Silent devices and crash reports only help if the firmware captures something useful before it resets. Field crash diagnostics covers what to record.

Example (fictional). Loamwick’s 40-probe trial fleet takes version 1.1.0, which fixes moisture readings that drifted upward after 30 days in wet clay. It goes to Loamwick’s own 4 bench probes first, then 12 trial probes, then the remaining 24, with 48 hours of soak between waves. The halt rule, written before wave 1, is strict for a small fleet: if any probe rolls back or goes silent, the rollout stops until someone can explain why.

Choose the first wave from devices you can reach: your own units, a friendly site, and the same hardware revisions as the rest of the fleet. A first wave that is too small may not show a rare failure, so the soak time and the signals matter as much as the wave size.

Write down who can start a wave, who can halt one and who tells customers, before the first release. The update policy worksheet has a row for each. Where to set thresholds, and how to tell a real regression from noise, is covered in staged firmware rollouts.

Staging still fits urgent security fixes. Shorten the soak time rather than skip the first wave. The CRA expects security updates to be disseminated “without delay”, and a fleet-wide failure would delay the fix far more than one short wave.

The update duties now written into rules

As of November 2026, the main rules for connected products in the EU and the UK, and for medical devices in the US, each require some mix of a secure update mechanism, a published support period and timely security updates. Figure 3 summarizes them. This is a planning summary of public texts, not legal or regulatory advice; check the current text and your product’s scope with a qualified advisor.

The EU Cyber Resilience Act, Regulation (EU) 2024/2847, entered into force on December 10, 2024. Its reporting obligations have applied since September 11, 2026, and its main obligations apply from December 11, 2027 (European Commission). Under Article 14, a manufacturer that becomes aware of an actively exploited vulnerability in its product must send an early warning within 24 hours and a fuller notification within 72 hours.

Annex I of the CRA turns the update path into a requirement. Products must “ensure that vulnerabilities can be addressed through security updates, including, where applicable, through automatic security updates”, on by default with an easy opt-out and an option to postpone. Manufacturers must “provide for mechanisms to securely distribute updates”, and security updates must go out “without delay” and, outside agreed tailor-made products, free of charge. Article 13 requires each security update to stay available for at least 10 years or for the rest of the support period, whichever is longer.

ETSI EN 303 645 says a consumer IoT device “shall have a secure update mechanism unless the device has a resource constraint determined by the use case that prevents the implementation” (provision 5.3-2). The device shall verify the authenticity and integrity of each update delivered over a network (5.3-10), and the manufacturer shall publish the defined support period (5.3-13).

The UK’s consumer product security regime has applied since April 29, 2024. One of its three requirements is about updates: manufacturers must publish “the minimum length of time security updates will be provided along with an end date.”

For medical devices, section 524B of the US Federal Food, Drug, and Cosmetic Act has applied to premarket submissions for “cyber devices” since March 29, 2023. FDA’s summary lists processes to assure device cybersecurity, “including postmarket updates and patches to devices and related systems”, plus an SBOM. FDA’s current premarket cybersecurity guidance is the February 2026 version.

The US Cyber Trust Mark is a voluntary FCC label for consumer wireless IoT products, and its registry is planned to show “whether updates/patches are automatic” and the product’s minimum support period end date. It was not open to products when the FCC’s program page was captured on November 1, 2026 (archived copy); the page says the FCC will announce when the program is ready to accept product applications. An October 28, 2026 FCC release describes the program as moving “toward use by manufacturers and consumers.”

Rule or programWho it coversWhat it says about updatesStatus, November 2026
EU Cyber Resilience Act, Regulation (EU) 2024/2847Products with digital elements on the EU marketSecurity updates, automatic by default where applicable; secure distribution; free of charge; separate from feature updates where feasible; support period of at least five yearsIn force since Dec 10, 2024; reporting since Sep 11, 2026; main obligations from Dec 11, 2027
ETSI EN 303 645 V3.1.3Consumer IoT devices (European standard)Secure update mechanism unless a use-case constraint prevents it; verify updates; publish the defined support periodPublished September 2024
UK PSTI regimeConsumer connectable products sold in the UKPublish the minimum security update period with an end dateIn effect since Apr 29, 2024
FD&C Act section 524BCyber devices in US premarket submissionsProcesses for postmarket updates and patches; SBOM; postmarket vulnerability planApplies since Mar 29, 2023; FDA guidance revised February 2026
US Cyber Trust Mark (FCC)Consumer wireless IoT products, voluntaryRegistry to show whether updates are automatic and the support period end dateNot yet open to product applications
Figure 3. Update duties in five rules and programs, as of November 2026. A summary for planning, not legal or regulatory advice. Sources: EUR-Lex and European Commission, ETSI, GOV.UK, FDA and FCC pages linked in the text, checked November 22, 2026.

The common thread is a support period you can keep. Choose it with the platform’s support window, your signing key’s planned life and your server costs in view, then publish it where the rules ask. The EU duties in detail, including the reporting chapter, are in what the Cyber Resilience Act requires of device makers, and firmware security describes the readiness work we do without claiming any certification.

An OTA update checklist for the first production run

If every line below holds on design-validation units, the update path is ready for a first fleet. Any gap shows where the next sprint should go.

Design

  • Two images, the bootloader, settings and logs fit with the growth you expect, or the second slot has a planned home in external flash.
  • The bootloader verifies signatures, refuses older images by version or security counter, and reverts an image that never confirms.
  • Power was pulled during download, swap and first boot, and every unit came back on a working image.

Keys

  • The MCUboot development key, or your chip vendor’s sample key, is gone from production builds.
  • The production key lives in a signing service or HSM, and named people approve production signatures.
  • A written plan covers a lost or leaked key, including units that are offline.

Agent and factory

  • The agent checks hardware revision and version before downloading, resumes interrupted transfers and reports version and update state.
  • Each unit has its own identity, no shared password, a locked debug port and a factory record.

Release and rollout

  • CI builds, signs and records every release, and notes and an SBOM ship with it.
  • Release tests include updating from the oldest field version and refusing wrong keys, old versions and wrong hardware.
  • A wave plan, soak time and halt rule are written down, each with an owner.

Product life

  • A support period is chosen and published, and the platform, keys and servers can last that long.

The arithmetic behind several lines is in the flash budget calculator and the staged rollout planner. The fictional example project follows one device through every link in this chain, week by week.

Fumbar’s engagements start with a firmware review: we read the schematics, the current code, the flash layout and the update plan, and deliver a written plan with the risks and the order of work. Later stages end with signed releases, a tested rollback and documentation your team can run, and you receive the source code, build instructions and signing setup under the ownership terms in the agreement. How we work describes the stages, and over-the-air updates describes the update path itself. If your boards are still prototypes, this is the cheapest moment to settle all eight links, so request a firmware review.

Facing this decision on a real device?

If this article describes a choice in front of you, a firmware review puts it in writing for your board, your code and your update plan.

Request a firmware review

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