Skip to content

Privacy and preparation

Healthcare admin multi-system joins: one case across scheduling, billing and support

By SourceX Editorial · Reviewed by Noah Loul ·

10 sections

Short answer

Link one administrative case by following the keys the systems already share: appointment to visit, visit to account and claim, claim to remittance through the patient account number, and tickets only through a structured account or claim field. Replace every native key with a random token, keep the crosswalk with the data owner, use relative time instead of dates, and validate before release.

Redaction

Healthcare admin multi

This page covers healthcare admin multi-system joins: one case across scheduling, billing and support.Illustrative

Key takeaways

  • Scheduling to billing and claim to remittance are usually hard links; support tickets usually are not.
  • Never ship a hash of a medical record number as a join key; HHS says a re-identification code must not be derived from the individual's information.
  • Generate fresh tokens per release so two licensed datasets cannot be joined to each other.
  • Replace timestamps with offsets from the case's first event to keep sequence and delay without calendar dates.
  • Keep statuses and adjustment reason codes; leave diagnosis codes, clinical notes and ticket text outside the schema.

Build a case spine from the keys the systems already share, then swap every native key for a random token before anything leaves the data owner. In practice the chain runs appointment to visit, visit to billing account and claim, claim to remittance by the patient account number, and support or patient service tickets to the case only where a ticket carries one of those keys. The crosswalk from native keys to tokens stays with the organization that holds the records.

That gives a dataset in which each row is an administrative event, every event carries the same case key, and nothing in the delivered files can be used to look the patient up. A model or an analyst can then follow one case from booking through denial, appeal and the billing call that closed it, which is exactly what single-system extracts cannot show.

This page gives the minimum fields, what each is for, a labeled worked record, the validator checks and a failing example. Everything here is administrative. Diagnoses, clinical notes and care decisions are outside the schema by design, and a qualified privacy reviewer should approve the final field list for any real release.

Which native keys actually connect scheduling, billing and support?

Scheduling to billing is usually a hard link, billing to remittance is usually a hard link, and support to anything is usually soft. The HL7 FHIR standard, cited here from release 4, models the first two well: an Encounter references the appointment that scheduled it and the accounts that may be billed for it, and charges point to the account rather than the account listing charges. FHIR also notes that Encounter is not meant to store appointment information, which mirrors how practice management systems commonly keep bookings and visits apart.

On the claim side, CMS explains that the patient account number a provider puts on the claim comes from the provider's own accounting system, and that Medicare returns it on the remittance as a courtesy. That returned value is the most dependable join between a claim and its payment or denial. Support tickets rarely have a structured key at all; when they do, it is because someone added a custom field for the account or claim number.

Measure each link before you trust it. For a sample period, count how many visits find their appointment, how many claims find a remittance, and how many tickets find a case, and record those join rates in the dataset documentation. A sudden drop in one month usually means a system upgrade, a payer that stopped returning the account number, or a help desk field that agents stopped filling, and each of those changes what the linked cases can show.

Which native keys actually connect scheduling, billing and support?
LinkTypical native keyWhere it livesLink strength
Appointment to visitAppointment ID on the visit or encounter recordScheduling module; FHIR Encounter.appointmentHard when the visit was booked; missing for walk-ins
Visit to billing accountAccount or guarantor account numberPractice management or patient accounting; FHIR Encounter.accountHard, but one account can span many visits
Visit to claimEncounter or visit ID on claim linesBilling system; FHIR Claim.item.encounterHard per line; a claim can carry several visits
Claim to remittancePatient account number returned on the remittanceElectronic remittance and posting filesHard when the payer returns it; check payer behavior
Remittance to adjustment reasonClaim adjustment reason and group codesRemittance detail linesHard; codes come from the X12 code list
Ticket to caseAccount or claim number in a custom fieldHelp desk or contact center systemHard only if the field exists and is filled
Ticket to case without a fieldAccount number found in ticket textTicket bodySoft; flag as inferred and review before use

Why can't the dataset join on names, medical record numbers or hashes of them?

Because those keys identify the patient, and a key computed from them still does. HHS guidance on de-identification lists names, medical record numbers, account numbers and dates tied to a person among the identifiers removed under Safe Harbor. The same guidance allows a covered entity to keep a re-identification code only if the code is not derived from or related to information about the individual and cannot otherwise be translated to identify the person.

That rules out a tempting shortcut: hashing the medical record number and shipping the hash as the join key. A hash of an identifier is derived from information about the individual, and anyone who holds the source system can recompute it. Generate random tokens instead, keep the token-to-native-key crosswalk inside the data owner's environment, and never deliver it.

Generate tokens per release, not once forever. If the same patient carries the same token across two licensed datasets, a licensee who holds both can link them, and linked datasets can identify people that neither dataset identifies alone. Fresh tokens per release, or per licensee, prevent that by construction.

What should the privacy reviewed cross-system case schema include at the case level?

One row per case, holding only what describes the case as a whole. The case is the administrative unit you choose, usually a single scheduled service and everything billed and discussed about it. Fields that would identify the patient or the practice are generalized before they enter the row, not afterward.

