Think about how a hotel, a coworking space and a members’ club each decide who gets through which door. The hotel hands out a card that opens whatever matches your job or booking. The coworking space checks your plan, the hour and whether the meeting room is free. The club asks whether a member you are connected to vouches for you. Three buildings, three styles of answering one question. Software teams face the same menu when they sit down to practise IAMOps, the craft of designing and tuning the rules for what people and programs are allowed to do. The three main styles are laid out below, so that you can judge which one matches your own setup.
Style one: roles, like a hotel keycard
Role-based access is the oldest and most familiar approach. You define a role such as “front desk” or “accounts clerk”, attach permissions to it, then assign people to roles. It was formalised in an American national standard back in 2004, and its appeal is plain: it is easy to explain to a manager and easy to review. If somebody changes jobs, you swap the role.
The weakness appears as the organisation grows. Roles multiply, because every special case seems to deserve its own, and soon nobody can say what “senior-accounts-temp-v2” actually opens. This is known as role explosion, and it is the reason many teams eventually reach for something more flexible.
Style two: attributes, like a smart coworking pass
Attribute-based access decides using facts about the person, the thing being accessed and the situation. A request might be allowed only if the person belongs to the right department, the document is not marked confidential, and the request arrives during working hours. A US government publication from 2014 set out the model, and it is still the reference many people cite.
The strength is precision. One rule can replace a dozen roles. The cost is that rules become harder to read, and a missing attribute can produce surprising results. For example, a condition written as “not equal to” can match when the attribute is absent altogether, so a request with no department listed might slip through a rule meant to block one particular department.
Style three: relationships, like a members’ club
Relationship-based access asks how a person is connected to the thing: owner, editor, member of the owning group, parent folder viewer. Google described a system built on this idea in 2019 to run permissions for products with enormous numbers of objects, and open-source implementations such as OpenFGA now exist for teams who want the same pattern. It suits shared documents, projects and anything with sharing links.
It is brilliant when your product is full of “who can see this particular thing” questions. It is overkill for a small internal tool with six users and three screens.
A side-by-side view
- Easiest to explain: roles. Everyone gets the keycard metaphor straight away.
- Most expressive for situations: attributes. Time, place and sensitivity can all join the decision.
- Strongest fit for sharing-heavy products: relationships. The graph of links does the heavy lifting.
- Hardest to audit by eye: attributes, closely followed by relationships once the graph gets big.
- Cheapest to start: roles, almost every time.
Few real systems pick only one. A common arrangement uses roles for the broad strokes, attributes for the conditions that matter, and relationships where sharing is central. According to the Atlas page that frames IAMOps as authorisation as code, the important thing is that all three feed the same shape of decision: who is asking, what they want, what it is aimed at, and the surrounding context.
Whichever style you pick, keep a ceiling
Here is a point that trips up friendly, fast-moving teams. Some rules grant, and some rules only limit. A company-wide guardrail that says “nothing leaves this region” never gives anybody access to anything; it just narrows what the other rules could have allowed. And when an explicit denial exists, it overrides generosity elsewhere. A comparison of access styles is incomplete without this layer, because it works the same way beneath all three.
What each style tends to get wrong
Roles drift: people collect them like loyalty cards and never hand any back. Attributes break quietly when the data feeding them goes stale, for instance when a department field is not updated after a reorganisation. Relationships can surprise you through inheritance, since someone who can edit a folder may be able to edit everything inside it, including files added years later. No style is ruled out by these flaws. They are simply reasons to schedule a review and to keep a few tests that say what must stay out of reach.
How to choose, without a week of meetings
- Count your audiences. Fewer than a dozen distinct job types? Roles will serve you well.
- Look for conditions you already write in policy documents, like “only from the office network” or “never for contractors”. Those are attribute territory.
- Ask whether customers share things with each other. If yes, relationships will earn their keep.
- Pilot your choice on one narrow area, and review what the rules actually did after a month.
If you are still working out how the technology side of the business hangs together, our earlier tour of choosing technology services for a growing business makes a handy companion read. And since permissions and spending leaks often share a root cause, namely nobody reviewing what has quietly accumulated, the walkthrough on stopping small cash drains before they grow follows a similar discipline of regular check-ups.
The friendly verdict
If you want one sentence: start with roles, add attribute conditions when the policy documents demand them, and bring in relationships only when sharing becomes the heart of the product. Whatever you choose, keep your rules somewhere you can read, test and change them, then look back at the results on a schedule. Like a good travel plan, the first draft is never the final one, and the people who enjoy the trip are the ones who adjust the route as they go.

