Skip to main content
JML IT provisioning SLA runbook to prevent device, access and entitlement errors

JML IT provisioning SLA runbook to prevent device, access and entitlement errors

A payload-first approach so no new hire sits idle on day one and no leaver keeps access they shouldn't have

Most JML (Joiner-Mover-Leaver) failures don't happen because IT is slow or HR is careless. They happen because the handoff between the two systems is built on free-text emails, half-filled Jira tickets, and assumptions about who owns what. The job title field says "Analyst," IT provisions a generic Analyst profile, and three weeks later the person still can't access the finance folder they needed on day two. Nobody did anything wrong. The payload was just incomplete.

This runbook is about fixing that one thing: the exact data HR sends to IT, when it sends it, what "done" means, and how both sides reconcile the record afterward. No philosophy, no transformation program. Just the payloads and timings that close the gaps.

If you want the broader systems context around identity and integrations, that's covered separately in resilient HR systems architecture for reliable integrations and identity. Here we stay narrow: the provisioning contract itself.

Why the handoff breaks (it's almost always the payload)

Across mid-market companies, JML failures that cause the most pain tend to fall into a small number of patterns — and almost all of them trace back to what HR actually sent IT at the trigger moment.

  1. Underspecified joiners. HR sends name, start date, and title. IT guesses the rest. Entitlements get inferred from the last person with the same title, who happened to also sit on a project committee. Now the new hire has access they were never meant to have.
  2. Silent movers. Someone changes teams. HR updates the HRIS, but no trigger fires to IT, so the person keeps every entitlement from their old role and gets new ones stacked on top. This is how people end up with access to five departments after two years.
  3. Leaver lag. The termination is processed in payroll but the de-provisioning payload goes out a day late, or lands in a queue with no SLA. The account stays live over a weekend. In regulated environments, this is the single finding auditors love most.

A pretty typical example: a 180-person company processes a cross-department move. HR updates the record Thursday afternoon. IT never gets a structured notification — they find out when the employee's new manager raises a ticket the following Tuesday complaining their report can't log into the new CRM. Five business days lost, and the old entitlements were never revoked at all.

The root cause isn't effort. It's that nobody defined the payload as a contract with required fields and rejection rules. Free text can't be validated. A structured payload can be rejected the moment a required field is missing — before anyone wastes a week chasing it down.

The provisioning contract: what every payload must carry

Before timings or reconciliation, agree on the schema. The principle is simple: entitlements are derived from role + attributes, never from a person's title alone. HR sends attributes. IT maps attributes to a defined entitlement bundle. If HR sends a role that isn't mapped, the payload is rejected — not guessed.

Here's the minimum field set for each event type.

FieldJoinerMoverLeaver
employee_idrequiredrequiredrequired
event_typeJOINERMOVERLEAVER
effective_daterequiredrequiredrequired (last working day)
role_coderequirednew + oldn/a
department_coderequirednew + oldcurrent
manager_idrequirednewcurrent
location_coderequiredrequired if changedcurrent
employment_typerequired (FTE/contractor)if changedcurrent
device_profilerequiredif changedreturn/wipe flag
entitlement_bundlederived by IT from role_coderecalculatedrevoke all
accessremovalmoden/an/aimmediate / scheduled
datahandoverownern/an/arequired

Two things make this work. First, role_code is a controlled value, not a free-text title — IT maintains the mapping from each code to a specific entitlement bundle. Second, for movers you send both old and new role so IT can diff: grant the delta, revoke what's no longer justified. The "revoke" half of a move is the step teams skip most often.

Sample joiner payload

{ "eventtype": "JOINER", "employeeid": "E-10432", "effectivedate": "2025-07-14", "rolecode": "FIN-ANALYST-II", "departmentcode": "FINANCE", "managerid": "E-00881", "locationcode": "UK-LON-HQ", "employmenttype": "FTE", "deviceprofile": "STANDARD-LAPTOP-WIN", "notify": ["managerid", "hrbpid"], "payloadid": "JML-2025-0714-00231", "sourcesystem": "HRIS", "createdat": "2025-07-07T09:12:00Z" }

Notice there's no entitlement_bundle in the joiner payload. HR doesn't decide entitlements — HR decides role. IT owns the role-to-entitlement mapping. That separation is what stops the "copy the last analyst's access" problem dead.

Sample mover payload

{ "eventtype": "MOVER", "employeeid": "E-10432", "effectivedate": "2025-11-03", "rolecodeold": "FIN-ANALYST-II", "rolecodenew": "FIN-MANAGER-I", "departmentcodeold": "FINANCE", "departmentcodenew": "FINANCE", "managerid": "E-00440", "accessremovalmode": "scheduled", "payloadid": "JML-2025-1103-00904", "sourcesystem": "HRIS" }

Sample leaver payload

{ "eventtype": "LEAVER", "employeeid": "E-10432", "effectivedate": "2025-12-19", "lastworkingtime": "2025-12-19T17:00:00Z", "accessremovalmode": "immediate", "deviceprofile": "RETURN-AND-WIPE", "datahandoverowner": "E-00440", "mailboxaction": "DELEGATE-30D", "payloadid": "JML-2025-1219-01120", "source_system": "HRIS" }

The leaver payload is where most real damage lives. accessremovalmode: immediate paired with lastworkingtime tells IT exactly when to kill the session — not "today," which is ambiguous when a termination lands at 9am for a 5pm departure.

Acceptance criteria: what "done" actually means

A ticket marked "complete" means nothing if nobody defined completion. For each event type, acceptance is a checklist IT confirms back to HR with a timestamp and the payload_id.

Joiner acceptance criteria:

  1. Identity account created and matches employee_id.
  2. Entitlement bundle mapped from role_code applied — and logged, so the exact grant is recoverable.
  3. Device provisioned against deviceprofile and shipped/ready by effectivedate minus one business day.
  4. Manager and HRBP notified that provisioning is complete.
  5. No entitlements granted beyond the mapped bundle. (Any exception requires a separate, approved request with its own record.)

Mover acceptance criteria:

  1. New entitlements from rolecodenew granted.
  2. Entitlements from rolecodeold not covered by the new bundle revoked. This line is the whole point of a mover process.
  3. Device profile adjusted if changed.
  4. Confirmation that no orphaned access remains from the prior role.

Leaver acceptance criteria:

  1. All sessions terminated at or before lastworkingtime.
  2. All entitlements revoked — confirmed by a post-revocation access scan returning zero.
  3. Mailbox handled per mailbox_action.
  4. Device return logged or remote wipe confirmed.
  5. Data ownership transferred to datahandoverowner.

The non-negotiable across all three: acceptance is confirmed by an actual check against the target system, not by someone ticking a box in a ticket. "I revoked it" and "the scan shows zero access" are different claims. Audits care about the second one.

SLA timings that match the risk, not the convenience

Not every event carries the same urgency. Treating a routine joiner and a for-cause termination with the same SLA is how both end up handled badly. Tier the timings.

EventTrigger pointProvisioning SLADe-provisioning SLA
Standard joinerSigned offer, ≥5 days pre-startReady by start date −1 dayn/a
Urgent joinerSigned offer, <5 days pre-startWithin 2 business daysn/a
Mover (planned)HRIS effective date loggedNew access within 2 business daysOld access revoked within 2 business days
Leaver (standard)Resignation/last-day setn/aFull revocation by lastworkingtime
Leaver (for cause / immediate)HR flagn/aWithin 1 hour of trigger

The two SLAs that cause the most audit trouble when they slip: mover revocation and standard-leaver revocation. A joiner who's blocked complains loudly, so it gets fixed. A leaver whose access lingers is silent — nobody's chasing it. That asymmetry is exactly why the leaver SLA needs the hardest deadline and the clearest owner.

One pattern worth building in: for immediate for-cause leavers, the HR trigger should be a single action that fires the payload — not a conversation that becomes a ticket. Every minute of manual relay is a minute the account is live.

Reconciliation cadence: catch the silent failures

SLAs catch the events you know about. Reconciliation catches the ones that slipped through — the mover whose old access was never revoked, the leaver whose contractor account in a third-party tool nobody remembered to touch.

  1. Daily

    Match every HRIS event from the prior 24 hours against IT's completed acceptance confirmations. Any event without a matching confirmation goes on an exception list for same-day follow-up.

  2. Weekly

    Reconcile active identity accounts against active HRIS records. Any live account with no matching active employee is an orphan — investigate and close.

  3. Quarterly

    Entitlement review. Pull every account's granted bundle and compare it to what its current role_code should map to. Drift here reveals accumulated over-provisioning from missed mover revocations.

The weekly orphan scan is the one most teams don't run, and it's where the real exposure hides. A typical mid-market reconciliation in month one surfaces a handful of accounts — ex-contractors, a transferred employee's old SaaS seat, a shared mailbox nobody owns. None of it showed up in any ticket because no clean payload ever fired. That's the gap reconciliation exists to close.

Here's a simple workflow for the reconciliation cadence.

Process diagram

Run three cadences: daily for recent events, weekly for orphan detection, and quarterly for entitlement drift. Each cadence surfaces different failure modes and together they close the silent gaps SLAs miss.

The audit-log format that actually survives scrutiny

When an auditor or security review asks "prove this leaver's access was removed on time," you need one record that answers it without a scavenger hunt across email threads and three different ticketing systems. Log every JML event in a consistent, append-only format.

{ "logid": "LOG-2025-1219-01120-03", "payloadid": "JML-2025-1219-01120", "employeeid": "E-10432", "eventtype": "LEAVER", "action": "ENTITLEMENTREVOKED", "targetsystem": "CRM-SALESFORCE", "performedby": "svc-provisioning", "requestedat": "2025-12-19T17:00:00Z", "completedat": "2025-12-19T17:04:12Z", "slatarget": "2025-12-19T17:00:00Z", "slamet": false, "verification": "ACCESSSCAN_ZERO", "notes": "Revocation 4m past target; session already expired at 17:00" }

The fields that matter most for an audit: slatarget vs completedat (breach is visible, not hidden), verification (how you know it's done), and payload_id (every log line ties back to the originating HR event). Log honestly — recording a four-minute breach with context is far stronger in an audit than a suspiciously clean record. Reviewers trust logs that admit misses.

A worked example: the mover that never got cleaned up

A professional-services firm with around 220 staff kept failing the same control in their annual security review: employees who'd changed roles still held access to their old department's systems. Not one or two — roughly 30 accounts carrying stale entitlements, some going back over two years.

The cause was the mover gap. Their joiner and leaver flows were decent. But a role change only ever triggered additive provisioning — IT got told what new access to grant, and nothing about what to remove. The old role_code was never in the payload, so there was nothing to diff against.

The fix was small and entirely payload-side. They added rolecodeold to every mover event, made old-access revocation a hard acceptance criterion, and started running quarterly entitlement reviews. The first review cleared the backlog of around 30 accounts. By the second quarter, drift was near zero — because the mover payload now carried everything IT needed to revoke in the same motion as granting.

No new platform. No additional headcount. The only real change was treating the mover event as a two-sided operation — grant and revoke — and putting the data to do both into the payload.

When to formalize this (and when not to bother)

This runbook makes sense when:

  1. You're past roughly 100 employees and JML events happen weekly, so informal handoffs no longer scale.
  2. You operate in a regulated or audited environment where access evidence gets inspected.
  3. You use enough SaaS tools that de-provisioning spans more than two or three systems.
  4. You've already been flagged — in an audit or a near-miss — for lingering access.

It's overkill when:

  1. You're a small team where one person provisions everything and knows every account personally.
  2. Your entire stack is a handful of tools with central SSO that handles the whole lifecycle automatically.

Who should not try to run this manually: any team processing immediate for-cause terminations by email relay. If a security-sensitive leaver's de-provisioning depends on someone reading a message and then raising a ticket, that's a structural risk no SLA document fixes. Those triggers need to be a single action that fires the payload directly.

Putting it in place without a six-month project

You don't need to rebuild anything to start. The sequence that works:

  1. Define role_code as a controlled list and map each code to an entitlement bundle. This is the foundation — do it first.
  2. Lock the payload schemas for joiner, mover, leaver with required fields and rejection rules.
  3. Write acceptance criteria per event type, with verification being an actual access check, not a checkbox.
  4. Set tiered SLAs and assign a single owner to the leaver and mover revocation deadlines.
  5. Turn on daily and weekly reconciliation before you worry about quarterly reviews.
  6. Adopt the audit-log format going forward — don't try to backfill it retroactively.

Lock the payload schemas early and enforce rejection rules in the integration layer to stop bad events at source.

Where structured payloads and reconciliation pay off is in removing the manual relay and the guesswork — HRIS events that flow as validated records, exceptions that surface the same day rather than at year-end audit. Whether that runs through your existing integration layer or a workflow platform matters less than the discipline of the contract itself. The payload is the product. If HR and IT agree on exactly what gets sent, when, and what "done" actually proves, most JML failures stop occurring.

This connects closely to how provisioning errors ripple into pay and systems — the same handoff discipline underpins avoiding the kind of breakdowns covered in prevent payroll and compensation failures with HR–Finance governance. A leaver whose access lingers and a leaver who stays on payroll a cycle too long are the same failure wearing different clothes: a handoff with no validated payload and no clear owner.

Get the contract right, make reconciliation routine, and the gaps that auditors find — along with the ones that quietly expose you between audits — close on their own.

Built for HR Teams Tailored tools for recruitment, onboarding, and employee management
Save Time Automate workflows and reduce manual HR tasks
Engage Employees Boost retention with continuous feedback and development tracking
Ensure Compliance Stay up-to-date with labor laws and reporting requirements