ProjekinAja. Embedded Systems Stage 5 · PCB Design Lesson 5.1
● Stage 5 · Lesson 5.1

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.

⏱ ~22 min read 🧠 Process model 🛠 KiCad 8/9

🎯 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.

🔑 Hold onto this

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.

Schematic capture symbols · nets · values Annotate R1, C7, U3 … unique ERC GATE · pin types, drive, labels Assign footprints GATE · check vs datasheet Update PCB from Schematic (F8) — the netlist crosses over Placement connectors · RF · decoupling Routing traces · vias · pours DRC GATE · your rules only Design review GATE · humans, checklist Fab outputs Gerber X2 · drill · stackup Assembly outputs BOM · CPL (placement) Fab DFM check GATE · their rules Bring-up · pilot the expensive gates cost of a fix minutes hours weeks + $ stroke-highlighted boxes are gates — the only places a defect can be stopped
The flow as KiCad 8/9 implements it. In older KiCad you exported a netlist file and imported it into the board editor; since KiCad 6 the netlist is passed internally by Update PCB from Schematic. The gates are highlighted. Notice that three of them — ERC, DRC, the fab's DFM — are automated and check different rule sets, and two — footprint checks and design review — are human.

Let's walk the stages once, naming what each one can and cannot see.

1

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.

2

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.

3

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.

4

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.

5

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).

6

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).

7

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.

8

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.

9

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.

FileWhat it holdsVersion it?
beacon.kicad_proProject settings: design rules, net classes, text variables, plot defaults, ERC/DRC severitiesYes
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 libraryYes
beacon.kicad_pcbBoard: footprints (embedded), tracks, zones, stackup, design-rule constraintsYes
sym-lib-table, fp-lib-tableProject-local library tables: name → path (${KIPRJMOD}/lib/…) for symbol and footprint librariesYes
lib/beacon.kicad_symProject symbol library — every symbol you checked or drew yourselfYes
lib/beacon.pretty/*.kicad_modProject footprint library — one file per footprintYes
lib/3d/*.step3D models referenced by footprints; used for the visual sanity check and mechanical exportYes (they are the sanity check)
beacon.kicad_prlPer-user UI state: layer visibility, last dialog positionsNo — machine-specific
*-backups/, fp-info-cache, *.kicad_pcb-bakAutosaves and cachesNo — .gitignore them
fab/ (your choice)Generated Gerbers, drill, BOM, CPL for a specific ordered revisionYes, 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.

fp-lib-tableproject-local footprint library table
; 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.

💡 Schematics and boards embed their symbols and footprints

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 atWhat "fixing it" meansTypical costCalendar
Schematic (self or peer review)Move a wire, change a value, add a resistor symbol5–15 minsame hour
ERCRead the message, fix the pin or add a flag2–10 minsame hour
Footprint checkEdit pads or pin-1 in the project library, update footprints on board15–40 minsame hour
Layout / DRCRe-place a part, re-route a region; possibly re-pour zones0.5–3 hsame day
Pre-fab design reviewAny of the above, plus regenerating outputs and re-checking1–4 h1–2 days
Fab DFM feedbackEdit, regenerate, resubmit; order paused1–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.

📖 Bodge, rework, respin

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.

⚙ Interactive · Cost-of-change ladder

Illustrative costs for a five-board prototype and a 25-unit pilot. The gate/defect matrix is deterministic: a gate either can see a defect class or it cannot.

Gates you will run (each costs the time shown, every revision):

Caught at
—
Review time spent
—
Fix cost
—
Calendar slip
—

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 footprint that got fixed after the boards arrived

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/Rev A project layout · git-tracked
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:

  1. 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.
  2. Library policy. Every symbol and footprint is copied into lib/ and gets a Checked field with a date and initials once it has been compared with the datasheet. A footprint without that field is a review finding.
  3. 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) and Default exist before routing starts.
  4. 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.
🔑 Stage 5 milestone, restated as gates

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

✗ Treating "ERC clean, DRC clean" as "board correct"

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.

✗ Editing the global library in place

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.

✗ Re-annotating after layout, or "cleaning up" reference designators

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

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.

Next: schematic capture — draw it for the reader debugging at midnight →