Skip to content

Reconciling two systems that disagree about the same registration record

IntegrationsUpdated 2026-08-238 min read

In short

Pull an extract from both systems at the same instant, join on a stable key, and assign every difference to a named bucket such as late cancellations, test records, staff badges or unsynced onsite registrations. The residual after bucketing is the only part that needs investigation.

The Monday after close, the show director asks how many people came. Registration says 11,640 registered. The access control system says it issued 11,207 badges. Somebody says the gap is probably no-shows, which it is not, because no-shows never collected a badge and this is a count of badges issued.

Reconciling two systems that disagree about the same registration record is a routine piece of work that almost nobody has a routine for, and the reason it keeps turning into an afternoon of guessing is that the difference gets treated as a single mystery. It is four or five ordinary things stacked on top of each other, and once you name them the residual is usually small enough to investigate properly.

Freeze one timestamp before you compare anything

The first mistake is procedural. Somebody exports registrations at nine in the morning, somebody else exports the badge file at noon, and the comparison silently measures three hours of a live sale as though it were a defect.

Pick an instant. Take both extracts as of that instant, using each system's own as-at parameter if it has one, and write the timestamp into the filename and into the reconciliation sheet. Where a system cannot answer as of a past moment, take the two extracts as close together as you can and record the actual gap, because you will need it to explain the residual.

The same discipline applies to the definition. Both sides need to agree on what counts before either side counts. Does registration include cancelled records? Does the badge count include reprints? A reprinted badge is one person and two badge records, and on a show with a busy registration desk reprints can run to a few per cent of the total on their own.

What buckets should a reconciliation have?

Five, in the order they usually matter, and every difference goes into exactly one of them.

Late cancellations. Cancelled after the badge file was cut, so the badge exists and the registration does not, or the reverse depending on which direction each system applies the change. Every system handles this differently, which is a whole problem of its own and belongs with handling cancellations across systems.

Test and internal records. Test registrations created during setup, staff badges, contractor badges, press. These are real rows in one system and deliberately excluded from the other, or included in both and counted differently in the report.

Onsite activity not yet synced back. People who registered at the desk. The access control system knows about them immediately and the registration platform learns later, or never, if the onsite tool writes to its own store.

Duplicates. The same person appearing twice on one side. Either they registered twice, or a delivery mechanism wrote the record twice.

Unexplained. Whatever is left. This is the bucket that matters, and the point of the other four is to make it small enough to look at row by row.

The arithmetic of one show's gap

Run the numbers on the example above so the shape is visible.

Registration platform, 11,640 records at the frozen timestamp. Access control, 11,207 badge records. Gap of 433.

Cancellations processed after the badge file was cut account for 186. Test records and staff badges, 92. Onsite registrations captured at the desk and never written back to the registration platform, 71, and note that this one runs in the opposite direction to the first two, so it enters the arithmetic with the other sign. Duplicate badge records from reprints, 39. That leaves 45 unexplained, which is 0.4 per cent of registrations.

Forty five rows is a list a person can read in twenty minutes. That is the whole aim of the exercise. Nobody can investigate a gap of 433, so it gets explained away in a meeting; anybody can investigate 45, and doing so is how you find the actual defect, which in my experience is usually one integration silently dropping a category of record, such as everyone who registered through the exhibitor guest pass flow.

Publish the bucket table with the report. A post show number that arrives with its reconciliation attached gets challenged once. A number that arrives alone gets challenged every year.

Why does a message based feed produce duplicates?

Because the delivery guarantee you get is almost always at least once, and at least once means more than once sometimes.

Amazon states it plainly for its standard queues: they "ensure at-least-once message delivery, but due to the highly distributed architecture, more than one copy of a message might be delivered, and messages may occasionally arrive out of order", with a best effort attempt to maintain sending order (Amazon Web Services, 2026). Stripe says the same about webhooks, that an endpoint "might occasionally receive the same event more than once", and recommends logging the event IDs you have processed and skipping ones already logged (Stripe, 2026). Stripe also states that it does not guarantee delivery of events in the order they were generated, and retries failed deliveries with exponential backoff for up to three days.

