Request a firmware review
Menu
About 23 minutes to read

Delta firmware updates: when smaller images pay off

Reader question: When are delta (differential) firmware updates worth their added complexity on a microcontroller fleet, and what do they demand from the bootloader and release process?

Micrograph-style illustration of a salt crystal with a thin new layer growing on one face, only the new layer tinted amber.

A delta firmware update is worth its added complexity when moving a full image is expensive, slow or impossible: metered cellular data across thousands of devices, LoRaWAN links where a full image takes hours of radio time, or batteries where update energy is a real share of the budget. It demands a byte-identical base image on every device, one patch per source version, a decoder that can rebuild the complete image beside the running one, and a release pipeline that keeps every binary you have shipped. For a few hundred devices on Wi-Fi or behind a Bluetooth LE gateway, a well-built full-image update usually wins.

The rest of this article gives the inputs, the arithmetic and the engineering changes, so you can run the numbers for your own fleet before anyone writes a patch decoder.

What a delta update sends instead of a full image

A delta update (also called a differential or incremental update) sends a patch: a compact set of instructions for rebuilding the new firmware from the firmware already on the device. The device runs a decoder, writes the rebuilt image, checks it and then installs it the usual way.

Three terms carry the rest of this article. The base image (also called the source or precursor image) is the exact binary the device runs today. The target image is the release you want it to run. The patch is the difference between them, usually compressed.

The IETF’s firmware update architecture, RFC 9019 (April 2021), already allows for this: it says an image “may consist of a differential update for performance reasons.” Its companion manifest model, RFC 9124 (January 2022), separates the payload that travels from the firmware image that runs, because the payload is often “encoded as a differential update.”

Two ways to compute the difference

Block-level deltas compare the old and new binaries in fixed blocks and send only the blocks that changed. Renesas’ application note R01AN8321 (Rev.1.00, July 3, 2026) works this way on its RX microcontrollers. The default block is 128 bytes, matched to the code flash program unit. The device writes the changed blocks into the buffer bank of its dual-bank flash and copies every unchanged block from the running firmware. In the note’s demo, a change to the logged version string and the LED pattern produced a 1,152-byte diff image containing one 128-byte block.

Byte-level deltas describe the new image as a sequence of “copy these bytes from the old image” and “add these new bytes” instructions. Colin Percival’s bsdiff, described in his 2003 paper “Naive differences of executable code,” is the best-known example. Tools used on microcontrollers include:

  • detools offers bsdiff, hdiffpatch and match-blocks algorithms, sequential, hdiffpatch and in-place patch types, and compression including LZMA and heatshrink, plus a C library for applying patches on constrained devices.
  • HDiffPatch points embedded users to HPatchLite, which its README says can run on devices with 1 KB of RAM when paired with its tinyuz decompressor.
  • janpatch is an Apache 2.0 applier for JojoDiff patches, written as a single C header.

Delta is not the same as compression

Compression shrinks a full image without knowing what the device already holds. Delta depends entirely on it. MCUboot’s design documentation defines image fields for compressed images (the decompressed size, hash and signature), but, as checked in November 2026, it describes no delta format. Many tools combine both: Espressif’s delta component compresses its patches with heatshrink.

Approach What travels What the device must already have Typical home
Full image The whole signed image Nothing beyond a free slot Every bootloader
Compressed full image The whole image, compressed A decompressor MCUboot’s compressed-image fields
Block-level delta Changed blocks only The exact base image and a second bank Renesas RX dual-bank update
Byte-level delta, streamed Copy and add instructions The exact base image, a decoder and a free slot detools, esp_delta_ota
In-place delta Copy and add instructions, ordered for in-place use The exact base image and resumable patch state detools in-place type, HPatchLite

The four inputs that decide whether delta pays off

Delta pays off when the bytes, radio time or battery it saves outweigh the engineering and the release discipline it costs. Four inputs decide that, and you can estimate each before writing any code.

1. Data cost. Multiply the data each device downloads by the fleet size, the number of releases a year and your price per megabyte. The OTA data cost calculator uses this formula: data per device equals image size times one plus protocol overhead, times one plus the share of devices that download twice. A delta reduces only the image term.

2. Radio time and battery. Every second the radio spends receiving firmware is current drawn from the cell. On a mains-powered gateway this does not matter. On a LoRaWAN sensor that must keep its receiver on for the whole update, it is a line in the battery budget you have to measure.

