Step one: learn to read what a board is made of

Before designing anything, learn to recognise a finished design’s paperwork. Work through what a Gerber file actually contains on our Gerber file hub, then open real layer sets in a viewer and name each layer as you toggle it: copper, solder mask, silkscreen, paste and outline. Our guide to opening Gerber files and the layer-by-layer walkthrough in loading and aligning layers turn that vocabulary into something you can see. Learners who can read fabrication output spot design mistakes in their own first boards that pure CAD practice never teaches, because the fab never sees your schematic — it sees exactly these layers.

Step two: export from a real tool, then check yourself

Next, take any small example project in KiCad — the tool most of this site’s workflow content uses, and one we recommend freely as a trust anchor — and export a complete fabrication set from it yourself. Then verify your own export like an outsider: follow checking KiCad Gerber files in Gerbv, measure the outline and a few known features with the measurement guide, and confirm the drill file lands where the copper says it should. Exporting and then independently checking closes the loop that most beginners leave open for months. If your main tool is a different one, the same loop exists here for Altium, EasyEDA and Eagle and Fusion.

Step three: rehearse the order before you place one

The final practice step is a dry run of ordering. Take your checked file set through the pre-order Gerber checklist end to end — layer count, units, alignment, drill overlay, silkscreen over pads, nothing stray outside the outline. A learner who has rehearsed this on practice files will not learn it expensively on a real order with a deadline attached. At this point you also understand, concretely, what design decisions become fabrication facts: clearances, annular rings, text sizes and board dimensions stop being abstract rules and become things you have measured yourself.

Step four: structured courses, chosen against your gaps

With that foundation, a structured course stops being a wall of unfamiliar terms and becomes targeted repair: schematic capture discipline, layout technique, grounding and signal integrity at the level your projects need, and the manufacturing constraints behind the checklist items you have already handled. Two marketplaces carry most of the PCB-design teaching aimed at this audience. You can explore current offerings through our links to Coursera and Udemy. Disclosure: those are placeholder affiliate links via Impact, pending the final tracking URLs — when the programmes are fully connected, purchases through them may earn this site a commission at no extra cost to you, as our Affiliate Disclosure explains. No course prices or ratings are quoted here, deliberately: catalogues change constantly, and the syllabus in front of you at enrolment is the only honest basis for choosing.

A recommendation we are not paid to make

FEDEVEL Academy’s PCB design courses are widely recommended in the maker and professional community for their depth, particularly on more advanced layout topics, and we recommend considering them on merit alongside the marketplaces above. We have no affiliate link for FEDEVEL and earn nothing if you enrol — it is included because a learning guide that only lists monetised options would not deserve your trust. Judge it, like every course here, by syllabus fit against the gaps your practice projects exposed.

How to study so the skill sticks

Whatever course you choose, pair every module with a board. Finished a section on footprints? Export a board using one and run it through your Gerbv checking routine. Covered clearances? Measure them in a real file set instead of trusting the lecture’s diagram. Keep a small library of your own exports — good and bad — because reviewing your earlier mistakes in the viewer, with the current Gerbv release open beside your CAD tool, is the fastest feedback loop available to a self-taught designer. Courses supply the map; only projects supply the mileage.

The path in one paragraph

Read fabrication files until you can name every layer. Export from your CAD tool and check your own work in a second program. Rehearse a complete pre-order check on practice files. Then buy structured teaching aimed at the weaknesses those three steps revealed, from whichever provider’s syllabus fits — and keep designing real boards throughout. That order costs little, wastes nothing, and means the boards you eventually order are checked by someone who understands what they are looking at: you.

Frequently asked questions

Should I learn to view Gerber files before learning PCB design?

Yes — reading fabrication output first gives every later design rule a concrete meaning. You learn what the fab actually receives, build an independent checking habit, and spot your own export mistakes from your very first project.

Which CAD tool should a beginner learn on?

KiCad is the tool most of this site’s workflows use and a strong default: it is capable, widely taught and free. The checking path here also covers Altium, EasyEDA and Eagle/Fusion exports, so the habits transfer if your work uses a different tool.

How do I choose between online PCB design courses?

