Why Design a Custom PCB
A development board like the Nucleo is designed for flexibility — it breaks out every pin, includes a debug probe, and has multiple header formats. This makes it physically large (70×133mm for the Nucleo-144), expensive per unit ($25), and inappropriate as a final product. A custom PCB includes only what your product needs: the MCU (or module), power regulation, the display connector, and perhaps a USB port. The result is smaller, cheaper, more robust, and manufacturable at scale.
A custom board for an ESP32-S3 + e-paper display might be 40×60mm and cost $3–5 per unit fully assembled in quantities of 100+.
The Design Pipeline
Schematic Capture
A schematic is a logical diagram of every component and every electrical connection, drawn in an EDA (Electronic Design Automation) tool. At this stage you select specific part numbers — the ESP32-S3-WROOM-1 module, an AMS1117-3.3 voltage regulator, a USB-C connector, decoupling capacitors (100nF ceramic on every power pin), the FPC connector for the e-paper flat-flex cable, boot-mode selection resistors.
The schematic captures what connects to what without specifying physical placement. Each component has a schematic symbol (a rectangle with labeled pins) and an associated PCB footprint (the physical copper pattern it solders to).
PCB Layout
You take the schematic’s component list and place the physical footprints on a board outline, then route copper traces between pads to realize the schematic connections. This is where physical reality dominates: trace widths must carry the required current (a 10mil trace handles ~300mA on outer layers), ground planes reduce noise, antenna keep-out zones (critical for ESP32’s Wi-Fi) must be free of copper, and the board must mechanically fit the enclosure.
A simple design uses a two-layer board (copper on top and bottom of the fiberglass substrate). Complex designs with high-speed memory buses (DDR), dense BGA packages, or controlled-impedance RF traces may require 4, 6, or 8+ layers. For an MCU + display product, two layers suffice.
Design Rule Check (DRC)
Before manufacturing, the EDA tool runs a DRC that verifies no traces are too close together (risk of short circuit), no pads are too small for the component, and all connections in the schematic are realized in the layout. This is analogous to a compiler’s type checker — it catches a large class of errors statically.
EDA Tools
The three dominant tools occupy different niches:
KiCad (free, open-source, cross-platform) has matured dramatically since v6/v7 and is now used by CERN, many startups, and hobbyists. It has a large community footprint library and a plugin ecosystem. This is the default recommendation for someone starting out.
Altium Designer (~$5,000+/year) is the industry standard for professional hardware teams. Superior auto-routing, constraint management, and multi-board integration. Overkill for personal projects.
EasyEDA / LCEDA (free, browser-based) is tightly integrated with JLCPCB’s component library and ordering system — you can search for parts with real-time stock levels, place them in your schematic, and order the finished board without leaving the tool. Lower design ceiling than KiCad for complex boards, but the lowest friction path from idea to manufactured PCB.
Manufacturing: Fabrication and Assembly
Fabrication (bare boards)
You export Gerber files from your EDA tool — the industry-standard vector format describing each copper layer, solder mask (the colored coating), silkscreen (text and labels), and drill locations. You upload these to a fab house.
The economics are remarkable. For a two-layer board up to 100×100mm:
| Fab House | Location | Qty 5 Price | Turnaround |
|---|---|---|---|
| JLCPCB | Shenzhen | ~5 shipping | 3–5 days fab + shipping |
| PCBWay | Shenzhen | ~5 shipping | 3–5 days fab + shipping |
| OSH Park | US | ~$5/in² (shared panel) | ~12 days |
JLCPCB and PCBWay offer board colors (green, black, white, blue, red, yellow) at no extra cost. OSH Park’s signature purple is their only option.
Assembly (populated boards)
Fab houses can also solder components onto the board. You upload three additional files:
- BOM (Bill of Materials) — a spreadsheet listing every component: part number, value, quantity, and designator (C1, R3, U2, etc.)
- CPL (Component Placement List) — X/Y coordinates and rotation for each component on the board
- Pick-and-place designation — which side of the board (top/bottom) each component goes on
The fab house’s pick-and-place machines pull components from reels and place them on the board with ~0.05mm accuracy, then the board passes through a reflow oven (for surface-mount) or wave solder machine (for through-hole).
Assembly pricing at JLCPCB for a simple board: ~0.001–0.05 per component placement + component cost. For a 20-component ESP32 board, total assembly cost might be ~2 per unit at qty 1000.
Tip
JLCPCB and LCEDA (EasyEDA) are owned by the same parent company. Using EasyEDA for design gives you one-click ordering with automatic BOM/CPL generation — the lowest-friction path from schematic to assembled board in a box on your desk.
When a Custom PCB Makes Sense
For prototyping and learning, dev boards and jumper wires are the right tool. A custom PCB becomes worthwhile when you want to make the device smaller (remove unnecessary headers and debug circuitry), cheaper per unit (a custom ESP32-S3 board might cost 15 for a dev board), mechanically robust (no jumper wires to come loose), or producible at volume. The threshold is typically when you want more than ~5 identical devices, or when the form factor matters (e.g., fitting inside a specific enclosure or wearable).