User Access Audit Template
A template for reviewing and certifying user access rights across systems, applications, and data repositories.
Overview
A user access audit checks that every account in your systems belongs to someone who still needs it, with a role that matches what they actually do. It’s a core control for identity governance and least privilege — and a hard requirement in SOC 2, ISO 27001, and PCI-DSS audits. Run without structure, these reviews devolve into a spreadsheet that nobody signs off on; this template gives you the scope tables, certification log, and remediation plan to run one that auditors can trace.
When to Use
- Performing quarterly or annual access reviews.
- Preparing for a compliance audit or certification.
- After a role change, reorganization, or merger.
- When privileged access is suspected to be excessive.
- After offboarding a user or removing a contractor.
If your goal is reviewing a single system’s permission model rather than certifying user-by-user access, the Access Control Review Template is a better fit.
Prerequisites
- An identity source such as an SSO provider or identity management system.
- A list of applications, systems, and data repositories under review.
- Owners or managers for each application who can certify access.
- A defined access review schedule and escalation process.
Solution
Template
1. Audit Scope
| Scope Item | Description |
|---|---|
| Period | 2026-Q2 |
| Systems reviewed | AWS, GitHub, Jira, Confluence, Slack, VPN, Google Workspace |
| Population | Employees, contractors, service accounts, privileged admin roles |
| Reviewers | Application owners, managers, security team |
| Due date | 2026-07-15 |
| Exceptions allowed | Yes, with risk acceptance and expiration |
2. Identity Inventory
| User ID | Name | Type | Department | Status | Last Reviewed |
|---|---|---|---|---|---|
alice@example.com | Alice Chen | Employee | Engineering | Active | 2026-03-31 |
bob@example.com | Bob Smith | Contractor | Finance | Active | 2026-03-31 |
| svc-api-prod | API Service | Service account | Platform | Active | 2026-05-15 |
carol@example.com | Carol Jones | Employee | Marketing | Inactive | 2026-01-31 |
3. Access Mapping
| User | System | Role / Permission | Business Justification | Reviewer | Decision |
|---|---|---|---|---|---|
alice@example.com | AWS | PowerUser | Manages infrastructure | Platform lead | Keep |
bob@example.com | GitHub | Read | Reviews pull requests | Engineering manager | Keep |
alice@example.com | Jira | Admin | Configures workflows | IT lead | Revoke |
| svc-api-prod | AWS | S3 read-only | Application reads reports | Platform lead | Keep |
carol@example.com | Slack | Member | Left company | HR | Revoke |
4. Privileged Access Review
| User | System | Privileged Role | Justification | Risk | Reviewer | Decision |
|---|---|---|---|---|---|---|
alice@example.com | AWS | Root access | Emergency break-glass | High | CISO | Keep with MFA |
dave@example.com | GitHub | Organization owner | Manages repositories | High | CTO | Keep |
eve@example.com | VPN | Full tunnel | Remote admin access | High | Security lead | Revoke |
5. Certification Log
| Application | Reviewer | Status | Date | Notes |
|---|---|---|---|---|
| AWS | Platform lead | Certified | 2026-07-10 | 2 revocations pending |
| GitHub | CTO | Certified | 2026-07-08 | 1 orphan account removed |
| Jira | IT lead | In progress | 2026-07-05 | Admin role under review |
| Slack | HR | Certified | 2026-07-09 | 3 inactive accounts revoked |
6. Remediation Plan
| Finding | Action | Owner | Due Date | Status |
|---|---|---|---|---|
| Excessive admin rights in Jira | Downgrade to user | IT lead | 2026-07-20 | Open |
| Inactive Slack account | Deactivate | HR | 2026-07-12 | Done |
| Orphaned service account | Investigate and disable | Platform team | 2026-07-18 | Open |
| Missing MFA on privileged users | Enforce MFA | IAM team | 2026-07-15 | In progress |
Explanation
Each table in the template answers a different audit question: who exists (inventory), what they can reach (mapping), who can break things (privileged review), who signed off (certification), and what’s being fixed (remediation). Without that chain, organizations accumulate stale accounts and over-privileged users — the two findings external auditors write up most often.
How often to run each layer depends on the risk of what it protects:
| Access type | Recommended cadence | Why |
|---|---|---|
| Privileged (admin, root, break-glass) | Quarterly | Highest blast radius |
| Employee/contractor access | Annual, plus on role change | Roles drift faster than headcount |
| Service accounts | Semi-annual, plus on deploy changes | Nobody notices when they go stale |
| Contractor/external | Every 90 days or at contract end | Access should die with the contract |
The “plus on X” triggers matter more than the calendar. A quarterly schedule still leaks privilege when someone changes teams in week two and keeps their old admin rights for ten weeks — wire revocation into your offboarding and transfer workflows, not just the review cycle.
Auditors don’t grade you on the tables — they grade you on the trail. For every “keep” decision they want a name, a date, and a justification; for every “revoke” they want proof the account actually died. That asymmetry is why the certification log and the evidence bundle matter as much as the review itself: a flawless set of decisions with no paper trail reads as “not performed” in a SOC 2 field test.
Size also changes the mechanics. At fifteen people, the template above is the whole process — one person exports the lists, managers certify in a shared doc, done in a week. Past a hundred users, the per-user mapping table stops fitting on a screen and you’ll want the automation scripts plus an owner per application rather than one reviewer for everything. The tables stay the same either way; what scales is who fills them and how the data gets there.
How to Run the Audit
Work through the template in this order — each step feeds the next:
- Fill the scope table first. List every system in scope and name its reviewer before touching data. Reviews that fail usually fail here: a system nobody owns gets skipped silently.
- Export the identity inventory from your SSO or IdP (Okta, Entra ID, Google Workspace). Pull every account type — employees, contractors, service accounts — because service accounts are the ones nobody reviews. Automate this with the Okta script in Advanced Solutions if you can.
- Map access per user per system. For each application, export the user list with roles and reconcile it against the inventory. Any account that exists in the app but not in the IdP is a candidate orphan — flag it immediately rather than in the remediation phase.
- Route the privileged table to a senior reviewer. Privileged access needs a second pair of eyes with authority — CISO, security lead, or CTO. Managers tend to approve their own team’s admin rights by default; a separate reviewer changes that.
- Collect certifications. Each application owner signs off on their system in the certification log. “Certified” means they looked, not that they clicked approve — require a decision (keep, revoke, downgrade) on every row.
- Open remediation items for every revoke or downgrade, each with an owner and a due date. The audit isn’t done when the review ends — it’s done when the last remediation item closes.
- Archive the evidence. Save the exported lists, signed certifications, and closed remediation tickets together. Your SOC 2 or ISO auditor will ask for exactly this bundle.
Budget three weeks for a full cycle the first time: one for data collection and mapping, one for certifications, one for remediation. It compresses to about two weeks once the exports are scripted and reviewers know the drill. Run privileged-only spot checks between full cycles so the quarterly deep dive isn’t your only safety net.
Worked Example: Q2 Audit at a 50-Person SaaS Company
Population: 47 employees, 6 contractors, 12 service accounts
Systems: AWS, GitHub, Jira, Slack, VPN, Stripe
Findings:
- 4 inactive accounts (1 departed employee, 3 contractors)
- 2 users with admin in Jira and GitHub (expected: engineering leads only)
- 1 orphan service account (svc-reporting, no deploy since 2025-11)
- 7 users without MFA on VPN
- 1 contractor access 60 days past contract end
Remediation:
- 5 accounts deactivated within 48 hours
- Jira admin downgraded for 1 user; second confirmed as legitimate
- svc-reporting disabled after platform team confirmed no dependencies
- MFA enforced via conditional access policy
- Contractor record corrected; HR added auto-expiry to contractor accounts
Cycle time: scope meeting Monday, certifications by Friday week 2,
remediation closed by day 18 of the 21-day window.
Note the pattern in the findings: four of five were process failures, not bad actors — a departed employee whose access lingered, a service account nobody owned, a contractor whose end date nobody recorded. That’s typical. Access audits rarely catch abuse; they catch entropy.
Variants
The same skeleton scales to narrower scopes — change the population, keep the tables:
- Application-specific access review: Focuses on one system, such as AWS IAM or GitHub organization access.
- Privileged access review: Only reviews admin, root, or emergency access accounts.
- Service account audit: Reviews non-human identities and their API keys or credentials. Pair it with the Secret Rotation Schedule Template — credentials for service accounts you keep should be on a rotation cadence.
- Contractor access review: Time-bound review for external users with temporary access.
- Data access audit: Focuses on users who can access sensitive databases, data lakes, or analytics tools.
What Works
- Pull the identity inventory from the SSO provider automatically — manual exports drift out of date before the review ends.
- Send reviewers a reminder one week before the deadline, then daily in the last three days. Certification stalls are the top cause of overdue audits.
- Require a written business justification for every privileged role — “manages infrastructure” passes, “needs it” doesn’t.
- Revoke on role change and offboarding immediately; the quarterly review is the safety net, not the trigger.
- Document every exception with risk acceptance and an expiry date — permanent exceptions aren’t exceptions.
- Track remediation to closure. An audit that finds problems and fixes none is worse than no audit, because now you knew.
Common Mistakes
- Reviewing access once a year with no follow-up — findings sit open until the next cycle.
- Letting managers keep admin rights for people who transferred into their team.
- Ignoring service accounts and shared credentials — they don’t appear in the org chart but hold real privileges.
- Skipping break-glass and emergency accounts because “we barely use them” — that’s exactly why they need review.
- Accepting “keep” decisions without business justification on privileged rows.
- Marking items “done” in the remediation plan without verifying the revocation actually happened in the system.
- Storing evidence across scattered emails and chats — auditors need one bundle per cycle.
Troubleshooting
- Reviewers ignore certification requests: escalate to their managers after the second reminder, and make certification a tracked deliverable, not a favor.
- Inventory exports don’t match reality: the IdP only sees managed accounts. Cross-check each application’s local user list directly — shadow accounts hide there.
- Too many findings to remediate in one cycle: rank by privileged access first, then stale accounts, then justification gaps. Don’t try to close everything; try to close the dangerous things.
- Service accounts nobody owns: assign an owner before you rotate or disable anything — killing an unowned account is how production breaks on a Friday.
- Can’t tell who uses a shared account: enable per-session logging on it for two weeks, then map sessions back to individuals. The RBAC Policy Template helps design the individual roles you’ll migrate them to.
Advanced Solutions
Automated access review with Okta API
Pull user access data from Okta and generate a review report automatically:
import requests
import csv
from datetime import datetime, timedelta, timezone
from dataclasses import dataclass
from typing import List
@dataclass
class UserAccessRecord:
user_id: str
user_name: str
status: str
last_login: str
assigned_apps: List[str]
admin_roles: List[str]
class OktaAccessReviewer:
def __init__(self, api_token: str, domain: str):
self.headers = {
"Authorization": f"SSWS {api_token}",
"Accept": "application/json",
}
self.base_url = f"https://{domain}/api/v1"
def get_inactive_users(self, days: int = 90) -> List[dict]:
"""Find users who haven't logged in within the specified period."""
cutoff = datetime.now(timezone.utc) - timedelta(days=days)
users = []
params = {"filter": 'status eq "ACTIVE"'}
resp = requests.get(
f"{self.base_url}/users",
headers=self.headers,
params=params,
)
for user in resp.json():
last_login = user.get("lastLogin")
if not last_login:
continue
login_time = datetime.fromisoformat(last_login.replace("Z", "+00:00"))
if login_time < cutoff:
users.append({
"id": user["id"],
"email": user["profile"]["email"],
"last_login": last_login,
"status": user["status"],
})
return users
def get_user_apps(self, user_id: str) -> List[str]:
"""Get applications assigned to a user."""
resp = requests.get(
f"{self.base_url}/users/{user_id}/appLinks",
headers=self.headers,
)
return [app["label"] for app in resp.json()]
def get_admin_roles(self, user_id: str) -> List[str]:
"""Get admin roles assigned to a user."""
resp = requests.get(
f"{self.base_url}/users/{user_id}/roles",
headers=self.headers,
)
return [role["type"] for role in resp.json()]
def generate_review_report(self, output_file: str) -> None:
"""Generate a CSV report of all active users and their access."""
resp = requests.get(
f"{self.base_url}/users",
headers=self.headers,
params={"filter": 'status eq "ACTIVE"'},
)
with open(output_file, "w", newline="") as f:
writer = csv.writer(f)
writer.writerow([
"User ID", "Email", "Status", "Last Login",
"Assigned Apps", "Admin Roles"
])
for user in resp.json():
apps = self.get_user_apps(user["id"])
roles = self.get_admin_roles(user["id"])
writer.writerow([
user["id"],
user["profile"]["email"],
user["status"],
user.get("lastLogin", "Never"),
"; ".join(apps),
"; ".join(roles),
])
# Example usage
reviewer = OktaAccessReviewer(api_token="YOUR_TOKEN", domain="yourorg.okta.com")
inactive = reviewer.get_inactive_users(days=90)
for u in inactive:
print(f"INACTIVE: {u['email']} - last login: {u['last_login']}")
reviewer.generate_review_report("access_review_q2.csv")
AWS IAM access analyzer for automated finding detection
Use AWS IAM Access Analyzer to detect unused permissions and cross-account access:
#!/bin/bash
set -euo pipefail
# Create an analyzer if it doesn't already exist
ANALYZER_NAME="org-access-analyzer"
ANALYZER_ARN=$(aws accessanalyzer list-analyzers \
--type ORGANIZATION \
--query 'analyzers[?analyzerName==`'"$ANALYZER_NAME"'`].arn | [0]' \
--output text)
if [ -z "$ANALYZER_ARN" ] || [ "$ANALYZER_ARN" = "None" ]; then
ANALYZER_ARN=$(aws accessanalyzer create-analyzer \
--analyzer-name "$ANALYZER_NAME" \
--type ORGANIZATION \
--region us-east-1 \
--query 'analyzer.arn' \
--output text)
fi
# List all findings
echo "=== Active Findings ==="
aws accessanalyzer list-findings \
--analyzer-arn "$ANALYZER_ARN" \
--filter '{"status":{"eq":["ACTIVE"]}}' \
--query 'findings[*].{id:id,resource:resource.resourceArn,type:findingType,createdAt:createdAt}' \
--output table
# Export findings to JSON for audit trail
aws accessanalyzer list-findings \
--analyzer-arn "$ANALYZER_ARN" \
--query 'findings[*].{id:id,resource:resource.resourceArn,type:findingType,createdAt:createdAt}' \
--output json > iam-findings-$(date +%Y%m%d).json
GitHub organization access audit script
Audit GitHub organization members and their roles programmatically:
const { Octokit } = require("@octokit/rest");
async function auditGitHubOrg(orgName, token) {
const octokit = new Octokit({ auth: token });
const findings = [];
// Get all organization members
const members = await octokit.paginate(
octokit.rest.orgs.listMembers,
{ org: orgName, per_page: 100 }
);
// Members with 2FA disabled — a dedicated API filter,
// the flag is not part of the default member payload
const no2faMembers = await octokit.paginate(
octokit.rest.orgs.listMembers,
{ org: orgName, filter: "2fa_disabled", per_page: 100 }
);
const no2faLogins = new Set(no2faMembers.map((m) => m.login));
for (const member of members) {
// Get the user's org role via membership endpoint
const { data: membership } = await octokit.rest.orgs.getMembershipForUser({
org: orgName,
username: member.login,
});
findings.push({
login: member.login,
role: membership.role,
two_factor: no2faLogins.has(member.login) ? "disabled" : "enabled",
});
}
// Flag users without 2FA
const noMfa = findings.filter((f) => f.two_factor === "disabled");
if (noMfa.length > 0) {
console.log(`\nUSERS WITHOUT 2FA (${noMfa.length}):`);
noMfa.forEach((u) => console.log(` - ${u.login} (role: ${u.role})`));
}
// Flag admins
const admins = findings.filter((f) => f.role === "admin");
console.log(`\nORGANIZATION ADMINS (${admins.length}):`);
admins.forEach((u) => console.log(` - ${u.login} (2FA: ${u.two_factor})`));
return findings;
}
auditGitHubOrg("your-org", process.env.GITHUB_TOKEN)
.then(() => console.log("\nAudit complete."))
.catch((err) => console.error("Audit failed:", err.message));
Shared Account Remediation Checklist
- Inventory all shared accounts (root, admin, service)
- Identify which individuals use each shared account
- Create individual accounts for each user
- Disable shared account after migration
- Implement break-glass procedure for emergency access
- Log all break-glass usage with automatic alerts
Further Reading
- NIST SP 800-53 Rev. 5 — the AC-2 account management and AC-6 least privilege controls these reviews satisfy
- Companion resources — downloadable template, Okta/AWS/GitHub audit scripts
Frequently Asked Questions
Who should certify access?
The system owner or the user's direct manager is the best reviewer — whoever can vouch that the person still does the work that needs the access. For privileged and sensitive systems, route it to the security team or data owner as a second approver instead.
What is an orphan account?
An orphan account is an active account that no longer maps to a known person or owner — usually left behind after offboarding, a team change, or a migration. They should be disabled pending investigation, then reclaimed or deleted.
How often should we review privileged versus general access?
Privileged quarterly, general annually — with trigger-based reviews between cycles. Any role change, transfer, offboarding, or security incident should kick off a targeted review no matter where in the cycle you land.
How do we make access reviews less tedious?
Automate the data collection and let humans make decisions. Identity governance tools (or the scripts below) pull the inventories and flag inactive accounts automatically, so reviewers spend their time on judgment calls, not copy-pasting CSVs.
What do we do about accounts with legitimate but temporary access needs?
Grant them with an expiry date, not an open end. Log them as exceptions with risk acceptance and a date, and let the next review cycle enforce the removal — or better, use your IdP's time-bound access controls so the expiry is automatic.
Related Resources
RBAC 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.
DocAccess Control Review Template
A template for auditing user access rights, verifying least privilege, and documenting access decisions across systems and teams.
DocSecret Rotation Schedule Template
A template for tracking and scheduling the rotation of API keys, passwords, certificates, and other secrets across systems.
DocData Retention Policy Template
A template to define how long data is kept, when it is archived, and when it must be deleted for compliance and cost reasons.
RecipeImplement RBAC: Role-Based Access Control
How to implement role-based access control with hierarchical roles, permission grants, and middleware enforcement across Python, Node.js, and Java.
GuideSecurity Best Practices Guide
A thorough guide to application security: authentication, authorization, input validation, secrets management, and common vulnerability prevention.