Choose by syllabus fit against your actual gaps, not by headline promises. Complete the free practice path first — it will show you precisely which topics you need — then compare course outlines on the marketplaces and specialist academies on that basis.

Why an offline check beats relying on the review

Three reasons. Timing: a problem found in your viewer costs a re-export; the same problem found in review costs the exchange of messages across time zones and a production slot that moves while you answer. Knowledge: the reviewer sees files, not intent — they can flag that an outline looks unusual or a drill file seems inconsistent, but only you know the board must measure a specific size, that a cutout is deliberate, or that the silkscreen shows last revision’s labels. Checking with intent in hand is a different, stronger check. Evidence: when your set has been opened, stacked, measured and verified by you, a review query becomes a lookup — you can answer from your own inspection instead of starting one. None of this replaces the board house’s checks; it means you stop outsourcing the ones you can do better and earlier.

The pre-check workflow, step by step

Extract the exact ZIP you intend to upload and open the folder in Gerbv. Count and identify: one file per layer your board needs — copper layers, mask, silkscreen, paste where relevant, outline, drill file — each identifiable by content, per loading and aligning Gerber layers. Outline alone: a single closed shape of the designed size under measurement, with any cutouts and slots present and deliberate. Engineering queries about board shape almost always start here, so make the answer boring. Drill overlay: stack the Excellon file over both copper sides as in viewing drill files — hits centred in pads, tool list matching the design, mounting holes where the enclosure expects them. Layer pairs: mask openings centred on the pads they expose; silkscreen legible, complete and clear of exposed pads; paste openings matching their surface-mount pads. Scale and units: two known dimensions, far apart on the board, both measuring as designed — the standing defence against the exported set being read at the wrong scale.

The details reviewers ask about

A few file details attract a disproportionate share of engineering questions, and all are checkable in advance. Board outline definition: if the edge is drawn on a layer the house does not expect, or shares a file with unrelated mechanical marks, clarify it in the export so the outline layer contains the outline. Slots and cutouts: confirm they appear in the data as you intend — a routed feature that exists only in a drawing note will generate a question, or worse, silence and no slot. Drill sizes at the extremes: the very smallest and largest tools in the drill report are the ones worth a second look against the components and hardware that use them. Text and polarity on the bottom side: view the bottom layers as manufactured, and confirm nothing reads mirrored that should not. File naming: clear layer names reduce mapping questions to zero; if a filename could mean two layers, rename it at export time. Each of these is a two-minute confirmation in Gerbv and a potential day in an email thread.

Upload the checked set, keep the record

When the workflow passes, upload that exact archive — and if a single file changes afterwards, re-export the complete set and re-check it, because a set is only verified as a set. Keep the checked ZIP with the project files as your release record: if questions do arrive, you are answering about files you have personally inspected, measurement by measurement. The full twelve-point gate behind this workflow is the PCB pre-order checklist, which applies unchanged whatever board house you choose; for the companion walkthrough aimed at a different destination’s upload flow, see checking your files before uploading to JLCPCB. Gerbv’s own place in the toolchain is summarised on our Gerber viewer page.

Frequently asked questions

Doesn’t PCBWay check my files anyway?

Yes — their engineering review is a genuine safety net. The point of checking first is timing and knowledge: you find file problems when they cost a re-export rather than a message thread, and you check them against your design intent, which no reviewer can see.

What do engineering reviews most often query?

At the file level, the recurring themes are outline definition, slots and cutouts, drill data consistency, and anything ambiguous about layer identity. Every one of those is visible in Gerbv before upload — the guide above walks through each.

Should I re-check if I change one file after checking?

Yes, as a set: re-export the complete set from the EDA tool, re-extract the new archive, and run the workflow again. A set is only verified as a whole; swapping one file invalidates the registration and completeness checks that were run on the old combination.

What JLCPCB’s viewer shows — and what it cannot

The upload preview’s job is confirmation at a glance: the files parsed, the board’s outline was found, the layers were identified, and the composite looks like a board. Treat it as a receipt, not an inspection. A composite preview flattens exactly the relationships you most need to judge — whether mask openings sit centred on pads, whether the drill pattern truly registers, whether the silkscreen avoids the pads — because in a rendered stack those relationships are hard to read at small scale, and some are only visible with layers isolated or measured. The preview also cannot know your intent: it does not know the board should be a particular size, that a connector pitch is critical, or that the silkscreen text is the wrong revision. Those judgements need the design knowledge only you bring, applied to the files themselves, offline, where every layer can be toggled, recoloured and measured.