Decide the case boundary before writing any join code, because the boundary decides what a case means. A case anchored on the appointment suits questions about access and no-shows; a case anchored on the claim suits questions about denials and appeals. Pick one anchor per release, write it into the dataset documentation, and attach other events to it rather than letting cases grow until they cover a patient's whole history.

What should the privacy reviewed cross-system case schema include at the case level?
FieldTypePurposePrivacy treatment
case_keyRandom tokenJoins every event in the caseGenerated per release; crosswalk retained by data owner
release_idStringTies the case to one versioned releaseNo personal content
service_categoryCoded categoryWhat kind of administrative service was scheduledBroad category list; no procedure or diagnosis codes
payer_categoryCoded categoryCommercial, Medicare, Medicaid, self-pay and similarNo payer name where it could identify a small practice
site_typeCoded categoryClinic, hospital outpatient, telehealth and similarNo facility name or address
region_bandCoded categoryBroad region for payer behaviorState or wider; never ZIP code
systems_presentListWhich source systems contributed eventsValues limited to scheduling, billing, remittance, support
case_outcomeCoded categoryPaid, partially paid, denied and not appealed, appealed, written offCategory only; no amounts

What belongs in each event row?

One row per event, with a type, a relative time and the coded facts that event produced. Relative time, counted in days or hours from the case's first event, preserves the sequence and the delays that make the data useful while removing calendar dates.

Expect many-to-many links and resolve them explicitly. One billing account can cover many visits, one claim can carry lines from more than one visit, and one ticket can ask about several statements. When an event belongs to more than one case, either duplicate it into each case with the same event_id and a shared flag, or assign it to the anchor it was created for; never let a single account number pull unrelated visits into one case.

What belongs in each event row?
FieldTypeExample valuesPrivacy treatment
case_keyRandom tokenSame token as the case rowAs above
event_idRandom tokenUnique per eventNot derived from any source ID
event_typeCoded categorybooked, rescheduled, no_show, visit_completed, claim_submitted, remit_received, ticket_opened, ticket_resolvedClosed list
source_systemCoded categoryscheduling, billing, remittance, supportNo vendor instance names
offset_hoursIntegerHours since the case's first eventReplaces timestamps; no calendar dates
status_codeCoded valueAppointment status, claim status, ticket statusFrom each system's fixed list
adjustment_codesList of codesClaim adjustment group and reason codes on the remittanceCodes only; no amounts or free-text remarks
ticket_categoryCoded categorybilling question, statement dispute, portal access, scheduling changeCategory only; no ticket text
link_methodCoded categorynative_key, custom_field, inferred_from_textInferred links carry review status
link_reviewedBooleantrue or falseFalse links are dropped before release

What does a valid worked record look like, and what does a failing one look like?

The record below is illustrative and invented for this page, not taken from any real practice or patient. It follows one case through scheduling, billing and remittance events and one support ticket, and the failing version underneath shows four mistakes a validator should catch.

At a glance

What does a valid worked record look like, and what does a failing one look like

  • Valid case row (illustrative): case_key K-7Q2M, service_category outpatient follow-up, payer_category commercial, site_type clinic, region_band Midwest, systems_present scheduling, billing, remittance and support, case_outcome paid after appeal.
  • Valid events (illustrative): booked at offset 0; rescheduled at offset 26; visit_completed at offset 340; claim_submitted at offset 388 with status accepted; remit_received at offset 742 with group code CO and a reason code from the X12 list; ticket_opened at offset 760, category statement dispute, link_method custom_field, link_reviewed true; claim_submitted again at offset 1,100 after appeal; remit_received at offset 1,580 with status paid; ticket_resolved at offset 1,610.
  • Failing record (illustrative): case_key equals a hash of the medical record number, which is derived from an identifier.
  • Failing record (illustrative): the visit event carries a calendar date and time instead of an offset.
  • Failing record (illustrative): service_category holds a diagnosis code copied from the claim, which brings clinical detail into an administrative schema.
  • Failing record (illustrative): a ticket is attached by matching the patient's surname in the ticket text, with link_method inferred_from_text and link_reviewed false, yet it was kept in the release.

Which validator checks should run before a release leaves the data owner?

Automate every check that a rule can express and make the release fail closed. The checks below are the minimum; a privacy reviewer may add others for a particular population.

Keep the validator's output with the release. A licensee, an auditor or your own team will want to see that each rule ran, how many rows it removed, and which version of the schema it enforced.

  • Every event row has a case_key that exists in the case table, and every case has events from at least two source systems.
  • Offsets are non-negative integers and events within a case are ordered; no field anywhere matches a date, phone, email, account number or record number pattern.
  • Every case_key and event_id appears in the token registry for this release and in no earlier release.
  • Coded fields contain only values from their closed lists; adjustment codes match the current X12 claim adjustment reason code list.
  • No row has link_method inferred_from_text with link_reviewed false.
  • No combination of service_category, payer_category, site_type and region_band describes fewer cases than the threshold the privacy reviewer set.
  • The delivered files contain no crosswalk, no free text and no attachment references.

