New: AI Part GeneratorFree to get started

Guide

How to Design a PCB, Step by Step

ProtoFlow drafting a schematic from a plain-English description, then moving it into layout.
Download for DesktopFree to start · macOS, Windows & Linux

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.

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.

Last reviewed: 2026-08-18 · By ProtoFlow Engineering Team

PCB design steps and the check that saves a respin

StepWhat you doThe check
1. RequirementsPower source, MCU/ICs, interfaces, connectors, size, environmentCan you list every connector and its pinout?
2. SchematicCapture with real parts (symbol + footprint + orderable MPN)ERC clean; every power pin has a net
3. PartsConfirm stock, price, package, footprint vs datasheetNo footprint you have not checked against the land pattern
4. Board setupLayer count, outline, stackup, fab design rulesRules entered before the first part is placed
5. PlacementGroup by function; decoupling at pins; connectors at edge; keep-outsEvery IC's decoupling within a few mm of its pin
6. RoutingPower wide and first; ground plane; short crystal/RF; then signalsNo return-path breaks under critical traces
7. DRCRun against the fab's real limitsZero errors; understood warnings
8. Silkscreen + 3DReference designators, polarity, pin 1, board name/version3D view shows no collisions
9. OutputsGerbers, drill, BOM, pick-and-placeLoad Gerbers in a viewer before ordering
10. Order + bring-upFab (and assembly) → test power rails firstRails correct before populating/powering everything

Skip the comparison shopping. Try the free one first and see if it does the job.

Download for Desktop

Step 1 — write the requirements down

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

CriteriaProtoFlow (free)KiCad (free)
Schematic startFrom a plain-English brief, real parts attached.Blank sheet, official library.
PartsLCSC / DigiKey / Mouser import with footprint + 3D.Official library + manual imports.
SimulationBuilt-in SPICE.Integrated ngspice.
LayoutAI-assisted placement + autorouter.Manual + interactive router.
FilesNative KiCad export, Gerbers.Native, Gerbers.

Migration Steps

  1. Write the requirements list; choose power, MCU, interfaces, connectors, size.
  2. Capture the schematic with real parts (or draft it in ProtoFlow from the brief) and run ERC.
  3. Set up the board with your fab's rules, place by function, route power then signals, run DRC.
  4. Finish 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.

Sources

Related Resources

PCB Design Rules and Guidelines: What to Set, What to Check

PCB design rules and guidelines that keep boards manufacturable and working: trace width and spacing, vias and annular rings, clearance, decoupling, ground planes, return paths, thermal relief, silkscreen — and how to turn them into DRC rules.

How to Make a PCB Schematic with AI (2026)

A practical, step-by-step guide to designing a PCB schematic with AI in 2026, from a plain-English prompt to real parts, validation, and a KiCad-ready export.

ESP32 Schematic Design, From Reference Circuit to Board

How to design an ESP32 schematic that boots and programs reliably: 3.3 V power, decoupling, EN reset, strapping pins, auto-program circuit, USB-UART or native USB, antenna keep-out — plus how to draft it with AI and real parts.

Is an AI-Routed PCB Actually Manufacturable?

A practical verification guide for AI-generated PCB layouts: what DRC catches, what DFM catches, what neither catches, and the checks that decide whether an AI-routed board is safe to fabricate.

The Best PCB Design Software for Beginners in 2026

The best PCB design software for beginners in 2026, easy tools to go from idea to board, including AI schematic capture with ProtoFlow, plus KiCad, EasyEDA, and DipTrace.

The Best Circuit Design Software in 2026

The best circuit design software in 2026 compared by what you are designing: schematics, simulated circuits, or real PCBs. Free, online, open-source, and AI-assisted options, with an honest fit for each.

Real parts library

KiCad symbols, footprints, and 3D models for real, orderable LCSC parts.

AI PCB Design in 2026: What's Real and What's Hype

A stage-by-stage guide to AI PCB design in 2026: what AI does well at schematic, sourcing, layout, and routing today, and where a human still wins.

Try ProtoFlow EDA

Evaluate the workflow directly with your own circuit scope and compare review-ready output speed.

Download ProtoFlow

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.