The causes behind most upload problems

Problems discovered at or after upload tend to come from a short list of file-level causes, all of them visible in Gerbv beforehand. A missing or ambiguous outline: the board edge is absent, drawn on a layer the importer does not treat as the outline, or left open — the upload then guesses at the board’s shape or flags the set, and any guess risks the wrong edge. Drill mismatch: the drill file’s origin, units or format disagree with the Gerber files, so holes sit offset or at the wrong scale relative to the artwork the preview composites so reassuringly. Layer naming the importer cannot map: files whose names do not make their layer identity clear can be assigned to the wrong layer or left unassigned — a top mask treated as something else produces a board built wrong with complete confidence. Mixed revisions: a set whose files come from different exports, so one layer describes a board the others have already moved on from. None of these requires statistics to take seriously; each is a known, recurring way a Gerber set fails, and each is a five-minute check in a viewer.

The Gerbv pre-check workflow

Extract the exact ZIP you will upload, into its own folder, and open it in Gerbv. Work the set in this order. Inventory: count the layers against your board and confirm each file’s identity from its content, not only its name — if you cannot tell which file is the top solder mask, neither can an importer; rename clearly in your EDA export if needed and re-export. Outline: display the outline layer alone, confirm it is a single closed shape, and measure its extents against the design. Stack and registration: build the layer order from loading and aligning Gerber layers, then overlay the drill file as in viewing drill files and confirm every hit is centred in its pad across both copper sides. Details: silkscreen clear of pads and legible, mask openings where they belong, nothing drawn outside the outline, and the tightest clearances measured rather than assumed. Discipline: if anything fails, fix it in the EDA tool, export a complete fresh set, and check that set — then upload the checked archive itself, not a re-zipped lookalike.

After the check: uploading with the evidence in hand

Upload the verified ZIP, and use the site’s preview for what it is good at: confirming that what arrived matches what you inspected — same outline, same layer count, same overall appearance. If the preview disagrees with your Gerbv check, stop and reconcile before paying; a disagreement means one of the two is looking at different files, and it is usually the upload that picked up the wrong archive. When everything agrees, order with the checked set kept alongside the project as the release record. Ready to order? JLCPCB — referral link: this site may receive coupons when new users register and complete a first order; coupons offset order amounts, cannot be redeemed for cash, and using the link never changes your price (see our Affiliate Disclosure). For the complete gate, the PCB pre-order checklist covers all twelve checks this workflow draws on.

Frequently asked questions

If JLCPCB shows a preview, why check in Gerbv first?

The preview confirms the files parse and renders a composite; it does not isolate layers, measure dimensions, or know your design intent. The failures that matter — drill mismatch, a wrong or missing outline, unclear layer identity, mixed revisions — are far easier to see and prove in an offline viewer before uploading.

What is the single most important check before a JLCPCB upload?

The outline: display it alone in Gerbv, confirm one closed shape, and measure it. A surprising share of upload problems trace back to the board edge being absent, open, or on a layer the importer does not recognise as the outline.

My drill holes look fine in the upload preview but wrong in Gerbv. Which do I trust?

Trust the files, examined closely: overlay the drill layer on each copper layer in Gerbv at magnification. A composite preview can mask a small consistent offset that is obvious when holes and pads are inspected directly — and the factory works from the files, not the preview.

Completeness: the set itself (checks 1–3)

1. Every expected layer is present. Open the extracted folder in Gerbv and count the loaded layers against your board’s structure: copper for every copper layer, mask and silkscreen for the sides you use, paste if a stencil is involved. A missing file is the most common export accident and the least visible — nothing anywhere reports it.

2. The board outline exists, is closed and is the right size. Display the outline layer alone: one unbroken shape. Measure its extents as in measuring distances in Gerbv and compare them with the mechanical design. An absent or open outline leaves the factory guessing at your board’s edge.

3. The ZIP re-extracts to the set you checked. If you will upload a ZIP, extract a fresh copy of that exact archive into a new folder and open it. What loads is what the board house gets. This test catches the wrong archive, the stale revision and the file that never made it into the ZIP.

