Print and apply verification is not a single test. It is a sequence of stations and handovers, and a supplier who shows you one clean run has shown you one part of it.
Four stations are involved. The label is printed, then applied, then read back, and anything that fails the read is pulled out of the good flow. Between those four stations sit three handovers, and each is where a part can leave the verified population without anybody noticing. A verification use case set walks those handovers one at a time, and proves what happens to a part that fails at each.
Two articles on this site sit either side of this one, and it is worth being clear about which is which. Filament label architecture is about which identity model to build the label on, a batch code or a per-spool code or both. Why a readable barcode can still carry the wrong batch is about the data side, the record behind the code. Neither tells you how to prove the stations are behaving. That is what a verification protocol is for.
What the Verification Is Actually For
Proving the sequence, not the printer
A printer that works is the easy half. It has to hold a ribbon, reach a temperature, and put an image on a label. What a plant needs to know is what happens to a part that arrives at the read-back station carrying the wrong image, no image, or an image from a previous run. That question belongs to the sequence, not the print engine.
The distinction matters when a supplier demonstrates a machine. A short run with good labels proves the print engine and the applicator. It does not prove that a bad label is caught, that the caught part is stopped, or that it is accounted for afterwards. Those are the parts of print and apply verification a plant has to ask for by name, because a demonstration will not volunteer them.
Three questions the run has to answer
First, does a bad label get caught, and where. Second, when it gets caught, does the line stop the part from leaving as a good one. Third, can the plant tell afterwards how many parts went through the station and how many came out. A verification that answers the first question but not the other two leaves a machine that catches some problems and no way to account for the rest.
Those three questions are what the use case set below is arranged around. Each case is a small provocation of one handover, written so the answer is something the plant can see and count, not something the supplier can assert. Print and apply verification is worth the effort only if the answers survive a shift change.
The Stations and What Each One Owns
Before the use cases, the sequence itself. Each station owns a different part of the promise, and a fault found at the wrong station, or a part that skips one, is a fault the plant only finds later.
| Station | What it establishes | What it cannot establish | What a fault here looks like |
|---|---|---|---|
| The image on the label matches the value the printer was given | That the value was the right one for this part | A legible label carrying the wrong data, or a ribbon fault that prints faintly | |
| Apply | The label is on the part, in the position and orientation the file calls for | That the label carries the right data | A label applied to the wrong face, or lifted at one corner by trapped air |
| Read back | The code on the applied label reads as the code that was expected | That the code identifies the right part of the business | A part that fails the read and has to be pulled, or a read that passes a label nobody checked |
| Divert | The failed part leaves the good flow and stays accounted for | That the part will be re-worked correctly, or why it failed | A part that is stopped but not recorded, or one that reaches the carton |
The third column is the one people argue about in demonstrations. A read-back station proves the code reads as expected. It does not prove the code belongs to that spool, because that question is answered by the data, not the reader. What a print and apply labeling machine actually does draws that line, and the line holds in a verification run too.
The Use Case Set
Each case below is one provocation at one handover. The wording is plain on purpose, because a case that cannot be run by someone who was not in the demonstration is not a use case, it is a promise.
| Use case | How to provoke it | What to watch | What a pass looks like |
|---|---|---|---|
| Normal run | Feed the customer label file and the customer master data, and let the line run | Every part carries a code, and the read-back station sees the same code it was given | Codes read back match the values printed, with no part skipped and no part read twice |
| Wrong value in the feed | Change one value in the customer data, so the printer is handed data that does not belong to the part in front of it | Whether the part still leaves the line as good | The fault is caught downstream of the print station, or the run is stopped, and the operator sees which part it was |
| Duplicate value | Run the same code onto two parts | Whether the second part is refused | The second part is held at the read-back station and does not reach the carton |
| Unreadable image | Supply a label with a damaged print, or interrupt the ribbon mid-run | What the station does with a label that will not read | The part is diverted, and the divert is counted |
| Label not applied | Stop the part before the applicator so no label goes on | Whether an unlabelled part is detected downstream | The part is caught, and the station that catches it is named |
| Feed interruption | Break the link to the data source while the line is running | Whether the line continues on stale data | The line holds or stops, and does not carry on printing a value it already had |
| Reprint of a damaged label | Reprint a label for a part that already carries one | Whether the reprint keeps the same code and is recorded | The reprint carries the same value, and the event log shows both prints against one part |
| Empty the divert bin | Clear the reject position while the line runs | Whether a diverted part can go missing without a signal | The line stops or alarms rather than continuing as if the bin were empty |
Eight cases, and the last is the one most suppliers skip. A divert station that does not report an empty reject position is where parts can disappear, and a plant counting good output against packed output will not see the difference for a long time. This is where print and apply verification earns its place: the case is cheap to run and expensive to discover late.

