WorkflowMulti-Site Manufacturing

Serialization & Aggregation Reconciliation

Serialization and aggregation reconciliation that accounts for each serial in a packaging run before the client's file leaves the plant.

See one packaging run's serials reconciled ↓
Watch with transcript →
The problem

A bottle swapped after its case scan passed the line's own count

On a serialized line each saleable unit gets a serial when its label prints, and each one must end the run in a single place: in a case that ships, or decommissioned as a reject, a sample or a destroyed unit. The serialization system reports what was scanned. The reject log, the batch record's packaging pages and the warehouse hold what physically happened.

Checking the line report against a glance at the batch record misses the actions the data never saw. A bottle is pulled by hand after its case was scanned and replaced from the rework tray; start-up print checks are destroyed in line clearance without a decommission scan. The file goes to the client, and the mismatch surfaces downstream at a trading partner as product without matching data.

Built forSerialization leadsPackaging QA specialistsPackaging line operatorsPackaging line managers

The Problem Today

A run is checked against the line system's own count, while the physical record sits in three other places.

5 years
after release, at least, records kept: EU FMD, Art. 15 published

Where a run's serial books live

  • Serial data
  • Reject log
  • eBR pages
  • Warehouse
  • A hand swap after the scanThe case data says a bottle ships that does not
  • Start-up prints left liveChecks destroyed at clearance never get decommissioned

The Solution

  1. The run drawn as one riverAllocated serials enter; never-printed, rejects, samples and destroyed units branch off
  2. A leak holds the fileCommissioned but neither shipped nor decommissioned shows red, and the file stops
  3. Each leaked serial tracedReject log lines, line events and eBR pages joined to the serial events
  4. Two signatures, then the filePackaging QA approves the corrections; the serialization lead countersigns

Built-in controls

  • A held file cannot be sent
  • Nobody approves corrections they drafted
  • A typed comment changes no count

What You Get

The client receives a file that matches its pallets, with the reconciliation behind each serial.

  • Files that match the palletsThe client's repository reads the counts the plant actually shipped
  • Breaks fixed inside the plantA broken parent-child link is corrected before a trading partner meets it
  • One run's lesson on each lineA check learned on one run covers all four lines once approved
Features

Serialization and aggregation features, from serial river to client file

A bottle line's run closes with three serials unaccounted for; the agents hold the client's file, trace each one to the line, and two people sign the corrections before it goes.

demoThe line, the run, its people and its serials are sample data.

  1. 01Serial river

    Serialization and aggregation drawn as one river, with the leak in red

    • Each branch a count from its record. Allocation, rejects, samples, destroyed units, cases and pallets each come from the system or page that holds them, one click away.
    • The file held when a leak appears. Holding is the safer step, so the leak finder stops the client's file at once; releasing it takes two signatures.
    • Findings with confidence and sources. Each leaked serial is listed with its likely physical cause, how sure the agents are, and which record shows it.
  2. 02Reject log

    Serial number reconciliation down to a single reject log line

    • Manual pulls joined to case events. A pull logged after its case's aggregation scan shows the case data still lists a bottle that is no longer in it.
    • The log as it was written. The record appears as the line wrote it, and counts as read only after the set time on screen.
  3. 03Client auditor

    The client's serialization auditor, played against the agents' own draft

    • The draft's wrong reason caught. Version one decommissioned the start-up serials as samples; the eBR page says destroyed, and the sample count would not have matched.
    • Points only the floor can settle. Where only a physical check can prove what a case holds, the point waits for the operator's re-scan.
  4. 04Corrections

    EPCIS corrections drafted as exact events, with each version kept

    • Corrections as the events to send. Each correction names the aggregation or decommission event, its reason from the fixed list and the evidence behind it.
    • Versions kept, never overwritten. The first draft and its error stay on record beside the fix, so an auditor sees what changed and why.
  5. 05Line question

    The operator re-scans the case and answers in fixed fields

    • Proof from the floor. The likely swap counts as proved only once the operator re-scans the case with the hand scanner.
    • Fixed answers, notes for people. Where the bottle went and who witnessed it are fixed choices; a typed note reaches a person and changes no count.
  6. 06Evidence

    Case label, re-scan, reject log line and start-up page on one screen

    • What packaging QA must open. The case, its re-scan, the log line and the batch record page sit together and count as read after the set time.
    • The case label the client receives. The label carries the product identifier and the logistics code, so QA checks the case as it will ship.
  7. 07QA approval

    Packaging QA approves the corrections first, with a personal PIN

    • QA first, then the serialization lead. Packaging QA approves the corrections against the packaging record before the serialization lead can countersign.
    • Nobody signs what they drafted. Whoever drafted or edited a correction set cannot approve it, and a send-back drafts a new version.
  8. 08Leak closed

    Leak closed, each commissioned serial in a case or decommissioned

    • The hold lifts after both signatures. Corrections apply only after the countersignature; the decommissioned count and the case contents update, and the next file version is built.
    • The file sent with its reconciliation. The client receives the EPCIS file with the counts behind it and replies through fixed fields.
  9. 09Market rules

    Each client market's serialization requirements as its own rule set

    • What counts, decided by the market. A sample is decommissioned as a sample under one rule set and left out of the upload under the other, on the same view.
    • A rule set for the next market. Another market is added by configuring a rule set, which packaging QA approves and the serialization lead countersigns before any run uses it.

The serialization lead countersigns only after packaging QA has approved