Geometry and registration (checks 4–7)

4. Layers are stacked and aligned. Build the stack as in loading and aligning Gerber layers — copper, mask, silkscreen, paste — and confirm features register: mask openings centred on pads, paste openings matching their pads, nothing shifted relative to everything else.

5. Drill hits land centred in their pads. Overlay the Excellon file as in viewing drill files, across the whole board, on both copper sides. A block offset, a miniature pattern in one corner, or holes uniformly the wrong size each point at an export setting to fix — before ordering, not after.

6. Units and scale are consistent. Measure one known dimension — the outline, a connector pitch — and confirm it is the designed value, not a value scaled by a unit conversion. Then confirm a second dimension far from the first: consistent smallness or largeness that grows with distance is the signature of a format or unit mismatch in the export.

7. Bottom layers are not mirrored. View the bottom copper and bottom silkscreen as the factory will use them. Mirrored data betrays itself through asymmetric features sitting on the wrong side and any bottom-side text reading backwards. If your workflow presents bottom layers as seen through the board, know exactly which convention your files use before uploading.

Readability and manufacturing sanity (checks 8–12)

8. Silkscreen does not print over pads. Show silkscreen over the mask and pads: ink belongs on the board surface, not across exposed pads it would contaminate. Check designators are complete, legible and the right way up.

9. Minimum clearances survive visually. Zoom into the tightest routing — between pads, around fine-pitch parts — and measure the smallest trace width and the smallest gap. Gerbv measures; it does not run design-rule checks, so this is your confirmation that what you routed is what was exported, comfortably inside what your board house can etch.

10. Apertures render as expected. Scan each layer at working magnification for shapes that render wrong: pads that became outlines, flashes that vanished, pours with ragged edges. Gerbv’s aperture-usage reporting helps here — the set of apertures and their counts should match the board you think you exported.

11. Nothing lives outside the outline. With all layers visible, look beyond the board edge: stray copper, a silkscreen legend, or a drill hit outside the outline is either data that will be clipped unpredictably or a symptom of a wrong-origin layer in the set.

12. The checked set is the uploaded set. Note the folder and archive you verified — name, date, revision — and upload exactly that. If anything changes after checking, re-export the full set and re-run this list; partial re-exports are how checked and shipped sets quietly diverge.

Where to order

Once the set passes, any board house that accepts standard Gerber uploads can build it. Three widely used options, with the referral relationships stated plainly: JLCPCB (referral link — this site may receive coupons when new users register and complete a first order; coupons offset order amounts and cannot be redeemed for cash); NextPCB (referral link — if you place a first order, this site receives a benefit as site credit that can only be spent with NextPCB, not cash); and PCBWay (plain link, included on its merits). For regional manufacture, OSH Park in the United States and Eurocircuits in Europe are long-established options. Using a referral link never changes the price you pay. Full details are on our Affiliate Disclosure page. Destination-specific walkthroughs: checking before a JLCPCB upload and checking before a PCBWay upload.

Frequently asked questions

How long does this checklist take?

Minutes, once the layer stack is built — the checks are mostly toggling layers you have already loaded, plus two or three measurements. It grows faster with practice; the first run on a new board design is the slowest and the most valuable.

Can Gerbv run these checks automatically?

No. Gerbv displays and measures fabrication data and reports statistics about the codes in use, but it has no design-rule or DFM checking. The checklist is a guided visual and numerical pass — which is also why it catches wrong-file and wrong-revision problems that automated rule checks cannot see.

Which check catches the most problems?

In practice, the completeness checks (1–3) and the drill overlay (5): a missing layer, a missing outline and a mismatched drill file are the failures that most often reach factories, and all three are unambiguous in the viewer.

The CAM processor, at a general level