3. Link feasibility. Some links cannot carry a full image in a practical window at all. Small payloads, duty-cycle or fair-use limits and poor coverage can turn a full-image update into hours of airtime. Here a delta changes what is possible, not just what it costs.

4. Change size and release cadence. A delta is small only when the release is small. Frequent maintenance releases diff well; a toolchain upgrade or a large feature release may not diff at all. In the LoRaWAN study discussed below, the authors classed patches larger than 20 percent of the firmware as major updates, and on their STM32WL target their encoder’s default mode produced a patch slightly larger than the image for that class (a compression factor of 0.951).

EU regulation points the same way. For products sold in the EU, the Cyber Resilience Act sets a support period of at least five years (Article 13(8)) and asks that, “where technically feasible, new security updates shall be provided separately from functionality updates” (Annex I, Part II). Its main obligations apply from December 11, 2027. Small security-only releases are exactly the kind that produce small patches. This is context, not legal advice.

A decision rule you can apply today

The rule below is our judgement, not a measured result. Build delta updates when at least one of these holds:

  1. A full image cannot reach the device within the update window your product can tolerate.
  2. Data savings over the support period, from the calculator, clearly exceed the cost of building, testing and running the delta path.
  3. Radio energy for updates over the product’s life is a share of the battery budget you would otherwise have to design around.

Skip delta, for now, when none of these holds. Also skip it when your fleet runs many different versions, when releases are rare and large, or when no one on the team can own the patch pipeline and its tests.

Situation Usually Why
Thousands of cellular devices, monthly releases Delta worth modeling Data cost scales with fleet times releases
LoRaWAN or similar low-rate link Delta often needed Full images take hours of receive time
Bluetooth LE devices updated from a phone or gateway Full image Transfer takes seconds; savings are tiny
Wi-Fi or Ethernet, mains powered Full image Data and energy are effectively free
Fleet spread across many old versions Full image, or delta for recent versions only Patch count grows with every source version

Worked numbers for a cellular fleet

On cellular, delta pays off when fleet size times release count times the bytes saved, priced per megabyte, beats what the delta path costs you to build and keep running. The calculator’s default example shows the scale.

Example (fictional). A fleet of 5,000 cellular devices runs a 412 KB firmware image. Typical deltas are 30 percent of the full image. Protocol overhead is 8 percent, 5 percent of devices download twice, data costs $0.40 per MB, and the team ships 6 releases a year.

  • Data per device: 0.456 MB for the full image, 0.137 MB for a delta.
  • One rollout: 2.23 GB and $913 with full images, 0.67 GB and $274 with deltas.
  • A year of releases: $5,475 with full images, $1,643 with deltas.
  • Per device per year: $1.10 with full images, $0.33 with deltas.

The delta path saves $3,832 a year, or about $0.77 per device per year. Over a five-year support period, at a constant fleet and price, that is about $19,160.

That saving is real, but it is not large next to the cost of an engineer building, testing and maintaining a patch pipeline. Put your own loaded engineering cost (call it C) beside it. The delta path pays back after C divided by the per-device annual saving, in device-years. With $0.77 per device per year, every $10,000 of delta work needs about 13,000 device-years to pay back.

What moves the answer

Three inputs swing the result more than anything else:

  • Price per MB. Plans billed per device with pooled data may make the marginal megabyte almost free. Plans with overage charges make it expensive. Check how your carrier counts a megabyte; the calculator uses 1,024 KB.
  • Delta share. The 30 percent default is an assumption. Measure it on your own last five releases by generating real patches; it may be far smaller for maintenance releases and far larger for feature releases.
  • Who downloads. If devices download from a gateway that relays over a local radio, count gateway downloads, not end devices.

The last point often settles the question on its own. The choice of cellular technology also changes transfer time and power during a download; the trade-offs are in LTE-M or NB-IoT for US deployments.

Radio time on LoRaWAN and Bluetooth LE

On low-rate links the deciding cost is radio time, not data price. A 2025 study of LoRaWAN updates shows how far a delta can move it, while a Bluetooth LE device updated over a fast link gains almost nothing.

LoRaWAN: from over two hours to minutes

