Data as of Oct 18, 2026Based on 349 AI responses from ChatGPT Search and Google AI Mode
Reviewed by Dimitry Apollonsky
AI summary
For connected IoT prototypes pick ESP32 for its built-in Wi‑Fi/Bluetooth and low cost. Use STM32 Nucleo/Discovery for professional Cortex‑M firmware and industrial peripherals. Choose Raspberry Pi or BeagleBone for Linux/high‑performance or heavy I/O; Arduino for fast POCs.
Explore the market rankingEmbedded IoT Development Toolchains
Brands AI recommends here
Mentioned in · Sep 5 – Oct 8, 2026
ChatGPT SearchOct 8, 2026
For an embedded systems engineer, I’d prioritize platforms that give you good access to peripherals, real debugging, low-level firmware control, and a credible path from prototype to custom PCB—not just boards that are easy to program.
| Platform | Best for | Debugging | Ecosystem | Production relevance |
|---|---|---|---|---|
| STM32 Nucleo | ⭐ Best overall embedded platform | Excellent | Excellent |
ChatGPT SearchSep 21, 2026
Google AI ModeSep 21, 2026
Google AI ModeSep 17, 2026
ChatGPT SearchSep 17, 2026
ChatGPT SearchSep 13, 2026
Google AI ModeSep 13, 2026
Google AI ModeSep 9, 2026
ChatGPT SearchSep 9, 2026
ChatGPT SearchSep 5, 2026
0% of citations to these sources link to brands' own websites.
verytechnology.com
livewireindia.com
| ⭐⭐⭐⭐⭐ |
| Raspberry Pi Pico / Pico 2 | Low-cost MCU prototyping | Excellent with Debug Probe | Very good | ⭐⭐⭐⭐ |
| ESP32 DevKit | Wireless/IoT embedded systems | Very good | Excellent | ⭐⭐⭐⭐ |
| TI LaunchPad | Power, analog, motor control, TI ecosystem | Excellent | Very good | ⭐⭐⭐⭐⭐ |
| Arduino Portenta | Fast professional/industrial prototyping | Excellent | Excellent | ⭐⭐⭐⭐ |
| Microchip Curiosity | PIC/dsPIC/AVR development | Good–excellent | Very good | ⭐⭐⭐⭐⭐ |
| Digilent FPGA/SoC boards | FPGA + CPU / hardware acceleration | Excellent | Excellent | ⭐⭐⭐⭐⭐ |
If you only buy one family of boards, I'd make it STM32 Nucleo.
ST's Nucleo boards cover a huge range of STM32 MCUs and include an integrated ST-LINK debugger/programmer, so you don't need an external debug probe. They also expose Arduino-compatible and/or ST Morpho connectors for expansion. ST supports them with STM32Cube software and a broad range of IDE/toolchain options.
Why I like them for engineering work:
Best use: learning serious MCU architecture, motor/control applications, instrumentation, industrial embedded systems, and developing firmware intended to migrate to a custom PCB.
The Pico family is exceptionally good for inexpensive prototyping.
The particularly nice thing for an engineer is that you aren't limited to Arduino-style programming. You can work close to the metal using the Raspberry Pi Pico SDK, C/C++, SWD, GDB and OpenOCD.
Raspberry Pi's Debug Probe provides both UART and standard Arm SWD, supports CMSIS-DAP, and integrates with OpenOCD/GDB. It lets you do proper breakpoints and single-stepping rather than treating the board like a black box.
Why choose it:
Best use: rapid digital prototyping, custom protocols, test fixtures, instrumentation, USB devices, robotics, and situations where you want lots of boards for very little money.
I'd especially recommend Pico 2/RP2350 for a new project rather than starting a new design around the older RP2040 unless you specifically need RP2040.
If the design needs Wi-Fi or Bluetooth, ESP32 jumps near the top of the list.
Espressif's official ESP-IDF is a full embedded development framework rather than merely an Arduino abstraction. It provides configuration, compilation, flashing, monitoring and the underlying APIs for the ESP32 platform.
The official development boards include things like the ESP32-DevKitC, while Espressif also offers boards/modules with Ethernet, LCD, camera and other capabilities.
Particularly good for:
One important engineering advantage is that Espressif's modules can be incorporated into your eventual PCB, giving you a relatively clean migration from prototype to product.
Best use: connected devices where wireless is fundamental.
Texas Instruments LaunchPad boards are particularly attractive when you're working in TI's ecosystem.
For example, TI's MSPM0 LaunchPads provide an integrated debug probe and expose MCU peripherals while also providing things such as energy measurement and onboard sensors on certain boards.
TI becomes especially compelling for:
Best use: choose the LaunchPad based on the specific TI MCU family you intend to use.
Don't dismiss Arduino just because you're an experienced engineer.
The Portenta family is aimed specifically at professional/industrial applications rather than basic hobbyist projects. Arduino positions Portenta for industrial IoT, automation, edge computing and connected systems.
The Portenta ecosystem is particularly interesting when you want to rapidly combine:
MCU + sensors + networking + Linux/AI + cloud
without building all of that infrastructure yourself.
The Portenta Breakout is also useful in an engineering lab because it exposes the high-density signals and provides JTAG access for debugging.
Best use: rapid industrial prototypes where time-to-working-system matters more than squeezing every last dollar out of the BOM.
Microchip Technology has a very broad Curiosity development-board ecosystem covering 8-, 16- and 32-bit MCUs.
It's particularly compelling if your eventual production MCU is going to be:
The dsPIC family deserves particular attention for motor control and DSP-oriented embedded applications.
Best use: projects already committed to Microchip silicon, especially motor control, automotive/industrial control, and cost-sensitive production designs.
If you're doing serious digital hardware design, I'd add an FPGA platform to your bench.
Digilent offers AMD FPGA and SoC boards ranging from relatively inexpensive Spartan-7/Artix-7 boards through Zynq ARM+FPGA systems.
For example, the Arty A7 is excellent for FPGA development, while boards such as Arty Z7/Zybo Z7 combine an ARM processor with FPGA fabric.
These are useful for:
I'd consider this a different category from the MCU boards above rather than a direct competitor.
If I were building an embedded engineer's prototyping kit today, I'd choose:
Core MCU platform → STM32 Nucleo
Cheap/general-purpose platform → Raspberry Pi Pico 2 + Debug Probe
Wireless → ESP32 DevKit
Power/motor/analog → TI LaunchPad
FPGA → Digilent Arty/ Zynq board
That combination covers an enormous percentage of embedded prototyping problems.
One important distinction: I'd avoid making Arduino Uno-class boards your primary platform if you're already an embedded systems engineer. They're fantastic for teaching and quick demonstrations, but STM32, RP2350, ESP32, TI, etc. give you much more exposure to the architecture, debugging, RTOS, peripherals, DMA, interrupts, memory systems, and toolchains you'll encounter in serious embedded products.
If you tell me whether you're primarily doing industrial control, robotics, automotive, IoT, DSP/audio, low-power battery devices, or general embedded firmware, I can narrow this to the 3–5 boards I'd actually buy, including specific board/MCU recommendations.
For an embedded-systems engineer, I’d choose platforms based less on “which board is best” and more on how closely the platform lets you prototype the architecture you’ll eventually ship.
| Platform | Best for | Why I’d use it |
|---|---|---|
| STM32 Nucleo | General-purpose embedded/product development | Excellent MCU variety, real debugging, rich peripherals, and a path toward production STM32 designs |
| Raspberry Pi Pico 2 / Pico 2 W | Fast firmware + hardware experimentation | Extremely inexpensive, capable RP2350, excellent documentation, PIO, and C/C++ or Python |
| TI LaunchPad | Analog, motor control, power electronics, industrial systems | Particularly useful when your design depends heavily on TI peripherals and analog/power ICs |
| Arduino Portenta | Rapid connected/IoT prototypes | Much faster route from idea → functional connected device, while retaining considerably more capability than classic Arduino |
| ESP32 development boards | Wi-Fi/Bluetooth products and inexpensive connected devices | Excellent wireless integration and huge ecosystem |
| Raspberry Pi / CM4/CM5-class SBCs | Embedded Linux, vision, networking, UI | Useful when your eventual product needs Linux rather than an RTOS/bare-metal MCU |
| FPGA boards such as AMD/Xilinx or Intel/Altera | FPGA + MCU/SoC work, high-speed interfaces | Best when deterministic parallel processing or custom digital logic is part of the architecture |
For someone doing serious embedded development, this is probably the first platform I'd keep on the bench.
ST offers Nucleo boards spanning low-power STM32L0/L4/U-series, mainstream G-series, wireless WB/WBA/WL parts, and high-performance H5/H7 devices. Nucleo boards include an onboard ST-LINK debugger/programmer, Arduino-compatible connectors on many models, and ST Morpho expansion connectivity.
The important distinction is that you're working with the actual MCU architecture, peripherals, clocks, interrupts, DMA, timers, ADCs, communication interfaces, etc., rather than an abstraction layer hiding them.
I'd particularly use:
ST also provides a large ecosystem of Nucleo expansion boards for sensors, connectivity, power measurement, etc.
The Pico 2 is unusually compelling for prototyping because the RP2350 combines dual Cortex-M33 cores, optional RISC-V cores, 520 KB SRAM, security features, and the programmable I/O system, while the board starts at $5.
The PIO subsystem is particularly interesting for an engineer experimenting with unconventional interfaces or timing-sensitive protocols.
The Pico 2 W adds 2.4-GHz Wi-Fi and Bluetooth 5.2.
I wouldn't necessarily choose it as the starting point for a product that must ultimately use an STM32, NXP, Renesas, etc. But as a cheap, flexible hardware/firmware laboratory, it's excellent.
If you're working on motor control, power supplies, battery systems, precision analog, industrial control, or TI-centric designs, LaunchPad becomes much more attractive.
The key advantage isn't simply the development board; it's being able to prototype around the same MCU and surrounding semiconductor ecosystem you're likely to use in the eventual design.
For example, a motor-control prototype can combine the MCU development board with appropriate gate drivers, current sensing, power stages, and other TI evaluation hardware rather than trying to reproduce everything on a generic Arduino-style board.
For wireless embedded products, ESP32 boards are hard to ignore.
They're particularly useful for:
The main caveat is that I wouldn't select an ESP32 merely because it's easy if the eventual product architecture calls for a different MCU. The hardware/software architecture can diverge substantially from your production target.
Portenta is interesting when the priority is rapidly turning an embedded concept into a sophisticated working prototype.
I'd reach for it when you need things like connectivity, sensors, displays, or higher-level application logic and don't want to spend the first several days building the plumbing yourself.
For a professional embedded engineer, though, I'd generally treat Arduino as a rapid-prototyping layer, rather than the platform I'd use to learn the exact behavior of a production MCU.
When the system needs Linux, move up from microcontrollers.
A Compute Module-based prototype makes sense for:
It's also a useful way to prototype the boundary between embedded firmware and embedded Linux.
Don't overlook FPGAs.
If your system involves:
then an FPGA development board can be considerably more appropriate than an MCU board.
For example, an AMD/Xilinx Zynq-class platform gives you a particularly interesting environment because you can prototype programmable logic + ARM processing + Linux in one system.
Rather than buying ten boards, I'd build a small prototyping stack:
And arguably more important than the development boards themselves:
The biggest professional upgrade is moving from “development board + jumper wires” toward “MCU evaluation board + custom carrier board.” That lets you prototype your actual power architecture, connectors, buses, level shifting, sensors, EMI considerations, and mechanical interfaces while retaining the vendor's known-good MCU/debug circuitry.
If you tell me whether you're primarily doing motor control, robotics, IoT, automotive, aerospace, consumer electronics, instrumentation, or general embedded, I can narrow this down to a very specific 5-board hardware lab setup.
For an embedded systems engineer, the "best" hardware prototyping platform depends heavily on whether you are prioritizing low-level microcontroller optimization, industrial reliability, wireless IoT connectivity, or edge AI and high-speed computing.
To help narrow down which platform fits your current project, tell me:
For an embedded systems engineer, the "best" hardware prototyping platform depends on whether you are optimizing for low-level peripheral control, industrial ruggedness, wireless IoT connectivity, or heavy edge-computing/AI.
The top hardware prototyping platforms used by embedded engineers are organized below by their primary strengths:
If you want to narrow this down, tell me:
I can recommend the exact board and toolchain to match your workflow.
For an embedded-systems engineer, I’d choose prototyping platforms based less on beginner friendliness and more on how well they let you develop code, exercise peripherals, debug hardware, and eventually migrate to a custom PCB.
| Platform | Best for | Why it stands out |
|---|---|---|
| STM32 Nucleo | General-purpose professional embedded development | Excellent peripheral coverage, integrated ST-LINK debugging, huge MCU family |
| ESP32 DevKit | Wireless/IoT products | Wi-Fi/Bluetooth, inexpensive, strong SDK and ecosystem |
| Raspberry Pi Pico / Pico 2 | Low-cost MCU prototyping & custom peripherals | Excellent documentation, flexible GPIO and PIO, inexpensive |
| TI LaunchPad | Analog/power/control-heavy systems | Strong TI MCU + analog/power ecosystem |
| NXP FRDM | Automotive/industrial embedded | Good access to NXP's Cortex-M and automotive-oriented ecosystem |
| Arduino-compatible boards | Fast proof-of-concept work | Huge ecosystem and very fast hardware bring-up |
| Raspberry Pi SBC | Linux + embedded hardware | Excellent when your system needs Linux, networking, cameras, AI, etc. |
STMicroelectronics's STM32 Nucleo family is particularly well suited to an engineer who wants to prototype something that may eventually become a real embedded product.
Nucleo boards cover a very large range of STM32 MCUs, from low-power parts through high-performance STM32H7 devices. They include an integrated ST-LINK debugger/programmer, and many boards expose Arduino-compatible and ST-specific expansion connectors.
The big advantage is that you can prototype with something like:
That makes the Nucleo ecosystem useful beyond the initial prototype: your development board can be relatively close to the MCU architecture you'll eventually put on your PCB.
If wireless connectivity is important, I'd keep an ESP32 board on the bench.
Espressif's current family spans conventional ESP32 devices as well as newer C/H/S/P families. Depending on the chip, you can get Wi-Fi, Bluetooth LE, Wi-Fi 6, Thread/802.15.4, and substantial processing capability. Espressif provides its ESP-IDF framework and extensive development-board documentation.
The ESP32-DevKitC is particularly convenient because the GPIO is exposed and it's designed for rapid prototyping.
I'd use it for things like:
One distinction: if you're building a safety-critical or very deterministic real-time system, I'd generally treat ESP32 as a specific architectural choice, rather than simply the default MCU.
The Raspberry Pi Pico family is unusually useful for experimenting with digital hardware.
The RP2040 has dual Cortex-M0+ cores, 264 KB SRAM, multiple SPI/I²C/UART peripherals, PWM, and—particularly interesting for an embedded engineer—programmable I/O (PIO).
PIO lets you implement unusual or timing-sensitive digital interfaces without consuming the CPU in the conventional way.
That's useful for experimenting with:
Raspberry Pi also provides a proper C/C++ SDK and GCC-based toolchain rather than forcing you into a simplified Arduino-style environment.
Texas Instruments's LaunchPad ecosystem is worth having if your work involves:
The important advantage isn't just the MCU—it is access to the broader TI ecosystem of op amps, ADCs, DACs, gate drivers, power-management ICs and sensors.
For an engineer working on hardware where the analog front end is as important as the firmware, that can be more valuable than an enormous software ecosystem.
NXP's Freedom development boards are another strong professional option, particularly if you're working in an environment where NXP MCUs are already part of the target architecture.
I'd consider them alongside STM32 Nucleo rather than as a replacement for it. The deciding factor is usually which MCU vendor you expect to use in the actual product.
Don't dismiss Arduino just because you're an experienced engineer.
For rapid hardware validation, an Arduino-compatible board can be incredibly productive. If you need to answer:
"Can this sensor communicate over I²C and can I get meaningful data out of it?" you don't necessarily need to spend half a day configuring clocks, linker scripts, RTOS tasks and peripheral registers.
Arduino is excellent for the first 30 minutes of an experiment. I'd then migrate the proven concept onto the actual MCU architecture.
A Raspberry Pi is a different category from the MCU platforms above.
Use it when you need things such as:
A common architecture is actually Raspberry Pi + STM32/ESP32, rather than choosing one or the other: the Pi handles high-level processing while the MCU handles deterministic real-time I/O.
If I were building a general-purpose embedded development kit, I'd have:
But there's an even more important point: development boards aren't the most important prototyping platform once you're past proof-of-concept.
For serious embedded work, I'd progressively move through:
Dev board → breadboard/peripheral prototype → custom breakout PCB → prototype PCB → EVT/DVT hardware
That transition is where tools such as KiCad/Altium, JTAG/SWD, oscilloscopes, logic analyzers, electronic loads, programmable supplies, and proper PCB fabrication become as important as the MCU development board.
If you tell me whether you're primarily doing automotive, robotics, IoT, consumer electronics, industrial control, or low-power/battery systems, I can narrow this down to a concrete $500–$2,000 embedded prototyping bench setup.
For an embedded-systems engineer, I’d prioritize platforms that teach and preserve real embedded-development skills—debugging, peripherals, RTOS work, datasheet-driven design, power management, and eventually custom-PCB migration—rather than just ease of programming.
| Platform | Best for | Why I’d use it |
|---|---|---|
| STM32 Nucleo | Best overall professional platform | Excellent peripherals, on-board debugger, huge MCU family, strong production relevance |
| Raspberry Pi Pico 2 / RP2350 | Best low-cost experimentation | Excellent documentation, flexible I/O, very inexpensive, C/C++ + Python |
| ESP32 development boards | Best connected/IoT prototyping | Wi-Fi/Bluetooth, inexpensive modules, enormous ecosystem |
| Arduino Portenta / higher-end Arduino | Fast application prototyping | Excellent ecosystem and libraries while still offering fairly capable MCUs |
| TI LaunchPad | Power, analog, motor control, TI ecosystem | Particularly compelling for MSPM0, C2000, MSP430 and TI wireless parts |
| NXP FRDM / MCX boards | Automotive/industrial + NXP ecosystem | Good path into NXP MCUs, RTOS, CAN, security and production-oriented designs |
| Raspberry Pi SBCs | Linux + embedded systems | Excellent when your system needs Linux, networking, cameras, UI, or substantial compute |
If you're serious about embedded engineering, I'd have an STM32 Nucleo board on your bench.
The Nucleo ecosystem spans a huge range of STM32 parts and includes integrated ST-LINK debugging/programming, Arduino-compatible connectors, STM32Cube tooling, and a large collection of expansion boards.
The big advantage isn't merely the board—it's the transferability of what you learn:
And ST publishes schematics, Gerbers and BOMs for the Nucleo family, which makes it particularly useful for learning how the development board translates into a real PCB.
Boards I'd consider: an STM32G4 for control/analog work, STM32H7 for high-performance applications, STM32U5 for low-power/security, or one of the newer wireless Nucleo boards.
The Raspberry Pi Pico 2 is arguably the best inexpensive "keep one on the bench" board.
Its RP2350 has dual Cortex-M33 cores at 150 MHz, 520 KB SRAM, extensive peripheral support, TrustZone, and Raspberry Pi's unusually flexible PIO peripheral system. It also supports C/C++ and MicroPython.
The interesting thing for an engineer is that Raspberry Pi provides documentation and even a minimal KiCad reference design, making the transition from development board → your own RP2350 PCB unusually approachable.
I'd especially use it for:
If the prototype needs Wi-Fi/Bluetooth, ESP32 becomes extremely attractive.
I'd use it for:
The important distinction is that I'd choose ESP32 because wireless connectivity is central to the design, rather than as my default platform for learning embedded fundamentals.
For a wireless product, however, it can dramatically shorten the path from "idea" to "something talking to the Internet."
Texas Instruments LaunchPad boards are worth having if your work touches:
I'd especially look at C2000 for motor/control applications and MSPM0/MSP430 for lower-complexity and low-power systems.
This is one area where having a platform-specific development board can be much more useful than trying to make a generic Arduino do everything.
NXP Semiconductors's FRDM ecosystem is another good choice, particularly if your career/work involves:
It's less universally convenient than STM32 for casual experimentation, but very valuable if NXP is part of your target ecosystem.
Don't confuse the Pico with the Raspberry Pi computers.
A Raspberry Pi-class SBC is appropriate when you need:
I'd pair one with a microcontroller rather than automatically replacing the MCU with it. A common architecture is:
STM32/RP2350 → real-time control Raspberry Pi → Linux/networking/UI/high-level processing
If I were putting together a small but extremely capable embedded prototyping kit, I'd buy:
The last point is important: as an embedded engineer, don't let the development board become the product architecture. Once you've demonstrated the concept, move toward the actual MCU/module, power supply, connectors, clocks, protection, programming interface and PCB layout you're likely to ship.
If you asked me to pick just one:
🥇 STM32 Nucleo — best overall embedded-engineering platform 🥈 Raspberry Pi Pico 2 — best experimental/value platform 🥉 ESP32 — best wireless platform 4. TI LaunchPad — best specialized control/analog/power platform 5. NXP FRDM — excellent industrial/automotive path 6. Raspberry Pi — best Linux-based embedded platform
For career development, I'd lean particularly heavily toward STM32 + RP2350 + ESP32. That combination exposes you to three very different approaches to MCU architecture and software while remaining inexpensive enough that you can build a lot of hardware around them.
The STMicroelectronics Nucleo and Discovery kits, ESP32 development boards , and Raspberry Pi Pico/RP2040 are the best hardware prototyping platforms for an embedded systems engineer because they offer direct low-level register access, robust vendor toolchain support, and low cost.
Choosing the right platform depends heavily on your application requirements, connectivity needs, and processing goals.
| Platform | Core MCU / Architecture | Best For | Key Advantage |
|---|---|---|---|
| ST Nucleo / Discovery | ARM Cortex-M (STM32 family) | Industrial control, motor drive, general professional firmware | Direct access to STM32CubeMX and comprehensive hardware abstraction layers (HAL). |
| ESP32 Boards | Dual-core Tensilica / RISC-V | IoT, Wi-Fi, and Bluetooth connected edge devices | Extremely low cost with integrated wireless stacks and FreeRTOS support out of the box. |
| Raspberry Pi Pico (RP2040) | Dual ARM Cortex-M0+ | Custom peripheral state machines and low-cost digital control | Programmable I/O (PIO) state machines allow custom hardware interfaces in software. |
| Arduino Portenta / GIGA | ARM Cortex-M7/M4 (STM32H7/H747) | High-performance dual-core edge computing and prototyping | Combines industrial-grade rugged connectors with Arduino's rapid prototyping ecosystem. |
| Digilent Zybo / Genesys (Zynq) | ARM + FPGA SoC (Xilinx/AMD) | Embedded Linux, high-speed DSP, and hardware acceleration | Seamlessly merges programmable logic with processing systems on a single chip. |
To help narrow down the ideal platform for your desk, tell me:
For a professional embedded systems engineer, the best hardware prototyping platforms balance raw peripheral access, debugging capabilities, and scalability into production-ready architectures.[](https://www.youtube.com/watch?v=cGs5xBxQXaA&t=12)
The top hardware prototyping platforms are organized by their use case below:
If you let me know your target application (e.g., battery-powered IoT, motor control, or edge vision) and preferred programming environment (bare-metal C, C++, or RTOS), I can narrow down the ideal specific board and toolchain for your project.
For an embedded systems engineer, the “best” hardware prototyping platform is not one board—it is a small set of platforms that cover MCU firmware, wireless, embedded Linux, and hardware acceleration. The strongest choices today are generally STM32, ESP32, Raspberry Pi, Nordic, TI, and FPGA ecosystems.
| Platform | Best for | Why use it |
|---|---|---|
| STMicroelectronics STM32 Nucleo/Discovery | General professional embedded firmware | Excellent debugging, huge MCU family, RTOS support, industrial peripherals |
| Espressif Systems ESP32 DevKit | IoT and connected devices | Wi-Fi/Bluetooth, low cost, strong SDK, lots of peripherals |
| Raspberry Pi Pico/Pico 2 | Low-level MCU experimentation | Cheap, flexible, excellent for learning peripherals and timing |
| Nordic Semiconductor nRF Development Kits | BLE, Thread, Matter, ultra-low-power | Industry-leading wireless MCU ecosystem |
| Texas Instruments LaunchPad | Motor control, analog, power electronics | Excellent peripherals and control-focused MCUs |
| FPGA development boards | High-speed digital hardware | Custom logic, DSP, accelerators, hardware/software co-design |
| Embedded Linux boards | Cameras, AI, UI, networking | Full OS environment for complex products |
For a career-focused embedded engineer, this is usually the first platform I would buy.
Strengths:
A good starter board:
This is the platform I would prioritize for firmware interviews and professional embedded work.
The ESP32 family is hard to beat for connected prototypes.
Use it for:
For engineering practice, use the native ESP-IDF framework rather than only Arduino libraries. It exposes a more production-like workflow.
Espressif Systems devices are particularly attractive because wireless connectivity is integrated into the chip ecosystem.
The Pico/Pico 2 is excellent for learning hardware fundamentals.
Great for:
It is not the first choice for many commercial products, but it is one of the best “engineering playground” platforms.
If you want to work on:
a Nordic platform is worth learning.
It teaches skills that matter in battery-powered products:
For products involving:
you want Linux.
Typical architecture:
Linux SBC / Compute Module
|
| SPI / UART / I2C / CAN
|
MCU
|
Sensors + motors + real-time I/OThe Linux processor handles high-level tasks; the MCU handles deterministic timing.
Learn FPGA if your work involves:
Good ecosystems include AMD/Xilinx and Intel FPGA boards.
A practical setup:
The test equipment often matters more than owning many development boards.
Arduino remains valuable for rapid experiments because of its huge ecosystem, but for developing deeper embedded engineering skills, vendor-native platforms like STM32, ESP-IDF, Nordic SDK/Zephyr, and TI tools expose more of the real constraints you encounter in products.
If I had to pick only three platforms for a serious embedded engineer: STM32 Nucleo + ESP32 + Raspberry Pi Pico 2. That combination covers most MCU firmware, IoT, and hardware experimentation scenarios.
If you're an embedded systems engineer, I’d prioritize platforms that give you good access to peripherals, debugging, RTOS support, documentation, and a path from prototype → production—not just boards that are easy to program.
| Platform | Best for | Why I like it | Main downside |
|---|---|---|---|
| STM32 Nucleo | Professional MCU development | Excellent peripherals, debugging, broad MCU family, production relevance | More learning curve |
| Raspberry Pi Pico 2 / RP2350 | Low-cost experimentation & custom hardware | Excellent documentation, PIO, dual-core M33/RISC-V, inexpensive | Smaller ecosystem than STM32 |
| ESP32 DevKit | Wireless/IoT | Wi-Fi + Bluetooth, powerful SDK, enormous ecosystem | RF/wireless complexity; less representative of some traditional MCU designs |
| Nordic nRF52/nRF54 DKs | BLE / low-power wireless | Excellent wireless stack and low-power tooling | Specialized toward wireless |
| Arduino-compatible boards | Rapid proof-of-concept | Huge peripheral/shield ecosystem, extremely fast iteration | Can hide important embedded details |
| Teensy | Fast MCU prototyping / DSP / audio | Very capable hardware with excellent libraries | Less representative of typical production MCU workflows |
| Raspberry Pi SBCs | Linux + hardware integration | Great for gateways, cameras, networking and higher-level software | Not a replacement for a real-time MCU |
This would be my #1 recommendation if your goal is to become better at professional embedded development.
The Nucleo family spans everything from low-power STM32L/U parts through high-performance STM32H/G parts, and boards generally include ST-LINK debugging/programming plus Arduino and/or ST-specific expansion connectors.
A particularly good setup is:
The important advantage is that you're working with the kinds of peripherals and development workflows you'll encounter in real products: DMA, timers, ADC/DAC, SPI/I²C/UART, interrupts, RTOS, bootloaders, linker scripts, debugging, etc.
Raspberry Pi's RP2350 is unusually interesting for an embedded engineer. It has dual Cortex-M33 cores or dual Hazard3 RISC-V cores, 520 KB SRAM, hardware security features, and the second-generation PIO subsystem.
The Pico 2 is therefore a fantastic little lab board.
I especially recommend it for learning:
It's also inexpensive enough that you can have several prototypes running simultaneously.
For anything involving Wi-Fi/Bluetooth, an ESP32 DevKit is hard to beat.
The current ESP32 family gives you a range of options, including RISC-V-based parts and devices supporting Wi-Fi, Bluetooth LE, Thread/Zigbee/802.15.4 depending on the chip. Espressif's official boards expose the GPIOs and are designed for breadboard/jumper-wire prototyping.
I'd particularly look at:
If you're building wearables, sensors, battery-powered devices, or anything heavily dependent on Bluetooth LE, I'd put Nordic very high on the list.
The big advantage isn't simply the MCU—it's the wireless software ecosystem and development/debugging experience.
I'd use Nordic rather than ESP32 when the problem is fundamentally:
"I need a really good low-power Bluetooth product." rather than:
"I need Wi-Fi/Bluetooth connectivity quickly."
Arduino remains useful even for experienced engineers.
Its real strength is hardware availability. You can grab a sensor, display, motor driver, relay, encoder, etc., connect it, and have something working very quickly.
But I'd use Arduino primarily for:
Concept → prototype → validate hardware
rather than:
Prototype → production firmware
For the latter, I'd move to STM32, Nordic, ESP32, RP2350, etc., fairly early.
Rather than picking one platform, I'd build a small multi-platform embedded lab:
That combination is considerably more valuable than having ten different Arduino boards.
I'd actually structure your learning around the same project implemented on different platforms.
For example, build a battery-powered environmental sensor:
STM32 → bare metal → FreeRTOS → custom PCB
Then reproduce it on:
RP2350 → DMA/PIO → custom PCB
Then:
ESP32 → Wi-Fi/BLE → cloud
Then:
Nordic → BLE → ultra-low-power
That forces you to understand what is fundamental embedded engineering versus what is merely an SDK/library abstraction.
If I had to choose just one: STM32 Nucleo. If I could choose two: STM32 Nucleo + Raspberry Pi Pico 2. If wireless matters: add ESP32 or Nordic depending on whether Wi-Fi or low-power BLE is the priority.