Systems and records
Support multi-channel continuity data: one case from chat to email
By SourceX Editorial · Reviewed by Noah Loul ·
10 sections
Short answer
Preserve one case across channels by keeping three keys apart: a pseudonymous person key, a case key for the problem and a conversation key per channel thread. Join each chat, email and call to the case with a link record that states its method and evidence, order every event on one UTC timeline, and label the outcome only after a maturity window shows the problem stayed solved.
Document stack
Support multi channel
Key takeaways
- Keep person, case and conversation keys separate; conflating them merges different problems or splits one problem by channel.
- Help desk merges, follow-ups and email threading change records permanently and rarely record why threads belong together.
- Every join between channels needs a link record with a method, stored evidence and a confidence level; same person and similar time is not enough.
- Order events on UTC with the source clock kept and one declared tie-break, never by export time.
- An outcome is proven only after a maturity window with no reopening, follow-up or linked repeat contact.
How do you preserve one customer case when the conversation changes channels?
Keep three keys apart: a pseudonymous person key for who the customer is, a case key for the problem being solved, and a conversation key for each channel thread. Join every chat, email, call and portal thread to the case through an explicit link record that says how the link was made and how strong it is, and order all events on one normalized timeline.
Help desks do some of this on their own, through merges, follow-ups and email threading, but those features rewrite or close records as they go, and they rarely record why two threads belong together. A dataset built only from the final ticket inherits those gaps: the chat that started the case is a separate closed ticket, the email reply became a new case because a relay changed a header, and the phone callback lives in another system.
Support multi-channel continuity data is the record of one customer problem across those channels, with its handoffs, commitments, corrections and reopenings intact. The schema below defines the minimum fields, a validator, and a valid and a failing worked record.
Where do help desks break the thread on their own?
Most continuity loss comes from documented platform behavior, so the first job is to know which behaviors your systems have used. In Zendesk, merging tickets is permanent: the merged ticket moves to closed, cannot be reopened or edited, and fields such as tags, type and priority are not carried over from it. A reply to a closed Zendesk ticket creates a follow-up ticket that references the original rather than reopening it.
Zendesk records a ticket's channel in its via object, and the developer reference says the channel can be set through the API only at ticket creation and cannot be changed afterward. A case that began in chat and continued by email therefore shows one channel per ticket, not the path the customer took.
Salesforce Email-to-Case links a reply to an existing case through a threading token or, failing that, the email's In-Reply-To and References headers matched against stored message IDs. Salesforce warns that a relay that changes the Message-ID can break threading and create new cases. Salesforce case merge combines up to three cases into a master case, cannot be undone, and can delete the non-master cases depending on the org's setting.
Merging end user accounts in Zendesk is also permanent, and the merging user's data is lost except tickets and email identities. Before export, list which of these features were used, and when, so the linkage step knows where links were made by the platform and where they were lost.
Why must person, case and conversation keys stay separate?
A person key says who wrote; a case key says which problem; a conversation key says which thread in which channel. Conflating them produces the two classic errors: one customer's separate problems merged into one case, and one problem split into several cases because it moved channels.
The table shows what each key can and cannot prove, using common systems as examples.
| Key | Typical source | What it proves | What it does not prove |
|---|---|---|---|
| Person key | Help desk user ID, CRM contact ID, verified email identity | The same customer was involved | That two contacts concern the same problem |
| Case key | Ticket or case ID, plus follow-up and merge references | The platform treated these events as one problem | That the platform was right, or that it saw every channel |
| Conversation key | Chat session ID, email Message-ID chain, call record ID | These messages belong to one exchange | Which case the exchange served when the customer had several |
| Account or order key | Order number, subscription ID, device serial | The contact concerned a specific purchase or asset | Who the customer was if accounts are shared |
Which records make up the cross-channel identity and chronology schema?
The schema has one case table and several event and link tables, all keyed by stable IDs. The person key is a pseudonym generated before export; raw emails and phone numbers never enter the dataset. Version it, so a consumer knows which rules a record was validated against.
At a glance
Which records make up the cross-channel identity and chronology schema
| Record | Required fields | Purpose | Validation rule |
|---|---|---|---|
| case | case_id, person_key, opened_at, first_channel, problem_category, schema_version | One customer problem across all channels | Exactly one first event; person_key present |
| conversation | conversation_id, case_id, channel, source_system, source_record_id | Each channel thread that served the case | source_record_id resolves in the export |
| event | event_id, conversation_id, actor_role, event_type, occurred_at_utc, source_time, text_ref | Every message, call, status change or handoff | occurred_at_utc present; actor_role from a fixed list |
| case_link | from_id, to_id, link_method, link_evidence, confidence, linked_by | Why two conversations or tickets are the same case | Method from the allowed list; evidence cites a record |
| platform_action | action_type (merge, follow-up, split), source_ids, target_id, performed_at | Merges and follow-ups the help desk made | Merged-away IDs still map to a case |
| policy_version | policy_id, version, effective_from, applied_at_event | Which refund, warranty or service rule applied | Effective on the event date |
| commitment | event_id, promise_type, due_at, fulfilled_event_id or open | Promises made to the customer and whether kept | Every promise has an outcome or an open flag |
| correction | event_id, corrects_event_id, reason | Agent errors fixed later in the case | Corrected event exists and precedes it |
| outcome | case_id, resolution_code, resolved_at, maturity_window_end, reopen_count, outcome_label | Whether the problem stayed solved | Label set only after the window ends |
Which link methods are strong enough to join two channels?
Header threading, platform follow-up and merge references, and a cited ticket number inside a message are strong enough to join channels on their own. Matching on the same customer and a similar time is not; it needs a second piece of evidence or a reviewer's confirmation.
Email threading rests on standard headers. RFC 5322 says every message should carry a Message-ID, and defines In-Reply-To for the message being answered and References for the thread. Those headers survive export from most systems and are the cleanest evidence that two emails belong to one exchange, though not that the exchange stayed on one problem.
| Link method | Evidence stored | Confidence | Use |
|---|---|---|---|
| Email header chain | Message-ID, In-Reply-To, References values | High for one conversation | Join emails; still check the problem did not change |
| Platform follow-up or merge | Source and target IDs, action time | High that the agent treated them as one case | Join, and keep the merged-away record |
| Cited case number | Message text span quoting the ticket ID | High | Join chat or call notes to the case |
| Agent handoff note | Note text naming the earlier contact | Medium | Join after a reviewer confirms |
| Same person, close in time, same order | Person key, order key, time gap | Medium | Join only with a matching order or product key |
| Same person, close in time only | Person key and time gap | Low | Do not join; flag for review |
How do you order events when channels keep different clocks?
Store each event's time in UTC together with the source system's original value and time zone, then order by the UTC time with a fixed tie-break. Never order by export or ingestion time, which reflects when the data moved, not when the customer spoke.
Channels disagree in predictable ways. Chat transcripts are often stamped per message by the chat tool, emails carry a sender's Date header that can differ from the receiving server's time, and call records may log only the call start. Record which clock each timestamp came from, and treat gaps of a few seconds across systems as ambiguous rather than as an ordering fact.
Use one tie-break rule for the whole dataset, for example source time, then system sequence number, then event_id, and write it into the schema version. A model that learns response timing or escalation order is learning from this field, so it should be boring and consistent.
Which chat-to-email record validates, and which one fails?
This example is illustrative; IDs, times and counts are invented and are not customer data. A customer opens a chat about a duplicate charge on order O-118. The agent promises a refund review within 2 business days and the chat closes. The customer emails the next day, quoting chat ticket T-501; the help desk opens T-517. A supervisor merges T-517 into T-501, refunds the charge and solves the ticket, which closes automatically later. Nine days after closure the customer replies that the charge reappeared, and the system creates follow-up T-560.
In the valid record, case C-77 holds three conversations: chat, email and the follow-up. Case links cite the quoted ticket number (high), the merge action (high) and the follow-up reference (high). The commitment is linked to the refund event and marked kept on day 2. The outcome waits for the window, records one reopening and labels the case resolved after reopen once the second fix holds.
In the failing record, T-560 is treated as a new case because only ticket IDs were used, the merged-away T-517 has no mapping, and the refund promise has no fulfilled or open status. It fails three of the six validator checks below, the first, third and fifth:
- Every conversation maps to exactly one case, including merged-away and follow-up tickets.
- Every case_link uses an allowed method and cites stored evidence; low-confidence links are not joins.
- Every commitment has a fulfilled event or an explicit open flag at the window end.
- Events are ordered on UTC with the declared tie-break, and no event precedes the case's first event.
- The outcome label is set only after maturity_window_end and counts reopenings and follow-ups.
- No raw email address, phone number or name appears outside text that has passed redaction.
When is a fix proven to have held, rather than just marked solved?
Only a closed window with no reopening, follow-up or new contact on the same problem from the same person proves the fix held. The ticket's solved status records an agent's view at one moment.
Platform timing matters here. Zendesk distinguishes solved from closed: once a ticket is closed, a customer reply creates a follow-up ticket instead of reopening it, so a late recurrence shows up as a new ticket rather than a reopened one. If follow-ups and repeat contacts on other channels are not linked back, the original case looks permanently resolved.
Set the maturity window by problem type, long enough for the issue to recur in normal use, and record it in each outcome row. Count reopenings, follow-ups and linked repeat contacts within it, and label the outcome from a fixed list such as resolved, resolved after reopen, unresolved and customer abandoned.
Why does linking identities raise the privacy stakes?
Joining a person across chat, email and phone makes a richer profile than any one channel holds, which raises re-identification risk even after names are removed. A privacy reviewer should approve the linkage design before it runs, not only the redaction of each channel.
Generate the person key inside the company from identifiers that never leave, use a salted or keyed method so it cannot be reversed from a known email, and drop the raw identifiers from the export. Phone numbers, email addresses, chat handles, order numbers and device serials in message text need redaction too, since they rejoin records the key was meant to separate.
Keep the distinctions clear: holding the support records, the privacy basis for using them and the right to license them are three separate questions. Removing names does not settle the last two.
Can a support team license its cross-channel case records?
Customer operations teams whose cases survive channel changes hold a better account of how problems actually get solved than per-channel exports. For a team that wants to license them, SourceX handles the rights review, contracting and data preparation that continuity records need.
Eligibility is settled first through a brief company questionnaire, with no transcripts sent, and the company approves the scope and terms and signs the agreement before delivery, so channels or regions the privacy reviewer has not cleared can be left out of scope.
Could the email agent see the chat at the moment they replied?
Only if the chat had already happened and had already been linked to the email's case when the reply went out. Grade each reply against a packet cut at that reply's own timestamp on two clocks: when each earlier event occurred, and when the link joining it to the case was created. The schema above records who made each case_link but not when, so add linked_at.
Machine learning feature stores hit the same trap and document the fix. Feast's documentation says its point-in-time joins constrain only the event timestamp by default, so a value backfilled or corrected after a row's timestamp can still be returned, and its filter_by_created_timestamp option restricts each row to values whose created timestamp is at or before the row's own. In a support reconstruction, the chat's message time is the event clock and linked_at is the created clock.
So a link added while building the dataset, by a reviewer or an inference rule, never counts as visible to the original responder, however strong its evidence; only links the help desk, an agent or the customer created before the cutoff do. The packet below is illustrative; the product, times and rule are invented.
| Packet part | In the illustrative case | Grader's note |
|---|---|---|
| Decision under grade | Email reply R2, sent by a human agent at 09:14 UTC on day 2 | One packet per reply or action; a ticket usually holds several |
| Cutoff on both clocks | Events that occurred, and links created, at or before 09:14 UTC on day 2 | The outage confirmation on day 3 stays out |
| Earlier channel | Day 1 chat, 15:02 to 15:20 UTC; the help desk attached it to the email ticket at 08:41 UTC on day 2 after matching a verified address | Event time and link time both precede R2, so the chat was visible |
| Facts the chat established | Integration already re-authorized; service credit promised if engineering confirms an outage | Written down by the grader before reading R2 |
| Rule in force | Credit rule as versioned on day 1, allowing credits for confirmed outages | The chat promise was within policy |
| Action under grade | R2 asks for another re-authorization and says credits are not offered | Repeats a tried step and contradicts a standing promise |
| Sealed outcome key | Outage confirmed on day 3; credit issued on day 6 after a complaint | Sets severity; never shown to a model under test |
Where does a chat-to-email switch hide inside one conversation record?
In the message-level fields, because a conversation's channel label usually describes only how the conversation began. Intercom's published API description (version 2.14) defines the conversation source as the type of the conversation part that started the conversation, while any part can carry an email metadata object described as "Contains metadata if the message was sent as an email". Zendesk's ticket comments reference likewise gives every comment its own via property recording how that comment was created.
Store a channel on every event, with channel_evidence naming the field and value that proved it, so a grader can tell a chat that continued by email inside one record from one that never left the widget.
The same specification shows how an export can hold less than the agent saw. Its description of a conversation's parts ends "There is a limit of 500 parts.", an author's name and email are null when the contact has since been archived or deleted, and each part carries a redacted flag. Set an export-loss flag on any packet that touches a conversation at the part limit, a redacted part or a deleted author, and keep it out of the failure rate.
Lost, ignored or never exported: which failure was it?
Decide from what the packet shows at the cutoff, not from how the case ended. A chat nobody had linked before the reply is a linkage failure, fixed in identity and case matching; a linked chat the reply contradicts is a use failure, fixed in agent guidance or the model; a packet with an export-loss flag is neither and is counted apart. Reply R2 above is linked and ignored. If its only link had been added by a reviewer during dataset building, the same words would grade as not linked before the reply.
Closure and ratings move the verdict in neither direction. A solved status or a warm rating after R2 records how the exchange felt, not whether the agent used what the chat had settled, so grade context from the packet, grade the outcome from the sealed key once the page's maturity window has passed, and keep both. A use failure the outcome absorbed still counts at lower severity, and a clean context grade on a failed case points to some other cause.
| Verdict | What the packet shows at the cutoff | Counted in the failure rate? | Where the fix belongs |
|---|---|---|---|
| Not linked before the reply | The earlier channel held material facts, but no help desk, agent or customer link to it existed yet | Yes, as a linkage failure | Identity matching and case linking |
| Linked and ignored | A qualifying link existed, and the reply re-asks a given fact, repeats a tried step or contradicts a standing promise | Yes, as a use failure | Agent guidance, macros or the model |
| Linked and rightly set aside | A qualifying link existed, and the earlier fact had been superseded or did not bear on the reply | No; graded as a pass | Nothing to fix |
| Lost in export | A conversation at the part limit, redacted text, a deleted author or a link stored without its evidence | No; reported as a separate count | The export, before either rate is trusted |
| Borrowed context | The reply relied on another person key's history or on records outside the cleared scope | Yes, as its own failure | Access rules and identity checks |
How would you show a context fix works on cases it has never seen?
Measure two rates on held-out cases over one denominator, and compare the old process with the fix on identical replies. The denominator is every graded reply whose packet held a material fact from another channel; the linkage rate counts not-linked verdicts, the use rate counts linked-and-ignored verdicts, and lost-in-export packets are reported as a count beside both.
Split by whole case and by date: tune link rules or prompts on earlier months and hold out the latest, keeping every channel of a case on one side so the email reply under test never sits in tuning data. Double-grade a sample, report agreement, and compare within problem category, since channel-switching cases may be harder to begin with. A linking fix should lower the linkage rate; giving a reply-drafting model the reconstructed packet should lower the use rate. If the lost-in-export count is large, repair the export before reading either rate.
No results from this test are published yet, and the next evidence needed is one approved case from a company's own help desk with both clocks logged. Add these checks to the schema's validator:
- Every graded reply has decided_at in UTC, and nothing in its packet carries a later timestamp.
- Every earlier conversation in a packet has a case_link with linked_at at or before the cutoff and linked_by of help desk, agent or customer; otherwise it grades as not linked.
- Links made while building the dataset carry linked_by reviewer or inference and never count as visible.
- Every event has a channel and a channel_evidence value naming the source field.
- Export-loss flags cover the part limit, redacted parts, deleted authors and links without evidence; flagged packets stay out of both rates.
- The grader lists the chat's material facts before reading the reply, and the outcome sits in a sealed key outside the packet.
- No packet fact comes from another person key or from records the privacy review did not clear.
Sources for this section
- Feast's documentation (repository commit 1e5e90c, October 2026) says point-in-time joins constrain only the feature's event timestamp by default, so a value backfilled or corrected after an entity row's timestamp can still be returned, and that filter_by_created_timestamp limits each row to values whose created timestamp is at or before its own, keeping backfilled values out of training data. Source
- Intercom's published OpenAPI description, version 2.14 (repository commit 4592ac5), defines the conversation source as the type of the part that started the conversation, gives each conversation part an email metadata object present if the message was sent as an email and a redacted flag, sets an author's name and email to null when the contact has since been archived or deleted, and states a limit of 500 parts when a conversation is retrieved. Source
- Zendesk's Ticket Comments API reference lists a via property on each comment, which records how the comment was created and follows the via object reference. Source
Frequently asked questions
What should a cross-channel identity and chronology linkage schema include?
It needs a case record, a record per channel conversation, an event table on one UTC timeline, link records stating how each join was made, platform merge and follow-up actions, policy versions, commitments, corrections and an outcome with a maturity window. The person key should be a pseudonym created before export.
Is the help desk's ticket merge enough to keep one case together?
Not on its own. Merges are permanent in tools such as Zendesk and Salesforce, merged-away records lose fields or may be deleted, and channels the help desk never saw are not merged at all. Record each merge as a platform action and map every merged-away ID to the case.
Can you link chat and email by matching the customer's name and time?
Not by itself. Same person and close timing can be two different problems. Join only when there is a second piece of evidence, such as a quoted ticket number, a matching order or a reviewer's confirmation, and store that evidence in the link record.
What proves the customer problem stayed resolved after the ticket was closed?
A closed maturity window with no reopening, follow-up or linked repeat contact on the same problem. Because some tools create a new follow-up ticket after closure instead of reopening, those follow-ups and other-channel contacts must be linked back before the outcome is labeled.
What valid and invalid examples demonstrate the declared structure?
A valid record maps every conversation, including merged-away and follow-up tickets, to one case with evidence-backed links, kept or open commitments and a matured outcome. An invalid one splits a recurrence into a new case, leaves a merged ticket unmapped or labels the outcome before the window ends.
Sources
- Zendesk ticket merges are permanent, and fields such as tags, type and priority are not carried over from the ticket closed by the merge. Source
- Zendesk tickets cannot be un-merged; the merged ticket moves to a closed status and is no longer editable. Source
- A reply to a closed Zendesk ticket creates a follow-up ticket that references the original. Source
- Zendesk's via object records a ticket's channel, which can be set through the API only at creation and cannot be changed afterward. Source
- Merging Zendesk end user accounts cannot be undone, and the merging user loses all data except tickets and email identities. Source
- Salesforce Email-to-Case threads replies by token or by In-Reply-To and References headers, and a relay that changes the Message-ID can break threading and create new cases. Source
- Salesforce support reps can merge up to three cases into a master case, a merge cannot be undone, and non-master cases may be deleted depending on the org setting. Source
- RFC 5322 says every message should have a Message-ID and defines In-Reply-To and References for replies and threads. Source
See if your company qualifies
A short company assessment. No data uploads are needed.