Identity Lifecycle Management: The Complete Guide for 2027
Identity lifecycle management (ILM) is the practice of creating, changing, and removing an identity's access as its relationship with the organization changes. It covers every joiner, mover, and leaver event for employees, contractors, service accounts, and AI agents, and it keeps a record of each change so access always matches current need.
Done well, identity lifecycle management means new hires work on day one, role changes don't leave old access behind, and departures close every account the same day. Done by ticket and spreadsheet, it produces the orphaned accounts and privilege creep that show up in audits and breach reports. This guide covers each lifecycle stage, how HR-driven automation works, how to handle contractors and AI agents, the metrics to track, and examples from four industries.
See how C1.ai automates the identity lifecycle. Explore C1 Lifecycle
What is identity lifecycle management?#
Identity lifecycle management governs an identity from the moment it's created to the moment it's retired. In practice that means four things:
- Creating the identity from an authoritative source, usually the HR system, with the attributes that decide access: role, department, manager, location, and employment type.
- Granting baseline access automatically, then handling requests for anything beyond it.
- Changing access when the identity's attributes change, removing what no longer fits as well as adding what's new.
- Removing access across every connected system when the relationship ends, then confirming nothing was missed.
People also call this user lifecycle management or account lifecycle management. The terms overlap. User lifecycle management usually means the workforce; account lifecycle management focuses on the accounts inside each application. Identity lifecycle management is the broader term, because it includes identities that aren't people.
Here's how ILM relates to the terms around it:
| Term | What it covers | Relationship to ILM |
|---|---|---|
| Joiner-mover-leaver (JML) | The three workforce events that trigger lifecycle changes | The core events ILM responds to |
| Provisioning and deprovisioning | Creating and removing accounts and entitlements in target systems | The mechanism ILM uses to make changes |
| Identity governance and administration (IGA) | Lifecycle, access requests, access reviews, separation of duties, and audit evidence | ILM is one part of IGA |
The identity lifecycle at a glance#
Diagram (designer brief): a loop with five stages and the trigger for each. Rendered version below for reference; final art should match the C1.ai design system.
flowchart LR
A[Create<br/>HR record or owner request] --> B[Join<br/>birthright access on day one]
B --> C[Request<br/>policy-approved extra access]
C --> D[Move<br/>role, team, or manager change]
D --> E[Review<br/>periodic and event-driven]
E --> D
D --> F[Leave<br/>revoke everywhere, confirm]
E --> F
Why identity lifecycle management matters#
Every access problem auditors and attackers look for traces back to a lifecycle event that didn't finish. Identity lifecycle management matters for three reasons.
Security. Accounts that outlive the person or purpose behind them are easy footholds, because nobody notices when they're used. Access that piles up across role changes widens what a single compromised account can reach. Automating the leaver and mover events closes both gaps at the source.
Compliance. HIPAA, PCI DSS, SOX, and SOC 2 all test whether access ends when it should and whether you can prove it. A lifecycle program that records each grant and removal, with timestamps and results, turns that proof into a report instead of a reconstruction.
Productivity. A new hire who waits a week for access loses a week. So does a team whose transferred engineer can't reach the new repo. When HR events start lifecycle workflows directly, IT stops working tickets for routine access and people start work on day one.
The stages of the identity lifecycle: joiner, mover, leaver#
Most lifecycle work happens at three events. Each has a clear definition of done and a predictable way to fail. For a deeper breakdown of each phase, see identity lifecycle management phases.
Joiner: access on day one, and only what the role needs#
A joiner event starts when HR records a hire. The identity gets created, birthright access goes to every system the role requires, and anything beyond that goes through a request with an owner's approval.
- Done looks like: the new hire signs in on day one to everything their role needs, with no tickets.
- Common failure: copying a teammate's access. It's fast, but it hands the new hire everything their teammate has accumulated over years.
Mover: recalculate access, don't just add to it#
A mover event starts when a job title, department, manager, location, or employment type changes. The new role's access gets granted, and the old role's access gets removed after a defined handoff window.
- Done looks like: within a set window, the person holds the new role's access and nothing left over from the old one.
- Common failure: adding the new access and never removing the old. This is how privilege creep builds, and it's the stage most teams automate last.
Leaver: revoke everywhere, then prove it#
A leaver event starts when HR records a termination date. Access gets removed across every connected system at the right moment (immediately for involuntary departures, at end of day for planned ones), accounts get disabled or deleted, and owned resources move to a new owner.
- Done looks like: every account is disabled within your target time, and a record shows each action and its result.
- Common failure: offboarding only from the identity provider. Apps outside SSO, local accounts, API keys the person created, and shared credentials stay live.
Review: confirm access still fits between events#
Not every change shows up as an HR event. People pick up access through requests, projects, and exceptions. Periodic and event-driven access reviews catch what the joiner, mover, and leaver workflows don't, and feed revocations back into the same lifecycle so removals are recorded the same way. For how review automation works, see the guide to user access review software.
Turn HR events into lifecycle workflows. Book a demo or see how C1.ai automates onboarding and offboarding.
HR-driven identity lifecycle management#
HR-driven lifecycle management uses the HR system as the source of truth. When HR records a hire, a change, or a termination, that event starts the matching workflow automatically, so IT isn't waiting on an email or a ticket.
Three things make HR-driven lifecycle work:
- Clean attributes. Automation is only as accurate as the data behind it. If job titles are inconsistent ("VP Sales" and "Sales Vice President") or the manager field is empty, role-based rules break. Standardize the attributes that drive access before you automate.
- Events, not just syncs. A nightly sync tells you a field changed. An event tells you why: a promotion, a transfer, a leave of absence, a termination. Each needs a different workflow.
- Rules for the edge cases. Decide in advance what happens for rehires, conversions from contractor to employee, leaves of absence, future-dated terminations, and people who hold two roles.
C1.ai connects HR systems and directories so a join, role change, leave, or departure starts the matching governance workflow (C1.ai).
Lifecycle management for contractors and non-employees#
Contractors, vendors, interns, and partners often aren't in the HR system, so HR-driven automation doesn't see them. That's why they're a common source of accounts that outlive their purpose. Three controls close the gap:
- A named sponsor. Every non-employee identity has an employee who sponsors it, approves its access, and gets asked when it should end.
- An end date at creation. Access expires on a set date unless the sponsor extends it. PCI DSS v4.0 requires third-party remote access accounts to be enabled only for the time needed and disabled afterward (PCI DSS v4.0 Requirement 8.2.7, PCI Security Standards Council; summarized by Microsoft Learn).
- A source of record. Pull non-employees from a vendor management system or a dedicated directory, so they move through the same joiner, mover, and leaver workflows as employees.
Lifecycle management for AI agents and service accounts#
Non-human identities (NHIs) and AI agents need lifecycle management too, and in most environments they now outnumber people. In C1.ai's 2026 Future of Identity survey of 508 IT and security leaders, 47% said non-human identities outnumber human users, and 95% said AI agents already perform autonomous IT or security tasks (C1.ai).
These identities don't have an HR record, a manager, or a termination date, so the lifecycle has to be anchored to something else:
| Stage | For people | For AI agents and service accounts |
|---|---|---|
| Create | HR record | Registration with a named human owner and a stated purpose |
| Join | Birthright access by role | Least-privilege scopes for that purpose only |
| Move | Role change | Purpose change, new tools, or a change of owner |
| Review | Periodic access review | Same campaigns as people, with the owner as reviewer |
| Leave | Termination date | Owner leaves, project ends, or the agent is retired |
Retirement is where NHI lifecycles fail most. OWASP ranks improper offboarding as the top risk in its Non-Human Identities Top 10, describing it as service accounts and access keys that aren't deactivated when they're no longer needed (OWASP). Two rules help: when a person leaves, review every non-human identity they own, and when an application is retired, retire its credentials with it.
C1.ai manages the lifecycle of the workforce, agents, and enterprise resources in one product, and offboarding flows surface access the workflow missed (C1.ai). For more, see the guide to non-human identity management.
Identity lifecycle management examples by industry#
The stages are the same everywhere. What changes is which events matter most and what auditors check.
Healthcare#
Clinicians, residents, and agency staff rotate between departments and facilities, which makes the mover event the busiest one. On the leaver side, the HIPAA Security Rule calls for procedures to terminate access to electronic protected health information when a workforce member's employment or other arrangement ends (45 CFR 164.308, eCFR). Lifecycle automation ties EHR access to the HR record so a department transfer changes access the same day.
Retail and payments#
Seasonal hiring brings large joiner and leaver waves at predictable times of year. For systems in scope for PCI DSS v4.0, terminated users' access has to be revoked immediately, and inactive accounts have to be removed or disabled within 90 days (Requirements 8.2.5 and 8.2.6, PCI Security Standards Council; summarized by Microsoft Learn). Retailers use end dates on seasonal identities and scheduled inactivity checks so both happen without a ticket.
Higher education#
A single person can be a student, a teaching assistant, an employee, and later an alumnus, sometimes holding more than one role at a time. Lifecycle rules need to handle overlapping roles, keep alumni email while removing student-system access, and process a large leaver event at graduation.
Technology and SaaS#
Fast-growing companies add new apps and new hires every week, so speed to day-one access matters as much as clean offboarding. Qualtrics uses C1.ai to onboard new employees in under an hour (vendor-reported) (C1.ai).
Common identity lifecycle management challenges#
Even teams with a lifecycle tool in place run into the same few problems.
Apps outside SSO. The identity provider offboards what it knows about. Finance tools, legacy apps, and anything with local accounts need their own connectors, or offboarding stops halfway. Start by listing every app with its own login and decide how each one gets deprovisioned.
Messy HR data. Missing managers, inconsistent titles, and late termination entries all break automation. Agree with HR on which fields drive access, who owns their accuracy, and how fast terminations get entered.
Mover cleanup. Removing old access is harder than granting new access, because it requires knowing which entitlements came from which role. Role-based access profiles make the calculation possible: when the role changes, access recalculates to the new profile.
Unowned non-human identities. Service accounts and agents created by someone who has since left have no one to approve, review, or retire them. Run an ownership sweep, assign every one a current owner, and make ownership transfer part of the leaver workflow.
Manager fatigue. Managers asked to approve and review constantly start approving everything. Send them fewer, better-scoped decisions in the tools they already use, and let policy handle routine access.
Identity lifecycle management metrics to track#
Pick a handful of metrics, record a baseline before you automate, and report them monthly.
| Metric | What it tells you | Direction |
|---|---|---|
| Time to provision | How long a new hire waits for day-one access | Down |
| Time to deprovision | How long a leaver's access stays live after their end time | Down |
| Orphaned accounts | Active accounts with no matching active identity | Down |
| Mover residual access | Old-role entitlements still held 30 days after a role change | Down |
| Lifecycle events completed without a ticket | How much of JML is truly automated | Up |
| Non-human identities without an owner | NHIs and agents that no one is accountable for | Down |
| Audit evidence prep time | Hours spent assembling lifecycle evidence for an audit | Down |
For a step-by-step rollout plan and how to set targets, see how to implement an identity lifecycle management program.
Tools that automate identity lifecycle management#
Three kinds of tools handle lifecycle work, and many organizations use more than one:
- Identity providers create and remove accounts in apps connected to SSO. They're a good start, but they usually don't cover apps outside SSO, mover cleanup, or non-human identities.
- IGA platforms run the full lifecycle across SaaS, cloud, and on-prem systems, and tie it to access requests, access reviews, and audit evidence.
- HR-driven provisioning tools connect the HR system to a directory and handle the joiner and leaver basics for smaller environments.
When you compare tools, test the mover event and the leaver confirmation, not just onboarding. Ask each vendor to show a role change that removes old access, an offboarding that reaches an app outside SSO, and the record of both. For a side-by-side comparison, see the best identity lifecycle management solutions.
How C1.ai handles it. C1 Lifecycle turns authoritative events into onboarding, role changes, and offboarding across connected systems, recalculates access when roles change, and finds what offboarding missed (C1.ai). Teams can draft a lifecycle flow from a description and add custom logic with Functions, and people and agents can request resources through policy-driven self-service (C1.ai).
FAQ#
What is identity lifecycle management?#
Identity lifecycle management is the practice of creating, changing, and removing an identity's access as its relationship with the organization changes. It covers joiner, mover, and leaver events for employees, contractors, service accounts, and AI agents, and records every change for audit.
What is the difference between identity lifecycle management and IGA?#
Identity lifecycle management handles access as identities join, move, and leave. Identity governance and administration (IGA) includes lifecycle management plus access requests, access reviews, separation of duties, and audit evidence.
What is user lifecycle management?#
User lifecycle management is identity lifecycle management applied to the workforce: onboarding, role changes, and offboarding for employees and contractors. It's often driven by the HR system as the source of truth.
What is account lifecycle management?#
Account lifecycle management focuses on the accounts inside each application: creating them, changing their permissions, and disabling or deleting them. It's the application-level part of identity lifecycle management.
How do you manage the lifecycle of AI agents?#
Give every agent a named human owner and a stated purpose at creation, grant only the access that purpose needs, review it in the same campaigns as people, and retire its credentials when the purpose ends or the owner leaves.
Which stage of the identity lifecycle is hardest to automate?#
The mover stage. Adding new access is easy; removing the old role's access requires knowing which entitlements came from which role. Most privilege creep starts at unfinished mover events.
What is C1.ai?#
C1.ai, formerly ConductorOne, is an AI-native identity governance platform that manages lifecycle, access requests, access reviews, and compliance for humans, non-human identities, and AI agents (C1.ai).
Onboard instantly. Offboard completely. Book a demo or see how C1.ai automates the identity lifecycle.
Related: Identity lifecycle management phases · Best identity lifecycle management solutions
Sources#
All sources accessed November 6, 2026.
- C1.ai: C1 Lifecycle, C1 Identity Governance, 2026 Future of Identity Report, Qualtrics
- OWASP: Non-Human Identities Top 10, 2025
- HIPAA Security Rule: 45 CFR 164.308, eCFR
- PCI DSS v4.0 Requirement 8: PCI Security Standards Council document library, Microsoft Learn, PCI DSS Requirement 8
Last updated: November 9, 2026


