Join our Newsletter — 33% off our NHI Course
Home› FAQ› Governance, Ownership & Risk› What is the difference between a relation and…
Governance, Ownership & Risk

What is the difference between a relation and a permission in a Zanzibar-style authorization model?

← Back to all FAQ
By NHI Mgmt Group Editorial Team Updated October 30, 2026 Domain: Governance, Ownership & Risk

A relation defines a direct relationship between objects or subjects, such as a reader or writer link. A permission is a computed authorization decision built from one or more relations or other permissions, such as read or write. This distinction helps teams model ownership and access logic more accurately and avoids mixing raw relationships with effective privileges.

How Zanzibar Separates Relationships From Effective Access

A Zanzibar-style model keeps raw graph data and effective access separate on purpose. Relations describe how objects and subjects are linked, while permissions describe what an identity can actually do after the model resolves tuples, rewrites, and other rules. That separation makes authorization explainable, composable, and easier to audit at scale.

A relation is usually the smallest durable unit in the schema: a user is a reader of a document, a team owns a folder, or an organisation member is a billing admin. A permission is the consumable result, such as view, edit, or administer. If teams blur the two, they usually end up with schemas that are harder to reason about and policy logic that is harder to test.

In practice, this distinction also helps you model inheritance and composition cleanly. A permission may be derived from several relations, from nested groups, or from another permission defined elsewhere in the schema. For a deeper treatment of relation tuples, userset rewrites, and rollout concerns in ReBAC, see the Fine-Grained Authorisation Guide.

Why Relations Stay Primitive While Permissions Stay User-Facing

Relations should answer “what is the structural link here?” not “what can this actor do?” That keeps the schema stable even when business meaning changes. A document can keep the same reader relation while the permission logic around it evolves to include inherited access, team membership, or ownership shortcuts.

Permissions are the layer that product teams, auditors, and application code usually care about. They translate the graph into operational outcomes. In a mature model, you can change how a permission is computed without renaming every relation in the data model, which reduces churn and preserves the integrity of stored relationships.

That design also supports clearer ownership boundaries. Platform teams can maintain the authorization schema, while application teams reason about domain actions like read, comment, or approve. If you want a broader comparison of authorization patterns and when to use each one, the Authorisation Models Guide is the natural next step.

What Breaks When Teams Treat Permissions Like Relations

The common failure mode is to encode effective access directly as if it were a raw relationship. That makes schemas brittle, because business logic gets duplicated into data shape. It also obscures intent: a tuple that looks like a relation may actually be hiding a derived privilege, which makes reviews, troubleshooting, and least-privilege tuning much harder.

Another problem is accidental privilege inflation. If a team models “can edit” as a direct relation everywhere, it becomes easy to overgrant access when a derived rule should have been narrower. The reverse is also true: if a true structural relation is forced to behave like a permission, it can become difficult to reuse that relation for other legitimate access decisions.

When relation and permission semantics stay distinct, you can inspect the graph for facts and the permission layer for decisions. That separation is the same practical reason Zanzibar-style systems scale better than ad hoc permission lists, because the evaluation step remains deterministic even as the underlying relationship graph grows.

Risk and Threat Considerations

Confusing relations with permissions creates authorization drift, especially when teams copy privilege logic into schema names or application code. The result is usually overbroad access, brittle policy changes, and poor visibility into why a user or service was allowed to act.

Failure mechanism: A structural relation is treated as if it were the final authorization decision, so derived access paths, inheritance, or exceptions get embedded in the wrong layer and become hard to review or revoke.

Impact: You get weaker least privilege, harder incident response, and higher odds of broken authorization behaviour when the graph or policy changes.

Standards & Framework Alignment

This section maps relevant standards and security frameworks to the operational risks and controls described in this guidance.

OWASP ASVS, NIST SP 800-53 Rev 5, CIS Controls v8 and NIST CSF 2.0 set the governance and control requirements practitioners need to meet.

FrameworkControl / ReferenceRelevance
OWASP ASVSV8 — AuthorizationReBAC permissions are authorization decisions derived from schema rules.
Recommendation — Verify that permissions are computed consistently from documented authorization rules.
NIST SP 800-53 Rev 5AC-3 — Access EnforcementSeparates effective access decisions from raw relationship data.
AC-6 — Least PrivilegeRelation/permission confusion often inflates access beyond necessity.
Recommendation — Enforce access decisions through the policy layer, not ad hoc tuples. Limit permissions to the minimum actions derived from each relationship.
CIS Controls v8CIS-6 — Access Control ManagementSupports review and governance of effective permissions versus data relationships.
Recommendation — Review and recertify effective permissions separately from stored relationships.
NIST CSF 2.0PR.AA-05 — Identity Management, Authentication and Access ControlCovers how access decisions are managed and enforced in authorization models.
Recommendation — Implement access control so permissions are derived from governed policy.

Practitioner Guidance

What to verify: Make sure every schema relation represents a factual link, and every permission can be traced to a readable rule or rewrite path. If a reviewer cannot explain whether a tuple is a relationship or an effective privilege, the model needs cleaning up.

Decision rule: If the value describes who is connected to what, keep it as a relation; if it describes what action is allowed, expose it as a permission. When a field starts to answer both questions, split it before the policy logic spreads further.

Practitioner takeaway: The cleanest Zanzibar-style schemas keep facts and decisions separate, because that is what makes authorization understandable, testable, and safe to evolve.

Free weekly newsletter

Subscribe to the NHI & AI Identity Journal

The latest on NHI and Agentic AI security – articles, research, breaches, news and events every week.

Bonus 33% off our NHI Course when you subscribe.

NHIMG Editorial Note
Reviewed and updated by the NHIMG editorial team on October 30, 2026.
NHI Mgmt Group — the #1 independent authority on Non-Human Identity, IAM, and Agentic AI security. nhimg.org