From Breadboard to PCB: The First-Timer’s Path

Freeze what actually worked

Before opening KiCad, photograph the breadboard from several angles and write down the firmware commit, supply voltage, measured current, module versions, and test results. Label every cable. Breadboards accumulate undocumented fixes: a pull-up moved to another rail, a capacitor added across power, or two module grounds joined through a programmer.

Redraw the prototype as connections, not physical breadboard rows:

5 V input -> 3.3 V regulator -> MCU and sensor VDD
MCU GPIO4 -> sensor SDA, pulled up to 3.3 V
MCU GPIO5 -> sensor SCL, pulled up to 3.3 V
MCU GPIO12 -> 1 kΩ -> LED anode; LED cathode -> GND

Measure ambiguous resistor/capacitor values and confirm module pin labels from datasheets. “It works on the breadboard” is evidence for that assembly, not a complete design specification.

Decide what remains a module

A breadboard prototype often uses a development board, breakout sensor, and USB power module. Your PCB can either mount those modules or replace them with their underlying components.

Keeping modules lowers first-revision risk: regulators, crystals, RF networks, and USB programming already work. Replacing them can reduce cost and size but adds every circuit the breakout was quietly providing. List those functions before deleting a module:

• voltage regulation and protection;
• decoupling and bulk capacitance;
• clock and flash;
• USB CC resistors and ESD;
• reset/boot pull resistors and buttons;
• level shifting and I2C pull-ups;
• antenna and keepout;
• programming/debug connector.

For a first PCB, a module carrier is often the better learning target. You still practice schematic capture, footprints, connectors, layout, and manufacturing without taking on RF or fine-pitch assembly at the same time.

Capture a complete schematic

Create functional blocks: power, controller, sensors, outputs, connectors, and programming. Add net labels and voltage names. Connect every ground and power pin, including hidden or exposed pads. Mark truly unused pins with explicit no-connect markers.

Add what the breadboard setup supplied implicitly: input connector, fuse/protection as needed, regulator capacitors from its datasheet, decouplers at IC pins, reset/boot controls, pull resistors, mounting holes, and test points. Put connector pin names and expected voltage on the schematic.

Run ERC and resolve findings rather than hiding them. A PWR_FLAG may tell KiCad that a passive connector drives a rail; it does not replace the power supply.

Select physical parts before layout

Every symbol needs a real, orderable part and matching footprint. A schematic value such as 10k is enough to understand a resistor but not enough to purchase its tolerance, power rating, package, and quantity. Record manufacturer and MPN for connectors, semiconductors, crystals, inductors, and other critical parts. Follow setting up a BOM with real part numbers.

Print unfamiliar footprints at 1:1 and place the parts on paper. Check connector mating direction, pin-one marks, package pitch, exposed pads, mounting tabs, and height. The symbol-versus-footprint guide explains the pin-number audit that prevents a correct net from landing on the wrong physical pad.

Prefer sizes you can assemble and rework. An 0603 passive or SOIC package may be worth a larger board on revision one. If an assembler will build it, ask for their package and stencil preferences before placement.

Place by mechanics and current flow

Draw the board outline and mounting holes from the enclosure first. Place connectors where cables can reach, buttons where fingers can press, LEDs where users can see, and antennas at the required edge/keepout. Then place power components in input-to-load order and decoupling capacitors against their IC pins.

Group each functional block. Keep switching regulator loops compact, crystals beside their pins, USB data together over ground, and noisy outputs away from analog inputs. Preserve a continuous ground reference. Route power and critical signals first; ordinary GPIO can adapt afterward.

Use wider traces for current based on copper and temperature calculations, not appearance. Add test pads for input power, every rail, reset, boot, ground, and at least one programming path. A first board is much easier to debug when a probe can touch it safely.

Check the design and manufacturing outputs

After every schematic change, update the PCB. Refill zones, run DRC, and enable schematic parity. Review all unconnected items and exclusions. Inspect the 3D model with the enclosure, but also compare dimensioned drawings because 3D library models can be missing or inaccurate.

Before ordering, complete the PCB DFM checklist. Generate Gerbers and drill files into an empty folder, then view them independently. Check board outline, holes, copper layers, solder mask, silkscreen, and slots. Do not upload the .kicad_pcb file and assume the supplier will infer your intentions.

Decide whether you are ordering bare boards or assembled boards. A bare PCB and PCBA require different files and preparation; PCBA normally adds a BOM, component-position file, DNP data, and assembly drawing.

Plan bring-up before boards arrive

Write tests while the schematic is fresh:

1. Visual inspection for wrong orientation, bridges, and missing parts.
2. Resistance from each power rail to ground with power off.
3. Current-limited power-up with the MCU held in reset if possible.
4. Measure input, regulator output, and reset/enable levels.
5. Connect the programmer and load minimal firmware.
6. Toggle one output, scan buses, then enable one peripheral at a time.
7. Run the original breadboard acceptance tests.

Order enough boards to sacrifice one to rework and probing. Populate power first if hand assembling, verify its rail, then add the controller and peripherals in stages. Keep thin wire, solder mask, and zero-ohm options in mind when placing parts; accessible pads can turn a pin swap into a bodge instead of a total loss.

Record every issue as schematic, footprint, layout, BOM, firmware, or assembly. Update the source immediately rather than relying on a handwritten patch for the next order. The goal of a first PCB is not zero lessons—it is a controlled path from observed prototype behavior to a board whose connections, parts, and tests are explicit.