Designing a printed circuit board is a sequence, and almost every first-board respin comes from skipping a step in it — usually placing parts before setting design rules, or routing before the schematic was actually checked. This is the sequence, with the free tools that cover it and the specific check at each stage that saves you a board.
Last reviewed: 2026-08-18 · By ProtoFlow Engineering Team
ProtoFlow drafting a schematic from a plain-English description, then moving it into layout.
Quick answer
To design a PCB: write down what the board must do; capture the schematic with real parts (not generic symbols) and run ERC; set up the board — layer count, outline, and your fabricator's design rules — before placing anything; place by function with decoupling next to pins and connectors at the edge; route power first and wide, then signals, over a solid ground plane; run DRC against the fab's real limits; add silkscreen and check the 3D view; export Gerbers, drill, BOM, and pick-and-place; order. Free tools cover the whole flow: ProtoFlow (AI-assisted schematic with real parts, simulation, layout, autorouter, KiCad export) and KiCad.
PCB design steps and the check that saves a respin
Step
What you do
The check
1. Requirements
Power source, MCU/ICs, interfaces, connectors, size, environment
Can you list every connector and its pinout?
2. Schematic
Capture with real parts (symbol + footprint + orderable MPN)
ERC clean; every power pin has a net
3. Parts
Confirm stock, price, package, footprint vs datasheet
No footprint you have not checked against the land pattern
4. Board setup
Layer count, outline, stackup, fab design rules
Rules entered before the first part is placed
5. Placement
Group by function; decoupling at pins; connectors at edge; keep-outs
Every IC's decoupling within a few mm of its pin
6. Routing
Power wide and first; ground plane; short crystal/RF; then signals
A PCB is easier to design than to redesign, so spend ten minutes on the boring list: what powers it (USB, battery, 12 V), what runs it (MCU or ICs), what it talks to (USB, I2C, SPI, UART, wireless), what connects to it (every connector and pinout), how big it can be, and where it lives (temperature, vibration, enclosure). This list decides the regulator, the layer count, and half the placement.
Step 2 — capture the schematic with real parts
Draw the circuit as symbols and nets, and use real parts from the start: a symbol tied to a footprint tied to an orderable manufacturer part number. Generic symbols feel faster and cost you the time back later, twice. Use power symbols and net labels to keep sheets readable, give every IC its decoupling right there in the schematic, and add test points on the rails you will want to probe. When it is drawn, run the electrical rule check and actually resolve what it flags — unconnected pins and conflicting drivers are the classic first-board bugs.
This is the stage AI helps most. In ProtoFlow you can describe the board in plain English and get an editable schematic with real LCSC, DigiKey, or Mouser parts already attached, then edit it like any schematic; KiCad is the reference manual editor and the format ProtoFlow exports to.
Step 3 — vet the parts
Before layout, confirm each part is in stock at the distributor you will use, in the package you drew, at a price you accept, and that its footprint matches the datasheet land pattern — especially for anything you generated or downloaded. If you plan to have the fab assemble the board, prefer parts in their catalog (for JLCPCB, "basic" and stocked "extended" parts). This is also when you simulate the analog bits that matter — regulator behavior, filters, sensor front-ends — with the built-in SPICE in ProtoFlow or ngspice in KiCad.
Step 4 — set up the board before placing anything
Choose the layer count (two layers for simple boards; four when you have an MCU with many signals, any RF, or want a solid ground plane under everything), draw the outline with mounting holes, and enter your fabricator's design rules: minimum trace width and spacing, minimum via drill and annular ring, clearance to the board edge. Typical low-cost fabs publish something like 0.127 mm (5 mil) trace/space and 0.3 mm via holes for standard service — but read the fab's capability page and enter their numbers, not a guess. Rules entered now mean DRC will catch you throughout instead of on the last day.
Step 5 — placement is most of the layout
Place by function: the MCU in the middle with its crystal and decoupling right at the pins, the power section together, connectors at the edges where the enclosure needs them, sensors where they must physically be. Keep switching regulators away from analog and RF. Leave room around the antenna if there is one (copper-free on all layers). A good placement routes itself; a bad one cannot be rescued by an autorouter — which is also why AI-assisted placement in ProtoFlow, or a careful hour by hand, pays for itself.
Step 6 — routing, in the right order
Route power first and wide (use a trace-width calculator for the current), then the sensitive nets short and direct (crystal, high-speed, analog), then everything else. Give the board a solid ground plane and do not cut it under signal traces; every signal needs a return path directly beneath it. Use vias freely on a two-layer board but keep them out of pads and away from the crystal. An autorouter — ProtoFlow has one built in — is fine for the bulk of ordinary signals once power and critical nets are hand-routed; check its work rather than trusting it.
Step 7 — DRC, silkscreen, 3D
Run design rule check with the fab's numbers and drive it to zero errors. Then finish the silkscreen: reference designators readable and not under parts, polarity marks on diodes and electrolytics, pin 1 on every IC and connector, and the board name and version somewhere visible. Open the 3D view: parts overlapping, connectors facing the wrong way, and a header under a heatsink are all obvious in 3D and invisible in 2D.
Step 8 — outputs and ordering
Export Gerbers (copper, mask, silk, outline) and the drill file, plus a BOM and pick-and-place file if the fab is assembling. Load the Gerbers into a Gerber viewer before uploading — what the viewer shows is exactly what the fab will make. Order a small quantity first. When boards arrive, power the rails with nothing else populated or connected, measure them, and only then bring up the rest. That order turns a mistake into a note instead of a smoking part.
Decision Matrix
Criteria
ProtoFlow (free)
KiCad (free)
Schematic start
From a plain-English brief, real parts attached.
Blank sheet, official library.
Parts
LCSC / DigiKey / Mouser import with footprint + 3D.
Official library + manual imports.
Simulation
Built-in SPICE.
Integrated ngspice.
Layout
AI-assisted placement + autorouter.
Manual + interactive router.
Files
Native KiCad export, Gerbers.
Native, Gerbers.
Migration Steps
01Write the requirements list; choose power, MCU, interfaces, connectors, size.
02Capture the schematic with real parts (or draft it in ProtoFlow from the brief) and run ERC.
03Set up the board with your fab's rules, place by function, route power then signals, run DRC.
04Finish silkscreen, check 3D, export Gerbers/BOM/CPL, order a small run, bring up rails first.
How This PCB Design Tutorial Was Assembled
Reviewed on: 2026-08-18
Methodology
Selected each target query from August 2026 US keyword data (volume, CPC, difficulty) for the circuit-design query family, filtered to intents no existing protoflow.ai page owned.
Reviewed the official product, pricing, documentation, or repository of every tool named on the page in August 2026.
Kept only workflow- and source-checkable claims. Nothing here is a hands-on benchmark, a speed measurement, or a simulation-accuracy test result.
Findings
The steps follow the schematic → layout → fabrication flow every board-level EDA tool implements; each step names the check that catches the common first-board mistake.
Fabrication numbers are given as typical low-cost-fab capabilities and explicitly deferred to the fab's own capability page.
Tools named reflect their official documentation in August 2026; ProtoFlow steps reflect the free desktop app.
Frequently Asked Questions
What software should I use to design my first PCB?
Free tools cover the whole flow: ProtoFlow (AI-assisted schematic with real parts, simulation, layout, autorouter, KiCad export) and KiCad (open-source reference editor). Many people use ProtoFlow to draft and check and KiCad as the long-term editor; they share files.
How many layers should my PCB have?
Two layers for simple boards; four as soon as you have an MCU with many signals, RF, or want an unbroken ground plane. Four-layer boards are cheap now and forgive more mistakes.
What are typical PCB design rules for a cheap fab?
Roughly 0.127 mm (5 mil) minimum trace/space and 0.3 mm minimum via drill for standard service at low-cost fabs — but always enter the numbers from your fab's own capability page.
Do I need to simulate my PCB?
Not the whole board, but simulate the analog stages that matter (regulators, filters, sensor front-ends). ProtoFlow and KiCad both simulate the schematic you lay out.
What files does a PCB fab need?
Gerbers for each layer (copper, solder mask, silkscreen, outline), the drill file, and — for assembly — a BOM and pick-and-place (CPL) file. Check them in a Gerber viewer before ordering.
How to design a PCB, PCB design tutorial, and PCB design process
Searches for how to design a pcb, pcb design tutorial, pcb design process, pcb design for beginners, how to make a pcb, and pcb design steps all want the same sequence: requirements, schematic with real parts and ERC, part vetting, board setup with the fab's rules, placement, routing, DRC, silkscreen and 3D, Gerbers and BOM, ordering and bring-up. Free tools — ProtoFlow with AI-assisted schematic, simulation, layout, and KiCad export, and KiCad itself — cover every step.