Ask three flight instructors how to teach a crosswind landing and you will hear three methods, each with fans and critics. Ask three cloud teams how to manage who may do what in their accounts and the same thing happens. This friendly comparison sets out three common ways of running IAMOps, the Atlas’s informal name for treating authorisation as something designed and tested, and tells you where each one shines and where it hurts.
First, what we are comparing
The framing comes from the Atlas page that frames IAMOps, which describes drafting, testing and steadily polishing the policy files behind every question of who or what may take which action. The three approaches below differ in where those policies live and how they change. Think of them as three ways of managing a training fleet’s rules: by word of mouth, by a binder, or by a controlled document system.
Approach one: console clicking
The first approach is the one everybody starts with. An administrator opens the provider’s web console and adjusts permissions by hand, usually in response to a request. It is fast, it needs no tooling, and for the first five users it is perfectly sensible.
Where it shines: speed and low overhead. A new instructor gets access before the first lesson.
Where it hurts: nobody can tell later why a permission exists. The Atlas observes that “grant admin now, tighten later” is a classic trap, because the activity recorded under admin rights later gets read as proof that admin was needed. Hand edits are exactly how that happens. With no review, a typo can widen access for months.
Approach two: scripts and templates
The second approach captures the setup in scripts or templates. Roles are created from a file, so rebuilding an environment is repeatable. This is a binder with every procedure printed in it.
Where it shines: repeatability and a record of what was intended.
Where it hurts: the binder gets out of date. Someone changes a permission in the console during an emergency, the script no longer matches, and the next run either undoes the fix or silently leaves it. Without automated checks, mistakes in the files themselves also slip through.
Approach three: policy files with review and tests
The third approach is the full authorisation-as-code pattern. Policies live in a repository, changes arrive as pull requests, automated checks run against them, and a reviewer signs off. The Atlas treats this as the third rung on its five-level maturity scale, where at least 90% of policy changes flow through the pipeline.
Where it shines: traceability, safer changes and the ability to measure. The same entry suggests testing guardrails in a sandbox first, a bit like rehearsing an emergency procedure in a simulator before you depend on it. If you enjoy that analogy, our post on the instrument-procedure simulator added to the training line-up describes why rehearsal in a safe space pays off.
Where it hurts: setup effort and cultural change. Requests take longer. In one example the Atlas works through, the wait for a new permission stretched by twelve hours after tightening, and the team shrugged it off.
Side-by-side summary
- Speed of a single change: console is fastest, scripts middling, policy files slowest by a small margin.
- Ability to explain why: poor, fair, strong.
- Risk of silent drift: high, medium, low.
- Effort to begin: trivial, moderate, substantial.
- Fit for measuring improvement: weak, partial, good.
Pitfalls that follow you into every approach
Moving between methods does not cure the quirks of the rules themselves. The Atlas names several that catch careful people out. An allow written with a “not action” clause grants everything except the listed items, which is almost always broader than intended. An organisation-wide control policy never grants anything, so a team that expects it to unlock access will wait forever. And a role exempted by name from a guardrail needs a companion rule protecting that name, otherwise anyone who can create a role with the same name inherits the exemption.
These are the aviation equivalent of misreading a chart legend. The tools differ, but the discipline of checking your own assumptions is the same whether you use a console, scripts or a repository.
A quick word on cost
People often assume tighter control must be expensive. The Atlas gives a worked example using one cloud provider’s pricing as of late 2026: scanning for unused access is billed per identity each month, which puts a fleet of 850 roles at about $170, while custom policy checks on 400 pull requests cost roughly $4 in total. Compared with an hour of simulator time, it is modest. Prices change, so treat these as an illustration and check current figures before planning.
The measurement difference
Only the third approach makes it easy to count things. The Atlas’s worked example tracks how much of a role’s allowed actions are actually used: one role used 27 of 180, or 15%. It also tracks wildcard exposure, with 168 of 1,400 allow statements using wildcards, about 12%. Numbers like these let a team show progress instead of just claiming it.
Which one should you pick?
Our honest, conversational answer is that you probably need a bit of each at different times. A very small team can start by hand, as long as it keeps notes. As soon as more than a few people share accounts, moving into scripts is worth it. When incidents, audits or growth start to bite, policy files with checks are the grown-up version.
The Atlas’s thirty-sixty-ninety plan is a gentle way to move across all three: inventory and owners in the first month, a repository with checks in the second, and a first monthly review with an exception register in the third.
If you like seeing how equipment choices shape training, have a look at our write-up on the modern glass-cockpit twin trainer joining the fleet. Choosing tools carefully is a theme that runs through aviation and through access control alike.
One more tip for the move between approaches: do not try to convert everything in a single weekend. Pick the account that worries you most, bring its rules under review first, and let the rest follow as confidence grows. Instructors do the same with a new student, adding one manoeuvre at a time, and the habit transfers surprisingly well. Keep a short note of what you changed and why, because that note becomes the memory your team will lean on when the original author has moved on to other work.
In short: pick the approach your team can keep up, not the one that sounds most impressive. A modest process that is followed every week beats an elegant one that fades after a month.