LoRaWAN firmware updates over the air can use the LoRa Alliance’s Fragmented Data Block Transport package (TS004-2.0.0, published April 14, 2022), which splits a block of data into fragments sent to one or more devices. Each fragment is small, so a full image means many of them.

Andrea De Simone, Giovanna Turvani and Fabrizio Riente measured this on an STM32WL55JC node with 256 kB of on-chip flash, 64 kB of SRAM and an external 8 Mbit flash (arXiv 2505.13764, published in Internet of Things, volume 34, 2025). At 868 MHz and spreading factor 9, the maximum payload was 115 bytes, leaving 112 bytes of firmware per fragment. A firmware image of about 100 KB needed more than 900 fragments and over 100 minutes of transmission.

The device stays in LoRaWAN Class C, with the receiver continuously on, for the whole session. The authors measured Class C consumption at more than three orders of magnitude above Class A.

Full image Incremental (bpatch) Pair 1 Pair 2 Pair 3 Pair 4 Pair 5 Pair 6 Pair 7 Pair 8 114 127 144 144 142 148 146 149 46 24 26 13 9 16 8 9 0 50 100 150 min
Figure 1. Transmission time in minutes for a LoRaWAN update, full image versus incremental patch, for eight firmware version pairs on an STM32WL55JC node at 868 MHz and SF9. Energy estimates in the same table range from 12.17 to 15.93 mAh for full images and 0.86 to 4.93 mAh for patches, fragment phase only. Source: De Simone, Turvani and Riente, arXiv 2505.13764, Table 4, read November 2026.

Across the eight pairs, the incremental update cut transmission time by a factor of 2.47 to 18.10. The energy figures cover only the fragment phase, so the authors call them a conservative lower bound. Rebuilding the image on the device took about 4.6 to 5.1 seconds at roughly 12 mA, an energy cost about three orders of magnitude below the transmission.

Two limits matter before you copy this result. The authors did not run competing decoders on the device, because those need a filesystem and more RAM than the target had. They also left security, authenticity and patch delivery out of scope, so a product needs the signing layer described later in this article.

Multicast sessions need a shared base

The paper names multicast, broadcasting the same fragments to many devices at once, as the other main way to cut the cost of LoRaWAN updates. Multicast and delta combine only if every device in a multicast group runs the same base image, because they all receive the same patch. Group devices by running version before you open a session. Devices on other versions go into their own session, or get a full image later.

Keep the update agent’s own failure path in mind on these links. If a device’s base check fails, a full-image retry in the setup above costs roughly another two hours of receive time. Version tracking on the server is what keeps that from happening.

Bluetooth LE: seconds saved, microamp-hours gained

A Bluetooth LE link with a short connection interval and a large data length moves a whole image in seconds. Here a delta saves little.

Example (fictional). Loamwick’s LW-1 probes receive updates over Bluetooth LE from a solar-powered gateway, and the gateway downloads each release over LTE-M. The probe image is 412 KB. With the BLE update time calculator defaults (244-byte payloads, 3 packets per connection event, a 30 ms interval, 80 percent of packets carrying image data), the transfer takes 21.6 seconds, or 36.6 seconds with verify, swap and reboot.

A 30 percent delta, 124 KB, would transfer in about 6.5 seconds, saving about 15 seconds of connection time per probe per release. At the battery life calculator’s default radio current of 6 mA, that is about 0.025 mAh per release, or 0.15 mAh a year at 6 releases. The calculator’s default cell gives 2,550 mAh of usable capacity, so the saving is under 0.01 percent of it.

On the cellular side, the pilot has 4 gateways. Each full-image download is 0.456 MB, or about $0.73 per release for all four at $0.40 per MB. A delta would save about $0.51 per release.

The verdict for Loamwick is to ship full images. Its real constraint is flash: the image fills 92.8 percent of its 448 KB slot, and a delta does not shrink the slot the rebuilt image needs.

The full Loamwick story, from first boards to signed updates on a pilot fleet, is on the fictional example project page. Faster transfers come from the link settings, not the image size; what limits BLE update speed covers MTU, data length, connection interval and PHY.

What delta costs: base images, patch counts and device resources

Delta moves cost from the network to your release process and the device. You pay in four places: a known base image, a patch per source version, device time and memory, and a larger test matrix.

A byte-identical base on every device