The lead runs each reconciliation and releases the file, packaging QA approves corrections first, and the line answers for what happened on the floor.

Serialization leads

Own serial allocation, aggregation and each client file from the lines

  • Each serial counted from its record
  • Leaks traced to the physical action
  • Files sent only after two signatures
Packaging QA specialists

Approve each correction to serial data against the packaging record

  • Case, log line and page on one screen
  • Corrections as exact events
  • Send-backs that draft a new version
Packaging line operators

Run the line, answer the agents' line questions and re-scan cases

  • Questions with fixed answers
  • A re-scan that settles the case
  • Notes that reach a person
Packaging line managers

Own line practice and agree the checks learned from each run

  • Line notes in their exact words
  • A say on each check before it applies
  • Runs across lines in one queue

Thirty-one seconds after its case was scanned, a bottle was pulled by hand

Four findings the line's own count passed, each traced to its source record.

A bottle in a case and in the reject log

The case data listed the pulled bottle while the reject log sent it to the reject bin, so the data shipped a bottle that did not.

A diverted bottle in no case

A bottle sent to the rework tray at a jam belonged to no case, and was most likely the one put back in the pulled bottle's place.

Start-up prints never decommissioned

Two print checks destroyed at line clearance stayed commissioned until the eBR start-up page was read.

A wrong reason in the agents' draft

The draft called those start-up serials samples; the eBR page says destroyed, and the sample log would have read two more.

demoSample data, from the working solution.

A check still waiting for approval let the drafter repeat a start-up mistake

Agents read and draft; people re-scan, approve and countersign.

Count reader

Reads the allocation, the serialization system's counts, the reject log and the eBR packaging pages.

  • Changes no record
  • Counts no source it could not open
Event matcher

Matches serial by serial from commission to decommission, case and pallet, and finds conflicts.

  • Infers no case's contents from its count
  • Resolves no conflict
Leak finder

Computes the leak, holds the file, traces each leaked serial with a confidence and asks the line in fixed fields.

  • Releases no hold
  • Decommissions nothing
Correction drafter

Drafts exact corrections as a versioned set, each with its evidence.

  • Signs nothing
  • Applies no check that is not approved
Client auditor

Plays the client's serialization auditor, the agents' own draft included.

  • Passes no run
  • Settles none of its points
File courier

Builds the EPCIS file after both signatures, sends it to the client's portal and reads back the client's receipt.

  • Sends no held or unsigned file
  • Counts no outside free text
More screens

Fifteen samples on a carton run were kept out of the Market B upload

Beyond the run itself: the sign-off order, the queue across plants and clients, another market's run, and the trail and settings behind them.

Two signatures in orderPackaging QA's approval is recorded with its meaning; the serialization lead's countersign waits until the correction set has been opened.
Runs across plants, lines and clientsEach run with its market, commissioned count, leak, state and file deadline; clean runs are released in bulk only after a sample of them is opened.
Another market on the same viewA carton run under the Market B rule set: reference and retention samples kept out of the upload, the leak closed and the file sent before release for sale.
The run's trailFile delivery, the hold lifted, corrections applied, both signatures, the re-scan and each record opened, with what each signature means.
Settings packaging QA signsLeak tolerance locked, the file deadline before pickup, read time, bulk sample rate and retention per market; nothing changes until packaging QA signs.

demoSample data, from the working solution.

A likely swap stays a guess until someone re-scans the case on the floor

Releasing a held fileTakes packaging QA's approval and the serialization lead's countersign, in that order.
Decommissioning a serialThe agents draft the event and its reason; it applies only after both signatures.
Proving what a case holdsA likely trace stays likely until the operator's re-scan proves it.
Reading outside free textA client's comment or an operator's note is set aside until someone named has read it.
Loosening the leak toleranceThe tolerance is locked, so no setting lets a run's file leave with a serial unaccounted for.

What serialization leads ask before trusting a reconciled run

What is serialization and aggregation?

Serialization and aggregation give each saleable pack a unique serial number and record which packs sit in which case, and which cases on which pallet. Here agents reconcile both for each packaging run, so each commissioned serial ends in a shipped case or a decommission before the client's file leaves the plant.

What does serial number reconciliation check?

That the serials commissioned on a run equal those aggregated into cases plus those decommissioned as rejects, samples or destroyed units. Anything left over is a leak, which the agents trace to the physical action behind it through the reject log, line events and batch record pages.

Is aggregation a DSCSA requirement?

The DSCSA asks for a product identifier on each package and homogeneous case. Aggregation to the pallet is industry practice agreed with the client, and the aggregated data sent downstream must match what was serialized, which is what this reconciliation checks.

How do EU FMD serialization requirements change the count?

Under EU FMD, the manufacturer keeps a record of each operation on the unique identifier, and reference and retention samples are not uploaded to the repositories system. A client market that follows those rules gets its own rule set, which keeps those samples out of the upload while aggregation stays voluntary by agreement.

What is in the EPCIS file the client receives?

The commission, decommission and aggregation events for the run, built only after packaging QA approves the corrections and the serialization lead countersigns. The client's reply comes back in fixed fields, stating what its repository accepted.

Does a reconciled run mean the batch can ship?

No. Reconciliation closes the serial books for the run; the QA head dispositions the lot, and the client, as brand owner, makes its own market release decision.

Send us one packaging run
and its reject log.

Share one run's serialization report with its reject log and the batch record's packaging pages, and we can account for each serial it commissioned.