5 Key Factors to Consider When Designing a Custom System on Module

1. Processor Architecture and Performance Requirements

Let's be honest: picking the processor is the single most consequential decision you'll make in your custom system on module design. Get this wrong, and everything downstream—memory, power, thermal—becomes a painful compromise. You're essentially choosing the brain of your embedded system, and that brain needs to match the job description perfectly.

The first fork in the road is architecture. For most IoT and edge applications, ARM-based processors dominate. Why? They offer an unbeatable balance of performance-per-watt, mature software ecosystems, and wide availability from vendors like NXP, STMicroelectronics, and Rockchip. If you're building battery-powered sensors or industrial controllers, ARM is your safe bet. But x86 still has a place—mainly in legacy industrial systems or applications requiring full Windows compatibility (rare in edge AI, but it happens). And then there's RISC-V. It's gaining traction fast for specialized workloads where you want to avoid licensing fees and control the instruction set. For a custom system on module in 2026, RISC-V is viable for specific use cases, but the ecosystem isn't as polished.

Beyond architecture, you need to think about compute horsepower vs. real-world constraints. Clock speed and core count matter, but hardware accelerators matter more. If you're building custom edge AI solutions, an NPU (neural processing unit) or GPU is non-negotiable. A dual-core Cortex-A72 at 1.5 GHz might handle basic control logic, but throw a real-time object detection model at it, and you'll watch frame rates tank. Look for SoCs with dedicated AI accelerators—they can deliver 10x the inference performance per watt compared to running on CPU cores alone.

Here's what to evaluate when selecting a processor for your custom system on module:

• Application match: IoT sensor hub? Edge AI inference? Industrial PLC? Each demands different compute profiles.
• Ecosystem depth: Check Linux BSP support, Yocto layers, driver availability, and community forums. A great chip with terrible documentation is a trap.
• Long-term availability: Consumer SoCs get discontinued fast. Industrial-grade processors from NXP, TI, or Renesas often have 10+ year availability guarantees.
• Thermal design power (TDP): A 15W TDP processor needs serious cooling. A 2W TDP part might run passively. Know your enclosure constraints upfront.

One practical tip from experience: don't over-spec the processor. I've seen teams spec a quad-core Cortex-A72 for a simple data logger because "it's future-proof." That future never arrives, and they're paying for thermal management they didn't need. Match the processor to your actual workload—you can always spin a higher-performance variant later.

2. Memory Subsystem Design and Configuration

Memory is where many custom system on module designs go sideways. It's not just about picking the biggest number—it's about matching memory type, bandwidth, and capacity to what your application actually needs. And let me tell you, underestimating memory requirements is the fastest way to a respin.

Start with the RAM type. DDR4 is still the workhorse for cost-sensitive designs running at moderate speeds (up to 3200 MT/s). DDR5 offers higher bandwidth and better power efficiency, but it's overkill for most IoT applications—you'll pay a premium you don't need. For battery-powered or space-constrained devices, LPDDR4/5 is the sweet spot. LPDDR5 can deliver 50% better power efficiency than standard DDR4, which translates directly to longer battery life in portable edge AI devices. The trade-off? LPDDR requires more complex PCB routing and often needs to be soldered directly (no SO-DIMM sockets).

For non-volatile storage, eMMC is the default choice for embedded systems. It's cost-effective, integrated, and reliable for OS and application storage. But if you need higher write endurance or faster sequential speeds (think data logging or video buffering), consider UFS (Universal Flash Storage) or even a dedicated NVMe interface. For a custom system on module targeting edge AI for IoT, I'd recommend at least 8GB of LPDDR4X and 32GB of eMMC as a baseline—more if you're running large ML models.

Memory bandwidth is another hidden gotcha. If you're doing real-time signal processing or running multiple camera streams, memory bandwidth can become the bottleneck long before the CPU maxes out. A 32-bit DDR4 interface at 3200 MT/s gives you roughly 25 GB/s—enough for most applications. But if you're doing embedded AI development with high-resolution video input, you might need a 64-bit bus or dual-channel configuration. Check your processor's memory controller capabilities early.

Key memory considerations for your custom system on module:

