Commission the site before lunch.

31 July 2026 · the launch journal

Commissioning day has a shape every field engineer knows: the readers are up, the network drop the client promised is a VPN ticket in someone else's queue, and a person with sign-off authority is standing behind you wanting to see data. The data layer that survives that day is a local one — reader feed to validated EPCIS event, on your bench, no cloud in the loop. Here is that pipeline, end to end, with the transcripts.

Reader payload to constructed event

A dock-door read gives you identifiers and a timestamp; the site gives you the rest of the context — read point, business step, disposition. Constructed, that is an ObjectEvent:

{ "type": "ObjectEvent",
  "eventTime": "2026-07-19T10:00:00.000Z",
  "eventTimeZoneOffset": "+00:00",
  "epcList": ["urn:epc:id:sgtin:0614141.107346.2018"],
  "action": "OBSERVE",
  "bizStep": "shipping",
  "disposition": "in_transit" }

The rule that keeps the rest of the day boring: the event is born conformant. Validate before anything leaves the function — locally, against the pinned official GS1 schema, with npx epcis.dev validate:

{ "valid": true,
  "schema": { "artefact": "epcis-json-schema.json", "version": "2.0.1",
              "sha256": "0f46ff694efffd8d8ce840a33dfde84228add11b516b8b258f3200740ae210af" },
  "errors": [] }

Note what the verdict carries: the exact schema artifact and its sha256. When the client's IT team asks "validated against what?", the answer is a digest they can check on the conformance page, not a vendor sentence.

Capture, locally, with the stamps visible

npx epcis.dev capture runs the full gateway on your bench — same validation, same error bodies, same stamping discipline as the hosted door. From a real run over the corpus's replay fixture:

{ "accepted": true,
  "job": { "captureID": "9ff624a6-99ef-4a16-8b38-dfd8dc5ecef6",
           "success": true, "captureErrorBehaviour": "rollback", "errors": [],
           "eventIDs": ["urn:uuid:5e900002-0000-4000-8000-000000000001"] },
  "events": [ { "type": "ObjectEvent", "...": "...",
                "recordTime": "2026-07-31T12:47:48.004Z" } ] }

Two things in that transcript matter on site. recordTime is stamped by the door, not supplied by you — the gateway asserts when it recorded, the event asserts when the world happened, and the two never blur. And the capture response reads the events back through the query door, stamps visible — what you show the client is what a query returns, not an echo of what you sent.

Failure is equally typed: an invalid document comes back as an RFC 7807 problem body carrying the standard's own exception types, per event, with no partial acceptance — a job lands whole or not at all. No "how much of that batch made it in?" forensics at 4pm.

Offline tolerance, done honestly

Retries are not an edge case in the field; they are the weather. Buffers flush twice, readers double-fire, the link drops mid-batch and the batch re-sends. The dedupe that survives all of it needs no sequence numbers and no coordination, because event identity is computed from event content — the CBV 2.0 §8.9 hash:

hash  0  ni:///sha-256;649a245b6e626325c60ca71777cfb66f386efd6fcc722fab7c2fecdfc56cd0c6?ver=CBV2.0

The golden corpus pins the law as a fixture (sequences/duplicate-benign-replay.json), in one sentence: "Re-capturing an identical event (same eventID, same event-hash, same errorDeclaration) is a benign no-op ack, never a re-append." So the offline pattern is simply: buffer everything, replay everything when the link returns, and let the hash make "did I already send this?" a non-question. The algorithm itself excludes eventID and recordTime, so a gateway stamping those fields does not break the dedupe. No distributed lock, no site-specific GUID scheme that shears the first time two systems disagree about it.

If the site has a cold chain, the same pipeline carries the evidence in-band — EPCIS 2.0's sensorElementList puts temperature series inside the custody event, one artifact instead of two systems glued in a spreadsheet later.

The 4pm artifact

What you hand the client at the end of commissioning day is not a promise, it is a validation summary: n events constructed from live reader feeds, n validated against the pinned official EPCIS 2.0.1 schema (digest cited), n captured with hashes computed, replay tested — here is the transcript. Every line of it re-runnable by their own team with npx epcis.dev, from the fixtures and the contract shipped in the tarball (node_modules/epcis.dev/AGENTS.md). The five-minute version of that transcript is Run it yourself; what your proposal may claim on the strength of it is the bid-language entry.

The buffered events on your bench eventually want a durable home — the hosted spine the client's partners can be granted reads against. That destination is on the dated ledger at /what-ships-today/, and the queue for capture keys is the key list: your address first, a few questions about the sites you commission, and the final step locks. Keys are provisioned from that list, in order — one email when yours is ready.