A patch only works against the exact bytes it was generated from. Microsoft’s Device Update delta documentation (updated May 21, 2026) says it plainly: “the corresponding source version must be available on the device.” Its agent caches previously installed updates for that reason.

On a microcontroller the base is usually the running image in the primary slot. Anything that changes those bytes breaks every patch built against them. That includes a field-written configuration value stored inside the image area, or a factory step that patches a serial number into the binary.

One patch per source version, and no chaining

Each patch takes one specific source version to one target. Microsoft’s service applies “at most one delta update per deployment” and does not chain deltas, so each patch must go directly from a source version to the target. It also tells you to “always include the full target update” for devices without a compatible source.

The patch count is easy to underestimate. Suppose, as a hypothetical, you support deltas from the last three releases on two board revisions that need different images. Every release then needs six patches plus two full images. With MCUboot’s direct-XIP mode, covered below, images are built for the slot they run from, which can double the count again.

Device time, RAM and flash

The device must read the base, decode the patch and write the target. Desktop bsdiff is not built for this: its author lists bspatch at n+m bytes of memory, the old and new files together. Microcontroller decoders stream instead, holding only small buffers.

Flash is the cost teams miss. A streamed delta still writes a complete target image into a free slot, so it needs the same two slots as a full-image update. Espressif’s component needs no extra partition for the patch, because it streams the patch straight into the next OTA partition. Only in-place patching, covered below, removes the second slot, and it brings its own risks.

Testing

Every patch is a separate artifact that can fail on its own. You now test each supported source-to-target path, interrupted updates during patching, and the fallback to a full image. That test matrix is the largest ongoing cost of delta and the easiest to skip.

Cost Where it lands How to contain it
Exact base image Device and build archive Keep the image area read-only in the field
Patch per source version Release pipeline Support deltas from recent versions only
Decoder RAM and time Device Use a streaming decoder with small buffers
Two slots still needed Flash budget Plan the layout as for full images
Larger test matrix CI and test rig Apply every patch in CI and on hardware

What the bootloader and flash layout must support

On most microcontrollers the bootloader never sees the patch. An update agent in the application rebuilds the full image into the inactive slot, and the bootloader verifies and installs that image exactly as it would a full download.

That division keeps the boot path simple. It also means the delta decoder runs in your application, where you can update it, rather than in a bootloader you may never be able to change.

1. Signed manifest and patch arrive The manifest names the base image digest, target digest and size 2. Device checks its running image Running image digest must equal the base digest, or ask for the full image 3. Decoder streams the patch into the empty slot Copies unchanged bytes from the running slot, writes a complete image 4. Device hashes the rebuilt image It must match the target digest before the image is marked for test 5. Bootloader verifies the full signed image Same signature check, swap or boot as a full-image update 6. New firmware self-tests and confirms If it is not confirmed before the next reset, the bootloader reverts
Figure 2. Where a delta patch is applied on a two-slot microcontroller. Pale amber steps are the ones a delta adds; the last two are the same as for a full image. Basis: RFC 9124 precursor digest requirement, MCUboot design documentation and the Espressif esp_delta_ota example, read November 2026.

MCUboot with swap or overwrite

MCUboot “must be configured at build time” to use either swap-based or overwrite-based upgrades, according to its design documentation. With either, the update agent reads the base from the primary slot and writes the rebuilt image into the secondary slot. MCUboot then checks the image’s integrity, including its hash and signature, before copying it into the primary slot.

Nothing about the swap, the revert or the trailer changes. A swap with revert keeps its rollback; overwrite-only still has none. The choice between them, and its power-fail behavior, is covered in A/B or single-slot updates.

MCUboot direct-XIP

In direct-XIP mode the bootloader runs an image from either slot without moving it, and the documentation notes this “requires that the images be built to be executed from the corresponding slot.” The base for a delta is therefore whichever slot is active. The patch must produce an image linked for the other slot, so you generate patches per slot as well as per source version.

ESP-IDF with esp_delta_ota

Espressif’s esp_delta_ota component, for ESP-IDF v4.3 and later, uses detools to build patches. Its README lists “No bootloader related changes required” and says the scheme can be added to devices already in the field. The example applies the patch to the running firmware and writes the result into the next OTA partition. ESP-IDF’s normal app rollback still applies to the new image.