In Eagle’s workflow, Gerber generation is not a save-as; it is a processing run. You open the CAM processor, load or confirm a CAM job — a template that lists output sections, each section producing one file from a chosen set of board layers, in a chosen format — and run it. A typical job produces the copper layers, solder mask, silkscreen, solder paste, and a board outline file, each as standard RS-274X Gerber (the format Gerbv views; legacy RS-274D is not supported). Read the job before you run it, especially if it came with a board house template or an old project: the silk screen section that also pulls in a documentation layer, the outline drawn from a dimension layer in one job and from a dedicated layer in another — these small mappings are exactly the ones that survive unnoticed for revisions. If you design in the Fusion-hosted environment, the same CAM concept produces the manufacturing outputs from the electronics design; boards started in the Fusion 360 environment follow the same discipline: confirm what the job maps, then run it, then check the output as files.

Drill data from the same run

The CAM job also produces the Excellon drill file, from the board’s drills and holes layers, in the same run as the artwork. Keep it that way. Artwork and drills generated together share the board state and the job’s conventions; a drill file regenerated later, from a different job revision, is how a correct-looking Gerber set acquires holes that sit a consistent distance from their pads. Generate the whole set per release, into a clean output folder, and treat the folder — Gerbers, drill file, and a pick-and-place export if assembly is planned — as one indivisible release unit. If the board’s outline lives in the dimension information, confirm the job actually emits an outline file; boards whose edge never becomes a file are a recurring CAM-job inheritance problem.

Checking the set in Gerbv: mapping errors are visible here

Load the output folder in Gerbv following loading and aligning Gerber layers, and take inventory first: one file per CAM section, matching the job you ran. Then inspect with the job’s failure modes in mind. Silkscreen layer: does it contain only silkscreen? Documentation or dimension lines riding along are a mapping error you can see at a glance — and one the board house would faithfully print. Outline layer: one closed shape, nothing else, measuring correctly under measurement in Gerbv. Mask layers: openings over the pads they serve and nothing stray — a mask file that accidentally includes both sides’ data is another classic mapping slip. Paste layer: openings that match the surface-mount pads. Each of these checks is fast precisely because a wrong mapping produces visibly wrong content, not subtly wrong geometry.

Drill overlay and dimensional checks

Stack the drill file over the copper as in viewing Excellon drill files, and run the registration pass: holes centred in pads and vias everywhere, mounting holes placed for the enclosure — a check that matters doubly for Fusion users, whose board is often designed against a mechanical model in the same workspace; the exported outline and hole positions, measured in Gerbv, are the numbers that model will be judged by. Read the drill statistics against expectations, and measure the features the mechanical side depends on: outline extents, hole-to-edge distances, connector positions. If the Fusion model and the Gerber set ever disagree, believe the Gerber set — it is what gets manufactured — and trace the difference back to the board or the CAM job.

Fix the job, not the files

When a check fails, the fix in this workflow is almost always the CAM job: correct the layer mapping, adjust the section, re-run the whole job, and reload the fresh set in Gerbv. Editing or nudging the generated files themselves forfeits the reproducibility that makes the job valuable. Once a job passes the full pass twice — once when you set it up, once on a later revision — it earns trust, and the per-release check becomes the short form: count the files, overlay the drills, measure the outline. The complete gate before ordering remains the PCB pre-order checklist, which this workflow feeds directly into.

Frequently asked questions

What is a CAM job, and why does it matter for checking?

A CAM job is the template that tells Eagle’s CAM processor which board layers go into which output file, and in what format. Inherited or edited jobs are the main source of mapping errors — extra layers in the silkscreen file, a missing outline — and those errors are obvious when the output is inspected in Gerbv.

My silkscreen file contains dimension lines. What happened?

The silkscreen section of the CAM job is pulling in a documentation or dimension layer alongside the silkscreen layers. Correct the section’s layer selection in the job, re-run the complete job, and reload the fresh set.

I design in Fusion. Is the Gerber check different?

The check is identical, because the deliverable is identical: a Gerber and drill set. What Fusion adds is a mechanical model the board must fit — which makes measuring the exported outline and hole positions in Gerbv doubly worthwhile, since the factory builds the files, not the model.

Export the ZIP from EasyEDA — then download it to your own machine

EasyEDA’s fabrication export produces a single ZIP archive containing the Gerber layers and the drill data for the board, named and organised the way its ordering pipeline expects. Generate the export from the finished, saved board — not from a tab you have been editing since — and download the ZIP to a local folder you control, even if you fully intend to order through the integrated flow. That download is the whole trick: it converts an invisible intermediate step into an artefact you can inspect, archive with the project, and re-upload later or elsewhere. Note the export’s filename and date, and if you export again after a fix, keep the versions in separate folders. Most wrong-board stories are not export errors at all; they are the previous revision’s ZIP, uploaded with complete confidence.

