Skip to content
Fundamentals

The Joiner, Mover, Leaver Process: One System, Not Three

The OutcomesBuilt Team14 min read

The short answer: the joiner, mover, leaver process is the single model that governs what happens to a person's access, equipment, and records from the day they are hired to the day they leave, and it works only when all three events run from the same HR triggers, the same role templates, and the same record of who holds what. Joiners get access from their role, movers get access re-derived from their new role, and leavers lose everything they actually hold. Treat those as three separate projects and each one quietly undoes the others.

Most companies meet this process in pieces. Onboarding gets fixed first because new hires complain loudly. Offboarding gets fixed after an audit or an internal review finds an active account for someone who left. Role changes rarely get fixed at all. We have written step-by-step guides for each piece: the employee onboarding automation guide, the employee offboarding automation guide, and the user access review automation guide, which covers role changes and the review that catches drift. This guide is not another how-to. It steps back and explains the lifecycle as one model: the three events, the shared data underneath them, why splitting them breaks, and what it looks like when they run as one system.

What the joiner, mover, leaver process is, and what it is not

The joiner, mover, leaver process (often shortened to JML, and sometimes called identity lifecycle management or the employee lifecycle) describes the three moments when a person's relationship with the business changes in a way that should change what they can reach:

  • Joiner: a person starts, and needs the accounts, access, equipment, and paperwork their role requires.
  • Mover: a person's role, department, manager, location, or employment type changes, and what they hold should change to match.
  • Leaver: a person departs, and everything they hold should be removed, transferred, or recovered.

The model applies to anyone who gets access, not only employees. Contractors, temporary staff, interns, and seasonal workers join, move, and leave too, often faster and with less paperwork, which is why they are a common source of leftover accounts.

JML is not a single piece of software, and it is not the same thing as onboarding with an offboarding checklist stapled to the end. It is a way of organizing the work so that the same facts drive every event. It is also not the access review. The review is the periodic check that runs between events to find whatever the events missed. A well-run lifecycle makes that review short; a poorly run one turns it into the only control that actually works, and a slow one at that.

The three events, in plain terms

Joiner: grant from the role

A joiner event starts when a hire is confirmed in the HR record. From that one fact, the business needs to create accounts, grant the access the role requires, order equipment, assign training and policy sign-offs, and confirm the person is ready on day one. The key idea is that the access comes from the role, not from a manager's email listing what they think the new person might need. The baseline set of access a role receives automatically is often called birthright access. Anything beyond it goes through a request and an approval.

Mover: re-derive from the new role

A mover event starts when something about the person's position changes in the HR record: a new title, a transfer to another team, a new manager, a move from contractor to employee, a promotion into management. The correct response is not "add what the new job needs." It is "work out what the new role should have, compare it with what the person holds today, add the difference, and remove what no longer fits," with a short grace period for handover. Anything the person keeps from the old role becomes a documented exception with an owner and an end date.

Leaver: remove what they actually hold

A leaver event starts when a departure is recorded. Sign-in is cut on schedule, access is revoked in every system, files and records are handed to a named owner before anything is deleted, equipment and licenses are recovered, and a log records that each step happened. The important word is "actually." A leaver should lose what they really hold, which, after a few years and a couple of moves, is usually more than their current role template says.

The three things all three events share

The lifecycle hangs together because the three events read from the same three sources. When those sources are shared, each event is a small variation on the others. When they are not, each event becomes its own project with its own spreadsheet.

One HR trigger set

Every event starts from a change in the HR record: a new hire, a change in position, a departure. Practitioners consistently treat the HR system as the authoritative source for these events, because it is the one place the business already records who works here and in what role. That has a practical consequence: the HR data has to be good enough to act on. Start dates, job codes or titles, departments, managers, and termination dates need to be accurate and entered on time, because the rest of the chain trusts them. Write down exactly which field changes count as a mover event, so that a corrected typo does not trigger a re-derivation and a genuine transfer does.

One role template library

A role template says what a role should receive: which systems, at what level, what equipment, what training. It is the most valuable artifact in the whole lifecycle because every event reads it. Joiners are granted from it. Movers are compared against the old and new templates. Leavers start from it as the minimum list of what to revoke. If onboarding keeps its own list of what a role gets and offboarding keeps another, the two drift apart within months, and nobody can say which is right.

Templates do not have to be perfect or granular to start. Most companies begin with a handful of common roles and a shared baseline everyone receives, then add detail where the risk is: finance, administrators, anyone who can see customer or patient records.

One access record