Which billing and support codes stay in the schema, and which clinical content stays out?

Keep what explains how the administrative work went, and leave out what explains the patient's health. Statuses, delays, payer categories, adjustment reason codes and ticket categories show where a case stalled and what resolved it. X12 describes claim adjustment reason codes as the reasons a claim or service line was paid differently than it was billed, which is administrative evidence even though it can hint at clinical context, so keep the codes and drop the free-text remarks.

Diagnosis codes, procedure detail, clinical notes and anything copied from a referral or chart stay out. HHS describes the minimum necessary standard as reasonable efforts to limit protected health information to what the intended purpose needs; for an administrative schema the intended purpose is understanding scheduling, billing and service work, and that purpose rarely needs clinical content. Where a buyer argues it does, that is a different dataset with a different review.

Support events need the same discipline. A ticket category such as statement dispute or portal access tells a model why the patient or the practice reached out; the ticket's words usually add names, dates and descriptions of care that the category already summarizes. Build the category list with the support team before export, map every ticket to one value, and send tickets that fit no category to review rather than inventing a catch-all that hides what they contain. Ticket resolution codes deserve the same closed list, so that a resolved ticket means the same thing across months and teams.

When does linking the systems become the privacy risk itself?

When the joined case carries more detail than any single system did. A sequence of rare events, an unusual payer in a small region, or a long chain of reschedules can single someone out even with every identifier removed. Linking support tickets adds risk fastest, because ticket categories and timing can echo a complaint the patient also made publicly.

Stop and request specialist review if the release needs exact dates, small regions, rare service categories, or ticket text. Those needs point toward Expert Determination, where a qualified expert documents that the risk of identification is very small, rather than a field list alone. Also stop if the scheduling, billing and support data come from different legal entities, because each source may carry its own agreement limits.

Treat inferred links with the same caution. A ticket matched to a case by an account number found in text is useful, but it is also the link most likely to be wrong, and a wrong link puts one person's billing dispute into another person's case. Review inferred links by sample before including any of them.

Licensing a linked administrative dataset

Linked cases are more useful to AI developers than three separate extracts, because they show the whole administrative path and its outcome. They also carry more risk, which is why the schema, token policy and validator output belong in the licensing file from the first conversation.

A company interested in licensing such cases can start with SourceX's short company assessment, for which no data is uploaded. Delivery follows only after the company approves the scope and terms and signs, with de-identification done by SourceX through approved processing routes as the agreement sets out, and a schema like this one gives the scope conversation a concrete field list to approve or narrow.

Frequently asked questions

What is the most reliable key between a claim and its remittance?

Usually the patient account number from the provider's own accounting system, which CMS says Medicare returns on the remittance as a courtesy. Payers differ, so confirm the behavior on a sample before relying on it. In the delivered dataset, replace it with a random token.

Can we hash the medical record number to make a join key?

Not if the goal is a de-identified dataset under HHS guidance. A re-identification code must not be derived from information about the individual, and a hash of the record number is. Use random tokens and keep the crosswalk inside the data owner's environment.

How do support tickets join to scheduling and billing?

Only through a structured account or claim number field when one exists. Matching on numbers found in ticket text is possible but should be flagged as inferred and reviewed. Matching on names should not be used.

Should a cross-system case keep calendar dates?

Usually not. Relative offsets from the case's first event keep sequence and delays, which carry most of the administrative signal, without the dates HHS lists as identifiers. Exact dates need specialist review.

Does FHIR define how to link these records?

FHIR gives useful reference patterns: Encounter references the appointment and the billing accounts, charges reference the account, and claim lines reference the encounter. Many practice management systems do not expose FHIR for billing, so treat it as a model for the links, not a required format.

Sources

  • The HL7 FHIR R4 Encounter resource references the appointment that scheduled the encounter and the accounts that may be used for billing, and is not meant to store appointment information. Source
  • The HL7 FHIR R4 Appointment resource describes a booking of a healthcare event that may result in one or more encounters. Source
  • The HL7 FHIR R4 Account resource tracks charges for a patient, and resources such as ChargeItem point to the account rather than the account listing charges. Source
  • The HL7 FHIR R4B Claim resource lets each claim line reference the encounters it relates to. Source
  • CMS explains that the patient account number comes from the provider's accounting system and that Medicare returns it on the remittance as a courtesy. Source
  • X12 maintains the Claim Adjustment Reason Codes that explain why a claim or service line was paid differently than it was billed. Source
  • HHS de-identification guidance lists Safe Harbor identifiers including names, record and account numbers and dates, permits a re-identification code only if it is not derived from information about the individual, and describes Expert Determination. Source
  • HHS describes the minimum necessary standard as reasonable efforts to limit PHI to the minimum necessary to accomplish the intended purpose. Source

See if your company qualifies

A short company assessment. No data uploads are needed.

See if your company qualifies