Systems and records
Business workflow concurrent events: how to preserve two teams' parallel work on one case
By SourceX Editorial · Updated
10 sections
Short answer
To preserve simultaneous work by two teams on one case, record each team's steps as intervals with start and completion times, keep only the orderings a record proves, such as a handoff, a reference or a reply, and mark everything else as concurrent. The result is a partial order: a case graph with dependency edges and their evidence, reconciled back to source totals, instead of one timestamp-sorted list.
System export
Business workflow concurrent
Key takeaways
- Sorting events by timestamp turns parallel work into a fake sequence and teaches a model dependencies that never existed.
- Only evidence proves an ordering: a state change on a shared object, an explicit reference, an assignment handoff or a reply; a timestamp alone does not.
- Store intervals, not points, so overlap is measurable, and store each dependency edge with the record that proves it.
- Clock offsets, identifier mismatches and unrecorded transitions can change the graph, so test each one before labeling a case.
- Take the outcome from the system of record that settled the case, and reconcile event counts per source and per team.
How do you preserve simultaneous work by two teams on the same case?
Keep the case as a partial order. Each team's steps become intervals on their own track, edges between tracks exist only where a record proves that one step needed the other, and any two steps without such a path are concurrent. Then check the graph against the source systems' totals.
A customer escalation is a typical example. Billing reviews a disputed charge while the technical team investigates the fault behind it. Both work the same case number in the same week, sometimes the same hour. A flat log sorted by time will show billing's review before the engineer's diagnosis, or the other way around, depending on which clock ran a few seconds fast.
For an AI agent trained on that log, the difference matters. A fake sequence teaches that billing must wait for engineering, or that engineering starts only after billing. The true record teaches that they can run in parallel and must meet at one point: the credit decision that depends on the root cause.
Why does sorting by timestamp invent an order?
Because a timestamp says when a system wrote a row, not what the work depended on. Leslie Lamport's 1978 paper on clocks in distributed systems showed that the happened-before relation is only a partial ordering of events; for some pairs, no one can say which came first, and for business systems with separate clocks that is the normal case.
Three practical problems make it worse. Systems write timestamps in different forms: RFC 3339 timestamps carry either Z or a numeric offset from UTC, and exports that drop the offset shift one team's events by hours. Systems batch: Zendesk stores one audit per ticket update, and one update can hold several events that share the audit's single created time. And systems record different moments: one logs when a person clicked save, another when a nightly job synced the change.
The outcome is ties, near-ties and silent shifts. Sorting resolves all of them arbitrarily, and the arbitrary order then looks like fact in the training data.
Which evidence proves that one step depended on another?
An ordering is real when a record shows the later step consumed something the earlier step produced. Rank the evidence and keep its type on every edge, so a reviewer can see how much the graph rests on inference.
Distributed tracing already works this way. The OpenTelemetry specification lets a span link to zero or more causally related spans and uses links for fork and join patterns, where one operation fans out work and a later operation aggregates it; a single parent field cannot describe that shape. A case graph for business work needs the same freedom.
| Evidence | Example | Ordering it proves | Strength |
|---|---|---|---|
| State change on a shared object | Credit memo can only be issued after root cause field is set | Setter before the step that requires the value | Strong when the system enforces it |
| Explicit reference | Billing note cites the engineer's diagnosis ID | Referenced step before the referencing step | Strong |
| Assignment handoff | Case reassigned from technical queue to billing queue | Work before the handoff, then work after | Strong for the handing team |
| Reply in a thread | Email answer with an in-reply-to header | Message before reply | Strong |
| Linked ticket or subtask | Child ticket created from the parent case | Parent creation before child creation | Medium: says nothing about completion |
| Approval gate | Refund approval workflow completed | Approval before the posting it unlocks | Strong when the gate is system-enforced |
| Timestamp only | Two events minutes apart on different systems | None on its own | Weak: treat as concurrent unless another record links them |
Reconstruction example (illustrative): one case, two teams, ten events
This case is invented to show the method; the times and counts are illustrative. A customer reports a service outage and disputes the month's charge. The case lives in a help desk, the fault in an issue tracker, and the credit in the billing system. Times are shown in UTC after offset correction.
Read the table by track. Technical work (T) runs from 09:12 to 15:40; billing work (B) runs from 09:30 to 16:05. Most of the two tracks overlap. Only one edge runs directly between the two tracks, besides the fork that opens them and the join that closes them, and each of those has a record behind it.
| Event | Track and activity | Interval (UTC) | Source | Depends on (evidence) |
|---|---|---|---|---|
| E1 | Case opened by customer | 09:05 | Help desk | None: case start |
| E2 | T: triage and reproduce fault | 09:12 to 10:40 | Issue tracker | E1 (linked issue created from case) |
| E3 | B: pull invoice and usage | 09:30 to 10:05 | Billing | E1 (case ID on billing note) |
| E4 | B: draft provisional credit | 10:10 to 10:25 | Billing | E3 (same billing note thread) |
| E5 | T: root cause recorded | 10:40 to 13:15 | Issue tracker | E2 (status transition) |
| E6 | B: customer update sent | 11:00 | Help desk | E4 (reply references the draft) |
| E7 | T: fix deployed | 13:20 to 15:40 | Issue tracker | E5 (status transition) |
| E8 | B: credit amount finalized | 13:30 to 14:10 | Billing | E5 (note cites the root cause ID) |
| E9 | B: credit posted | 14:15 | Billing | E8 (approval workflow completed) |
| E10 | Case resolved and customer confirms | 16:05 | Help desk | E7 and E9 (both referenced in resolution note) |
Reading the dependency graph the example produces
The graph has a fork at E1, two parallel tracks and a join at E10. One cross-track edge sits in the middle: E8 depends on E5, because the billing note cites the root cause. That edge is the decision point the case is really about.
At a glance
Reading the dependency graph the example produces
Everything else between the tracks is concurrent. E3 and E4 overlap E2 entirely; E6 sits inside E5; E7 overlaps E8 and E9. A flat sort would have placed E3 after E2 and implied billing waited for triage. It did not, and the record shows it did not.
- Fork: E1 to E2 (linked issue) and E1 to E3 (case ID on billing note).
- Technical chain: E2 to E5 to E7, each by a status transition in the issue tracker.
- Billing chain: E3 to E4 to E8 to E9, by note thread and approval workflow; E4 to E6 by reply reference.
- Cross-track dependency: E5 to E8, by explicit reference to the root cause ID.
- Join: E7 and E9 to E10, both referenced in the resolution note.
- Concurrent pairs to keep: E2 with E3 and E4; E5 with E6; E7 with E8 and E9.
The record schema for a partially ordered case
Store each event with an interval, its source clock and an explicit list of dependencies; derive concurrency from the graph rather than storing it by hand. Two standards help. The XES lifecycle extension records transitions such as start and complete for an activity, which is what turns points into intervals. OCEL 2.0 lets each event relate to several objects with a qualifier describing the role each object plays, which keeps the help desk case, the issue and the invoice distinct while still linked.
| Field | Content | Why it is needed |
|---|---|---|
| event_id and source_event_ref | Stable ID plus the native row reference | Traceability back to each system |
| track | Team or queue that did the work | Separates parallel lines of work |
| objects with qualifiers | Case, issue, invoice, each with a role | Links one event to several business objects |
| start_time and complete_time | UTC instants with the original offset kept | Makes overlap measurable |
| clock_source and offset_bound | Which clock wrote the time and its tolerance | Decides when a near-tie is unresolvable |
| depends_on | List of event IDs, each with evidence type and pointer | Records only proven orderings |
| observed_or_inferred | Whether the event row exists or was reconstructed | Keeps guesses out of graded labels |
Could clock drift, identifier mismatch or an unrecorded transition change the case?
Yes, each of the three can add or remove an edge, so test them before labeling. Clock drift matters only where a dependency rests on time: if two events are closer together than the offset bound, treat them as concurrent unless another record links them. Identifier mismatch matters when the billing note cites an issue ID in a different format from the tracker's; a crosswalk with a match rule and a confidence label decides whether the E5 to E8 edge exists at all.
Unrecorded transitions are the quietest risk. If the issue tracker records only the latest status, an engineer who reopened the fault after E7 leaves no trace, and the join at E10 looks cleaner than it was. Mark any interval whose start or end is inferred, and exclude cases with inferred cross-track edges from graded evaluation sets.
Which linked record proves the decision and the outcome?
The decision is proven by the record that consumed the other team's result, here the billing note citing the root cause, and the outcome by the system of record that settled the case: the posted credit in billing and the deployed fix in the tracker, followed by the customer's confirmation. A help desk status of solved is not the outcome; it is a label someone set.
Keep the outcome fields separate from the event graph and attach them by object ID. That lets a buyer evaluate an agent on whether it reached the same decision with the same evidence, rather than on whether it reproduced a status change.
Reconciling the reconstruction to source totals
Before any case leaves the pipeline, count. Every event row pulled from each source should appear exactly once in a case graph or in an explicit exclusion list with a reason, and the per-team and per-source counts should match the source extracts for the same period.
Then measure concurrency as a check, not as a label. The open-source pm4py library, for instance, counts how often two activities were concurrent from start and complete timestamps, with a strict option that counts only overlaps of positive length. If the reconstructed graph says two activities run in parallel in most cases but the overlap count says they almost never overlap, one of the two is wrong.
- Rows in, rows placed, rows excluded with reason: per source, per period.
- Cases with at least one cross-track edge, and the share of those edges resting on strong evidence.
- Ties inside the offset bound left unresolved, counted rather than broken.
- Counterexample check: bulk imports or scheduled jobs that stamp many rows with one time look concurrent but are a single batch; collapse them before measuring overlap.
Licensing case histories that show parallel work
Cases worked by two teams carry more personal data than single-queue tickets: employee names, internal notes, customer messages and billing details. Being able to export them is not the same as having the right to license them, and de-identification does not settle customer contract terms or internal policy on employee data.
Pseudonymize people and teams consistently across systems so the tracks still line up, redact free text before export, and keep billing amounts out unless the task needs them. SourceX can then take selected case histories through rights review and preparation as licensed AI datasets, delivered only after the company has approved the scope and signed. A business curious whether its two-team cases fit can begin with a short company assessment that needs no records uploaded.
Frequently asked questions
What is a partial order in an event log?
It is an ordering that says which events must come before which others, and leaves the remaining pairs unordered. In a business case, it keeps two teams' independent steps side by side and orders only the steps connected by a handoff, a reference or a reply.
Why not just use the timestamps to order events?
Timestamps come from different clocks, offsets and batch jobs, so close events can appear in the wrong order or in an arbitrary one. A timestamp tells you when a system wrote a row, not whether one step needed the other.
How do I record activities that overlap in time?
Store a start and a completion time for each activity, as the XES lifecycle extension does with start and complete transitions. With intervals, overlap can be measured; with single points, it cannot.
What should happen when two events are too close to tell apart?
If the gap is smaller than the known clock tolerance and no record links them, keep them as concurrent and count the unresolved tie. Breaking ties by sort order hides uncertainty that a reviewer needs to see.
Is a solved status enough to label the case outcome?
No. Use the record that settled the work, such as a posted credit, a deployed fix or a customer confirmation. A status field shows what someone clicked, not what happened.
Sources
- Lamport's 1978 paper shows that the happened-before relation defines only a partial ordering of events in a distributed system. Source
- RFC 3339 timestamps carry either Z or a numeric offset from UTC. Source
- Zendesk stores one audit per ticket update, and one update can consist of one or more events. Source
- OpenTelemetry spans can link to zero or more causally related spans, which covers batch and fork/join patterns. Source
- The XES lifecycle extension records the lifecycle transition, such as start or complete, that each event represents. Source
- OCEL 2.0 qualifies each event-to-object relationship with the role the object plays in that event. Source
- pm4py counts how often two activities were concurrent from start and complete timestamps, with a strict option for positive-length overlaps. Source
See if your company qualifies
A short company assessment. No data uploads are needed.