Skip to content

Revisions & change control

Hardware Revision Control: A Practical Guide for Electronics Teams

Why hardware needs its own approach, what freezing actually means, a five-rule process, and a worked example over eighteen months.

Carlos Antonio Benito 6 min read

What is hardware revision control?

Hardware revision control is the practice of identifying each state of a design, freezing the states that get built, and keeping the documents that describe each state together — so that you can answer, at any point in the future, what a particular board actually was.

It is not version control in the software sense. There is no branching, no merging, and the files are mostly binary. What it borrows from software is the idea that a released state must be identifiable and immutable.

Why hardware needs its own approach

Three differences make software tooling a poor fit.

The artefacts are not text. A schematic diff is not meaningful line by line. Two layouts that differ by one moved track produce completely different files.

There is no merge. Two engineers cannot edit a PCB layout simultaneously and combine the results. Hardware work serialises in a way software does not.

A revision has physical consequences. A software release can be rolled back. Four hundred boards cannot. That asymmetry is why hardware processes put weight on approval before release rather than on fixing forward.

The three things that get revised

Confusing these is the most common source of mess, and they have separate articles because each deserves one.

WhatChanges whenExample
PCB revisionthe bare board changes — copper, footprints, outlineRev B → Rev C
Assembly revisionwhat is fitted changes without the board changingRev C-1 → Rev C-2
BOM revisionthe parts list changesrev 3 → rev 4

A single PCB revision normally carries several BOM revisions over its life. A substitution does not require a new board.

What "freezing" actually means

A frozen revision is one that cannot be edited. Not "should not" — cannot.

This is the part that separates real revision control from a naming convention. If the folder for the revision that was manufactured is still writable, then a year later you cannot be certain it still contains what was built. Someone may have corrected a typo, replaced a file, or tidied something. Usually with good intentions.

Once a revision is frozen, a correction produces a new revision. That feels heavy the first time and is the whole point: the record of what was built has to be more durable than the convenience of editing it.

A minimum viable process

For a small team, this is enough, and it is considerably better than nothing:

  1. Every released revision has an identifier that lives in the data, not

only in a file name.

  1. The identifier appears inside the files — on the silkscreen if possible,

in the fabrication drawing, in the BOM, in the release note.

  1. Released packages are read-only. Whatever mechanism you have: a separate

directory nobody edits, an archive, a tag.

  1. One person approves a release, and their name is recorded with the date.
  2. Changes between revisions are written down, one line per change, with the

reason.

Five rules. None of them needs software to start, and all five survive the arrival of software later.

What a release should contain

A release is a named set of documents that together describe one buildable state:

  • fabrication package — Gerbers, drill, stackup, fabrication drawing;
  • assembly package — BOM, centroid, assembly drawing;
  • the schematic as a PDF, for people rather than for tools;
  • a release note saying what changed and why;
  • the identity: board revision, release identifier, date, approver.

Everything in it carries the same identifier. Nothing in it changes after issue.

Where revision schemes come from — and why they vary

There is no universal convention, and teams that argue about letters versus numbers are usually arguing about nothing.

Common patterns:

  • Letters for boards, numbers for documents. Rev C of the board, rev 4 of

the BOM. Makes the two visually distinct, which is the main benefit.

  • Numbered with a prototype prefix. P1, P2, then 1.0 at first

production. Signals maturity.

  • Date-based. Unambiguous, no sequencing arguments, but gives no hint of how

much changed.

Pick one, write it down, and apply it consistently. The scheme matters far less than the consistency — and far less than whether the identifier is stored in the data or only in a file name.

A worked example

The fictional ORION CONTROL UNIT, Main Control Board, over eighteen months:

RevisionChangeWhat moved
Rev Afirst prototype, 5 boards—
Rev A, BOM rev 2C12–C18 changed to X7R after temperature testingBOM only
Rev Bground plane split corrected, J1 moved 2 mmPCB, Gerbers, assembly drawing
Rev B, BOM rev 3R22 second source approvedBOM only
Rev CJ1 replaced — original EOL, different land patternPCB, Gerbers, BOM rev 4, drawing
Rev C-2R7 now DNP for the export variantBOM rev 5, centroid, drawing — not the PCB

Sample data. Note the pattern: of six changes, two needed a new PCB. The rest changed the parts list or what was fitted, which is exactly why BOM and PCB revisions have to be separate numbers.

Common mistakes

The revision lives only in the file name. Files get copied and renamed. The data does not.

Reusing a designator after removing it. R7 removed in rev C must not come back in rev D meaning something else.

Editing a released package. Even a trivial correction. It destroys the only guarantee the release offered.

No record of why. "Rev C" with no note means that in two years the only way to understand the change is to diff the Gerbers and guess.

Revising everything together. If every BOM change forces a new PCB revision, people stop issuing revisions. Let the clocks run independently.

Approval by nobody. If no name is attached, there is no decision — just a file that appeared.


The process above works on paper, and plenty of teams run it on a shared drive. What a shared drive cannot do is refuse to let you edit a released package, or tell you which BOM belongs to the revision that shipped.

In XKEMA each element carries its own version chain, an approved version is frozen with a verifiable fingerprint of what was approved, and two versions can be compared — BOM rows, PDF pages, Gerber geometry.

Where to go next

¿Te ha resultado útil?

Reddit LinkedIn

The XKEMA newsletter

Hardware engineering worth keeping

New courses, engineering notes and hardware guides, whenever there is something genuinely worth reading. Nothing else.

We will email you to confirm. You can unsubscribe from any issue.

XKEMA, in one sentence

Engineering knowledge management software for companies that develop electronic products: the product structure, its bills of materials, its documentation and its revisions, all in one place.