From Schematic to Board: The PCB Design Flow and KiCad
The cost of a mistake multiplies by ten at every step from schematic to fabrication. Find it early or pay for it late.
🎯 By the end you'll understand
The nine steps between a schematic and an assembled board, and which of them are gates that can stop a defect. How a KiCad project is actually organised on disk — symbols, footprints, 3D models, library tables — and why a versioned project library is the difference between a reproducible board and a folder of mysteries. What the same mistake costs when it is caught at each stage, in hours and in dollars, so that "we'll review it later" becomes a number rather than a mood. And how Beacon Rev A is set up so that Stage 5 can build it without going back.
KEY INSIGHTThe board is the last place to find a mistake, and the most expensive
A wrong net label is fixed with a keystroke. The same wrong net, discovered on twenty-five assembled boards, is fixed with a scalpel, a spool of 30 AWG wire, and a week you did not have.
Here is a bench scene that every hardware engineer has lived through. Five boards arrive from the fab. They are beautiful — matte black solder mask, gold pads, your logo in silkscreen. You plug one in. The regulator comes up. The MCU enumerates over USB. The temperature sensor answers on I2C. And the RGB LED does nothing, except get slightly warm. Twenty minutes with a loupe and a datasheet later you find it: the LED footprint's pin-1 mark is on the wrong corner, so the assembler placed every LED rotated. Power is on the ground pad. The part is soldered, tiny, and on all five boards. You can rework a 2 × 2 mm LED with hot air if you are patient. You cannot rework twenty-five of them for the pilot. You respin.
Nothing about that defect was hard to see. It was visible in the footprint editor, in the 3D viewer, in the layout, in the Gerber preview, and in the fab's assembly rendering before you clicked "order". It was not caught because nobody looked at the right thing at the right stage. That is the whole lesson: the PCB design flow is a sequence of stages, each stage has a gate — a tool check or a human check — and the cost of a defect grows roughly tenfold every time it slips through a gate. The design flow is not bureaucracy. It is a filter with known mesh sizes, and you decide how much gets through.
Every stage of the flow can only catch certain classes of defect. ERC cannot see a wrong footprint. DRC cannot see a swapped I2C pair. A bench bring-up cannot see a strapping-pin conflict that only appears when a button is held at power-on. Because the gates are class-specific, skipping one does not "save time" — it moves a specific class of defect to the next gate that can see it, which is usually the fab or the field. The widget in this lesson makes that arithmetic concrete.
HOW IT WORKSThe flow and its gates
The flow below is the one every serious EDA tool implements, and it is the one KiCad 8 and 9 implement almost literally as menu items. The steps are ordered, but the arrows run backwards as often as forwards: a layout problem sends you back to the schematic to add a test point; a footprint problem sends you back to the library. What stays fixed is which gate can catch what.
Let's walk the stages once, naming what each one can and cannot see.
Schematic capture
You place symbols, wire pins, name nets, and write values. What exists after this step is a connectivity graph: which pins are on which net. Nothing physical exists yet. Every "logic" mistake — a swapped SDA/SCL, a missing pull-up, a button on a strapping pin — is born here and is cheapest to kill here.
Annotation
Every symbol gets a unique reference designator (R1, C7, U3). KiCad's annotator can number by sheet, by position, or keep existing numbers. Annotation is boring until you re-annotate a board that has already been laid out and every footprint loses its link to its symbol. Rule: annotate once, then never let the tool renumber.
ERC — Electrical Rules Check (gate)
ERC checks the connectivity graph against pin electrical types: an input with no driver, two push-pull outputs tied together, a power net with no power source (the famous PWR_FLAG), unconnected pins without a no-connect flag, labels that look alike. It does not know what an I2C bus is. It cannot tell SDA from SCL. Lesson 5.2 dissects exactly what it can see.
Footprint assignment (gate — human)
Each symbol is bound to a footprint: a pad pattern, a courtyard, a silkscreen, a 3D model. This is where the physical world enters, and the only check is you, the datasheet, and the footprint editor. Lesson 5.3 is entirely about this step because it is where Beacon Rev A's LED defect was born.
Update PCB from schematic
The netlist crosses over. Footprints appear in a heap with a "ratsnest" of straight lines showing which pads must connect. From here the schematic and layout are two views of one design, and KiCad keeps them consistent in both directions (Update PCB from Schematic, and Update Schematic from PCB for reference and footprint changes).
Placement, then routing
Where each part goes (Lesson 5.5) and how the copper connects them (Lesson 5.6). Placement is a decision about physics — heat, loop area, antenna clearance. Routing turns the ratsnest into traces, vias, and pours under the constraints of the stackup (Lesson 5.4).
DRC — Design Rules Check (gate)
DRC checks geometry against the rules you entered: clearance, minimum track width, via drill and annular ring, copper-to-edge, courtyard overlap, unrouted nets. If your rules are looser than the fab's capability, DRC passes a board the fab cannot build. If you have not loaded the fab's numbers, DRC is checking against KiCad's defaults, which are not anyone's manufacturing limits.
Fabrication and assembly outputs
Gerbers (one file per layer, in the Gerber X2 format that carries layer function and net attributes), an Excellon drill file, a board outline, optionally a stackup and impedance note. For assembly: a BOM with manufacturer part numbers, and a CPL (component placement list) with the X, Y, side, and rotation of every part. The CPL rotation convention is where footprint orientation errors turn into placed parts facing the wrong way.
Fab DFM, then bring-up, then pilot (gates — expensive)
The fab's engineer runs your files against their rules and either fixes silently, asks, or rejects (Lesson 5.8). After that the only gates left are your bench (Lesson 6.1) and your customers. Everything caught here costs at least one board spin.
CORE CONCEPTInside a KiCad project: what the files are and where the libraries live
KiCad is a suite, not a single program: a project manager, a schematic editor, a symbol editor, a PCB editor, a footprint editor, a 3D viewer, a Gerber viewer, and a calculator. What ties them together is a small set of plain-text files. Understanding them is what lets you version a design with git, review a diff, and recover when a colleague's machine has a library you do not.
| File | What it holds | Version it? |
|---|---|---|
beacon.kicad_pro | Project settings: design rules, net classes, text variables, plot defaults, ERC/DRC severities | Yes |
beacon.kicad_sch (+ sub-sheets) | Schematic: symbols, wires, labels, sheet hierarchy. Symbols used are embedded in the file since KiCad 6, so the schematic opens without the original library | Yes |
beacon.kicad_pcb | Board: footprints (embedded), tracks, zones, stackup, design-rule constraints | Yes |
sym-lib-table, fp-lib-table | Project-local library tables: name → path (${KIPRJMOD}/lib/…) for symbol and footprint libraries | Yes |
lib/beacon.kicad_sym | Project symbol library — every symbol you checked or drew yourself | Yes |
lib/beacon.pretty/*.kicad_mod | Project footprint library — one file per footprint | Yes |
lib/3d/*.step | 3D models referenced by footprints; used for the visual sanity check and mechanical export | Yes (they are the sanity check) |
beacon.kicad_prl | Per-user UI state: layer visibility, last dialog positions | No — machine-specific |
*-backups/, fp-info-cache, *.kicad_pcb-bak | Autosaves and caches | No — .gitignore them |
fab/ (your choice) | Generated Gerbers, drill, BOM, CPL for a specific ordered revision | Yes, tagged with the order |
Two facts about libraries matter more than the rest. First, there are two library tables: the global one in your user configuration directory, and the project one next to the project file. A library named in the project table shadows the global one, and a path written as ${KIPRJMOD}/lib/… is relative to the project, so the project moves between machines intact. Second, KiCad's bundled libraries are excellent and you should still never rely on them unchecked: they follow the KiCad Library Convention and generally use IPC-7351 nominal land patterns, but a footprint is a reading of a datasheet by a volunteer, and the datasheet may have changed revision since. The professional habit is a project library: every symbol and footprint you use is copied into it, checked against the datasheet, and marked as checked. The global library is a source you copy from, not a dependency you ship with.
; lives next to beacon.kicad_pro — one line per library the project may use (fp_lib_table (version 7) (lib (name "beacon")(type "KiCad") (uri "${KIPRJMOD}/lib/beacon.pretty") (options "")(descr "Beacon Rev A — checked footprints only")) )
That single line is the versioned library. Any footprint on the Beacon board must resolve to beacon:something. If a footprint resolves to the global Package_DFN_QFN: or LED_SMD: namespace, it has not been checked, by definition. Make that a review item and the LED problem in the opening story cannot recur unnoticed — it can still recur, but it will have your initials next to it.
Since KiCad 6 the schematic file carries a copy of every symbol it uses and the board carries every footprint. That is why a project opens on a machine without the libraries. It is also why "I updated the footprint in the library" does nothing to the board until you run Update Footprints from Library in the PCB editor (or Update Symbols from Library in the schematic). People lose days to this: the library is fixed, the board is not, and the Gerbers are generated from the board.
CORE CONCEPTWhat the same mistake costs at each stage
The tenfold rule is folklore, but it is folklore with a mechanism. At each stage the defect is embedded in more artefacts, more people have acted on it, and more physical material has been committed. Undoing it means undoing all of that. Here is the ladder for a small board like Beacon, with numbers that are illustrative for a five-board prototype run at a low-cost fab in the mid-2020s — your fab's quote replaces them, the shape does not change.
| Caught at | What "fixing it" means | Typical cost | Calendar |
|---|---|---|---|
| Schematic (self or peer review) | Move a wire, change a value, add a resistor symbol | 5–15 min | same hour |
| ERC | Read the message, fix the pin or add a flag | 2–10 min | same hour |
| Footprint check | Edit pads or pin-1 in the project library, update footprints on board | 15–40 min | same hour |
| Layout / DRC | Re-place a part, re-route a region; possibly re-pour zones | 0.5–3 h | same day |
| Pre-fab design review | Any of the above, plus regenerating outputs and re-checking | 1–4 h | 1–2 days |
| Fab DFM feedback | Edit, regenerate, resubmit; order paused | 1–4 h | +2–5 days |
| Bench bring-up (5 boards) | Diagnose, bodge wires or rework by hand, then respin for the pilot | ~$100–200 boards + 4–10 h | +2–4 weeks |
| Pilot in the field (25 units) | Recall or site visits, rework or scrap, respin, re-deploy, apologise | ~$500–1,500 + days of labour + trust | +6–10 weeks |
Read the right-hand columns as a curve, not a list: minutes, minutes, minutes, hours, hours, days, weeks, months. The dollar column is small compared with the calendar column for a hobby project and the reverse for a business — a pilot that slips six weeks may miss the customer's budget cycle, and no amount of cheap PCBs buys that back. This is why Beacon's requirement table (Lesson 1.9) includes a date next to R1–R9: a board that is late is a board that fails a requirement.
A bodge is a wire or part added by hand to correct a board — fine for five units, a liability for twenty-five. Rework is removing and re-soldering a placed part, which for a 2 × 2 mm LED means hot air, tweezers, and a success rate that falls with every attempt. A respin is a new revision fabricated from corrected files. Anything found after fabrication costs at least one of these; anything found in the field costs all three.
SEE ITCost-of-change ladder
Pick a defect that really was in, or nearly in, Beacon Rev A. Then choose which gates you are willing to run — every review costs time, and the widget charges you for it. The ladder shows which gates can see that class of defect, where it is actually caught under your configuration, and what the catch costs. Then turn a gate off and watch where the defect lands next. The worst configuration is not "no reviews"; it is a set of reviews that all look at the same thing.
Three things the ladder should have shown you. The GPIO9 button is caught only by a review that runs a checklist that includes "check every strapping pin" — a generic schematic review, even by a good engineer, tends to pass it, because a button on a GPIO looks like a button on a GPIO. The footprint defect is invisible to every schematic-side gate and to ERC, because footprints are not part of the electrical graph. And the I2C swap, the easiest to catch, is also the most annoying to find on the bench, because a swapped bus produces no ACK and no error message — just silence at address 0x44.
IN PRACTICEDesign reviews are the cheapest test you will ever run
A test on the bench costs a fabricated board. A test in the field costs a deployment. A review costs an hour of someone's attention. The return on that hour is so lopsided that the only real question is how to make the hour count, and the answer is the same at every stage: a review is a checklist walked against artefacts, not a conversation about the design.
Three properties separate reviews that catch things from reviews that feel productive:
- The reviewer looks at the artefact that contains the defect class. A schematic review cannot find a footprint defect. If the review is "walk through the schematic", then the footprints, the 3D view, the CPL rotations, and the Gerbers are unreviewed, no matter how carefully the schematic was read. Lesson 5.9's Beacon review is structured by domain and by artefact for this reason.
- The checklist encodes previous failures. "Check every strapping pin against the datasheet's boot-mode table" is on the list because someone once put a button on GPIO9 (or GPIO0, or BOOT1, or SWCLK). A review without a written list re-discovers only the failures the reviewer personally remembers.
- Findings are written, classified, and closed. Accept, fix, or defer — with a name and a reason. A deferred finding is not a lost finding; it is Rev B's first line item and Stage 6's bring-up log knows to look for it.
Here is what the opening story costs in full. Five boards, assembled, LED rotated. Diagnosis: 20 minutes with a loupe and the datasheet. Rework attempt with hot air on a 2 × 2 mm four-pad LED: about ten minutes per board, and on one of five the pad lifts. Four working boards for bring-up — acceptable. But the pilot needs twenty-five, and the CPL file that was uploaded for the five will be uploaded again for the twenty-five. The fix is a one-line change in the footprint (pin-1 on the correct corner) and a regenerated CPL. It takes five minutes. The respin it forces takes two weeks and about $150 in boards and assembly for a run this small. Two weeks against five minutes: that is the ratio the widget was charging you.
The counter-argument you will hear — "we are moving fast, reviews slow us down" — is right about the hour and wrong about the weeks. For a first revision of a board with a radio, a charger, and a fine-pitch module, the pre-fab review is the fastest thing on the schedule. It is also the last moment where the design is still just files.
BEACONBeacon Rev A: the project set up so Stage 5 does not go backwards
Everything Stage 5 builds lands in one KiCad project, and this lesson sets it up so that Lessons 5.2 through 5.9 can each add their piece without restructuring. The requirements from Lesson 1.9 are the constraints: R8 fixes the board at 35 × 25 mm, four layers; R2 (BLE range ≥ 10 m through a plaster wall) means the ESP32-C3-MINI-1 goes at a board edge with its antenna clear; R6 (USB-C charging at 500 mA) means the USB-C receptacle, the MCP73831 charger, and the DW01A + FS8205 protection pair are on the board; R1 (six months on 1000 mAh) is why the regulator is the TPS62840 buck chosen in Lesson 4.2 and not the XC6220 LDO from the breadboard; R3 puts the SHT40 and LIS2DH12 on the I2C bus with INT1 wired for motion wake.
beacon-hw/ ├── beacon.kicad_pro # rules, net classes, text vars (REV=A) ├── beacon.kicad_sch # root sheet: title block + 4 sub-sheets ├── power.kicad_sch # USB-C, TVS, MCP73831, DW01A+FS8205, TPS62840, VBAT sense ├── mcu.kicad_sch # ESP32-C3-MINI-1, button, LED, Tag-Connect, pogo pads ├── sensors.kicad_sch # SHT40, LIS2DH12, pull-ups ├── usb.kicad_sch # receptacle, 5.1 kΩ CC pulldowns, 22 Ω series, PRTR5V0U2X ├── beacon.kicad_pcb # 35 × 25 mm, JLC04161H-7628 stackup entered ├── sym-lib-table fp-lib-table ├── lib/ │ ├── beacon.kicad_sym # checked symbols only │ ├── beacon.pretty/ # checked footprints only │ └── 3d/ # STEP models for the sanity check ├── fab/revA/ # gerbers, drill, BOM, CPL — as ordered ├── docs/review-revA.md # findings: accept / fix / defer └── .gitignore # *-backups/ fp-info-cache *.kicad_prl *-bak
Four decisions are made now so they are not re-litigated later:
- Hierarchy. One root sheet and four sub-sheets — power, MCU, sensors, USB — matching the domains the Lesson 5.9 review will walk. Sheets are cheap; a 200-symbol flat schematic is not readable at midnight.
- Library policy. Every symbol and footprint is copied into
lib/and gets aCheckedfield with a date and initials once it has been compared with the datasheet. A footprint without that field is a review finding. - Design rules loaded before the first trace. JLCPCB's published 4-layer capability — 0.09 mm (3.5 mil) minimum trace and space, 0.15 mm minimum via drill — goes into Board Setup → Constraints on day one, with Beacon's own rules set slightly more conservative than the fab's limits (Lesson 5.8 explains why "at the limit" is not free). Net classes for
USB_DIFF(90 Ω pair),RF,PWR(charge path) andDefaultexist before routing starts. - Stackup entered, not assumed. Board Setup → Physical Stackup is filled with the JLC04161H-7628 numbers (Lesson 5.4) so the built-in calculator and the design review are talking about the board that will actually be built.
The milestone is "Rev A schematic + 4-layer layout passing DRC and DFM, reviewed, ordered, five boards assembled." Each verb is a gate from this lesson: ERC after 5.2, footprint checks after 5.3, DRC after 5.6 and 5.7, DFM in 5.8, the review in 5.9. The canon is honest that Rev A ships with three defects — the GPIO9 button, a battery-divider leak of 1.8 µA more than planned, and the rotated LED footprint. Two of the three pass through every automated gate in this flow. Keep that in mind as you decide, lesson by lesson, which human gates are worth their hour.
WEAKNESSWhere this flow bites
Both tools are rule checkers, and both check rules that you supplied or that are electrical-type bookkeeping. A board with SDA and SCL swapped, an antenna over the battery, a charge trace at 0.15 mm, and a regulator next to the humidity sensor is ERC-clean and DRC-clean. The tools are gates for a narrow defect class each; the wide classes — wrong physics, wrong intent — are caught only by people looking at the right artefact with a list. A green DRC report is a precondition for ordering, not evidence of a working board.
It feels efficient: the bundled footprint is nearly right, so you nudge a pad in the global library and move on. Three months later, a KiCad update replaces the library, or a colleague opens the project on a machine with the stock library, and the pad is back where it was — on a board whose Gerbers were generated from the fixed version. Nobody can reproduce which files were ordered. The project library exists precisely so that the design is self-contained and the diff is in git. Copy, check, then edit the copy.
Footprints on the board are linked to symbols by reference designator (and, more robustly, by a unique identifier under the hood — but tools and people use the designator). Re-annotating the schematic after the board is placed can silently re-link footprints, so R12's pads now belong to what used to be R7. KiCad's update dialog will warn you and offer to match by reference or by unique ID; read the dialog. Better: annotate once, early, and treat designators as immutable for the life of the revision. A tidy numbering scheme is worth exactly nothing compared with a CPL file that places the right resistor.
KEY INSIGHTHow this connects
- Beacon's Schematic v0: The Front-End Comes Together (2.9) — the paper schematic this stage turns into a KiCad project; every net name and value there is an input to Lesson 5.2's capture.
- Schematic Capture Done Right (5.2) — the first gate in detail: hierarchical sheets, power flags, and what ERC's messages actually mean.
- Symbols, Footprints, and the Lie in Every Library (5.3) — the human gate that this lesson's opening story skipped; the LED footprint is checked there.
- Beacon Rev A: Design Review Before Fab (5.9) — the last cheap gate, run as a checklist by domain and by artefact, with findings accepted, fixed, or deferred.
The rest of Stage 5 is this flow, one stage per lesson. Keep the ladder in mind at each: whatever a lesson teaches you to see is a defect class that becomes cheap to catch, and everything you cannot yet see is on its way to the fab.
GLOSSARYKey terms introduced
- Gate
- A stage in the design flow where a check — automated (ERC, DRC, fab DFM) or human (footprint check, design review) — can stop a defect. Each gate sees only certain defect classes.
- ERC (Electrical Rules Check)
- KiCad's schematic-level check of pin electrical types, drivers, power flags, and labels. It checks connectivity bookkeeping, not circuit intent.
- DRC (Design Rules Check)
- The board-level geometric check against the constraints and net classes you entered: clearance, widths, drills, annular rings, courtyards, edge distance.
- Footprint
- The physical land pattern for a part: pads, courtyard, silkscreen, mask and paste layers, and a linked 3D model. Bound to a symbol during footprint assignment.
- Library table
- KiCad's map from a library nickname to a path. The global table lives in the user configuration; the project table (
sym-lib-table,fp-lib-table) lives with the project and shadows it. - Gerber X2
- The extended Gerber format that adds file-function and net attributes to the per-layer image files; the format fabs prefer and KiCad's default plot option.
- CPL (component placement list)
- The assembly file listing each part's reference, X, Y, side, and rotation, generated from the board; where footprint orientation errors become placed-part errors.
- Respin
- A new fabricated revision of a board made from corrected files; the cost floor for any defect found after fabrication.
ACTIVE RECALLCheck your understanding
Answer in your own words first, then reveal.
1ERC and DRC both passed. Name two defects that could still be on the board and say which gate would have caught each.›
Any defect of intent or physics survives both tools. Examples: SDA and SCL swapped at a sensor (both pins are bidirectional, ERC has nothing to object to; DRC checks geometry) — caught by a schematic review against the datasheet pinout. A footprint with pin 1 on the wrong corner — footprints are not in the electrical graph and DRC only checks the footprint's own geometry — caught by the footprint-versus-datasheet check or by opening the 3D viewer during layout review. Others: a regulator placed next to the humidity sensor (placement review), an antenna over copper (RF layout review), a charge trace too thin for 500 mA (routing review with IPC-2221 in hand).
2Why does the professional workflow copy every footprint into a project library instead of using KiCad's bundled library directly?›
Three reasons. Reproducibility: the project resolves every footprint to a file inside the project, so the design opens identically on any machine and the exact pattern that was ordered is in git. Verification: copying is the moment you check the footprint against the datasheet and record that check; anything still resolving to a global namespace is, by definition, unchecked. Safety: you never edit the global library in place, so a KiCad update or a colleague's machine cannot silently revert a fix. The bundled library is a good source to copy from, not a dependency to ship with.
3A schematic review by an experienced engineer passed the Beacon design with the user button on GPIO9. Was the review bad?›
Not necessarily bad — under-specified. A button on a GPIO is not wrong in general; it is wrong on the ESP32-C3's GPIO9 specifically because that pin is sampled at reset to select boot mode, so a button held at power-up changes what the chip does. That is a fact from the datasheet's strapping-pin table, not from circuit theory. A review catches it only if the checklist includes "compare every strapping pin against its reset-time requirement". This is why reviews are checklists walked against artefacts, and why the checklist grows with every field failure. Beacon's canon records that the Rev A review did flag it and the team accepted the risk — a deferred finding, written down, that Rev B fixes.
4What actually happens in KiCad when you fix a footprint in the library after the board is laid out — and what does not?›
Nothing happens to the board. Since KiCad 6 the board file embeds its own copy of every footprint, so the library edit changes the library only. To propagate it you run Update Footprints from Library in the PCB editor (selecting the affected footprints or all of them), re-check the affected routing (pads may have moved), re-run DRC, and regenerate the Gerbers and CPL. The Gerbers come from the board file, never from the library — if you regenerate outputs without updating the board you will order the old footprint with a clear conscience.