Skip to content

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

This page covers business workflow concurrent events: how to preserve two teams' parallel work on one case.Illustrative

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.

Which evidence proves that one step depended on another?
EvidenceExampleOrdering it provesStrength
State change on a shared objectCredit memo can only be issued after root cause field is setSetter before the step that requires the valueStrong when the system enforces it
Explicit referenceBilling note cites the engineer's diagnosis IDReferenced step before the referencing stepStrong
Assignment handoffCase reassigned from technical queue to billing queueWork before the handoff, then work afterStrong for the handing team
Reply in a threadEmail answer with an in-reply-to headerMessage before replyStrong
Linked ticket or subtaskChild ticket created from the parent caseParent creation before child creationMedium: says nothing about completion
Approval gateRefund approval workflow completedApproval before the posting it unlocksStrong when the gate is system-enforced
Timestamp onlyTwo events minutes apart on different systemsNone on its ownWeak: 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.

Reconstruction example (illustrative): one case, two teams, ten events
EventTrack and activityInterval (UTC)SourceDepends on (evidence)
E1Case opened by customer09:05Help deskNone: case start
E2T: triage and reproduce fault09:12 to 10:40Issue trackerE1 (linked issue created from case)
E3B: pull invoice and usage09:30 to 10:05BillingE1 (case ID on billing note)
E4B: draft provisional credit10:10 to 10:25BillingE3 (same billing note thread)
E5T: root cause recorded10:40 to 13:15Issue trackerE2 (status transition)
E6B: customer update sent11:00Help deskE4 (reply references the draft)
E7T: fix deployed13:20 to 15:40Issue trackerE5 (status transition)
E8B: credit amount finalized13:30 to 14:10BillingE5 (note cites the root cause ID)
E9B: credit posted14:15BillingE8 (approval workflow completed)
E10Case resolved and customer confirms16:05Help deskE7 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.

The record schema for a partially ordered case
FieldContentWhy it is needed
event_id and source_event_refStable ID plus the native row referenceTraceability back to each system
trackTeam or queue that did the workSeparates parallel lines of work
objects with qualifiersCase, issue, invoice, each with a roleLinks one event to several business objects
start_time and complete_timeUTC instants with the original offset keptMakes overlap measurable
clock_source and offset_boundWhich clock wrote the time and its toleranceDecides when a near-tie is unresolvable
depends_onList of event IDs, each with evidence type and pointerRecords only proven orderings
observed_or_inferredWhether the event row exists or was reconstructedKeeps 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.

See if your company qualifies