Use a microcontroller unless the product needs something only an application processor running Linux provides: a camera or video pipeline, a rich graphical display, a container runtime or other operating-system services, or software that exists only for Linux. Once you count a support period of five years or more, a Linux device also carries a standing maintenance job: tracking kernel and userland fixes, running a larger A/B update system, and migrating to a new kernel and build-system release at least once. A microcontroller product has the same kinds of jobs, at a much smaller size.
This article sets out the requirements that genuinely point to Linux, the dated support windows you will live inside, and a way to count the work before you commit to a board.
What actually differs between the two
A microcontroller runs one program from its own flash and RAM, with no operating system or a small real-time one. A Linux-capable application processor boots a chain of bootloaders, a kernel and a root filesystem from external storage into external memory. That difference in structure, more than clock speed, decides cost, power and maintenance.
A microcontroller (MCU) puts the processor, flash, RAM and peripherals on one chip. Firmware is a single image, usually hundreds of kilobytes, built from your code, a vendor SDK and an RTOS such as Zephyr or FreeRTOS, or none at all. TI’s CC2340R5, a Bluetooth LE and IEEE 802.15.4 part, is one example from one vendor’s line: a 48 MHz Arm Cortex-M0+, up to 512 KB of flash and up to 64 KB of SRAM, with full RAM retention in standby at under 710 nA on its CC2340R52 variant.
An embedded Linux system uses an application processor (often called an MPU) with external DRAM and storage such as eMMC or NAND. The software is a stack: boot ROM, one or two bootloaders, the Linux kernel, device tree, a root filesystem with system libraries, and your application. You build it with a distribution builder such as the Yocto Project or Buildroot, or start from a general-purpose distribution.
System-on-modules change the board work, not the software work
A Linux product can use a system-on-module: a small board carrying the processor, DRAM, storage and power regulators, which plugs into your carrier board. It removes the hardest layout work, routing DRAM and sequencing power rails, from your own board. It does not remove the software work. You still own the kernel, the root filesystem, the update system and their fixes, usually starting from the module vendor’s board support package.
Power is a structural difference
Sleep current is where the two classes diverge most. The Linux kernel’s sleep states documentation describes suspend-to-RAM as putting everything into a low-power state “except for memory, which should be placed into the self-refresh mode to retain its contents.” Keeping DRAM alive costs current a microcontroller with on-chip SRAM does not spend. Measure both on real boards, but expect a different order of magnitude, not a tuning gap.
| Property | Microcontroller | Embedded Linux processor |
|---|---|---|
| Memory | On-chip flash and SRAM | External DRAM and storage (eMMC, NAND, SD) |
| Software unit | One firmware image | Bootloaders, kernel, device tree, root filesystem, application |
| Full update size | Bounded by on-chip flash, often hundreds of kilobytes | A whole root filesystem, from megabytes to gigabytes |
| Sleep | On-chip retention, sub-microamp on some parts | DRAM kept in self-refresh during suspend-to-RAM |
| Timing | Interrupt-driven, deterministic when designed so | Scheduler-driven; real-time needs PREEMPT_RT or a coprocessor |
| Build system | Vendor SDK, Zephyr west, CMake | Yocto Project, Buildroot, or a distribution |
| Security fixes to track | RTOS, SDK, bootloader, crypto library | Kernel, bootloader, C library, every package in the image |
The update sizes are ranges, not measurements of a particular product. SWUpdate’s delta update documentation notes that it is “not unusual now” for the operating system and application on Linux devices to reach gigabytes. Check your own build.
Requirements that point to Linux, and those that do not
Choose Linux when a requirement depends on software that already exists for Linux and would take months to rebuild on a microcontroller. Choose a microcontroller when the requirements are sensing, control, low power and a radio link.
The table below is our judgement, built from what each class of software stack provides. Read it per requirement, then look at where most of your must-have rows land.
| Requirement | Points to | Why |
|---|---|---|
| Camera capture, video encoding or streaming | Linux | Camera, codec and streaming stacks exist as Linux drivers and libraries |
| Rich display with a browser-like UI | Linux | Toolkits such as web engines and desktop-class UI libraries target Linux |
| Simple display, buttons, status LEDs | Microcontroller | MCU graphics libraries cover this at far lower power |
| Wi-Fi, Ethernet, TLS, MQTT or HTTP to a cloud | Either | Both have mature stacks; MCUs handle this every day |
| Containers, multiple third-party apps, a package manager | Linux | These are operating-system features |
| Local machine learning on images or audio | Usually Linux or an accelerator | Model size and memory decide; small models fit MCUs |
| Hard real-time motor or power control | Microcontroller | Deterministic interrupt timing with no scheduler in the way |
| Years on a battery | Microcontroller | Sub-microamp to microamp sleep with retention |
| Instant-on after power is applied | Microcontroller | No bootloader chain, kernel or filesystem to start |
| A team that knows Linux and not embedded C | Weighs toward Linux | Skills matter, but they do not change power or maintenance cost |
Cloud connectivity does not require Linux
Founders sometimes reach for Linux for the cloud connection alone. Microcontroller stacks cover it. Zephyr’s networking documentation lists IPv6, TCP, a BSD sockets subset, TLS and DTLS backed by Mbed TLS, MQTT 3.1.1 and 5.0, CoAP, LwM2M, and an HTTP client and server. The FreeRTOS 202604-LTS release bundles FreeRTOS-Plus-TCP, coreMQTT, coreHTTP, corePKCS11 and a cellular interface library, all with LTS until April 30, 2028.
What a microcontroller does not give you is a general-purpose runtime for someone else’s software: a Python interpreter, a container engine or a vendor agent shipped only as a Linux binary. If the cloud platform you have chosen requires one of those on the device, that is a real Linux requirement. If it only needs MQTT or HTTPS with device certificates, it is not.
Real-time needs are often the deciding row
Linux can meet some timing requirements. The mainline kernel documentation includes a real-time preemption section explaining how PREEMPT_RT changes locking, interrupts and scheduling. Even so, a microcontroller closing a control loop in an interrupt handler is the simpler design to reason about and to test. When a product needs both a rich interface and tight timing, the usual answer is the split design described later.
Boot time and power cuts
A microcontroller starts executing its firmware almost immediately after reset. A Linux system runs a boot ROM, bootloaders, the kernel and user space before your application starts, and it keeps a filesystem that must survive power cuts. Boot time can be tuned, but it is a project of its own. If your product loses power often, as a vehicle or a solar device can, count both before deciding.
What a Linux product has to maintain for five years
A Linux device ships a kernel and many packages, and each has its own fix stream and end-of-life date. Over a support period of five years or more you will pull fixes continuously and change kernel and build-system releases at least once.
The support period you are designing for
For products sold in the EU, the Cyber Resilience Act (Regulation (EU) 2024/2847) says the support period “shall be at least five years,” unless the product is expected to be in use for less (Article 13(8)). Its main obligations apply from December 11, 2027. It also asks for a software bill of materials “covering at the very least the top-level dependencies” (Annex I, Part II). A Linux image has many more of those dependencies than a microcontroller image. This is a planning input, not legal advice; the Cyber Resilience Act article covers the duties and dates in detail.
Kernel support windows
The kernel.org releases page lists the longterm kernels and their projected end of life. As of November 22, 2026:
| Longterm kernel | Released | Projected EOL |
|---|---|---|
| 6.18 | 2025-11-30 | December 2028 |
| 6.12 | 2024-11-17 | December 2028 |
| 6.6 | 2023-10-29 | December 2027 |
| 6.1 | 2022-12-11 | December 2027 |
| 5.15 | 2021-10-31 | December 2026 |
| 5.10 | 2020-12-13 | December 2026 |
The same page says each new longterm kernel “usually starts with only a 2-year projected EOL that can be extended” if industry helps support it. New mainline kernels arrive every 9 to 10 weeks, and stable updates are “usually once a week.”
Vendor kernels add a layer. If your processor vendor supplies a board support package with its own kernel tree, ask which kernel.org longterm branch it is based on, how long the vendor will update it, and when its next release moves to a newer branch.
If five years on one kernel matters more than staying current, the Civil Infrastructure Platform project provides “Super-Long-Term Stable (SLTS) kernels with a maintenance period of ten years.” Check whether your processor is supported by a CIP kernel before you rely on it.
Vulnerability identifiers follow the supported branches
The kernel project is its own CVE numbering authority. Its CVE documentation explains that kernel changes that are potentially security issues “have CVE numbers automatically assigned to them” as part of the stable release process. It also states: “No CVEs will be assigned for any issue found in a version of the kernel that is not currently being actively supported by the Stable/LTS kernel team.” Once your kernel branch passes its end of life, you stop receiving even the identifiers that tell you what to fix.
Build system support windows
The root filesystem comes from a build system with its own releases. The Yocto Project’s releases page, as of November 2026, lists Scarthgap (5.0, April 2024) with long-term support until April 2028 and Wrynose (6.0, April 2026) until April 2030. Non-LTS releases such as Blacksail (6.1, October 2026) get six months. The page says “Future LTS releases are planned for 4 years.”
Buildroot’s manual describes quarterly stable releases with monthly bugfix releases. Starting with 2025.02, the first release of every odd-numbered year is a long-term support release supported for three years, so 2025.02.x reaches end of life when 2028.02 is released.
How fixes reach a Linux image
Fixes arrive as point releases of the build system and as stable kernel updates, and each one is a rebuild of your whole image. The Yocto Project’s releases page lists Scarthgap’s current point release as 5.0.18, from June 2026, about two years after 5.0 shipped in April 2024. Each point release you adopt means rebuilding the image, rerunning your tests and shipping a full root filesystem update or a delta of it.
Your own layers sit on top. Board support layers from the chip vendor, third-party layers for your runtime, and your application all have to build against the new release. A layer that is not maintained for the new release becomes your job to port. Check the release support of every layer you add, not only the core.
Read the figure as a planning tool. No kernel or build-system release on it covers the whole hypothetical support period, so a Linux product launched in late 2027 should budget for at least one kernel migration and one build-system migration, tested and shipped to the field, unless it moves to a ten-year kernel. The microcontroller rows run out too, which is the next section’s point.
What a microcontroller product has to maintain
A microcontroller product also outlives its software’s support windows, but it has fewer components and a smaller image to rebuild, test and ship. The jobs are the same kind; the size is different.
The RTOS sets the main clock. Zephyr’s release process says LTS releases are “published every 2.5 to 3 years” and maintained “for approximately 5 years,” with general fixes for the first two years and security and stability fixes after that. Its releases page lists Zephyr 3.7.0 (LTS3) with an end of life of 2029-07-27 and notes the next planned release, Zephyr 4.6, is targeted for April 2027.
FreeRTOS’s LTS README says its LTS libraries receive security updates and critical bug fixes “for two years.” The 202604-LTS release lists the kernel at version 11.3.0 with LTS until April 30, 2028; the previous 202406-LTS ran until June 30, 2026.
Around the RTOS sit the vendor SDK, the radio stack, the bootloader (often MCUboot) and a crypto library. Each needs watching, but the total is a handful of components, not a whole distribution. A microcontroller image is also small enough to rebuild, test on a hardware rig and ship in a day when a fix is urgent.
The vendor SDK is a clock too
The chip vendor’s SDK carries the radio stack, drivers and often the RTOS port, and it has its own release and support pattern. Ask the vendor three questions before you commit: which SDK release line receives security fixes, for how long, and how often a new major version changes the APIs your code uses. A vendor that moves its SDK onto a new RTOS release every year hands you a migration every year, whatever the RTOS project’s own LTS window says.
The trade-offs between Zephyr, FreeRTOS and bare metal, including how their windows affect a product, are in Zephyr, FreeRTOS or bare metal. If you settle on a microcontroller, choosing a microcontroller covers flash for two image slots, secure boot and vendor support.
| Maintenance job | Microcontroller product | Linux product |
|---|---|---|
| Components with their own fix stream | RTOS, SDK, radio stack, bootloader, crypto | Kernel, bootloaders, C library, system services, every package |
| Where fixes are announced | RTOS and vendor advisories | Kernel CVE announcements, distribution and package advisories |
| Planned migrations in five years | One RTOS LTS move is likely | At least one kernel and one build-system move is likely |
| SBOM contents | A handful of components plus your code | Every package and library in the image |
| Image to rebuild and test per fix | One firmware image | Full root filesystem image, plus bootloader when affected |
Generate the bill of materials for your own build to see the real component count; the Yocto Project, for example, generates SPDX SBOM data by default.
How the update system differs
A microcontroller update replaces one signed image in a second flash slot. A Linux update replaces a whole root filesystem, usually in a second partition, and it involves the bootloader, the kernel and the filesystem in recovery. The Linux system is larger to build, larger to download and has more ways to fail.
Microcontroller: two slots and a small bootloader
A microcontroller update path built on MCUboot uses two image slots in flash. The device downloads the new signed image into the second slot, the bootloader checks its signature and swaps it in, and the new firmware confirms itself or the bootloader reverts. On the fictional Loamwick LW-1 probe, the flash budget calculator shows a 48 KB bootloader and two 448 KB slots in 1 MB of internal flash.
Linux: A/B partitions, an update agent and bootloader cooperation
On Linux, a common pattern keeps two copies of the root filesystem. RAUC’s scenarios page calls symmetric root filesystem slots “probably the most common setup”: two root partitions of the same size, often called A and B, with the update written to the inactive one. SWUpdate’s overview describes the same “double copy with fall-back” strategy and an alternative single-copy design with a stand-alone rescue system. Its author reports rescue root filesystems of 2.5 to 8 MB, depending on the setup.
Either way, the bootloader must cooperate. SWUpdate’s documentation notes that the bootloader has to detect an interrupted update, and lists U-Boot, GRUB and EFI Boot Guard as supported bootloaders. The work includes integrating the update agent, the bootloader environment, boot counting, a read-only root filesystem and a place for data that must survive updates.
What the larger image costs on cellular
The difference in update size shows up directly in data cost. The OTA data cost calculator multiplies image size by overhead, retries, fleet and price.
Example (fictional). Two versions of the same product ship to 5,000 cellular devices, with the calculator’s defaults of 8 percent protocol overhead, 5 percent of devices downloading twice and $0.40 per MB.
- The microcontroller version has a 412 KB firmware image. One rollout costs about $913, or about $0.18 per device.
- The Linux version, suppose, sends a 40 MB compressed root filesystem update. Each device downloads about 45.4 MB, so one rollout costs about $90,700, or about $18.14 per device.
At six releases a year, the gap is about $539,000 a year. Linux fleets on metered links therefore rely on delta or adaptive updates, application-only updates and fewer full releases.
The numbers in that example are hypothetical; your image sizes and data plan decide the real ones. When update size dominates, delta firmware updates explains when patches pay off and what they demand, including the delta options in RAUC, SWUpdate and Mender.
Secure boot and signing on each class
Both classes can refuse unsigned software, but a Linux device has more links in the chain to sign, verify and keep keys for. Count those links when you compare the two.
Microcontroller: one signed image
On a microcontroller, the chain is short. The chip’s boot ROM or an immutable first-stage bootloader, such as MCUboot, checks the hash and signature of the application image before running or installing it. There is usually one image to sign per release and one production signing key, with the public key or its hash stored in the bootloader or in one-time-programmable memory. The rest of the work is locking the debug port and making sure the factory programs the right keys.
Linux: a chain from boot ROM to root filesystem
On Linux, each stage verifies the next. U-Boot’s verified boot documentation gives a typical chain: “loading U-Boot from read-only memory, then loading a signed kernel, then using the kernel’s dm-verity driver to mount a signed root filesystem.” The processor’s boot ROM must also verify the first bootloader, using the vendor’s own secure boot scheme and key fuses.
The kernel’s dm-verity documentation describes it as “transparent integrity checking of block devices,” and notes that the target is read-only. That is one reason production Linux images use a read-only root filesystem with a separate partition for data that changes. Anything in the writable partition sits outside dm-verity’s protection, so configuration files and scripts stored there need their own checks.
What the longer chain costs
A Linux release may need three or four signed artifacts: bootloader, kernel image, root filesystem hash, and sometimes the update bundle itself. Each needs a signing step in CI, a key with an owner, and a test that the device refuses a wrongly signed version. The work is well understood, but it is more than the microcontroller’s, and it repeats at every kernel or bootloader migration. Our firmware security service covers both chains.
Counting the maintenance before you choose
Write the recurring jobs down for each option, estimate the hours for each from your own team’s pace, and multiply by the support period. The comparison is quick, and it uses your own numbers instead of a rule of thumb.
A worksheet in five rows
For each processor class, fill in these rows:
- Routine fix releases. How often will you pull upstream fixes, rebuild, run your tests and ship? Monthly is one reasonable planning cadence for a connected product; your security policy decides.
- Urgent security releases. Assume some fixes cannot wait for the routine cycle. Estimate how many per year and the hours for an out-of-cycle build, test and rollout.
- Planned migrations. Count the kernel, build-system or RTOS LTS moves that fall inside your support period, using Figure 1. Each is a small porting project with a full regression test.
- Vulnerability triage. Someone must read advisories and decide whether each one affects your configuration. For Linux, that includes the kernel’s CVE announcements.
- Update system upkeep. The update agent, server and bootloader integration have their own releases and fixes.
Then add the one-off costs: board support package and build system setup, update system integration, and the factory programming flow.
Example (fictional). A two-founder startup is choosing between a Linux module and a microcontroller for a connected air-quality monitor with a small display. It plans a five-year support period and estimates its own hours, as planning assumptions, not measurements.
- Microcontroller: 12 routine releases a year at 2 engineer-days each, 2 urgent releases at 3 days each, and one RTOS LTS migration of 15 days over five years. That is 30 days a year, plus 15 days once, or 165 days over five years.
- Linux: 12 routine releases at 4 days each (larger image, more packages to review), 4 urgent releases at 3 days each, one kernel and one build-system migration at 25 days each, and 10 days a year of vulnerability triage. That is 70 days a year, plus 50 days once, or 400 days over five years.
The display needs are modest, so the founders choose the microcontroller and keep the 235-day difference for product work. Had the product needed a camera, the same worksheet would have shown what Linux would cost them to keep.
Your numbers will differ. The point of the exercise is to make the maintenance visible before the board is designed, when it can still change the decision.
The split design: a microcontroller next to a Linux processor
Some products end up with both: a Linux processor for the interface, networking and heavy software, and a microcontroller for real-time I/O, power management and anything that must keep running when Linux restarts. The split keeps each part doing what it does well, at the price of two firmware stacks and two update paths.
How the two talk
Some application processors include a microcontroller core on the same chip. The Linux kernel’s remote processor framework exists for this case: it lets Linux “control (power on, load firmware, power off) those remote processors,” and adds rpmsg devices for messaging between them. On separate chips, a UART, SPI or I2C link with a small framed protocol does the same job.
What the split asks of the update system
With a remoteproc design, Linux loads the coprocessor firmware, so it ships inside the root filesystem and updates with it. With a separate microcontroller, Linux becomes its update server: it holds the signed microcontroller image, transfers it, and checks that the microcontroller reports the new version. Either way, keep the two versions compatible across a partial update, because one side can roll back while the other does not. Version the protocol between them, and have each side accept the previous protocol version for at least one release.
When the split is the right answer
Choose the split when the product needs Linux features and also hard timing, very low standby power or fast wake-up on a sensor event. A battery-powered camera trap is a good example of the shape: the microcontroller watches the motion sensor for months, and the Linux side powers up only to capture and upload. The cost is real: two toolchains, two test suites, two sets of security fixes and two update paths.
Example (fictional). A startup builds a wildlife camera that runs on a battery pack for a season. A Linux module captures and uploads images; a small microcontroller watches a motion sensor and the battery voltage and switches the Linux module’s power. Most of the time only the microcontroller is awake.
The team ships one combined release. The Linux root filesystem carries the signed microcontroller image, and after a Linux update the module checks the microcontroller’s version over UART and updates it if needed. The message protocol between them carries a version number, and each side accepts the previous version for one release, so a rollback on either side leaves a working camera.
Moving from a Raspberry Pi or dev-kit prototype
A prototype on a single-board computer proves the product idea, not the processor choice. Before you design a board, find out which parts of Linux the prototype actually uses; sometimes it is only a few libraries a microcontroller can replace.
Questions to ask of the prototype
- Which Linux features does the application call? List the libraries, services and kernel drivers in use. Python, a web framework and a database are prototype conveniences, not requirements.
- What would the product lose without them? A camera pipeline is hard to replace. JSON over HTTPS, a sensor driver and a scheduler are not.
- What does the product need that the prototype ignores? Battery life, boot time, signed updates, a read-only root filesystem, factory programming, and fixes for five years or more.
- Who will own the result? A Linux image is a distribution you maintain. A microcontroller image is firmware you maintain. Both need a named owner.
Two common outcomes
If the answers show a camera, a rich UI or third-party Linux software, plan a Linux product. Build it with Yocto or Buildroot on a production module, with an A/B update system and a kernel plan from day one, rather than shipping the prototype’s general-purpose distribution.
If the answers show sensing, control and a cloud connection, port the logic to a microcontroller. The prototype still earns its keep: it fixes the behavior, the data formats and the cloud API that the firmware must match. Capture those in the firmware requirements worksheet before the port starts.
Mistakes to avoid when a Linux prototype becomes a product
If you do go Linux, these are the gaps a prototype hides:
- A hand-built image. An image assembled by installing packages on a running board cannot be rebuilt exactly. Build the production image from a recipe, in CI, so every release is reproducible.
- A writable root filesystem. If any process can change system files, devices drift apart, and neither A/B updates nor dm-verity can do their job. Keep changing data in its own partition.
- No kernel plan. A board support package kernel with no stated end of life becomes your problem in two years. Write down the branch, its projected end of life and the next migration.
- Debug access left open. Serial consoles, SSH with shared passwords and development keys are normal on a prototype and unacceptable on a product. Close them in the production configuration and test that they stay closed.
- No bill of materials. Generate it from the build, keep it per release, and use it to triage advisories.
A decision procedure for your first product
Decide by requirements first, then by the maintenance worksheet, then by team. If the first step settles it, stop there; the worksheet is for the close calls.
- List the must-have requirements and mark each one Linux, microcontroller or either, using the requirements table above. If no must-have row points to Linux, choose a microcontroller.
- Check power and timing. If the product runs on a battery for months, or closes a control loop, the microcontroller or the split design is usually the better fit.
- Set the support period. Use at least five years if you sell in the EU, and your own warranty and customer promises elsewhere.
- Lay the support windows over it. Use Figure 1 and your vendor’s board support package dates to count the migrations each option needs.
- Fill in the maintenance worksheet for each option with your own hours, and add the update system and data cost for each.
- Check the team. Ask who will own kernel updates or RTOS updates in two years. If no one will, plan for that before the board is designed.
- Decide, and write down why. Record the requirement or number that decided it. When requirements change, you will know whether the decision still holds.
What changes the answer later
Products change after launch, so record what would reopen the decision. These three changes are the ones to watch:
- A camera or a richer display in the next version. Consider the split design first: keep the proven microcontroller for sensing and power, and add a Linux module for the new feature.
- A customer requirement for a longer support period. Recount the migrations in Figure 1 for the new period, and price a ten-year kernel or an extra RTOS migration.
- A new market. A move into the EU brings the Cyber Resilience Act’s support period and bill of materials duties; other markets bring their own rules.
None of these is a reason to start on Linux “just in case.” A microcontroller product that needs Linux later can add it beside the existing design. A Linux product that should have been a microcontroller keeps its higher power draw and maintenance load for its whole life.
What to do next
If you are leaning toward Linux, read our embedded Linux service page for what a Yocto or Buildroot build, A/B updates and an SBOM per image involve. If you are leaning toward a microcontroller, our firmware development service describes application firmware on Zephyr, FreeRTOS or bare metal. Either path can suit hardware startups moving from prototype to first production run.
Fumbar is a Denver company that writes embedded firmware and builds the update path for hardware startups, on microcontrollers and on embedded Linux. If you want a second opinion before you commit to a board, you can request a firmware review: it covers the schematics, the current code if there is any, the flash layout and the update plan, and ends in a written plan with the risks and the order of work.