The third shared source is a current record of who actually holds what, across every system, refreshed often enough to trust. The role template says what a person should have; the access record says what they do have. The gap between the two is where every interesting finding lives: the leftover access from a previous role, the temporary grant that never expired, the account nobody can match to a person. Offboarding needs this record to revoke everything. The mover event needs it to know what to remove. The access review needs it to have anything to review. One record serves all three.

Why running them as three projects breaks

When onboarding, role changes, and offboarding are owned by different teams or built at different times, the same few failures appear.

Each project keeps its own list. Onboarding has a spreadsheet of what each role gets. Offboarding has a checklist of systems to remove. Neither matches the other, and neither matches what people actually hold.

The mover falls between them. Onboarding owns the start date. Offboarding owns the last day. Nobody owns the role change, so it is handled as a series of access requests that add and never remove. Practitioners describe the mover as the stage where lifecycle programs most often leak, and it is easy to see why: nothing in most processes treats "no longer needed" as an event.

Offboarding revokes the template, not the person. A leaver process that removes what the current role template lists will miss everything the person collected in earlier roles, which is exactly the access most likely to be forgotten.

The triggers disagree. Onboarding might start from an offer letter, offboarding from a manager's email, and role changes from nothing at all. When the triggers are different, timing drifts: IT learns about a departure days later, or provisions a new hire before the start date is confirmed.

Evidence is scattered. When an auditor or a customer asks how access is managed, the answer lives in three places in three formats. For companies under a compliance framework, auditors commonly sample recent hires and departures, compare the HR record against the access record and the dates, and check that current access matches the current role. Three disconnected processes make that comparison slow at best.

None of these failures is about effort. Each team can do its own piece well and the lifecycle still breaks, because the pieces were never designed to read from the same facts.

Why the mover is the hard one

The joiner and the leaver have natural deadlines. A new hire cannot work without access, so someone makes sure it arrives. A departure has a last day, and, at least for sensitive systems, someone usually feels the urgency. The mover has no deadline and no visible pain. The person keeps working, now with more access than before, and nobody complains.

Three things make the mover harder than it looks:

  1. It needs both templates and the access record. Re-deriving access means knowing what the old role granted, what the new role grants, and what the person actually holds. A company that has only built onboarding has the first two at best.
  2. Removal needs a decision. Some old access should go on the day of the move. Some should stay for a few weeks while the person hands over work. Someone has to decide, and that someone is usually the new manager, who may not know what the old access was for.
  3. Many changes are not obviously moves. A new manager, a temporary cover arrangement, a project assignment, a shift from part-time to full-time: some should change access and some should not. The rule has to say which.

This is why the user access review guide calls role changes the place access drifts. The fix sits in the lifecycle model rather than in the review: one trigger from the HR record, one re-derivation against the templates, one decision list for the manager, and one dated exception for anything kept.

How mature is your lifecycle? Four stages

It helps to place yourself honestly. Most companies sit somewhere on this path.

  1. Requests and memory. Access is granted by email or ticket, removed when someone remembers, and nobody has a list of what a role gets. Fine for a very small team with few systems. It breaks as soon as people start changing roles.
  2. Checklists per event. Onboarding and offboarding each have a checklist, kept by different teams. Role changes have nothing. This is where most growing companies are, and it works until an audit, a customer security questionnaire, or an incident asks for proof.
  3. Automated ends, shared templates. Joiners and leavers run from the HR record using the same role templates, and the evidence is logged. The mover is still manual. A big step forward, and the point where the mover becomes the obvious next gap.
  4. One system. All three events run from the same triggers, templates, and access record. Movers are re-derived automatically with a manager decision list. Continuous checks catch what slips, and the periodic review is a short confirmation rather than an excavation.

You do not have to reach stage four in one move. Our guide to what to automate first explains how to pick the first piece; for most companies it is either the joiner (if onboarding is visibly painful) or the leaver (if a review has already found leftover accounts). What matters is that whichever piece you build first reads from the shared sources, so the next piece reuses them instead of starting over.

What to write down before you build anything

These are the decisions the whole lifecycle depends on. None of them needs software, and every one of them makes any later build faster.

  1. The trigger rules. Which HR events start a joiner, mover, or leaver event, which fields count as a move, and how contractors and other non-employees are recorded.
  2. The role templates. What each common role receives, plus the baseline everyone gets. Start with your three to five most common roles.
  3. The system inventory. Every application, who owns it, whether it signs in through your identity provider, and whether access can be granted and removed automatically or needs a person.
  4. The mover rule. What is removed on the day of a move, what gets a grace period and how long, and who decides on anything kept.
  5. The exception policy. Who may approve access outside a template, for how long, and what happens when it expires. Exceptions should run through the same kind of approval workflow the business uses elsewhere, so each one has a record.
  6. The leaver tiers. Which departures need an immediate cutoff and which can follow the standard schedule, and who owns the transfer of files and records.
  7. The evidence format. What your auditor, examiner, or largest customers actually ask to see for joiners, movers, and leavers, so the log is built to that shape from the start.