Extract the ZIP and take inventory

Extract the archive into its own folder and look at what is actually inside before opening anything. A healthy set contains one file per artwork layer — copper for each side (and any inner layers), solder mask, silkscreen, solder paste where relevant, and a board outline — plus the drill file. Count the files against the board you designed: a two-layer board with silkscreen on top only should not suddenly have a bottom silkscreen story to tell, and a four-layer board missing its inner copper files is an export to regenerate, not to upload. Keep the extracted folder exactly as extracted. The filenames EasyEDA assigns carry the layer identities, and renaming or tidying them helps nobody — least of all the board house’s importer, if you later upload the extracted files instead of the ZIP.

Inspect each layer in Gerbv

Open the folder in Gerbv, stacking the layers as in loading and aligning Gerber layers: copper first, then mask, silkscreen and paste, with the outline and drill file where they can be toggled over the rest. Then do the layer-by-layer pass that a browser-based design view never gave you. Copper alone: do the pours, traces and pads look like the board, with nothing floating outside the outline? Mask over copper: are the pads you need exposed actually opened, and are vias treated the way you intended? Silkscreen alone, then over the pads: is every designator present, legible and clear of exposed pads, and does any text run off the board edge? Paste over top copper, if the board will be assembled: do the openings match the surface-mount pads? Toggle slowly and look at edges and corners, where export and design most often part company. Gerbv also views the pick-and-place data as a CSV layer if you exported it — component positions should sit inside the outline, on the footprints the silkscreen describes.

Drills, dimensions and the outline

Stack the drill file over the copper using viewing Excellon drill files: every hole centred in its pad, mounting holes where the mechanical design puts them, and the reported drill sizes matching the components you chose — no unexpected tool, no near-duplicate pair. Then measure, following measuring distances in Gerbv: overall outline width and height, one connector pitch, the tightest clearance you routed. The outline deserves its own moment: displayed alone, it should be one closed shape of the size you designed. A surprising share of upload problems trace back to the outline being absent, open, or drawn on a layer the board house does not treat as the outline — all three are obvious in the viewer and ambiguous everywhere else. None of this requires Gerbv to run design-rule checks (it does not); it requires you to look at the files the factory will look at.

Upload the set you checked — and only that set

Close the loop with file discipline. Upload the ZIP (or the extracted set) that you just inspected — not a sibling export from an earlier edit. If any check failed, fix the design or the export choice in EasyEDA, export a fresh ZIP into a fresh folder, and inspect the new set; never mix files between exports. Keep the checked ZIP with the project as the release record: when the boards arrive, it is the evidence of what was actually ordered. From here, the destination-specific guides take over — the full PCB pre-order checklist as the final gate, and, if JLCPCB is the destination, checking your files before uploading to JLCPCB.

Frequently asked questions

Do I need to check EasyEDA exports if I order through the built-in flow?

Yes — the integrated flow is exactly why checking matters. The export travels from the design to the factory without being seen as files. Downloading the ZIP and inspecting it in Gerbv is the one step where a wrong layer, a stale revision or a missing outline can still be caught for free.

What should the EasyEDA ZIP contain?

One Gerber file per artwork layer — copper, solder mask, silkscreen, solder paste where relevant and the board outline — plus the Excellon drill file. Extract it and count the files against your board’s layer structure before viewing.

I exported twice. Which ZIP do I upload?

The one you inspected, from the folder you inspected it in. Keep each export in its own dated folder, and never mix files between exports — a mixed set is the most common cause of a layer disagreeing with the rest.

Exporting from Altium: Gerber setup and fabrication outputs