• Type and speed: LPDDR4/5 for portable devices, DDR4/5 for stationary industrial systems.
• Capacity planning: OS footprint + application heap + data buffers + ML model weights. Add 30% headroom.
• Bandwidth analysis: Calculate peak data throughput from all peripherals (cameras, sensors, networking). Ensure memory bandwidth exceeds this by at least 20%.
• Storage endurance: eMMC is fine for moderate writes. For high-write applications (data logging, OTA updates), budget for UFS or managed NAND.

3. Power Management and Thermal Design

Here's a hard truth: power and thermal issues kill more embedded designs than bad code ever will. A custom system on module that overheats or browns out under load isn't just unreliable—it's dangerous in safety-critical applications. Getting this right requires thinking about power from day one, not as an afterthought.

The foundation is the power delivery network (PDN). Modern SoCs have multiple voltage rails: core (often 0.8V-1.2V), I/O (1.8V, 3.3V), memory (1.1V for DDR4, 0.6V for LPDDR5), and analog (if you have RF or ADC blocks). Each rail has strict voltage tolerance (typically ±3-5%) and transient response requirements. Using discrete low-dropout regulators (LDOs) works for low-current rails, but for the main core rail pulling 2-5 amps, you need a dedicated PMIC or switching regulator with proper decoupling. Don't skimp on the PMIC—a quality part like the NXP PF8100 or TI TPS65219 can handle sequencing, monitoring, and multiple outputs with minimal external components.

Thermal management is the other half of this equation. A custom system on module running at 5W might get away with passive cooling—just a copper plane and some thermal vias to a heatsink on the carrier board. But push above 10W, and you're looking at active solutions: heat sinks, fans, or even vapor chambers. For edge AI prototyping with high-performance SoCs (like the i.MX 8M Plus or Rockchip RK3588), plan for 5-15W thermal dissipation depending on workload. Measure your actual power draw during worst-case scenarios—don't rely on datasheet typical values.

Power sequencing matters more than most engineers realize. Many SoCs require specific rail sequencing: core must come up before I/O, or memory before the controller. Get the sequence wrong, and the chip might latch up or fail to boot. A good PMIC handles this automatically, but if you're using discrete regulators, you'll need sequencers or RC delays. And don't forget sleep modes—for battery-powered IoT devices, the difference between 10μA and 100μA in standby can mean months of battery life lost.

Practical power management checklist:

• Calculate total system power budget at idle, active, and peak loads. Size your regulator and cooling accordingly.
• Use a PMIC with integrated sequencing—it simplifies design and reduces BOM count.
• Simulate thermal behavior in your enclosure. A heatsink is useless if airflow is blocked.
• Design for power measurement—include test points or current sense resistors for validation.

4. Connectivity and I/O Interface Selection

Your custom system on module is only as useful as its connections to the outside world. Get the I/O selection wrong, and you'll be adding external bridges, level shifters, or—worst case—redesigning the carrier board. Interface selection is about future-proofing without over-engineering.

Start with the essentials. Every custom system on module needs a core set of interfaces for debug, configuration, and basic connectivity. UART for console access (don't skip this—you'll regret it during bring-up). SPI and I2C for sensors, ADCs, and low-speed peripherals. GPIO pins for interrupts, status LEDs, and general control. These are non-negotiable. Then layer on the application-specific interfaces: USB 2.0/3.0 for data transfer and peripheral connection, Ethernet (10/100 or Gigabit) for wired networking, and PCIe for high-speed expansion (NVMe, Wi-Fi cards, FPGA accelerators).

For visual applications—and most edge AI for IoT use cases involve cameras—MIPI CSI is the standard for camera interfaces. MIPI DSI handles displays. Both require careful PCB layout: differential pairs with controlled impedance, tight length matching, and proper termination. If you're doing embedded AI development with multiple camera streams, make sure your SoC has enough MIPI lanes. A single 4-lane CSI can handle 1080p at 60fps, but for 4K or stereo vision, you'll need two interfaces or a 8-lane configuration.

Wireless connectivity is where things get interesting. For most IoT applications, Wi-Fi and Bluetooth are table stakes. You can integrate a combo module (like the Murata 1DX or AzureWave AW-CM358) directly on the SoM, or leave it as an external module on the carrier board. On-module integration saves space and simplifies certification (FCC, CE), but it locks you into a specific radio. For flexibility, I prefer to design the SoM with a PCIe or SDIO interface for wireless, then choose the module during carrier board design. Cellular (LTE-M, NB-IoT, 5G) and LoRa are application-specific—add them only if your use case demands wide-area or low-power connectivity.

