A breadboard is great when you are figuring things out. It lets you move wires, swap parts, test ideas, and make mistakes without committing too hard.
But at some point the project gets annoying. The jumper wires fall out. The sensor works only when the board is sitting perfectly still. The wiring looks like a bowl of spaghetti. You cannot put it in a box without praying nothing moves.
That is when it is time to think about a more permanent version: perfboard, stripboard, or a real PCB. This guide explains how to move from “it works on the breadboard” to a cleaner board you can design in KiCad, order from a board manufacturer, solder, test, document, and actually use.
Moving from breadboard to PCB is one of the clearest upgrades a student electronics project can make. It shows that you did more than follow a wiring diagram. You turned a temporary prototype into a buildable system.
A breadboard demo is useful, but it usually looks temporary. A soldered board or PCB shows planning, iteration, component choices, pin labels, power routing, and build quality.
That matters for class projects, GitHub writeups, portfolio pages, robotics builds, sensor boxes, IoT projects, and anything that needs to survive being moved.
Breadboards can hide confusion. A schematic forces you to name every connection. A PCB layout forces you to think about power, ground, connectors, part placement, trace routing, and how someone will assemble the thing.
That process turns a pile of jumper wires into an electrical design you can explain.
The goal is not a perfect first PCB. The goal is to make v1, test it, find the mistakes, document what changed, and make v2 better.
This is not just theory. I use this workflow for real hardware projects.
I use KiCad on Linux because it is free, serious enough for real PCB work, and a good fit for student hardware projects. It lets me draw schematics, assign footprints, lay out boards, run design checks, and export the manufacturing files needed to order a PCB.
I used this kind of workflow for my 8-bit CPU PCB work and for a train horn conversion board, where the goal was to move from rough wiring and circuit planning toward something cleaner, repeatable, and easier to document.
After creating the board files, I used JLCPCB to manufacture the PCBs. That step turns the design into a real board with copper traces, solder mask, silkscreen labels, holes, and a physical layout that can be soldered and tested.
The important part is not that the first board is perfect. The important part is learning the full path: breadboard, schematic, PCB layout, exported files, ordered board, soldered build, meter testing, and v2 notes.
Do not rush to PCB too early. Breadboards are for learning and testing. But once the circuit is basically proven, a more permanent version starts to make sense.
You tested the basic idea. The sensor reads, the LED responds, the relay clicks, the ESP32 publishes data, or the display shows output.
If the project only works when nobody touches it, the breadboard has done its job. It is time for stronger connections.
Project boxes, sensors, buttons, displays, power jacks, and connectors are easier to manage when the wiring has a real layout.
You do not always need a manufactured PCB. Sometimes perfboard or stripboard is the right next step.
Perfboard is a blank board with holes. You solder parts and wires manually. It is good for small one-off builds and practice.
Stripboard has copper strips connecting rows of holes. It can be useful, but you must cut traces correctly or you will accidentally connect things.
A custom PCB gives you routed copper traces, labels, mounting holes, connectors, and repeatable layout. It takes more planning but looks and works cleaner.
This is the basic flow. It is not fancy. It is the same idea every time: prove it, draw it, lay it out, build it, test it, improve it.
Build the idea on a breadboard and prove the main circuit works.
Write down parts, pin numbers, voltage rails, ground, and what each wire does.
Draw the circuit in a tool like KiCad so the connections are clear.
Place components, route traces, add labels, check rules, then export board files.
Project workflow
breadboard prototype
-> wiring notes
-> schematic
-> footprint check
-> PCB layout
-> design rule check
-> Gerber export
-> order board
-> solder parts
-> meter test
-> power-on test
-> document v1 and improve v2Before opening PCB software, freeze what you already built. The breadboard is temporary, so document it before it changes or falls apart.
Take clear photos from above and from the side. Get the full board, power source, sensor labels, resistor positions, module pins, and microcontroller pins.
Photos are not a replacement for a schematic, but they help when you forget what the working version looked like.
Write down which microcontroller pin connects to each sensor, display, button, LED, relay, MOSFET, or connector.
Also write down each voltage rail. A PCB layout needs to know what is 3.3V, 5V, 12V, and ground.
Example breadboard notes
Project: ESP32 soil sensor box
Version: breadboard v1
Power:
- ESP32 powered by USB
- Sensor powered from 3.3V
- OLED powered from 3.3V
- All grounds connected
Pins:
- GPIO 21 -> OLED SDA
- GPIO 22 -> OLED SCL
- GPIO 34 -> soil sensor analog output
- GPIO 18 -> status LED through 220 ohm resistor
Notes:
- Sensor works at 3.3V
- OLED uses I2C
- Add screw terminal for external sensor cable
- Add mounting holes for project boxA schematic is not supposed to look like the physical breadboard. It shows the electrical connections clearly. That is what matters.
Resistors, LEDs, capacitors, connectors, sensors, regulators, and microcontroller headers each get a symbol in the schematic.
Names like GND, 3V3, 5V, SDA, SCL, and
SENSOR_OUT make the circuit easier to understand.
A schematic helps you catch missing grounds, reversed LEDs, wrong resistor placement, and power rails that were only clear in your head.
In PCB software, the schematic symbol says what the part is. The footprint says what the physical pads look like on the board.
A resistor symbol is generic. The actual resistor footprint depends on the size and package. A connector footprint depends on pin spacing, orientation, and mounting style.
If the footprint is wrong, the board may arrive looking correct on screen but impossible to assemble.
Check pin spacing, connector orientation, mounting holes, and part sizes. If possible, print the PCB layout at 1:1 scale and place parts over it.
This one step can save a full board revision.
PCB layout is where the board starts to feel real. You place parts, route traces, add labels, and decide how someone will actually use the thing.
USB, screw terminals, buttons, switches, sensors, displays, and power jacks often need to line up with a case or edge.
Put resistors, capacitors, headers, and support parts near the chip, module, or connector they belong to.
Power and ground should be easy to follow. Do not make the board a maze if it can be simple.
Add silkscreen labels for voltage, ground, connectors, pin names, polarity, and board version.
A board that cannot mount anywhere is still half temporary. Mounting holes make project boxes easier.
Leave room for screw terminals, headers, heat shrink, plugs, tall capacitors, and fingers.
Small signal traces are different from traces carrying power to motors, LEDs, or larger loads.
Use the design rule checker before exporting files. It catches spacing and connection problems.
Silkscreen is the text and markings printed on the board. Use it. Future you will not remember every connector pin.
Mark 3V3, 5V, 12V, and GND. Do not make someone guess
which terminal is safe.
Label sensor connectors, switch inputs, display headers, motor outputs, and communication pins.
Put the project name and version on the board. When v2 exists, you will be glad v1 was labeled.
Useful silkscreen labels
Project name: Soil Sensor Node
Board version: v1.0
Power: 3V3, 5V, 12V, GND
Signal pins: SDA, SCL, TX, RX, SIG, PWM
Polarity: +, -, LED direction, capacitor polarity
Connectors: SENSOR, POWER IN, FAN OUT, DISPLAYPower and ground are not the boring part. They are the part everything depends on.
If the board has 3.3V, 5V, and 12V, label them clearly and keep them separated. A 12V trace touching a 3.3V input is not a small typo.
Use the schematic and layout to show which parts belong to each voltage rail.
Ground should not feel like an afterthought. A ground pour or clear ground routing can make the board easier to wire, test, and troubleshoot.
For beginner boards, simple and readable beats clever.
Once the board layout is ready, PCB software exports manufacturing files. These are usually called Gerber files, plus drill files for the holes.
Gerber files describe copper layers, solder mask, silkscreen, board outline, and other manufacturing details. Drill files describe the holes.
You usually upload these files as a zip archive to the PCB manufacturer.
Most board houses show a preview. Check the outline, labels, holes, connector orientation, and whether the board looks like what you expected.
Ordering without previewing is how silly mistakes become physical objects.
Do not immediately solder everything and plug it in. Treat the board like a new version that needs inspection.
Use this before ordering a custom board. It is cheaper to catch mistakes on screen than after the boards arrive.
PCB pre-order checklist
[ ] Breadboard version was tested
[ ] Schematic matches the working circuit
[ ] Power rails are labeled
[ ] Ground is clearly connected
[ ] Connector pinouts are checked
[ ] Footprints match real parts
[ ] Board outline fits the project box or mounting plan
[ ] Mounting holes are included
[ ] Silkscreen labels are readable
[ ] Polarity markings are clear
[ ] Design rule check passes
[ ] Gerber preview looks correct
[ ] No private/sensitive text is printed on the board
[ ] Version number is on the boardThese happen. The first PCB is usually where theory meets “oh, that connector is backwards.”
The part looked right in the schematic, but the real pins do not fit the pads.
The connector is electrically correct but faces the wrong direction or has the pin order flipped.
The board works, but nobody knows which terminal is power, ground, sensor, or output.
The circuit is fine, but the board cannot attach to the project box or panel.
Parts fit on screen but not in real life because connectors, wires, or hands need space.
A trace carrying load current is treated like a tiny signal trace. That can cause heating or voltage drop.
The board has no easy place to measure voltage or signals once it is assembled.
v1 and v2 look almost the same, and now nobody knows which board has which fix.
When the first board has a mistake, do not panic. This is normal. Board v1 is often the expensive checklist that teaches you what v2 needs.
Check whether the board was built according to the schematic. Then check whether the schematic actually matched the breadboard. The mistake can be in either place.
Use a multimeter, photos, notes, and the PCB layout to trace what happened.
Do not rely on memory. Write a board revision list: move connector, flip polarity mark, widen trace, add test point, change footprint, add mounting hole, fix silkscreen.
That list becomes the plan for v2.
Board v1 debug note
Project: ESP32 fan controller PCB
Board version: v1.0
Problem:
- Fan connector polarity label is confusing
- Mounting hole too close to screw terminal
- GPIO label uses board pin name instead of ESP32 GPIO number
What worked:
- 3.3V rail measures correctly
- 12V input reaches fan connector
- MOSFET switching works
- No short between 12V and GND
Changes for v2:
- Rename connector labels
- Move mounting hole 4mm away from terminal block
- Add test point for GPIO signal
- Add larger GND label near power inputA PCB project is strong portfolio material because it shows planning, iteration, hardware skill, documentation, and real troubleshooting.
Include breadboard photos, schematic screenshots, PCB layout screenshots, ordering notes, soldering photos, test results, and v2 fixes.
Explain connector placement, power routing, mounting holes, labels, board size, and what changed from the breadboard version.
A board mistake can be embarrassing for five minutes or useful forever. Document it and show what v2 fixed.
A PCB is just the next version of the project. Start with the breadboard, prove the circuit, draw the schematic, check the footprints, route the board, inspect the files, solder carefully, test with a meter, and document what v1 taught you. The board does not need to be perfect. It needs to teach you enough to build v2.