Both of those properties show up in a registration reconciliation as noise that looks like data. A duplicate delivery inflates one side. An out of order delivery applies a cancellation before the creation it refers to, so the consumer either errors or, worse, creates a record from the cancellation payload and leaves it active. A retry three days later reintroduces a record somebody deleted by hand in the meantime.

None of that is a bug in the vendor. It is the contract, stated in the documentation, and a consumer that ignores it produces a warehouse that disagrees with its source in a way nobody can explain. The fix on the write path is to make the write safe to repeat, which is the subject of idempotency keys, and the fix on the read path is to key everything on the event ID and process each one once.

Which side wins when they disagree?

Decide this once, in writing, before the argument happens in a room with the show director in it.

For a registration record, the registration platform is the source of truth about whether a person is registered and what type they hold. The access control system is the source of truth about whether a badge was issued and when it was scanned. Those are different facts and neither system should be overwriting the other's.

The trouble starts when someone edits a record in the downstream system because it was faster. A name corrected at the badge desk, a company spelling fixed in the access control tool, a registration type upgraded on site. Every one of those creates a divergence that no sync will resolve, because both sides now think they are correct and the last write wins depending on which job ran most recently.

Write down, per field, which system owns it, and make the reconciliation report on ownership violations as a separate line. A field that keeps appearing in that line is either owned by the wrong system or being edited in the wrong place, and both have straightforward fixes once somebody can see the count.

Making it a routine rather than an incident

Reconciliation done once after a show is archaeology. Done nightly, it is monitoring.

The nightly version is cheap: count rows on both sides, apply the bucket rules you already wrote, and record the residual as a number in a table. What you are watching is the shape of the series rather than any single value. A residual that sits at 0.3 per cent every night and jumps to 4 per cent on Tuesday tells you something changed on Monday, and you still have the logs.

Three habits make the series useful. Store the counts rather than recomputing them, because the sources move. Record the extract timestamps alongside, so a future reader can tell a real jump from a comparison taken badly. And alert on the change rather than the level, since every show has its own baseline residual and a fixed threshold will either scream constantly or never fire.

A reconciliation that runs nightly also catches the deliveries that never arrived, though from the other direction. Counting what is missing at the endpoint is the more direct approach and it is covered in catching webhook delivery failures.

Where this stops

Bucketing explains the difference. It does not tell you which side is right.

When registration says 11,640 and the badge system says 11,207, the reconciliation can account for all 433 and still leave the honest answer that neither number is attendance. Attendance is a third thing, measured by scans at the door, with its own coverage problem. Teams that reconcile carefully sometimes come away believing they have measured attendance because the two systems now agree, and agreement between two systems that both count registrations is not evidence about who walked in.

The other limit is that reconciliation depends on a shared key. If the access control system stores a badge ID and the registration platform stores a registration ID, and the only link between them is a name and an email captured at different times, then your join is itself a matching problem with its own error rate. Buckets built on a fuzzy join inherit that error, and the residual will never go below it. Where that is your situation, fixing the key is worth more than any amount of bucketing, and it is the first thing to raise about the integration design.

This week, take both extracts at one agreed timestamp, join them, and write the difference into five named buckets. Whatever will not fit into a bucket is the list you should be reading, and it is almost certainly shorter than you fear.

Questions people ask about reconciling two systems

Why do the registration platform and the access control system never agree?
Because the difference is structural. Cancellations processed after the badge file was cut, test records, staff and contractor badges, and onsite registrations that have not synced back each account for a slice. Message based feeds add more, since at-least-once delivery means the same event can arrive twice and events can arrive out of the order they were generated.
What is the right way to compare two extracts?
Freeze a single timestamp, take both extracts as of that instant, and record the timestamp with the files. Comparing a pull taken at nine in the morning against one taken at noon on a live sale measures the intervening three hours as though it were a defect, and every explanation you build on top of that comparison will be wrong.
Can duplicate events cause a reconciliation gap?
Yes. Stripe documents that a webhook endpoint might receive the same event more than once and recommends logging processed event IDs to guard against it. Amazon states that its standard queues deliver at least once, so more than one copy of a message might be delivered. A consumer that writes on every message inflates one side of the comparison.

Related reading

All integrations articles