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.
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.
| What | Changes when | Example |
|---|---|---|
| PCB revision | the bare board changes — copper, footprints, outline | Rev B → Rev C |
| Assembly revision | what is fitted changes without the board changing | Rev C-1 → Rev C-2 |
| BOM revision | the parts list changes | rev 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:
- Every released revision has an identifier that lives in the data, not
only in a file name.
- The identifier appears inside the files — on the silkscreen if possible,
in the fabrication drawing, in the BOM, in the release note.
- Released packages are read-only. Whatever mechanism you have: a separate
directory nobody edits, an archive, a tag.
- One person approves a release, and their name is recorded with the date.
- 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, then1.0at 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:
| Revision | Change | What moved |
|---|---|---|
| Rev A | first prototype, 5 boards | — |
| Rev A, BOM rev 2 | C12–C18 changed to X7R after temperature testing | BOM only |
| Rev B | ground plane split corrected, J1 moved 2 mm | PCB, Gerbers, assembly drawing |
| Rev B, BOM rev 3 | R22 second source approved | BOM only |
| Rev C | J1 replaced — original EOL, different land pattern | PCB, Gerbers, BOM rev 4, drawing |
| Rev C-2 | R7 now DNP for the export variant | BOM 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.