In Altium, Gerber files are produced as a fabrication output: you open the Gerber setup for the board, choose which layers to include, set the format options, and generate. Many teams capture this in an output job file so every release uses the same recipe — a good practice, because it makes the checks below comparable from revision to revision. The layer set for a typical board mirrors every other EDA tool: all copper layers, solder mask, silkscreen, solder paste where assembly needs it, and the board outline — in Altium workflows the outline may travel as its own layer, so make sure the set you generate actually contains a file that draws the board edge, because the factory cannot guess it. The format options deserve a deliberate look before you generate: the units the files will be written in, the coordinate precision (how many integer and decimal places positions carry), and the zero-suppression convention. None of these has a universally right answer — what matters is that the Gerber files and the drill file, generated next, tell the same story.

NC Drill output: the second half of the set

Drill data is a separate fabrication output in Altium — NC Drill — with its own format settings, and it must be generated as part of the same release as the Gerbers. The classic Altium-specific failure lives exactly here: the Gerber files written with one combination of units and precision, the drill file written with another, so the artwork is correct and the holes arrive at a different scale or offset. Set the drill output’s units and format to match the Gerber setup’s choices, generate both outputs in the same pass from the same saved board, and keep them in one folder. If the board will be assembled, export the pick-and-place data in the same pass as well; Gerbv views it as a CSV centroid layer alongside the artwork and drills.

Verifying in Gerbv: units and format first

Load the set in Gerbv in the order described in loading and aligning Gerber layers — copper, mask, silkscreen, paste, with outline and drill file on top. Before judging any detail, settle the units question with measurement: measure the board outline and compare it with the size the mechanical design calls for. This single check exposes the classic catch of Altium exports. If the Gerber files were written with one zero-suppression or precision convention and read back under another assumption, positions come out scaled by a factor of ten in one direction or the other; a board that measures ten times too large or too small is not a design error, it is a format conversation gone wrong between export and reader. The remedy is at the export: align the format settings, regenerate, and reload. Do not try to compensate anywhere else.

The drill overlay: where the mismatch shows itself

With the artwork verified at the right size, stack the NC Drill file over the copper, following viewing Excellon drill files. Because the drill output has its own format settings, it can disagree with the artwork even when the artwork is self-consistent: holes uniformly too large or too small point at a units disagreement between the two outputs; the whole hole pattern shifted points at an origin disagreement; a pattern that is correct in one corner and drifts across the board points at precision being dropped somewhere. Work area by area — every hit centred in its pad, mounting holes inside the outline where the enclosure expects them — and read the drill statistics Gerbv reports against the board’s intent: the sizes present should be the sizes the design uses, with no near-duplicate pair betraying one footprint specified in different units from the rest. Altium libraries accumulated over years are exactly where such a pair hides.

Layer-by-layer pass, then the checklist

Finish with the pairwise pass. Mask over copper: every pad that should be exposed is opened, nothing else is. Silkscreen over mask and pads: reference designators legible, the right way up, and not printed across exposed pads. Paste over the top copper: openings match the surface-mount pads they serve. Aperture usage reporting in Gerbv can corroborate that the set of shapes in the files is the set you expect. Remember the viewer’s limits while you work: Gerbv shows and measures fabrication data and reports the codes in use, but it runs no design-rule or DFM checks — the visual and numerical pass is yours, backed by the board house’s own checks after upload. When the Altium set passes, run the complete PCB pre-order checklist as the final gate before ordering.

Frequently asked questions

What is the most common problem in Altium Gerber exports?

A format mismatch between outputs — the Gerber files and the NC Drill file generated with different units, precision or zero-suppression settings. It shows up in Gerbv as a board measuring a factor of ten off, or holes at the wrong size or offset relative to correct artwork.

How do I check the mismatch in Gerbv?

Measure the board outline first: if the size is wrong by a clean power of ten, the format conversation between export and reader is the problem. Then overlay the drill file on the copper — disagreement between the two outputs localises which one’s settings to fix.

Should the outline be a separate file in an Altium export?

The set must contain a layer that draws the board edge — board houses cannot infer it reliably from copper. Whether it travels as a dedicated outline layer or within another file, confirm in Gerbv that a closed outline exists and measures correctly.

Exporting from KiCad: the Plot dialog, at a general level