Renesas RX dual bank

The Renesas note runs inside the RX Firmware Update Module’s dual-bank scheme. Diff data goes to the buffer bank, unchanged blocks are copied from the current firmware, the result is verified, and the banks swap.

Single slot and in-place patching

In-place patching rewrites the running image without a second slot. detools describes its in-place type as useful “when flash operations are faster than the external interface transfer speed,” and says an interrupted in-place update can resume only if a step state and the patch header are stored persistently. Until the patch completes, there is no intact old or new application. You need a recovery path that does not depend on the application, such as a loader that can fetch a full image. Treat in-place patching as a flash-saving measure of last resort; the flash budget calculator shows whether you need it.

Signing and verifying a delta without weakening the chain

Sign and verify the full target image exactly as you would without delta, then add two checks: authenticate the patch before parsing it, and confirm the device holds the expected base. A delta should change how bytes travel, never what the bootloader trusts.

Name the base image in signed metadata

RFC 9124 sets the requirement in one line: “If an update uses a differential compression method, it MUST specify the digest of the precursor image, and that digest MUST be authenticated.” The threat it addresses is a valid patch applied to the wrong base. RFC 9124 notes this “could cause the update to break,” and that an attacker able to force it might gain elevation of privilege.

Espressif’s example shows the minimum form. Each patch starts with a 64-byte header holding a magic number and the SHA-256 of the base binary. Before patching, the device compares that digest with the SHA-256 of its running partition and refuses a mismatch. That header is an integrity check, not a signature. Authenticity still depends on the transport and on the signed-image checks you have enabled for the rebuilt image.

Verify the rebuilt image, not the patch alone

The bootloader should verify the complete target image with the same key and the same rules as a full image. Renesas does this: the diff image’s header carries the signature of the full update firmware, and verification covers the entire update image after reconstruction. On MCUboot, the rebuilt image carries its own hash and signature, so step 5 in Figure 2 is unchanged.

The same logic covers downgrade protection. The rebuilt image carries its version and, if you use one, MCUboot’s security counter, so anti-rollback rules apply to it as to any image. Rollback and anti-rollback explains the difference between recovering from a bad release and refusing an old one.

Treat the decoder as an attack surface

A patch decoder parses input from the network and writes to flash. Authenticate the patch, or the manifest that carries its digest, before the decoder reads a byte. Bound every copy and add instruction against the slot size, and fuzz the decoder in CI with corrupted patches. The research encoders above leave this to you: the LoRaWAN paper states that security and authenticity were outside its scope.

Encryption and deltas

Encrypted images look like random data, so a diff between two encrypted images saves nothing. Generate patches from plaintext images and protect the patch in transit, or encrypt the patch itself. If you encrypt images at rest in external flash, the decoder has to work on decrypted data. Settle this before choosing a delta tool. The signing side of this work is part of our firmware security service.

The release pipeline delta requires

Delta turns each release from one artifact into a set: the full signed image, one patch per supported source version, and a manifest tying them together. Your pipeline has to build, verify and archive all of them every time.

Steps for every release

  1. Archive every shipped binary. Keep the exact signed image of each release, with its build metadata, forever. You cannot generate a patch from a version you cannot reproduce byte for byte.
  2. Choose the supported sources. Decide which earlier versions get a patch, for example the last three releases. Everything older gets the full image.
  3. Generate patches in CI. Build one patch per source and target pair from the archived binaries, never from a fresh rebuild of an old tag.
  4. Verify each patch before publishing. Apply it to the archived base in CI and compare the result’s hash with the target. Espressif’s patch generator includes a verify_patch command for this.
  5. Publish a manifest. List the base digest, target digest and size for each patch, and sign it.
  6. Serve the right file per device. The server reads each device’s reported version and offers the matching patch, or the full image.
  7. Fall back automatically. If a patch fails its base check or its target hash, the device asks for the full image instead of retrying the patch.
  8. Report the path taken. Have devices report whether they used a delta or a full image, and why a delta failed. Rising fallbacks point to drifted base images.

How many source versions to support

Base the choice on the version spread your devices report, not on a fixed rule. If most of the fleet updates within days of each release, deltas from the previous one or two versions cover nearly everyone. If devices sit offline for months, for example sensors stored over winter, the spread widens and each extra source version adds a patch, a test and an archive entry.

