Authentication tells your application who someone is. Authorization decides what they may do. Most authorization bugs are not exotic: a user sees another customer’s invoice, a support agent can change data they should only read, a former manager still approves expenses. The access control model you choose shapes how easy those mistakes are to make and how easy they are to find.
Two models dominate the conversation: role-based access control (RBAC) and attribute-based access control (ABAC). This article explains both as NIST describes them, compares them, and suggests a practical way to combine them.
Role-based access control
In RBAC, permissions are not granted to people directly. Users are assigned to roles, and roles are assigned permissions. NIST’s RBAC project describes this as managing security at a level that corresponds to an organization’s structure: you think in terms of “accounts payable clerk” or “support lead”, not individual names.
RBAC has a long standards history. NIST combined two earlier models into a unified NIST RBAC model in 2000. It was adopted as the American National Standard ANSI/INCITS 359-2004 in February 2004 and revised as INCITS 359-2012. The standard includes a reference model defining users, roles, permissions, operations and objects, and a functional specification for the system and administrative functions around them.
Where RBAC works well
- Stable job functions. When access maps cleanly to what people do, roles are easy to explain and to audit.
- Access reviews. “Who has the Finance Approver role?” is a question auditors and managers can answer.
- Identity provider integration. Group or role claims from an identity provider map naturally onto application roles.
Where RBAC strains
RBAC struggles when the right answer depends on context rather than job title. “Managers can approve expenses” is a role rule. “Managers can approve expenses for their own team, under a set amount, during the current period” is not. Teams often try to encode each variation as a new role, and the number of roles grows until nobody can say what any of them means. When you find roles named after a single person or project, the model is being stretched past what it does well.
Attribute-based access control
NIST Special Publication 800-162, Guide to Attribute Based Access Control (ABAC) Definition and Considerations, was first published in January 2014 and updated in August 2019. It describes ABAC as a logical access control method in which authorization is decided by evaluating attributes against policy.
Those attributes fall into a few groups:
| Attribute group | Examples |
|---|---|
| Subject (who is asking) | Department, clearance, employment status, team |
| Object (what is being accessed) | Owner, classification, region, record status |
| Operation (what they want to do) | Read, update, approve, export |
| Environment (context, in some cases) | Time of day, network location, device posture |
A policy then combines them: “A user may approve an expense if they manage the submitter’s team, the amount is below their approval limit, and the expense is in an open period.”
Where ABAC works well
- Fine-grained, data-dependent rules, such as ownership, tenancy and record status.
- Multi-tenant software, where every request must be checked against the tenant it belongs to.
- Context-aware decisions that depend on location, time or device.
Where ABAC strains
ABAC moves complexity from role assignments into policies and attribute data. If attributes are stale or inconsistent, decisions are wrong. Policies can also become hard to review, which makes it harder to answer the simple audit question of who can access what.
A side-by-side comparison
| Question | RBAC | ABAC |
|---|---|---|
| Unit of decision | Role membership | Attributes evaluated against policy |
| Granularity | Coarse to medium | Fine |
| Audit “who can do X?” | Straightforward | Requires policy analysis |
| Handles context (time, location) | Poorly | Well |
| Main risk | Role sprawl | Opaque policies, bad attribute data |
| Typical owner | Identity and application admins | Developers and policy owners together |
A practical hybrid
Most real applications benefit from both. A pattern that works in many systems:
- Use roles for coarse capability. Roles decide which features a person can reach: “can approve expenses”, “can manage users”.
- Use attributes for the specific record. Policies decide whether that capability applies to this object: same tenant, own team, under the limit, status still open.
- Keep roles few and meaningful. If a new requirement would create a role for a single customer or project, model it as an attribute instead.
- Source attributes from systems of record. Department and manager should come from HR or the identity provider, not from a field users can edit.
Implementation checklist
- Centralize decisions. Put authorization logic in one module or service, not scattered across controllers and templates.
- Check on the server, every time. Hiding a button is not authorization. Every API call that reads or changes data must check access for that specific object.
- Deny by default. If no rule grants access, the answer is no.
- Write policies as code with tests. Each rule should have tests for the allowed case and at least one denied case, including another tenant’s data.
- Log decisions for sensitive actions, including which rule allowed or denied the request.
- Review access regularly. Role membership drifts as people change jobs, and attributes go stale.
- Plan for separation of duties. Some combinations, such as creating and approving the same payment, should be impossible for one person, whatever their roles.
Choosing for your application
- Internal line-of-business app with clear job functions: start with RBAC, add a few ownership checks.
- Multi-tenant SaaS product: roles for features, attributes for tenant and record-level checks from day one.
- Regulated data with context rules: lean on ABAC, with policies reviewed by the people who own the regulation.
Whichever model you start with, keep the decision point in one place. That single choice makes it far easier to evolve from roles to attributes later.
How Devacon can help
We design authorization models and build them into applications, from role definitions mapped to your identity provider to policy-based checks for multi-tenant and record-level access. A typical engagement includes a permission model, a central decision module and automated tests for allowed and denied cases. Learn more about our identity and access management services.
Sources
Facts in this article were checked against the sources above on November 17, 2026. Standards and products change, so check the source before relying on a detail. Related service: Identity & Access Management.