In KiCad’s board editor, fabrication output is produced from the Plot dialog. The general shape of the job is always the same, whatever the version: choose an output folder dedicated to this export, select the layers to plot as Gerber files, set the general options, and plot. The layers a normal two-layer board needs are the copper layers (top and bottom, plus any inner copper), the solder mask layers, the silkscreen layers, the solder paste layers if the board will be assembled with a stencil, and the board outline layer — the edge cuts that define the board’s shape. Plot them all in one pass, into the same folder, so the whole set shares one origin and one moment in the design’s history. A set plotted piecemeal across edits is a set whose layers may quietly disagree. Leave the format choices at the modern defaults your version offers unless you have a specific reason to change them: board houses expect standard RS-274X output, which is also the format Gerbv views (legacy RS-274D is the one Gerber variant it does not support).

Generating the drill file — a separate step, on purpose

Drill data does not come out of the Plot dialog with the artwork. KiCad generates it separately, through its drill-file generation, producing an Excellon (NC drill) file that lists the drill tools and every hole position. Generate it in the same session, from the same board state, and into the same output folder as the Gerbers. The setting that matters most is consistency: the drill file must use the same origin and compatible units and format conventions as the Gerber set, because the two are manufactured as one board. Most drill disasters — holes shifted as a block, holes at miniature scale in one corner — are born here, when the drill export’s origin or format settings differ from the artwork’s. If your board will be assembled, this is also the moment to export the component position file, which Gerbv can view as a CSV pick-and-place layer. Then ZIP the folder for the board house if needed — but keep the unzipped folder, because that is what you are about to inspect.

Opening the set in Gerbv: layer order that reads well

Open the exported folder in Gerbv, following loading and aligning Gerber layers: bottom copper first, then top copper, then the mask layers, the silkscreen layers and the paste layers, with the outline and the drill file near the top of the stack where they can be toggled over everything. Opening a folder loads the loadable files it finds, detected by content, so a file KiCad named unexpectedly still lands in the stack — but compare the layer list against the list you plotted. Count them. A layer missing from the viewer was missing from the export, and a missing layer (an unplotted bottom mask is the classic) is invisible in every other check you are about to run. Give layers colours you can tell apart, and work in pairs: copper with its mask, silkscreen against the pads it must avoid, paste openings against the surface-mount pads they serve.

The drill overlay and measurement sanity checks

Now stack the Excellon drill file over the copper, as in viewing Excellon drill files. Every drill hit should sit centred in its pad or via, across the whole board — connectors, ICs, mounting holes. A block shift means the drill origin differed from the artwork’s; a pattern that is the right shape at the wrong size means the format or units differed. Read the drill statistics Gerbv reports and compare the tool list with what the board should use: via size, lead sizes, mounting holes, and nothing you do not recognise. Finish with numbers, using measurement in Gerbv: the outline’s overall width and height against the mechanical design, one mounting-hole position against two edges, the pitch of a fine-pitch footprint against its datasheet, and the thinnest trace and tightest gap against what your board house can comfortably make. Also flip the silkscreen on alone over the outline and read it: KiCad exports exactly what the board editor shows, including any text that overlaps a pad — visible here, fixable in two minutes back in the editor, and expensive only if it reaches the factory.

If something looks wrong, fix it in KiCad — not in the viewer

Gerbv’s job in this workflow is evidence, not repair. A layer that is mirrored, offset or missing was exported that way; the fix is to correct the plot selection or the drill settings in KiCad, re-export the complete set in one pass, and reload. Never order from a set you have nudged into alignment in a viewer — the factory receives files, not views. When the re-export registers cleanly, runs the right layer count and measures correctly, the set is ready for the full pre-order pass in our PCB pre-order checklist.

Frequently asked questions

Which KiCad layers should I plot for a typical board?

Top and bottom copper (plus any inner copper), solder mask for both sides, silkscreen for the sides you use, solder paste if a stencil is involved, and the board outline layer — all plotted in one pass into one folder, with the drill file generated in the same session.

Why are my drill holes shifted in Gerbv when they look fine in KiCad?

KiCad’s board view shows the design, where holes and copper share one model. In the exported files, a shifted drill pattern means the drill file was generated with a different origin or format setting than the Gerber files. Regenerate both in one pass with consistent settings and reload the set.

Can Gerbv fix a bad KiCad export?

No — and it should not. Gerbv shows the exported data exactly as the factory will receive it. Correct the plot or drill settings in KiCad, re-export the whole set, and check the fresh files.