Can you actually ship one?
Yes — but the board you prototype on is rarely the board you should ship. A single-board computer that costs tens of dollars, runs full Linux, drives a display, and lets you write everything in Python is the fastest path to a working demo. Whether it belongs in a product you have to manufacture, certify, and support for years depends on five operational issues that have almost nothing to do with processing power: supply continuity, storage integrity, certification, thermal behavior, and unit cost at volume. Get those right and a Linux single-board computer is a legitimate production choice. Ignore them and you ship a product that fails in ways that are expensive to fix remotely.
When a single-board computer is the right answer
There are products where a Linux board is not a compromise at all:
- Anything with a graphical touchscreen interface.
- Camera, video, or image-processing products.
- Devices needing multiple network interfaces, a local database, or a web server on board.
- Industrial or professional equipment in low volumes, where engineering time is worth more than hardware cost.
- Products that need a rich software ecosystem — computer vision libraries, machine learning runtimes, container tooling.
If the workload is really just reading sensors and driving actuators, a microcontroller is smaller, cheaper, boots instantly, and cannot corrupt a filesystem. That decision is covered in how to choose a microcontroller, and it is worth settling before you commit to Linux.
The compute-module route
The single most useful move for a commercial product is to switch from the consumer board to the compute module variant — the same processor and memory on a small module that plugs into a carrier board you design. The benefits are concrete:
- Exactly the connectors you want, in the positions your enclosure needs, instead of a fixed consumer layout.
- Your own power input, protection, and reset circuitry.
- Soldered storage instead of a card slot.
- A longer, more explicitly stated production lifetime than consumer models.
- A sane mechanical stack — no ribbon cables snaking around an enclosure.
You take on a custom carrier board, which means a real PCB development cycle. Budget for that development cycle and plan the build stages described in EVT, DVT, PVT explained.
Risk one: availability and lifecycle
Commercial products need predictable supply. Popular single-board computers have gone through severe shortage periods with long queues, and model generations turn over — a new revision arrives with a different processor, different connector placement, and sometimes higher power draw. Before you base an entire product line on one model:
- Confirm the specific variant is offered under an industrial or long-term availability program.
- Understand the vendor's stated production lifetime, in writing.
- Design the carrier so a next-generation module could drop in with a known set of changes.
- Keep a buffer of modules bonded to your production plan, not just to your optimism.
Risk two: storage, boot, and sudden power loss
This is the number one field failure, and it is entirely preventable. A Linux system writing logs to a cheap memory card will wear it out, and a unit unplugged mid-write can come up with a corrupted filesystem. What production designs do instead:
- Industrial storage. Soldered eMMC, or an industrial-grade card with real wear management — never a random consumer card.
- Read-only root filesystem. Lock the system partition; give writes a small, journaled data partition that can be recovered or discarded.
- Graceful shutdown. A brownout detector plus enough stored energy to finish the write, or at minimum an interrupt that tells software power is going away.
- Battery-backed real-time clock. Without a network, a board wakes up with no idea what time it is, which breaks logs, certificate validation, and scheduling.
- A recoverable update mechanism. An interrupted update must still leave a bootable device — see OTA firmware updates for the A/B pattern that makes this safe.
Risk three: certification is on your finished product
Module-level certifications do not transfer to your box. What gets tested is your product: the enclosure, your cabling, your power supply, your accessories. Fast single-board computers emit plenty of energy, and a flat ribbon cable to a camera or display is an excellent accidental antenna. Plan filtering, shielding, and short cable runs from the start, and run pre-compliance screening early rather than discovering the problem in a formal test slot. See EMC testing cost and, for radio modules, FCC certification for electronic products.
Risk four: heat and enclosure design
A Linux board under sustained load produces real heat. Passive cooling inside a sealed enclosure is a calculation, not a guess — and if the product also needs an ingress rating, you cannot simply add a vent. Understand what you are committing to via IP ratings explained before promising a sealed, fanless, always-on device.
Risk five: the cost curve crosses over
At low volumes a single-board computer wins easily: no board development, no verification rounds, fast to market. As volume grows, the module's unit price stops being trivial while the amortized cost of a custom board keeps falling. The crossover depends on how much of the module you actually use — if you need only two interfaces out of a dozen, you are paying for silicon you never touch. Somewhere in the low thousands of units per year, a purpose-built board on a lower-cost application processor usually becomes the cheaper total. Model it honestly, including the non-recurring engineering, rather than assuming either direction.
A sensible progression
- Prototype on the consumer board. Prove the concept fast — the same logic applies to moving an Arduino prototype to production.
- Move to the compute module on your own carrier for pilot production, with industrial storage and proper power handling.
- Re-evaluate the silicon only once volume and feature set have stabilized.
Skipping step two is what produces products held together by ribbon cables and hope.
Let's look at your design
Projects House takes Linux-based products from breadboard to production hardware — carrier boards, enclosure and thermal design, robust update paths, and the compliance work that goes with them. If you have a working single-board prototype and need to know what it takes to make it manufacturable, tell us about it through our contact form. Related reading sits in our electronics development section.