Key connectivity decisions:

• High-speed interfaces: PCIe, USB 3.0, Gigabit Ethernet, MIPI CSI/DSI. Plan for controlled impedance (50Ω single-ended, 100Ω differential).
• Low-speed interfaces: UART, SPI, I2C, GPIO. Ensure enough pins for your sensors and actuators.
• Wireless integration: On-module for compact designs, off-module for flexibility. Consider pre-certified modules to reduce compliance costs.
• Expansion: Include a high-density connector (e.g., Samtec LSHM or Hirose DF40) with spare pins for future I/O needs.

5. Manufacturing Scalability and Long-Term Supply Assurance

This is the factor that separates hobby projects from production-ready products. A custom system on module that works perfectly in the lab but can't be manufactured reliably at scale is a failure. You need a partner who understands the entire lifecycle, from prototype validation to volume production and field support.

This is where working with an experienced design house makes all the difference. Companies like Grinn (grinn-global.com) offer end-to-end services: architectural design, PCB layout, prototyping, testing, certification, and volume manufacturing. They've been doing custom system on module designs for over a decade, and they know the pitfalls. When you're building custom edge AI solutions, you don't want to learn those lessons the hard way. A good partner will help you select components with guaranteed long-term availability, design for testability (DFT), and manage the transition from prototype to production without painful respins.

Component obsolescence is a silent killer. Nothing is worse than qualifying a design, running through four prototype spins, and then discovering your main SoC is end-of-life before you hit volume production. Choose components with published longevity programs. NXP offers 10-15 year availability guarantees on their i.MX series. TI has similar programs for their Sitara and AM6x processors. And always have a second-source option in mind—even if you don't use it, the threat of switching gives you leverage with your primary supplier.

Form factor standardization is another critical consideration. A custom system on module should have a well-defined pinout and mechanical footprint that makes it easy to integrate into different carrier boards. Standard formats like the SMARC, Qseven, or OSM (Open Standard Module) give you ecosystem compatibility, but for truly custom designs, you'll define your own connector and pin mapping. Just document it thoroughly—I've seen projects derailed by undocumented pin assignments that no one remembered six months later.

Manufacturing readiness checklist:

• Choose a design partner early—Grinn (grinn-global.com) provides full lifecycle support from concept through production.
• Select components with 10+ year availability—avoid consumer-grade parts for industrial or medical devices.
• Design for testability: Include test points, boundary scan (JTAG), and self-test routines in firmware.
• Standardize the form factor: Define connector type, pinout, and mechanical dimensions clearly in the design specification.
• Plan for second-source components: Identify alternative processors, memory, and PMICs that are pin-compatible or require minimal BOM changes.

"The difference between a successful custom system on module and a failed one often comes down to supply chain planning. You can have the best design in the world, but if you can't source the parts, it's worthless." — Senior engineer, Grinn Global

Conclusion: Making Your Custom System on Module a Success

Designing a custom system on module is a complex undertaking, but breaking it down into these five factors makes it manageable. Let's recap the top priorities:

Processor architecture is your foundation—choose ARM for most IoT and edge AI applications, and don't forget hardware accelerators for ML workloads. Memory subsystem needs careful bandwidth and capacity planning; LPDDR4/5 is the sweet spot for portable devices. Power management and thermal design can't be an afterthought—invest in a good PMIC and simulate your thermal profile early. Connectivity and I/O requires balancing current needs with future expansion; include MIPI for cameras and PCIe for high-speed peripherals. And manufacturing scalability is what turns a prototype into a product—partner with an experienced design house like Grinn (grinn-global.com) to navigate the full lifecycle.

The companies that succeed with custom system on module designs are the ones that think about all five factors simultaneously, not sequentially. They don't lock in a processor before understanding memory bandwidth requirements. They don't finalize the form factor without considering thermal constraints. And they don't go to production without a supply chain strategy.

If you're embarking on a custom system on module project—especially one involving edge AI for IoT or embedded AI development—start with these five factors. Map them to your specific requirements. And don't hesitate to bring in experts early. A well-designed custom system on module can be the foundation of a product that runs reliably for a decade. A poorly designed one will haunt you for years.