A label going onto a corrugated carton carries two things at once, the data the customer asked for and the data the plant needs to find the part again. A verification run has to check both arrived, and that the second still reads after the carton has been through a folder and a sealer.
Where the NG Part Goes
The divert station gets the least attention in a demonstration and the most attention in a plant. A part that fails the read has to leave the good flow, and it has to be somewhere the plant can find it afterwards, because somebody will want to know what happened to it.
| Where it is caught | What gets pulled | What the line does next | What has to be written down |
|---|---|---|---|
| At the applicator | A part that arrived without a label | Holds the part and keeps the position | The part and the reason, against the run |
| At the read-back station | A part whose label does not read as expected | Takes it out of the good flow and signals | The code that failed, the code that was expected, and the reason |
| At the case packer | A part that arrived from upstream with no record | Refuses the case rather than closing it | The case that was held and what was missing from it |
| After the case is closed | A case whose contents were checked too late | Stops the outbound movement and flags the case | The case, the order and the station that let it through |
Each row is a different answer to the same question, and the plant chooses where it wants the answer. Catching everything at the read-back station means a small divert to empty but a busy operator; catching at the case packer means a bigger divert and a slower line. Neither is right on its own, but the wrong answer is the one where nothing gets written down. That table is the part of print and apply verification a plant should argue about first.

This is a detection station doing the unglamorous part of the job, checking the pack as it passes rather than trusting it is right. A code reader is the same idea with a code instead of a sensor, and the question asked of it is the same one: what does it do when the answer is not what it expected.
Running the Set Against Real Data
Who runs the cases matters as much as which cases run. Run them on the customer own master data and label file, on a line configured as it will run in production. A run against a demonstration file proves the machine handles that file, which is a smaller claim.
Where the code is a GS1 identifier, the encoding rules are published rather than private, so a plant can check its own file against the specification instead of against the supplier’s habits. The GS1 General Specifications are where those rules live.
The person standing at the machine should be the person who will run it after the handover. A verification protocol executed by the supplier, with the plant watching, tends to skip the cases the supplier is least comfortable with. A plant operator running the list will stop at the one that misbehaves.

The pack the cases run on is the pack the customer receives, so the label read back is the one a person will later hold. A verification that stops at line output has not tested what the customer sees.
Ask for the outcome of each case in a form the plant can keep. A pass or fail per case, the reason recorded for anything that failed, and the state of the run at the end. That record is worth more than a video of a good run, because it is what the plant can point at when the question comes back later.

A wrinkled label and a label with a bubble under it look the same to a person and different to a reader. The use case set has to cover both, because a plant that only checks whether the code reads will accept the label that reads and does not stick.
What to Bring Into the Conversation
Bring the label file and the master data, and a list of the cases the plant wants run. Ask which the supplier has run before, on what data, and with what result. Ask what the plant would have to add to run them itself afterwards, because a verification only the supplier can perform is one the plant pays for again at every changeover.
And ask the question that decides where the line stops. Not where the code goes wrong, but where a part that fails at the read-back station physically stops. The answer decides whether the divert is a small reject position an operator watches, or a lane needing its own handling. The station is described in where labeling sits on a filament packaging line, and the head options are in the labeling machine range.
[Bring us your label file and your master data, and ask for the verification cases you want run on your own line. Engineering will say which handovers the set covers and which ones stay open.]
Email: helen@huanlianauto.com
FAQ
Is one clean run enough to verify a print and apply station?
No. One run proves the print engine and the applicator. It does not prove that a part with a bad label is caught, that the caught part is kept out of the good flow, or that the plant can count what went through the station afterwards. Those are separate questions and each one needs its own provocation.
Who should run the verification cases?
The people who will run the line after the handover, on the customer own master data and the customer own label file. A case list executed by the supplier with the plant watching tends to skip the cases the supplier is least comfortable with, and the cases that get skipped are usually the ones a plant operator would have found.
What is the difference between a read-back failure and an NG part?
A read-back failure is the event, the label did not read as expected. An NG part is the consequence, that part is out of the good flow and has to be accounted for. The event is easy to see and the consequence is where the plant loses track, so the verification has to cover what happens after the failure and not only the failure itself.
Does the verification cover the data behind the code?
It covers the handover between the data and the part. A wrong value in the feed is one of the cases, and the line should catch it or stop. Whether the value was the right one for that part is a data question, and it belongs to the plant system rather than to the reader. The two are separate checks and they are run separately.
How many cases does a plant really need?
Enough to reach every handover. A typical set runs from a normal run through the failed read, the duplicate value, the feed interruption, the reprint and the divert position, which is where a plant can see how many parts went into the station and how many came out.





