Privacy and preparation
Event log actor role mapping: what an anonymous actor ID still needs
By SourceX Editorial · Reviewed by Noah Loul ·
10 sections
Short answer
An anonymized actor ID should travel with five things: the actor kind (person, bot, shared login or external party), the role the actor held at the moment of the event, the authority that action required and whether the actor had it, the organizational unit at a coarse level, and the date range the mapping was valid. Generalize rare roles so the role itself cannot name the person.
Record timeline
Event log actor role mapping
Key takeaways
- A pseudonymized actor token keeps the log's shape but loses handoff, approval and segregation-of-duties meaning unless role data travels with it.
- Describe each actor in five layers: token, actor kind, role at event time, authority required and held, and a coarse organizational unit.
- Keep role history in a separate mapping table with valid-from and valid-to dates, joined to events by token and time.
- Validate coverage, single matches, authority, separation, automation and minimum group size, and keep failing cases visible instead of fixing them silently.
- Merge any role held by a single person into a broader role; a role map does not make a pseudonymized log anonymous.
What role information should accompany an anonymized actor identifier?
Keep the token, and add a small, time-bound description of the job the token was doing when it acted. In practice that means five fields beside every actor token: actor kind, role at event time, authority required by the action, authority held, and a coarse organizational unit, each with the date range the mapping covers. With those fields, a reviewer can still see handoffs, approvals and segregation of duties after every name and employee number is gone.
Without them, the log keeps its shape but loses its meaning. A token such as act_7f2c approving an invoice tells you that somebody approved it; it does not tell you whether a clerk approved her own entry, whether a controller signed inside a delegated limit, or whether an integration account pushed the record through overnight. Those are the facts process analysts and agent builders most often need, and they are exactly what a careless pseudonymization step throws away.
This page gives a field-level role and authority mapping schema, a worked record, the checks a validator should run, and one failing example. All records shown are illustrative and describe no real company.
Why a token that only says who acted is not enough
The IEEE Task Force on Process Mining's XES organizational extension already separates three ideas: org:resource is the name or identifier of the resource that triggered the event, org:role is that resource's role within the organizational structure, and org:group is the group the resource belongs to. Pseudonymization usually touches only the first attribute. If the role and group attributes were never populated, or were dropped because they looked like personal data, the log can no longer answer organizational questions.
Four analyses depend on role. Handoff analysis needs to know that work moved from accounts payable to purchasing, not from one token to another. Segregation-of-duties checks need to know whether the same actor held two conflicting duties; NIST SP 800-53 control AC-5 asks organizations to identify and document the duties of individuals requiring separation and to define access authorizations that support it. Workload and queue analysis needs roles to group actors. And agent training needs role so a model learns which kind of participant is allowed to take which step.
A fifth reason is less obvious: automation. In many ERP, CRM and ticketing exports, scheduled jobs, integrations and shared mailboxes write events under a user account. If the log does not say that a token is a service account, a reconstructed process will show a tireless employee approving hundreds of records at 2 a.m., and any model trained on it learns a pattern no person follows.
Which five layers describe an actor without naming one?
Treat the actor as five separate layers, each answering one question, and decide per layer what to keep. Mixing them in a single free-text field such as job_title is the most common reason a mapping fails review: titles carry seniority, location and sometimes a name, and they change without an effective date.
| Layer | Question it answers | Keep in the released log as | Usually drop or coarsen |
|---|---|---|---|
| Actor token | Is this the same actor as in another event? | Keyed pseudonym, stable within the release | Login name, email, employee number |
| Actor kind | Was this a person, a bot, a shared login or an outside party? | Closed list of four or five values | Vendor or bot product names if they identify a customer |
| Role at event time | What job was the actor doing when this event happened? | Role code from a published role dictionary | Job titles, grade levels, location suffixes |
| Authority | Did this action require a permission, and did the actor hold it? | Required authority code and held flag, with limit band | Exact approval limits if they reveal a person |
| Organizational unit | Which part of the business acted? | Function-level unit such as AP or purchasing | Team, cost center, site and manager chain |
The role and authority mapping schema, field by field
The mapping sits in its own table, joined to the event log by actor token and time, rather than being copied into every event. That keeps the role history auditable and lets the privacy reviewer generalize roles in one place. The fields below are the minimum; a team can add fields, but removing one breaks a check in the validator section.
At a glance
The role and authority mapping schema, field by field
| Field | Type and allowed values | Purpose | Privacy treatment |
|---|---|---|---|
| actor_token | String, keyed pseudonym | Joins mapping rows to events | Key held by the data owner, never shipped |
| actor_kind | person, service_account, shared_login, external_party, unknown | Separates people from automation | None needed; values are generic |
| role_code | String from role_dictionary | Role held during the valid interval | Rare roles merged before release |
| role_dictionary_version | Semantic version, e.g. 1.2.0 | Pins meanings of role codes | None |
| org_unit | Function-level code | Groups actors for handoff analysis | Coarsened to function, never team |
| authority_codes | List from authority_dictionary | Permissions the actor held, e.g. approve_invoice | Generic codes only |
| limit_band | none, low, medium, high | Delegated approval limit as a band | Bands replace exact limits |
| valid_from, valid_to | Timestamps with time zone offset | When the mapping applies | Rounded to the day if hours identify a person |
| mapping_source | hr_system, identity_provider, app_role, inferred | Shows how the role was obtained | None |
| mapping_confidence | high, medium, low | Flags inferred or conflicting roles | None |
Where should role and authority values come from in source systems?
Take role from the system that granted the permission, and take job function from the HR record only as a cross-check. The application's own role model is usually the closest thing to authority at event time. In Salesforce, for example, the UserRole object represents a user role in the organization and sits beside profiles and permission sets; identity providers hold group membership; ERP systems keep approval hierarchies and limits. NIST SP 800-53 control AC-2 expects organizations to specify group and role membership and access authorizations for each account, which is why mature environments usually have a role history somewhere, even if nobody has exported it before.
Record which source each mapping row came from. A role inferred from behavior, such as an actor who only ever posts journal entries being labeled accountant, is useful but weaker, and the mapping_source and mapping_confidence fields let an analyst filter it out. Where the HR title and the application role disagree, keep the application role for authority checks and note the disagreement rather than resolving it silently.
Object-centric logs need one more step. The OCEL 2.0 specification lets an event relate to several objects through qualifiers that describe the role an object plays in that event, and it lets object attribute values change over time. If employees are modeled as objects, their role becomes a time-varying attribute and the qualifier says whether they acted as approver, requester or reviewer in that specific event. The same generalization rules apply to those attributes.
A worked mapping for an invoice approval case (illustrative)
The example below follows one illustrative supplier invoice through four events. Tokens, roles and times are invented for this page. The case is valid: every action requiring authority is taken by an actor that held it, the service account is labeled as one, and the person who entered the invoice is not the person who approved it.
- Role dictionary entry used here: ap_specialist means enters and codes supplier invoices; cannot approve variances or payments.
- Authority dictionary entry used here: approve_variance with a band, where the band boundaries are documented in the dictionary but not tied to any one person.
- Mapping rows behind this case: act_7f2 held ap_specialist from the start of the quarter to its end; act_c03 held purchasing_manager over the same period; act_a91 is a service account with no human role.
| Event (illustrative) | Actor token and kind | Role and unit at event time | Authority required, held |
|---|---|---|---|
| Invoice captured from email, 09:02 | act_a91 service_account | integration, finance_systems | create_invoice, held |
| Invoice coded to PO, 09:40 | act_7f2 person | ap_specialist, accounts_payable | edit_invoice, held |
| Price variance routed, 09:41 | act_a91 service_account | integration, finance_systems | route_exception, held |
| Variance approved, next day 11:15 | act_c03 person | purchasing_manager, purchasing, limit band medium | approve_variance up to medium, held |
Seven validator checks for a role map, and four ways it fails
A validator should reject any event it cannot resolve to exactly one mapping row at the event's timestamp, and it should report authority and separation problems as findings rather than silently fixing them. The checks below run in order; the first three are structural, the rest are business meaning.
- Coverage: every actor token in the event log has at least one mapping row; report the share of events with no mapping and fail above a threshold the team sets in advance.
- Single match: each event matches exactly one mapping row by token and time; overlapping intervals for the same token fail.
- Dictionary integrity: every role_code and authority code exists in the pinned dictionary version.
- Authority: when an event's activity requires an authority, the matched row holds it and the amount band fits; failures are listed, not deleted.
- Separation: no single token both creates and approves the same case where the dictionary marks those duties as separated, unless a documented exception code is present.
- Automation sanity: service accounts never hold approval authority unless the dictionary says a rule-based auto-approval exists.
- Group size: every released role_code and org_unit combination covers at least the minimum number of distinct actors in each reporting period.
| Failing case (illustrative) | What the log shows | Validator finding | Correct fix |
|---|---|---|---|
| Self-approval | act_7f2 codes the invoice, then approves the variance | Separation check fails: same token holds create and approve on one case | Keep the case, flag it as a control exception; never relabel the role |
| Role changed mid-case | act_7f2 promoted the day before approving | Single match passes only if the new row starts before the event | Load the new mapping row with its own valid_from |
| Bot approval | act_a91 approves at 02:00 | Automation sanity fails | Check for an auto-approval rule; if none, investigate the export |
| Unique role | Only one actor ever held treasury_lead | Group size fails | Merge into a broader finance_manager role before release |
Can clock offsets, split identities and informal delegations corrupt the role join?
Yes, and each one changes which role an event appears to have been done under. Role mappings are joined on time, so a clock offset of a few hours between the identity provider and the ERP can place an approval before or after a promotion. Normalize every timestamp to UTC with its original offset kept, and test boundary events, those within a day of a valid_from or valid_to, by hand.
Identifier mismatch is the second trap. The same person may appear as an email address in the ticketing tool, a numeric ID in the ERP and a display name in chat exports. If those are tokenized separately, one person becomes three actors with three roles, and separation checks pass when they should fail. Resolve identities before tokenizing, using the key held by the data owner, so one person maps to one token across systems in the release.
Unrecorded transitions are the third. Delegations, temporary cover and acting-up arrangements are often handled by email rather than in the role system. If a manager delegated approval for two weeks and the log does not record it, the validator will flag valid approvals as authority failures. Capture delegation as its own mapping row with mapping_source set to the evidence type, and keep the flagged events visible so a reviewer can see the reconstruction confidence.
How coarse must a role be before it stops identifying the person?
Coarse enough that each released role, within each unit and period, covers several people. A role held by exactly one actor is a name in all but spelling: chief accountant, the only Spanish-speaking dispatcher, the night-shift supervisor. Research on process mining logs has shown how little it takes to re-identify cases, with one study finding that, depending on an attacker's background knowledge, potentially up to all cases in an event log may be re-identified. A survey of privacy threats in process mining adds that a person can be linked to an activity as well as to a case, giving an employee recorded as a resource as its example.
The legal framing matters too. GDPR Article 4(5) defines pseudonymization as processing so that data can no longer be attributed to a specific person without additional information kept separately and protected. The EDPB's 2025 guidelines on pseudonymization, published for consultation, treat pseudonymized data that can be re-linked using additional information as personal data. A role map does not make an event log anonymous; it is a utility layer on top of pseudonymized data, and the privacy review covers it as such. This is general information, not legal advice; counsel reviews the specific facts of any release.
Practical rules that work: set a minimum number of distinct actors per role and unit per period before the release is prepared, merge roles that fall below it into their parent role, replace exact approval limits with bands, drop team and manager chains, and round role-change dates to the day when hours would point to one person.
Who signs off the role map before an event log is licensed?
Two people should sign: the workflow owner, who confirms the role and authority dictionaries describe how the process really runs, and the privacy reviewer, who confirms the generalization rules were applied. A process mining or data engineer runs the validator and attaches its report, including the failing cases kept in the release, so the buyer sees reconstruction confidence rather than a cleaned story.
Access to the log, privacy permission to share it and the contractual right to license it are separate questions, and a good role map answers none of them; it only makes a permitted release useful. When the business decides to license a released log, SourceX takes on rights review, contracting, preparation and delivery, and the company approves the scope and signs before any data reaches SourceX. That process opens with a short company assessment that needs no data upload.
Frequently asked questions
What should the privacy preserving role and authority mapping schema include?
At minimum: actor token, actor kind, role code, role dictionary version, coarse organizational unit, authority codes, an approval limit band, valid-from and valid-to timestamps, the source of the mapping and a confidence flag. Each row describes one actor for one interval, joined to events by token and time.
Is org:role in XES enough on its own?
It is a good start, because the XES organizational extension already defines org:resource, org:role and org:group. It does not carry authority, actor kind or effective dates, so a separate mapping table is still needed to check approvals, automation and role changes during a case.
Should bots and integration accounts get roles?
They should get an actor kind of service account and a role describing their function, such as integration. They should not inherit a human role, and they should hold approval authority only when a documented rule-based auto-approval exists.
Does replacing names with role codes make an event log anonymous?
No. Role codes reduce what an event says about a person, but tokens, timestamps and rare roles can still single someone out, and under the GDPR pseudonymized data that can be re-linked remains personal data. Treat the role map as part of a pseudonymized release and review it that way.
Which example cases show a role map passing and failing validation?
A valid case shows each authority-requiring step taken by an actor that held the authority at that moment, with service accounts labeled. Invalid cases include self-approval on one case, an approval by a service account with no auto-approval rule, overlapping mapping intervals for one token, and a role held by a single person.
Sources
- The XES organizational extension defines org:resource as the name or identifier of the resource that triggered an event, org:role as its role in the organizational structure, and org:group as the group it belongs to. Source
- The OCEL 2.0 specification relates events to objects through qualifiers that describe the role an object plays in an event, and allows object attribute values to change over time. Source
- NIST SP 800-53 Rev. 5 (official OSCAL catalog) control AC-5 asks organizations to identify and document duties requiring separation and define access authorizations to support it; AC-2 asks them to specify group and role membership and access authorizations for accounts. Source
- In Salesforce's object reference, the UserRole object represents a user role in the organization. Source
- GDPR Article 4(5) defines pseudonymisation as processing so data can no longer be attributed to a specific person without additional information that is kept separately and protected. Source
- The EDPB's Guidelines 01/2025 on pseudonymisation (consultation version) treat pseudonymised data that can be attributed to a person using additional information as personal data. Source
- A study of event-log re-identification risk found that, depending on prior knowledge, potentially up to all cases in an event log may be re-identified. Source
- A survey of privacy threats in process mining notes that a person can be linked to an activity as well as a case, for example a hospital employee recorded as a resource. Source
See if your company qualifies
A short company assessment. No data uploads are needed.