KiCad's missing manufacturing package: the files your fab actually needs

KiCad is a genuinely great design tool. You capture a schematic, lay out the board, run DRC, admire the 3D view, and it all feels finished. Then a fab or a colleague asks you to "send the manufacturing files" — and you realize the thing KiCad hands you by default is a folder of .kicad_sch and .kicad_pcb design files that almost no manufacturer can build from.

That's the gap. KiCad designs the board; it doesn't package it. A professional manufacturing package is the deliverable — a self-contained bundle that lets a fab, an assembly house, or future-you build the exact board you designed, with zero follow-up questions. This post is the map: what belongs in that package, who each piece is for, and how to produce every one of them from KiCad.

What a complete manufacturing package contains#

Think of the package in four layers:

• Fabrication data — what the board is physically: copper, drills, soldermask, silkscreen. This is what makes the bare PCB.
• Assembly data — what goes on the board and where: the parts list and their placements.
• Verification data — proof the design is clean: DRC and ERC reports.
• Human context — the STEP model, an assembly drawing, and a short README of fab notes so a person can sanity-check the machine data.

Skip a layer and you create friction. Send only fabrication data to an assembly house and they can't source or place parts. Send a BOM with no placements and they can't run pick-and-place. A complete package removes the back-and-forth entirely.

The artifacts, one by one#

Here's every file that belongs in a professional handoff, what it's for, and who actually reads it.

Two things worth calling out. First, the BOM and CPL are a pair — the BOM says what, the CPL says where, and an assembly house needs both to place a single part. Second, the fab notes README is the most-skipped and most-valuable file: soldermask color, board thickness, surface finish, copper weight, and any controlled-impedance requirement live here. Leave it out and the fab guesses, or emails you.

How to generate each one from KiCad#

The good news: KiCad can produce all of it. Even better, most of it can be exported from the command line with kicad-cli, which means the whole package can be generated in one pass instead of a dozen manual GUI trips.

• Gerbers — Plot from the PCB editor, or kicad-cli pcb export gerbers. Pick your layer set once and reuse it. See how to export Gerbers from KiCad for the exact layer list and settings.
• Drill files — kicad-cli pcb export drill produces Excellon NC drill files alongside the Gerbers. Keep them in the same folder so the set stays together.
• BOM — kicad-cli sch export bom pulls the component list straight from the schematic, with the fields you choose (value, footprint, manufacturer part number, supplier number).
• CPL / pick-and-place — kicad-cli pcb export pos writes the position file with per-part X/Y and rotation. Watch rotation conventions; they trip up first-time assembly orders.
• Assembly drawing — Plot the fab layers plus the fab/assembly drawing layers to PDF, or export via kicad-cli pcb export pdf.
• DRC report — kicad-cli pcb drc runs the check headless and writes a report you can archive as evidence the board passed.
• ERC report — kicad-cli sch erc does the same for the schematic.
• 3D / STEP — kicad-cli pcb export step produces a STEP model for mechanical review and enclosure fit.
• Fab notes / README — This one's on you. A short text file with stackup, thickness, finish, and impedance notes. Write it once per board; update it when the physical spec changes.

You don't have to memorize the flags. The point is that every artifact has a headless export, so the package is scriptable — a single command sequence turns a finished design into a complete handoff.

Why reproducibility is the whole game#

Generating the package once is easy. Keeping it correct across revisions is where teams quietly bleed hours and ship wrong boards.

The classic failure: you export Gerbers, then notice a footprint issue, fix the layout, re-plot the Gerbers — and forget the BOM. Now your Gerbers describe rev C and your BOM describes rev B. Nothing errors. The fab builds exactly what you sent, and the mismatch surfaces at assembly, or worse, at bring-up.

A manufacturing package should be treated like a build artifact, not a pile of files you assemble by hand:

• Generate everything from one source, in one pass. No artifact should be able to drift from the others.
• Tie it to a revision. The package for rev C is the package for rev C — reproducible from that exact design state, forever.
• Never hand-edit an output. If a Gerber is wrong, fix the design and regenerate. Edited outputs are how untraceable boards happen.

Altium bundles a lot of this into its Output Jobs — a premium suite with packaging built in, which is part of what you pay for. KiCad gives you every underlying capability for free; it just doesn't prescribe the packaging step. That's a process to set up, not a missing feature. And once you treat the package as reproducible output rather than manual busywork, the "is KiCad professional enough?" question mostly answers itself. If you want the full workflow, see our guide on a professional manufacturing handoff.

The short version#

KiCad hands you design files. Your fab needs a manufacturing package — fabrication data, assembly data, verification reports, and notes — and KiCad can produce every piece, most of it headless via kicad-cli. The real work isn't generating the files once; it's keeping them in sync, revision after revision.

That's exactly what GoForFab automates: connect a KiCad project and every push regenerates the complete package — Gerbers, drill, BOM, CPL, DRC/ERC reports, 3D renders — all from the same source, all tied to that commit, always reproducible. It's free forever, so the missing packaging step stops being your problem.