User Access Review Automation: Reviews That Actually Finish
The short answer: an automated access review pulls who can reach what from every system on a schedule, compares it against what each person's current role should have, settles the matches automatically, puts only the exceptions in front of a reviewer who can understand them, executes the revocations that result, and writes the whole thing down as evidence. Start with the inventory and the role baseline, because a review built on a typed-up spreadsheet reviews the wrong list. Then add the continuous checks that shrink the review, the role-change trigger that stops access from stacking, and finally the review packets and the proof.
Onboarding grants access and offboarding takes it away. We covered both ends in the employee onboarding automation guide and the employee offboarding automation guide. Between them sits the stretch most companies handle worst: the years in which a person changes roles, covers for colleagues, joins projects, and collects access that nobody ever takes back. The access review is supposed to catch that drift. In most companies it is a quarterly spreadsheet that managers approve in bulk on the last day, and the findings it was meant to prevent arrive anyway. This guide is about making the review real: smaller, more often, decided by people who understand what they are deciding, and finished with revocations that actually happen.
What an access review is, and what it is not
An access review (also called an access recertification or an entitlement review) is a periodic check in which a responsible person looks at what someone can reach and confirms that they still should. The unit of review is the entitlement: one person, one system, one level of access. A review produces three things: a decision per entitlement (keep or remove, with a reason), a revocation for every "remove" that actually lands in the system, and a record of both that an auditor can read later.
It is not the same as onboarding, which grants a role's access from a template, or offboarding, which revokes a departed person's access from one trigger. Those are events. The review is the check that runs between events, and it exists because events are not the only way access changes. Access accumulates through role changes, temporary grants, project work, shared accounts, and administrators doing favors, and none of those fires a trigger. The review is where that accumulation is supposed to be found.
Three parties are involved, and naming them matters. The reviewer decides, usually the manager for a person's access or the system owner for a system's access. The system owner administers the system and executes revocations in it. The program owner (compliance, security, IT, or whoever carries the obligation) runs the cycle and holds the evidence. Manual reviews blur the three, which is one reason they stall.
Why manual reviews get rubber-stamped
Ask anyone who has run one. The spreadsheet goes out with several hundred rows per manager, the rows carry system-level group names nobody outside IT can read, the deadline is in two weeks, and the manager approves everything in one pass because removing something might break a person's work and approving costs nothing today. Four failures sit underneath that scene, and automation has to fix all four.
The list is wrong before it is sent. It was typed or exported by hand from a few systems, weeks before the reviewer sees it. People have changed roles since, applications outside single sign-on are missing, and the rows do not say what role the person is supposed to have, so the reviewer has nothing to compare against.
The reviewer cannot read it. A group called FIN_AP_RW_GRP2 is not a decision anyone can make. A row has to say, in plain language, what the access lets the person do and whether it matches their role.
Approve is the default. When every row needs a decision and nothing is pre-settled, the only way to finish is bulk approval. A review in which approving is free and removing is risky will approve everything, every time.
Decisions do not land. The spreadsheet comes back with twelve "remove" rows, goes into a folder, and the twelve removals become tickets somebody may raise. Months later the same rows are approved again by a different manager.
A review that is accurate, legible, small, and closed with executed revocations is a different thing from the spreadsheet, and it is almost entirely a plumbing problem, which is why it automates well.
Why role changes are where access drifts
Of the three lifecycle events, the role change is the one with no process. A new hire has a start date and a template. A departure has a last day and a revocation list. A role change has a note in the HR system, sometimes, and the access conversation that follows is "what do they need for the new job," never "what from the old job should go." Access is granted additively and almost never re-derived.
Three mechanics drive the drift:
- Grants add; nothing subtracts. A move from field technician to dispatcher adds the dispatcher's access to the technician's. A move from sales to operations keeps the pipeline. Five years and three roles later, one person holds the access of four.
- The trigger never reaches the people who could act. The role change happens in HR, in payroll, or in a manager's head. IT learns about it when the person asks for something new, and the request form has no field for what to remove.
- Temporary is permanent. Access granted to cover a colleague's leave, join a project, or close out a quarter has no expiry date, so it stays. Nobody remembers it was temporary, including the person who has it.
This is the privilege creep that auditors find and that segregation-of-duties conflicts grow out of: the person who moved from accounts payable to purchasing and can now both create a vendor and pay it. The fix is a rule plus a trigger. The rule: a role change re-derives access from the new role, and anything the person keeps from the old role is an exception with a named owner, a reason, and an end date. The trigger: the role change in the HR record fires that re-derivation, the same way a start date fires onboarding. Without the trigger, the review is the only thing that will ever catch the drift, and it will catch it a quarter or a year late. Our guide to the joiner, mover, leaver process explains how that trigger fits alongside onboarding and offboarding as one lifecycle.
The order: what to automate first
1. The entitlement inventory, pulled rather than typed
Everything else depends on one accurate list: every person, every system, every entitlement, as of last night. The workflow pulls it from each system directly, from the identity provider for everything behind single sign-on and from each application's own administration interface or export for everything that is not, and joins it to the HR record so each row carries the person's current role, manager, and status. Where a system cannot be read automatically, its owner gets a scheduled task to upload the current list, with a deadline, so the gap is visible instead of silent.
Two translations happen here. Technical group names become plain-language descriptions, written once per entitlement by the system owner ("can approve vendor invoices up to the department limit"). And accounts are matched to people, which surfaces the first findings before any review runs: accounts with no matching employee, shared accounts with no named owner, and service accounts nobody claims.
This is first because a review of a wrong list is worse than no review. It produces evidence that the wrong things were approved.
2. The role baseline and the exception register
With the inventory in place, write down what each role should have. If you have automated onboarding, these are the role templates you already built. If you have not, this is the moment to build them, and it is the most valuable artifact in the whole program, because onboarding, offboarding, and the review all read from it.
Everything a person holds that is not in their role template becomes an entry in an exception register: what, who holds it, who approved it, why, and when it expires. Most exceptions are legitimate. The register does not forbid them; it makes them visible and gives them an end date. Approval of a new exception runs through the same approval workflow you use for spend, so it has a record from day one.
3. Continuous checks between reviews
Now the comparison can run nightly instead of quarterly. The workflow flags, the day they appear: accounts for people who are no longer employed, access outside the role template with no exception on file, exceptions past their expiry, segregation-of-duties conflicts from your rule list, dormant accounts with no sign-in for a set period, and administrator access added anywhere. Each flag routes to the right owner with a deadline, and each one either becomes a revocation or an approved exception.
This is the step that makes the review small. By the time a review cycle opens, departed accounts and expired exceptions are already gone, and what remains for a human is the judgment call: does this person, in this role, still need this. Our automated compliance monitoring guide treats these checks as the first control to automate in a compliance program; here they are the engine under the review.
4. The role-change trigger
A change to the role, department, or manager in the HR record starts a re-derivation. The workflow computes what the new role's template grants, compares it to what the person currently holds, and produces two lists: access to add, and access from the old role to remove. The additions go through the normal grant path. The removals go to the new manager (and, for sensitive systems, the system owner) as a short decision list with a grace period you set, long enough to finish a handover and short enough that "temporarily" cannot become permanent. Anything the manager keeps becomes a dated exception.
Build this fourth, after the inventory, the baseline, and the checks exist, because it needs all three. Once it runs, drift stops accumulating from its most common source, and the periodic review turns into a confirmation rather than an excavation.
5. The review itself: compiled, scoped, and routed
The review packet is generated, not assembled. The workflow builds one packet per reviewer from last night's inventory, scoped to what that reviewer is responsible for and to the systems in that cycle's tier. Every row carries the plain-language description, the person's role, and a verdict from the checks: matches the role, exception on file (with its reason and expiry), or unexplained. Rows that match the role are pre-settled and shown for information; the reviewer's attention goes to exceptions and unexplained access, which is usually a short list.
A "keep" on an unexplained row requires a reason, which is the opposite of the spreadsheet's incentive. Reminders, escalation to the reviewer's manager at a set point before the deadline, and reassignment when a reviewer leaves are all rules the workflow enforces. A review nobody finished is a review that did not happen, and the program owner can see completion by reviewer, by system, and by day without asking anyone.
6. Revocations executed, and the evidence written
Every "remove" becomes an action, not a note. Where the system allows it, the workflow revokes directly; where it does not, it opens a task for the system owner with a deadline and then re-reads the system to confirm the access is gone. The review for that row stays open until the verification passes. The result, per cycle, is a package an auditor can read without a meeting: the inventory as of the cycle start, every decision with its reviewer, reason, and timestamp, every revocation with its verification, and the exceptions still open with their owners and dates. Our automated compliance reporting guide explains what makes that package acceptable to an auditor and how to assemble it from continuous checks.
Reviews that finish: sizing and cadence
Reviews stall on volume, so size them by risk rather than reviewing everything on one date.
- Tier one, reviewed quarterly or more often: administrator access anywhere, systems that move money or change pay, systems holding customer or patient records, and every exception in the register.
- Tier two, reviewed twice a year: the business applications most roles use, scoped to the rows the checks could not settle.
- Tier three, reviewed annually or by the checks alone: low-risk tools, read-only access, and anything the role template fully explains.
With continuous checks settling the matches and the role-change trigger stopping new drift, a quarterly packet for a manager of twelve people is often a page, not a spreadsheet. The question for each reviewer changes from "approve four hundred rows by Friday" to "here are seven things we could not explain; keep or remove, and why." That review gets done, and done honestly.
Seven things to write down before you automate anything
- The system inventory. Every application, whether it signs in through the identity provider, who owns it, and whether entitlements can be read and revoked automatically or need a person.
- The role templates. What each role should hold, in enough detail to compare against.
- The exception policy. Who may approve access outside a template, for how long, and what happens when it expires.
- The segregation-of-duties rules. The combinations of access one person should not hold, written in plain language before anyone encodes them.
- The review tiers and cadence. Which systems are in which tier, how often each is reviewed, and the deadline and escalation path for a cycle.
- The reviewer rule. Who reviews what: the manager for people, the system owner for systems, and what happens when the two disagree or the reviewer is the person being reviewed.
- The evidence format. What the auditor, examiner, or customer actually asks for, so the package is built to that shape from the first cycle.
If the role templates do not exist, start there. They are the shared foundation for onboarding, role changes, offboarding, and the review, and every one of those gets easier once the templates are written down.
When your identity provider is enough, and when it is not
Many identity platforms and HR suites include an access review feature, and for some companies it is sufficient. If nearly every application sits behind single sign-on, the roles are few and stable, and the built-in review produces decisions your auditor accepts, use it and put your effort into writing the role templates.
The signals that the built-in feature has stopped fitting are consistent:
- Important systems sit outside single sign-on, so the built-in review cannot see them and a spreadsheet fills the gap.
- Reviewers approve in bulk, and nobody can show a revocation that resulted from the last cycle.
- Role changes do not remove anything, and a recent audit or internal review found stacked or conflicting access.
- Exceptions are tracked in email, or not tracked.
- The review packet is a group name and a yes-or-no column, with no role to compare against.
- A customer contract, framework, or examiner requires provable, timely reviews with executed revocations, and assembling the proof takes weeks.
If two or three of those describe you, the review is costing more than it returns and protecting less than it appears to. If none do, we will say so in discovery.
What a custom access review build looks like
A custom build does not replace the identity provider or the HR system. It reads from both, reaches the applications they do not, and runs the loop they cannot: pull, compare, flag, route, revoke, verify, record. The integration work connects every system in the inventory so entitlements can be read and revocations executed; the workflow and process automation work encodes the role templates, exception policy, tiers, reviewer rules, and escalations. If you have already built onboarding or offboarding automation, the role templates and most of the connections exist, and the review is largely the comparison and the packets on top of them. The employee onboarding and offboarding automation and compliance monitoring automation use cases list what those builds typically include.
An illustrative example. A 240-person community bank with nine branches runs quarterly access reviews on spreadsheets exported from its core banking platform, its loan origination system, and its wire platform, with eleven other applications reviewed from memory or not at all. Tellers become personal bankers and personal bankers become lenders, and nobody removes the old role's access, so an examiner found a lender who could still post teller transactions and a branch manager with administrator rights left over from a system migration. Each quarter's review takes six weeks, and the removals it produces are tickets that get raised in some quarters and not in others. A build for this bank pulls entitlements nightly from all fourteen systems and joins them to the HR record, encodes eleven role templates and the bank's segregation-of-duties rules, fires a re-derivation from every role change in HR with a ten-business-day grace period, keeps an exception register with expiries, flags orphaned, conflicting, and expired access the day it appears, generates quarterly tier-one packets for thirty managers with the matches pre-settled, executes and verifies every removal, and produces the examiner's package from the system in a day. The next review cycle closes in nine days, and the exceptions the examiner sees have owners and dates.
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
- Pull your last review. Count the rows, the decisions that said remove, and the removals you can prove happened. That gap is the business case.
- Pick five people who changed roles in the last two years. List what they can reach today against what their current role needs. Expect stacked access; that is the role-change finding, found before an auditor finds it.
- Start the system inventory. Every application, whether it is behind single sign-on, who owns it, and whether its entitlements can be read automatically.
- Draft role templates for your three most common roles. Imperfect is fine; the review will correct them.
- Decide configure versus build. Try the inventory and the templates against your identity provider's review feature. Count the systems it cannot see and the rules it cannot express. Those gaps are the scope of a custom build.
The short version
Automate the access review by pulling the inventory instead of typing it, writing role templates and an exception register as the baseline, running the comparison nightly so departures and expired exceptions are gone before anyone reviews anything, firing a re-derivation from every role change so access stops stacking, generating small plain-language packets by risk tier, and closing every remove with an executed, verified revocation and a record. Role changes are where access drifts; the trigger, not the review, is what stops it.
If you have the last-review count and the five role-change cases, bring them to a free discovery call. You will get a straight answer on whether your identity provider and HR platform can carry the review, and if they cannot, a free Blueprint that names the outcome, the plan, and one fixed monthly price.