How Individual Products Become Cartons and Pallets

A factory does not ship bottles one at a time. It ships cartons of bottles, stacked on pallets, wrapped and labelled. Somewhere between the packaging line and the loading dock, thousands of individually identified products become a handful of boxes. This guide explains how that happens, how the identities are kept connected, and what goes wrong when they are not. For the bigger picture of why these links matter, start with what is product traceability?

Three levels of packing

Most consumer goods move through a simple hierarchy:

Some supply chains add levels: an inner bundle of three units, or a bundle of pallets for export. The principle stays the same. Each level is a container, each container has an identity, and each identity is linked to what is inside it.

The journey diagram above shows where this sits: after the coder and camera on the line, before the distributor. For the upstream part, see the journey of a serialized product through a packaging line.

Two different questions: "what kind of box?" and "which box?"

Cartons cause more confusion than any other level, because two different GS1 identifiers can sit on them and they answer different questions.

• A carton GTIN says what kind of item the case is. "Case of 12 Ambre Nuit 100 ml" is a trade item that a distributor can order and be invoiced for, so it can have its own GTIN. Every identical case shares it.
• An SSCC (Serial Shipping Container Code) says which physical unit this is on its journey. It is 18 digits long, carried under Application Identifier (00), and it is different on every case or pallet, even when the contents are identical.

A pallet of 48 identical cases therefore has one SSCC for the pallet, possibly 48 SSCCs for the cases, and one carton GTIN repeated 48 times. The SSCC is explained fully in what is an SSCC?

Step by step: from unit to pallet

Here is how a serialized line at Maison Ardent, a fictional fragrance house, turns boxed bottles into a pallet.

1. Only good units reach the case packer

Each retail box has been printed with a serialized code and read back by an inline camera. Boxes whose code was missing, unreadable or wrong have already been rejected. This matters: if a rejected box reaches a case, its serial ends up in the case record. We cover why in why "printed" is not the same as "verified".

2. The case is filled and its contents are read

Twelve verified boxes go into a shipper case. Either a reader at the case packer scans each box as it goes in, or the line software already knows the order of boxes on the conveyor and assigns the next twelve. In many lines a camera reads all twelve codes through the open top of the case before it is sealed, which is the stronger check.

3. The case gets a label and an identity

A label printer applies a case label carrying a new SSCC, for example:

(00) 395011010000004574

That is extension digit 3, Maison Ardent's company prefix 9501101, serial reference 000000457 and check digit 4. The label is usually scanned straight back to confirm it is readable and matches what the software intended to print.

4. The parent-child link is recorded

Now the important part. The line software records:

Case 395011010000004574 contains these 12 serials: A7K29Q, A7K29S, …

That record is aggregation. The case is the parent; the twelve units are its children. Nothing about the label itself reveals the contents; the knowledge lives in the record. Read more in what is aggregation in traceability?

5. Cases are built into a pallet

At the end of the line, 48 cases are stacked on a pallet, each case label scanned as it is placed. The pallet is wrapped and given its own label with its own SSCC, say (00) 395011010000012012. A second aggregation record links the pallet to its 48 cases.

6. The hierarchy is complete

The result is a tree. One pallet SSCC leads to 48 case SSCCs, each of which leads to 12 unit serials: 576 bottles reachable from one scan.

Pallet 395011010000012012
├── Case 395011010000004574 → 12 units (A7K29Q, A7K29S, …)
├── Case 395011010000004581 → 12 units
└── … 46 more cases

Why the records matter as much as the labels

A label proves only that a box carries a number. The value of the hierarchy comes from the records, because they let people downstream skip work and answer questions:

• Receiving. A distributor scans one pallet label and can receive 576 units into stock without opening anything. See why warehouses scan cartons and pallets instead of every unit.
• Recall and investigation. If batch L2609 is recalled, the records show which cases and pallets contain it, and where those were shipped.
• Diversion checks. If a unit meant for one market turns up in another, its serial leads back to the case, pallet and shipment it left in.

In traceability systems these links are often expressed as standard events. In EPCIS, the GS1 standard for sharing supply-chain event data, packing is recorded as an AggregationEvent, with the business step "packing". See what is an aggregation event?

When the tree changes: disaggregation and rework

Real warehouses unpack things. A pallet is split to fill two smaller orders. A case is opened because one bottle was damaged. A quality check pulls a sample unit for testing. Each of these breaks the tree, and the records have to follow.

Disaggregation is the opposite of aggregation: recording that a child has left its parent. When a pallet is broken down, the pallet's links to its cases are ended, and the pallet's SSCC should not be reused for whatever is built next. A new pallet gets a new SSCC.

Rework combines both directions. Suppose one bottle in case …4574 is damaged:

1. The case is opened, and the system records that the damaged unit is removed from it.
2. The damaged unit's serial is marked as destroyed, never returned to stock under the same status.
3. A replacement unit is scanned in and added to the case.
4. The case record now lists 12 serials again, one of them different.

If step 1 or step 3 is skipped, the case label still points to twelve serials, but one of them is wrong. Downstream, the replacement bottle cannot be traced back through its case or, worse, the destroyed bottle's serial still appears to be in circulation. Rework stations therefore need a scanner and a simple, enforced procedure, not just a roll of tape.

A related rule from exactly-once serialization: a unit that is repacked keeps its serial. Only a unit that is reprinted, because its code was damaged, gets a new serial, and the old one is voided.

What makes aggregation trustworthy

Aggregation data is worth exactly as much as the discipline behind it. The checks that matter most:

• Read, don't assume. Reading codes into the case is stronger than inferring them from conveyor position. Inference works until a box is picked off by hand.
• Confirm rejects. A box the system thinks was rejected must not end up in a case. A sensor confirming each reject closes that gap.
• Count before you close. A case should not be labelled until its child count matches its expected quantity.
• Make changes go through the system. Every manual repack, split or sample needs a scan.
• Reconcile. At the end of a batch, units verified should equal units aggregated plus units rejected, sampled or held.

Who needs this, and how far down?

Not every product needs unit-level aggregation. A detergent maker shipping by batch may aggregate only cases to pallets, with no unit serials at all. A perfume or pharmaceutical brand dealing with counterfeits, regulated traceability or loyalty programmes is more likely to aggregate all the way down to the unit. The decision follows the same logic as whether you need serialization at all.

Where the hierarchy does exist, the label and the record have to stay in step from the case packer to the store shelf. The identity of the place where each step happens, a factory, warehouse or store, is usually recorded with a GLN; see what is a GLN?