
What an IT Auditor Actually Checks in Your AWS IAM Setup
Most AWS security content is written for engineers. This one is written from the other side of the table — the four things an ITGC auditor asks for when your cloud environment lands in scope, and how to have the answers ready before they ask.
I spent a summer as an intern on an Assurance Technology Risk team, testing IT general controls — the access, change, and operations controls that sit underneath a financial audit. Most of that work involved on-premises systems and SAP. But cloud environments increasingly land in scope, and when they do, something interesting happens: the engineering team and the audit team are looking at the same IAM configuration and seeing completely different things.
Engineers see least privilege. Auditors see evidence.
Those aren't the same standard, and the gap between them is where most audit findings live. Here's what the audit side is actually asking.
1. "Show me who has access, as of a date"
The first request in almost any access-controls test is a user listing — every account with access to the in-scope system, as of a specific point in time, with their permission levels.
In a well-run AWS environment this sounds trivial. It usually isn't, for three reasons:
- Access is federated. If you're using IAM Identity Center with an external IdP, the authoritative list of who lives in the IdP, while the list of what they can do lives in AWS. Reconciling the two is the auditor's problem, and they'll hand it to you.
- Access is transitive. A user with
sts:AssumeRoleon a permissive role has that role's permissions. A listing of directly-attached policies understates real access.
- Access is historical. "As of March 31" is not "as of today." If you can't reconstruct a past state, you're relying on the auditor accepting a current snapshot for a period-end test — and they may not.
What helps: AWS Config records configuration history for IAM resources, which is the closest thing to a time-machine for this question. Setting it up before an audit is dramatically easier than reconstructing after.
2. "Show me that access was approved"
Existence of access isn't the control. Authorized access is the control.
For every new user or permission grant in the audit period, the auditor wants to trace back to an approval — a ticket, a request form, something with a named approver who isn't the person receiving access. And they want it for a sample they select, not a sample you select.
This is where cloud environments often fail on documentation rather than on security. The access was appropriate. The approval just lived in a Slack thread.
What helps: routing all permission changes through a ticketing system, and being able to tie a CloudTrail event to a ticket ID. If the only record of a change is the CloudTrail event itself, you can prove what happened and when, but not that anyone authorized it.
3. "Show me that access was removed"
Termination testing. When someone left the organization during the period, how quickly did their access go away?
Federated access makes this look easy — disable in the IdP, access is gone. But the edges matter:
- Long-lived IAM access keys attached to a human user, created for a script two years ago
- Service accounts that a departing employee had credentials for
- Access to third-party tools that hold AWS credentials, outside the IdP's reach
Auditors specifically look for orphaned credentials, because they're the classic finding.
What helps: IAM credential reports show access key age and last-used dates. IAM Access Analyzer's unused-access findings surface credentials and roles nobody is using. Running these on a schedule and acting on the output turns a potential finding into evidence of a working control.
4. "Show me nobody can do two conflicting things"
This is segregation of duties, and it's the one I find genuinely underserved in cloud tooling.
SoD isn't about whether a permission is excessive. It's about whether a combination of permissions lets one person complete a sensitive transaction end to end with no second pair of eyes. In an ERP context these conflicts are well-mapped — create a vendor and approve a payment, for example. In a cloud infrastructure context they look like:
- Modify a deployment pipeline and approve the deployment to production
- Create an IAM principal and grant it permissions
- Write to a data store and modify or delete the audit logs covering it
- Raise a change request and approve it
AWS gives you excellent tooling for evaluating what a principal can do — Access Analyzer, Access Advisor, policy simulation. What it doesn't give you is a way to declare "these two capabilities must never coexist in one principal" and have that evaluated continuously against effective permissions.
So teams export IAM data and analyze it externally, everyone rebuilds the same conflict logic, and the result is a point-in-time snapshot rather than a monitored control.
What helps right now: define your conflict matrix explicitly, even if you have to test it with a script. Write down the pairs that matter for your environment — most teams have fewer than fifteen that genuinely matter. Half the value is in having decided what a conflict is; auditors will accept a documented, tested matrix far more readily than an assertion that permissions are appropriate.
I've filed this as a Wishlist item, because I think native SoD rule evaluation is a natural extension of the engine that already powers Access Analyzer's unused-access findings.
The underlying shift
The pattern across all four: a control that isn't evidenced is, to an auditor, a control that doesn't exist.
That framing feels unfair from an engineering seat. Your environment might be genuinely well-secured and still generate findings, because security and auditability are different properties. Security is about what an attacker can do. Auditability is about what you can prove to a skeptical third party, months later, about a state that no longer exists.
The good news is that AWS gives you most of the primitives for the second one — CloudTrail, Config, Access Analyzer, credential reports, Security Hub. What's usually missing isn't tooling. It's the decision to treat evidence generation as a design requirement rather than something to assemble under deadline pressure.
If your environment is heading toward its first audit, the highest-leverage thing you can do is pick one of these four questions and try to answer it cold, today, without asking anyone for help. Whichever one takes longest is where your next finding is coming from.
I'm a Computer Science Engineering undergraduate working at the intersection of AI/ML and technology risk. Currently going deeper on cloud architecture and on what auditable AI systems look like in practice.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article