Access Control Review Template
A template for auditing user access rights, verifying least privilege, and documenting access decisions across systems and teams.
Overview
Access reviews are the recurring hygiene check that keeps an access control policy honest: every quarter (or month, for privileged access) someone goes through the access register and asks of each entry “is this still justified?”. This template structures that review — who reviews what, what evidence to record, how findings turn into remediation, and how the attestation becomes audit-proof. It supports SOC 2, ISO 27001, and PCI-DSS review requirements by documenting who has access, the justification behind it, and whether it’s still needed.
The review verifies the controls defined in your access control policy — the policy says what should exist; the review proves it does. For the data-collection side, the User Access Audit Template covers extracting the access snapshot this review consumes. The two documents answer different questions: the audit asks “what access exists right now?” — a point-in-time inventory with certification of the current state. This review asks “is that access still justified, and what do we do about what we find?” — the recurring cycle of decisions, findings, remediation, and attestation that audits feed into.
When to Use
- During quarterly or annual access reviews.
- Before an external audit or certification.
- After a role change, termination, or reorganization.
- When onboarding or offboarding a sensitive system.
- After detecting an account with excessive privileges.
Prerequisites
- An authoritative list of systems, roles, and users.
- Access to identity provider logs or role management APIs.
- A defined policy for least privilege and role lifecycle.
- A reviewer who is a manager or system owner, not the user being reviewed.
Solution
Template
1. Review Scope
| Field | Description | Example |
|---|---|---|
| System or application | Resource under review | Production database |
| Review period | Start and end date | Q2 2026 |
| Reviewer | Person accountable | Engineering manager |
| Review date | When the attestation is performed | 2026-06-27 |
| Sample size | Number of users reviewed | 42 |
2. User Access Register
| User | Role | Permissions | Business Justification | Still Needed? | Reviewer Notes |
|---|---|---|---|---|---|
| alice@example.com | db-admin | Read, write, schema | Database maintenance | Yes | Valid |
| bob@example.com | read-only | Read | Reporting | No | Account to be disabled |
| deploy-bot | service | Deploy to production | CI/CD pipeline | Yes | Managed by IAM role |
3. Service Account Checklist
| Account | Purpose | Last Used | Key Rotated | Action Required |
|---|---|---|---|---|
| backup-sa | Nightly backups | 2026-06-26 | Yes | None |
| integration-sa | Third-party sync | Never | No | Review or remove |
| monitoring-sa | Metrics ingestion | 2026-06-27 | Yes | None |
4. Findings and Actions
| Finding ID | Description | Severity | Owner | Due Date | Status |
|---|---|---|---|---|---|
| AC-01 | Two users with admin access never use it | Medium | IAM team | 2026-07-04 | Open |
| AC-02 | Orphan account from former contractor | High | Security | 2026-06-30 | Open |
| AC-03 | Missing MFA on three privileged accounts | High | Identity team | 2026-07-02 | Open |
5. Attestation
| Field | Value |
|---|---|
| Reviewer name | Alice Rivera |
| Role | Engineering manager |
| Date | 2026-06-27 |
| Outcome | Approved with conditions |
| Conditions | Remove two orphan accounts and enforce MFA within 5 days |
| Next review date | 2026-09-27 |
Explanation
The review separates identification of access from approval. By listing every account, its role, justification, and necessity, reviewers can spot privilege creep, orphan accounts, and missing MFA. The attestation step creates an audit trail that proves compliance to an auditor.
The design detail that matters is who reviews. A reviewer’s job is to catch what the system can’t: whether the access still makes sense for the person’s actual work. That’s why the template insists the reviewer be a manager or system owner and never the account holder — self-review certifies whatever already exists. It’s also why each register row forces a justification field: “yes” is free, but writing “Alice needs schema access because she owns the migration pipeline” is the act of thinking the review exists to produce.
The attestation is the deliverable. Everything else — the snapshot, the register, the findings — exists to support the signed statement “I reviewed this access on this date, and here’s what I found and what was decided.” Auditors anchor on it: the attestation is what turns a spreadsheet exercise into evidence. That’s why conditions belong in the attestation itself (“remove two orphan accounts and enforce MFA within 5 days”) rather than in a follow-up email — a condition without a record is a finding nobody will verify got fixed.
Why Reviews Fail
Reviews die two deaths. The first is rubber-stamping: the reviewer approves 500 rows in one sitting, which means nobody actually read them — a review where 100% of access is approved with zero comments is evidence the process isn’t operating, not that access is clean. Fix it by shrinking scope (tiered frequency, sampling) and by requiring a written reason per row.
The second death is findings without remediation: the review happens, findings get logged, and nobody owns fixing them, so the next review finds the same orphan accounts. Fix it by treating every finding as a ticket with an owner and a due date — the attestation isn’t complete until findings have a remediation path.
There’s also a subtler failure: reviewing the wrong data. If the access snapshot comes from a manual spreadsheet updated “when someone remembers,” the review certifies a fantasy. Automation — IdP exports, IAM APIs, the scripts in this template — is what turns the review from a quarterly ritual into a real control.
Review Frequency by Risk Tier
Not everything deserves the same cadence. Tier the review by what a mistake costs:
| Access tier | Examples | Frequency | Reviewer |
|---|---|---|---|
| Privileged | Admins, prod deploy, break-glass, database admin | Monthly | CISO or security lead |
| Service accounts | CI/CD bots, integrations, API keys | Quarterly | Technical owner |
| Standard users | Employees with role-based access | Quarterly (or 10-15% sample) | Direct manager |
| External | Contractors, vendors, partners | Monthly + expiry enforcement | Sponsor manager |
| Dormant | Accounts unused 30+ days | Monthly, auto-disable | Automated + IT spot-check |
The tiering solves the two failure modes: reviewing everything too rarely (annual reviews miss a year of privilege creep on admin accounts) and reviewing everything too often (fatigue turns reviews into rubber-stamping). A review calendar with owners per tier keeps the cadence honest — the calendar belongs to compliance, not to each team’s memory.
Variants
The same template adapts to narrower scopes — keep the structure, shrink the register:
- Privileged access review: Focuses only on administrators, root accounts, and break-glass credentials. Higher frequency, tighter findings SLAs.
- Application-level review: Reviews roles and permissions inside a single application rather than infrastructure. Useful when one system has its own permission model (Salesforce, GitHub org, Kubernetes cluster).
- Cloud IAM review: Targets AWS, Azure, or GCP roles, policies, and groups. The automation scripts below are built for this variant.
- Contractor review: Reviews time-bounded access and expiration dates — every contractor account should have an expiry at provisioning time, and this review verifies the expiry exists and fires.
What Works
- Review privileged access monthly, standard access quarterly. Annual cadence lets privilege creep compound for twelve months — quarterly catches it while remediation is still cheap.
- The reviewer is a manager or system owner, never the account holder. Self-review certifies whatever already exists; independence is the control.
- Auto-disable dormant accounts. Inactivity is the cheapest signal an account is unnecessary — a 30-day dormancy rule removes most orphan-account work before the review even starts.
- Require MFA on every privileged account. No exceptions without a documented expiry — most “temporary” exemptions outlive the reason they were granted.
- Remove access on the last day, not the week after. The 24-hour offboarding window exists because departed-employee credentials are the highest-value dormant credential an attacker can find.
- Keep attestation records a year minimum. The previous review’s attestation is what auditors compare against — recurring findings across cycles are the signal.
Common Mistakes
- Reviewing access without checking the account is still active — attesting to permissions on a disabled account is a false positive that wastes the row.
- Allowing self-review — it certifies the status quo; independence is what makes a review a review.
- Keeping broad access after a role change — the classic privilege-creep finding; fix the transfer process, not just the account.
- Skipping service accounts and API keys — they’re the least-reviewed and most-abused category.
- Missing cloud console access when reviewing application roles — the app review says “read-only,” the console says admin.
Common Findings and How to Remediate
Most reviews surface the same handful of problems. Knowing the standard remediation for each keeps the findings table actionable instead of a list of complaints.
Privilege creep. The most common finding: a user changed teams twice and kept every role they ever had. Remediation is role hygiene, not a one-time revocation — fix the transfer process so old access is removed when new access is granted, or you’ll be logging the same finding next quarter.
Orphan accounts. Accounts whose owner left, whose project ended, or whose purpose nobody can explain. Default action: disable immediately, delete after a grace period (30-90 days covers the “wait, that was running the nightly report” discovery). Document the deletion — auditors ask what happened to orphan accounts found in previous reviews.
Standing privileged access. Admins with permanent production access when a just-in-time flow exists. The remediation is process change (move to JIT elevation), not revocation — the access is often legitimate, the standing part is the problem.
Missing MFA on privileged accounts. Usually a handful of accounts created before the MFA requirement or exempted “temporarily.” Fix the accounts and fix the exemption process — expired exemptions that never expired are the usual root cause.
Unreviewed service accounts. The script output nobody owned. Every service account needs a named owner and a purpose line in the register; accounts without either get flagged for review or removal. Rotate the credentials of any account that survives review — the review is the natural rotation checkpoint.
Shared and generic accounts. A finance-readonly login that three analysts share defeats individual accountability — actions can’t be attributed, and offboarding one person leaves the credential alive. Remediation is splitting access back to named accounts; where sharing is genuinely required (a kiosk, a break-glass credential), record it as an exception with an owner and an expiry instead of pretending it doesn’t exist.
Preparing Evidence for Auditors
The review document is half the deliverable; the other half is the evidence trail that proves it happened the way the document says.
What auditors actually pull. The access snapshot used for the review (or proof it was fresh), the completed register with per-row decisions, remediation tickets created from findings, and the signed attestation. Timestamped artifacts beat narrative descriptions — a remediation ticket closed before the review date is stronger evidence than a sentence saying “access was removed.”
Common audit questions to pre-answer. How was the reviewer chosen (independence from the reviewed users)? What happened to findings from the previous review (do they recur)? How are exceptions documented? If your attestation says “approved with conditions,” the conditions and their resolution are the first thing sampled.
Retention. Keep each review’s full evidence package — snapshot, register, findings, attestation — for at least a year, or per your framework’s requirement. The annual policy review uses these artifacts; losing them means reconstructing a year of access decisions from memory.
Running the Review
A review that starts with “everyone look at your access” produces a spreadsheet nobody finishes. The process that works runs in four stages:
1. Prepare the data. Pull a fresh access snapshot — from the IdP, from each system’s role API, or from the automation scripts below. The snapshot is the review’s ground truth; a review run on a stale export certifies a state that no longer exists. Include service accounts and API keys explicitly — they’re the most-skipped category and the highest-risk one.
2. Scope it. You don’t have to review everything every cycle. Tier by risk: all privileged access every cycle (monthly), all service accounts quarterly, standard user access quarterly or by sampling. Sampling is legitimate — a 10-15% sample of standard users catches systemic problems (a team whose transfers never lose old access) without reviewing thousands of rows.
3. Review and record decisions. Each row gets a verdict: keep, modify, or remove — with a reason. “Yes” without a justification is what auditors flag; the value is in the reviewer writing why access is still needed. Watch for the usual findings: privilege creep (user accumulated roles through transfers), orphan accounts (owner left or project ended), missing MFA on privileged accounts, and access granted “temporarily” that never expired.
4. Remediate and attest. Every finding becomes a ticket with an owner and a due date — the findings table above exists for exactly this. The review closes when the attestation is signed with any conditions recorded. An attestation without findings recorded is evidence the review was rubber-stamped.
Cadence check. A review that consistently finds zero problems usually means one of three things: access is genuinely clean (rare), the scope is wrong (the risky systems aren’t in the snapshot), or the reviewer is approving without reading (most common). Zero-finding streaks deserve the same scrutiny as bad findings.
Connecting the Review to the Policy
The review doesn’t exist in isolation — it’s the operational half of the access control lifecycle. The access control policy defines what access should look like (roles, MFA rules, offboarding SLAs); the review is the periodic proof that reality matches. When the same finding shows up in consecutive reviews — privilege creep every quarter, for instance — that’s not a review problem, it’s a policy problem: the transfer process defined in the policy isn’t working, and the fix belongs upstream in the policy, not in another round of revocations.
The same feedback loop runs in the other direction. Findings from the review feed the next policy revision: repeated MFA gaps argue for tighter enrollment at provisioning, recurring orphan accounts argue for automated offboarding triggers, and a growing list of exceptions argues the policy itself needs an exceptions section rather than pretending they don’t exist. A mature program treats the review report as the input to the annual policy update — the document you refine each year because the findings tell you where the rules meet reality.
And when the audit lands, the review history is the story you tell: three or four consecutive cycles, each with a snapshot, decisions, findings, and a signed attestation, prove a control that works over time — the difference between “we’ve got a policy” and “we run one.”
A note on scope creep in the other direction: the review verifies access, it doesn’t grant it. Requests for new access belong in the provisioning process, not in review findings — mixing the two turns the review into a bottleneck and the findings table into a request queue.
The same holds for remediation depth: the review decides whether access should change; how the change gets executed (which admin revokes it, which ticket system tracks it) lives in your IAM runbooks, not in the attestation.
Automation Scripts
Automated access review with AWS IAM Access Analyzer
Use AWS IAM Access Analyzer to detect unused permissions and generate findings for review:
#!/bin/bash
set -euo pipefail
# Generate access analyzer findings
ACCOUNT_ID=$(aws sts get-caller-identity --query Account --output text)
# List all IAM users and their last activity
echo "=== IAM Users Last Activity ==="
aws iam get-account-authorization-details --output json | \
jq -r '.UserDetailList[] | {
user: .UserName,
groups: (.Groups | join(", ")),
policies: (.AttachedManagedPolicies | map(.PolicyName) | join(", ")),
last_used: .PasswordLastUsed
}'
# Check for unused access keys
echo ""
echo "=== Unused Access Keys (>90 days) ==="
for user in $(aws iam list-users --query 'Users[].UserName' --output text); do
aws iam list-access-keys --user-name "$user" --output json | \
jq -r '.AccessKeyMetadata[] | select(.Status=="Active") | "\(.UserName) \(.AccessKeyId) \(.CreateDate)"'
done
# Generate unused permissions report
echo ""
echo "=== IAM Access Analyzer Findings ==="
aws accessanalyzer list-findings --analyzer-arn "$ANALYZER_ARN" --output json | \
jq -r '.findings[] | select(.status=="ACTIVE") | {
resource: .resource,
finding: .findingType,
principal: .principal
}'
GitHub organization access audit script
Audit GitHub organization members and their repository access with the GitHub API:
#!/usr/bin/env python3
"""Audit GitHub org access and flag inactive members."""
import requests
import sys
from datetime import datetime, timedelta
ORG = "your-org"
TOKEN = sys.argv[1] if len(sys.argv) > 1 else ""
HEADERS = {"Authorization": f"token {TOKEN}", "Accept": "application/vnd.github+json"}
def get_org_members() -> list:
resp = requests.get(f"https://api.github.com/orgs/{ORG}/members", headers=HEADERS)
return resp.json()
def get_user_activity(username: str) -> dict:
resp = requests.get(
f"https://api.github.com/users/{username}/events",
headers=HEADERS,
params={"per_page": 1},
)
events = resp.json()
if events:
last_event = datetime.strptime(events[0]["created_at"], "%Y-%m-%dT%H:%M:%SZ")
days_inactive = (datetime.utcnow() - last_event).days
return {"username": username, "last_active": events[0]["created_at"], "days_inactive": days_inactive}
return {"username": username, "last_active": "never", "days_inactive": 999}
def audit_members() -> None:
members = get_org_members()
print(f"Total org members: {len(members)}\n")
print(f"{'Username':<25} {'Last Active':<25} {'Days Inactive':<15} {'Status'}")
print("-" * 80)
threshold = 90
for member in members:
username = member["login"]
activity = get_user_activity(username)
status = "REVIEW" if activity["days_inactive"] > threshold else "OK"
print(f"{username:<25} {activity['last_active']:<25} {activity['days_inactive']:<15} {status}")
if __name__ == "__main__":
audit_members()
Kubernetes RBAC audit with kubectl
Audit Kubernetes RBAC bindings and identify over-privileged subjects:
#!/bin/bash
set -euo pipefail
echo "=== ClusterRoleBindings with cluster-admin ==="
kubectl get clusterrolebindings -o json | \
jq -r '.items[] | select(.roleRef.name=="cluster-admin") | "\(.metadata.name) -> \(.subjects[].name // "unknown")"'
echo ""
echo "=== RoleBindings per namespace ==="
for ns in $(kubectl get namespaces -o jsonpath='{.items[*].metadata.name}'); do
echo "--- Namespace: $ns ---"
kubectl get rolebindings -n "$ns" -o json | \
jq -r '.items[] | "\(.metadata.name): role=\(.roleRef.name) subjects=\([.subjects[].name] | join(", "))"'
done
echo ""
echo "=== Service accounts with secrets ==="
kubectl get serviceaccounts --all-namespaces -o json | \
jq -r '.items[] | select(.secrets != null and (.secrets | length > 0)) | "\(.metadata.namespace)/\(.metadata.name)"'
Advanced Techniques
- For a deeper guide, see Compliance Gap Analysis Template.
- Implement just-in-time access for privileged operations. Instead of granting permanent admin access, use just-in-time elevation with approval and time limits. That shrinks the standing attack surface and every elevation leaves an audit record:
# Teleport role: temporary admin access with approval
kind: role
metadata:
name: jit-admin
spec:
allow:
node_labels: "*"
max_session_ttl: 4h
require_session_join: true
- Use access review dashboards for continuous visibility. Build a dashboard that shows access metrics in real time, such as number of privileged accounts, inactive accounts, and MFA coverage:
-- Query: privileged accounts without MFA
SELECT u.username, u.role, u.last_login
FROM users u
LEFT JOIN mfa_enrollments m ON u.id = m.user_id
WHERE u.role IN ('admin', 'operator') AND m.id IS NULL
ORDER BY u.last_login DESC;
Service Accounts and Automation Pitfalls
- Not reviewing service accounts and machine identities. Service accounts often accumulate permissions over time and are rarely reviewed. Include them in every access review cycle and verify their last usage:
# Check last used date for AWS access keys
aws iam list-access-keys --user-name deploy-bot --query 'AccessKeyMetadata[].{Key:AccessKeyId, LastUsed:CreateDate, Status:Status}' --output table
- Relying on manual spreadsheets for access reviews. Spreadsheets are error-prone and quickly outdated. Use identity governance tools or scripts that pull live data from your identity provider:
# Export live access data instead of maintaining spreadsheets
aws iam get-account-authorization-details --output json > access-snapshot-$(date +%Y%m%d).json
Further Reading
- NIST SP 800-53 AC-6 — Least Privilege — the control the review verifies
- SOC 2 CC6.3 — Logical Access — removal-of-access evidence auditors request
- AWS IAM Access Analyzer — unused-access findings referenced in the scripts
- Companion resources — downloadable AWS/GitHub/Kubernetes audit scripts
Frequently Asked Questions
What is an orphan account?
An account that remains active after the owner has left the organization, changed roles, or stopped using the associated service. These accounts are high-risk and should be disabled or removed.
Can access reviews be automated?
Yes. Identity governance tools can collect access data, trigger reminders, and route approvals. Most compliance frameworks still require a human to sign off, though.
What evidence is needed for an auditor?
A complete access register, reviewer decisions, remediation actions, and signed attestation with dates and reviewer names.
How do I handle access reviews for contractors and temporary staff?
Set expiration dates on all contractor accounts at provisioning time. Use time-bound role assignments that auto-expire. Send reminders to the sponsor manager 7 days before expiration. Require re-approval for extension. Never grant permanent access to non-employees.
What is the difference between attestation and certification in access reviews?
Attestation is the act of a reviewer confirming that access is appropriate. Certification is a formal, auditable process where the reviewer signs off on the entire access list, often with legal or compliance significance. Most compliance frameworks require certification, not just attestation.
Related Resources
Access Control Policy Template
A template for defining authentication, authorization, RBAC, ABAC, MFA, password policies, session management, and access review procedures.
DocRBAC Policy Template: Roles, Permissions & Reviews
A copy-ready template for defining role-based access control policies: role definitions, assignment rules, approval workflow, review cadence, and break-glass handling.
DocUser Access Audit Template
A template for reviewing and certifying user access rights across systems, applications, and data repositories.
DocCompliance Gap Analysis Template
A template for mapping current security controls to compliance frameworks like SOC 2, ISO 27001, and PCI-DSS.
DocData Breach Response Playbook
A step-by-step playbook for responding to security incidents involving unauthorized data access, from initial detection through notification and remediation.