A workable policy has three parts: a patch for each version that still holds a meaningful share of the fleet, a full image for everything else, and a review of the spread at every release. Write the policy down next to who may ship and when; the update policy worksheet keeps those rules in one document.

Test on hardware, not only in CI

Run each supported path on real boards: apply each patch, cut power during patching and during the swap, and confirm the device ends on either the old or the new image. Roll out patches in the same waves as full images. The firmware release checklist already covers interrupted updates and rollback; delta adds one row per patch.

Build habits that keep patches small

A few build choices decide whether consecutive releases diff well:

  • Remove volatile bytes. A build timestamp or a host path embedded in the image changes bytes in every build. Keep version and build data in one small, fixed place.
  • Keep the link order stable. Changing source file order, linker scripts or optimization flags moves code and inflates the patch.
  • Expect toolchain upgrades to be full releases. A new compiler can change most of the binary. Plan to ship those as full images.
  • Keep data that changes often out of the code image. Calibration tables and certificates in a separate region stop their changes from touching the code image.

Block-level schemes are more sensitive to moved code than byte-level ones. In the Renesas scheme, which compares blocks at the same addresses, a few inserted bytes can shift and change every following block, while bsdiff-style copy instructions can follow code that moved. The Renesas tool also refuses to produce a diff image when 32 or more blocks change, because of a header limit, and when a block becomes entirely blank (0xFF).

Delta on embedded Linux devices

Several embedded Linux update frameworks include delta support. Linux images are larger, and the devices usually have the storage and RAM to rebuild them. If your product sits on that boundary, compare the options before choosing a platform.

As of November 2026:

  • Device Update for IoT Hub supports delta updates for image-based updates in SWUpdate (SWU) format, with Microsoft’s reference implementation of delta generation and on-device reconstruction. Its documentation notes that “delta updates trade additional on-device storage and processing for reduced network usage.”
  • Mender says its delta updates are available in its Enterprise plan and partially in Professional. The server picks a delta when one exists for the device’s running release and falls back to the full image otherwise. Its mender-binary-delta tool uses xdelta.
  • RAUC added “adaptive updates” in version 1.8. Its documentation says the only mode, block-hash-index, works for block devices and needs a server that supports HTTP range requests.
  • SWUpdate ships a delta handler built on the zchunk format. Its documentation notes that with librsync, once the difference grows, the delta image can become larger than the original.

The same principles hold: an exact base, one path per source version, verification of the rebuilt image, and a full-image fallback. Whether a product needs Linux at all is a separate decision, made mostly on hardware and software requirements rather than update size.

A decision checklist before you build delta

Run the numbers first, then decide; most of this checklist needs only your build archive and the calculators, and it can spare you a patch decoder you did not need.

  1. Price a year of full-image releases. Enter your image size, fleet, data price and release count in the OTA data cost calculator. Count gateway downloads if devices sit behind one.
  2. Measure your real delta share. Generate patches between your last few releases with the tool you would use, and record their sizes. Use the median, not the best case.
  3. Estimate update energy. Multiply transfer time by radio current and releases per year, and compare it with usable battery capacity.
  4. Check link feasibility. Work out how long a full image takes on your worst-case link. If that exceeds your update window, delta may be required rather than optional.
  5. Count the patches. Multiply supported source versions by board revisions, and by two for direct-XIP. Decide which versions get a full image.
  6. Confirm the flash layout. Make sure two slots still fit, with room to grow. Delta does not reduce the slot size.
  7. Plan signing. Put the base and target digests in signed metadata, verify the rebuilt image with your existing key, and fuzz the decoder.
  8. Plan the fallback. Every device must be able to take the full image if its patch does not apply.
  9. Decide who owns it. Someone must archive binaries, generate and verify patches, and watch fallback rates for years.

If items 1, 3 and 4 show small numbers, ship full images and revisit when the fleet or the link changes. A clean full-image path with signed releases and a tested rollback comes first either way; what it takes to ship firmware you can safely update describes that foundation.

Fumbar is a Denver company that writes embedded firmware and builds the over-the-air update path for hardware startups, including delta images where the numbers justify them. Our over-the-air update service starts from the same arithmetic as this article. If you want a second opinion on your own fleet’s numbers, flash layout and update plan, you can 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.