A carrier board is a circuit board that provides the physical connections, power delivery, and external interfaces for a small computing module. Think of it as the “body” of an embedded system: the computing module (often called a System on Module, or SoM) contains the processor, memory, and storage, while the carrier board connects that brain to the outside world through ports like USB, Ethernet, HDMI, and any custom hardware the application needs.
This modular split is one of the most common design patterns in embedded computing, showing up in everything from autonomous robots to industrial sensors to medical devices. Understanding how carrier boards work helps clarify why so many products are built this way instead of putting everything on a single board.
How a Carrier Board Works With a Computing Module
A computing module plugs into the carrier board through high-density board-to-board connectors or an edge connector. These connectors carry a large number of signals between the two boards: power supply lines, communication interfaces like USB and Ethernet, display outputs, camera inputs, and control signals. The module itself is typically a small, dense board packed with a processor, RAM, flash storage, and sometimes wireless radios. It handles all the computation.
The carrier board’s job is to take those raw signals and make them physically accessible. That means providing RJ45 jacks for Ethernet, USB ports, display connectors, antenna mounts, and whatever specialized hardware the final product requires. A carrier board for a warehouse robot, for example, might include connectors for ten navigation cameras and integration points for multiple processor modules. A carrier board for a digital sign might focus on display outputs and network connectivity instead.
This separation means you can swap the computing module for a newer, faster one without redesigning the entire system. It also means different products can share the same module but use completely different carrier boards tailored to their specific needs.
What a Carrier Board Actually Contains
Every carrier board needs to handle three essential subsystems: power management, clock distribution, and reset sequencing. The power circuitry converts incoming voltage into the specific levels the computing module and peripherals require, and it needs to handle transient peak currents without voltage drops that could crash the system. Different modules have different power needs. An NVIDIA Jetson Nano runs on 5V, while an Orin AGX supports both 5V and 19V inputs.
Beyond power, the carrier board routes high-speed signals between the module and external connectors. Interfaces like USB 3.0 and camera links require controlled impedance traces on the circuit board, typically 90 to 100 ohms for differential signal pairs. Poor routing on these signals causes data errors, so carrier board design demands careful attention to trace length, spacing, and shielding. The board also provides mounting holes, standoffs, and mechanical features that secure the module and fit the carrier into its final enclosure.
Why Use a Carrier Board Instead of One Board
The alternative to the carrier board approach is a single board computer (SBC), where the processor, memory, and all connectors live on one integrated board. Both approaches have clear trade-offs.
An SBC is ready to use out of the box. No additional hardware design is needed, all software drivers are complete, and you buy the entire platform from one source. For projects where time to market matters most, an SBC cuts development time dramatically. The downside is higher initial cost per unit, and you may end up paying for components and interfaces your application doesn’t need, which wastes board space and power.
The modular approach, pairing a computing module with a custom carrier board, gives you flexibility. You choose exactly which interfaces to include, how the board is shaped, and what peripherals it supports. The module itself tends to be lower cost than a comparable SBC. But you’re taking on real engineering work: designing, manufacturing, and debugging that carrier board adds 3 to 6 months of development time and its own set of costs. You also need to write low-level software like drivers and device tree configurations for every interface on your custom board.
The modular path makes the most sense when you need custom hardware integration, plan to build at volumes where per-unit savings outweigh the upfront design cost, or want to upgrade the processor module in future product generations without starting from scratch.
Industry Standard Form Factors
Several standardized form factors exist so that modules from different manufacturers can plug into compatible carrier boards. Qseven modules, for example, use a standardized 70mm by 70mm or 40mm by 70mm footprint with a high-speed MXM connector that has the same pinout regardless of the vendor. COM Express is another widely used standard, targeting higher-performance applications with more available interfaces. SMARC focuses on low-power, ARM-based processors common in IoT and edge devices.
These standards matter because they prevent vendor lock-in. If a module manufacturer discontinues a product or a competitor releases a better option, you can swap modules without redesigning your carrier board, at least in theory. In practice, differences in power requirements, thermal behavior, and software support mean some validation work is still needed after a swap.
Real-World Applications
Carrier boards show up wherever embedded systems need to be customized for a specific task. In robotics, a Swiss automation company developed a custom carrier board that supports up to ten simultaneous navigation cameras on mobile robots and forklifts, enabling real-time obstacle detection and autonomous path planning. The carrier board was designed to work with multiple NVIDIA Jetson modules, so the same platform could scale from a small robot running a Jetson Orin Nano to a larger vehicle using the more powerful Orin NX.
Industrial IoT is another major use case. Sensor hubs deployed in factories or remote infrastructure often pair a low-power computing module with a carrier board that includes analog-to-digital converters, industrial communication interfaces, and ruggedized connectors. Medical devices, drones, point-of-sale terminals, and edge AI cameras all commonly use this architecture. The pattern is consistent: the application has specific physical and electrical requirements that off-the-shelf boards don’t meet, so a custom carrier board fills the gap while a proven computing module handles processing.
What Designing a Custom Carrier Board Involves
A typical custom carrier board project takes 8 to 16 weeks from start to a working prototype. The process breaks down roughly into 2 to 3 weeks for schematic design, 3 to 4 weeks for PCB layout, 2 to 3 weeks for prototype fabrication, and 3 to 6 weeks for software integration and testing. The schematic phase defines which interfaces to expose and how to route power. PCB layout turns that into a physical board design, paying close attention to connector alignment, mounting hole positioning, and keep-out zones around the module edges where components can’t be placed.
Software integration is where many projects hit unexpected delays. Every interface on the carrier board needs driver support in the operating system, and the device tree (a configuration file that tells the OS what hardware is present) must be written and tested for the specific combination of module and carrier board. If you’re connecting cameras, sensors, or custom peripherals, each one adds its own layer of software work. Teams that underestimate this phase often see their 8-week timeline stretch closer to 16.