If you only write one of these down, make it the role templates. They are the one artifact every event shares.

When your HR platform and identity provider are enough

Many HR platforms and identity providers include lifecycle features: provisioning from the HR record, role-based assignment, and automatic deactivation on departure. For some companies that is all they need. If nearly every application signs in through your identity provider, your roles are few and stable, role changes are rare, and the built-in features produce evidence your auditor accepts, use them. Put your effort into the role templates and the data quality of the HR record, which matter however the work is automated.

The signals that the built-in features have stopped fitting are consistent:

  • Important systems sit outside single sign-on, so provisioning and deprovisioning there are still manual tickets.
  • Role changes add access and never remove it, and a review has found stacked or conflicting access.
  • Onboarding and offboarding use different lists of what a role gets.
  • Contractors and temporary staff are handled outside the HR record, so their accounts are tracked by memory.
  • Departures reach IT late, or the transfer of files and records is improvised each time.
  • Producing evidence for an audit or a customer means stitching together exports from several systems.

If two or three of those describe you, the lifecycle is costing more than it appears to, in time, in licenses for people who are gone, and in risk nobody is measuring. If none do, we will tell you so on the call.

What one system looks like when you build it

A custom lifecycle build does not replace your HR platform or your identity provider. It reads the triggers from the HR record, holds the role templates and the exception register, keeps the access record current across every system, including the ones outside single sign-on, and runs the three events from those shared sources. The integration work connects each system so access can be read, granted, and removed. The workflow and process automation work encodes the trigger rules, templates, mover rule, exception policy, and leaver tiers. The employee onboarding and offboarding automation use case lists what those builds typically include, and the compliance monitoring automation use case covers the continuous checks that sit on top. Our automated compliance monitoring guide explains how those checks feed a wider compliance program.

An illustrative example. A 300-person home services company with six regional offices hires seasonally, promotes technicians into dispatch and supervisor roles every year, and uses contractors during busy months. Onboarding runs from a checklist owned by HR, offboarding from a separate IT checklist, and role changes from whatever the new manager asks for. Contractors are set up by office managers and rarely removed. An internal review finds former contractors with active accounts in the scheduling system and supervisors who still hold technician access from three promotions ago. A build for this company takes triggers from the HR record (with contractors added to it through a short form), keeps one library of nine role templates, refreshes the access record nightly across its eleven systems, re-derives access on every role change with a two-week handover period and a decision list for the new manager, ends contractor access on the contract end date unless it is extended, and writes one log covering every joiner, mover, and leaver. The next review finds a short list of dated exceptions instead of a list of surprises.

That kind of build typically ships in two to eight weeks from an approved Blueprint, with a working demo every week, and it runs inside one fixed monthly price that covers the build, hosting, maintenance, and ongoing improvements, with nothing to pay up front. Your employee and business data stays yours. How it works walks through the whole process from the first call.

A plan you can start this week

  1. Map your three triggers. Write down what actually starts onboarding, a role change, and offboarding today, and who learns about each one and when. Mismatched triggers are usually the first finding.
  2. Compare the two lists. Put your onboarding list of what a role gets next to your offboarding list of what to remove. Every difference is a gap one of the processes is missing.
  3. Pick five recent movers. For five people who changed roles in the last two years, list what they hold today against what their current role needs. That is the mover gap, measured.
  4. Draft role templates for your most common roles. Three to five is enough to start, plus the baseline everyone receives.
  5. Place yourself on the four stages. Decide which event to fix next, and make sure it reads from the shared templates and access record rather than building its own.

The short version

The joiner, mover, leaver process is one model, not three projects. Joiners are granted from the role, movers are re-derived against the new role with a decision on what to keep, and leavers lose everything they actually hold. All three read from the same HR triggers, the same role templates, and the same access record. Split them up and each keeps its own list, the mover falls through the gap, and offboarding misses the access people collected along the way. Build whichever event hurts most first, but build it on the shared foundation so the other two reuse it.

If you have mapped your triggers and measured your mover gap, bring them to a free discovery call. You will get a straight answer on whether your HR platform and identity provider can carry the whole lifecycle, and if they cannot, a free Blueprint that names the outcome, the plan, and one fixed monthly price.

Have the outcome this article made you think of?

Bring it to a free Outcome Discovery call: 45 minutes, a straight answer, and one fixed monthly price within days if it fits.