Basic Django permissions are typically static and application bound, so they work well for simple access control but break down when permissions must vary by tenant, context, or business rule. A dynamic RBAC policy separates roles, resources, and conditions from code, making access decisions easier to update centrally and better suited to real multi-tenant authorization.
Why Django’s built-in permissions are enough for simple apps, but not tenant-aware authorisation
Django’s default permission model gives you a clean, static starting point: a small set of model-level permissions that can be assigned to users and groups. That is fine when access rules are mostly global and easy to reason about. It becomes awkward when the same role means different things per tenant, or when business rules depend on tenant membership, plan, region, or customer-specific policy.
The core limitation is that basic Django permissions are usually attached to the application model, not to the tenant context in which the request is being evaluated. In a multi-tenant app, the same authenticated user may need different rights depending on which organisation, workspace, or account they are operating in. A static permission set cannot express that relationship cleanly without pushing a lot of conditional logic into code.
That is why a tenant-aware policy layer is often a better fit. It lets you keep the role definition stable while varying the effective access decision by tenant, resource ownership, or request context. If you need a broader comparison of access-control patterns, NHIMG’s Authorisation Models Guide explains how RBAC, ABAC, ReBAC, and policy-based access control differ in practice.
What changes when roles and rules are separated from code
A dynamic RBAC policy keeps the “who can do what” decision outside the application’s hard-coded permission checks. Roles still matter, but they are no longer the only input. A policy engine or central rules layer can also evaluate tenant identity, resource scope, membership, status, and other conditions before granting access.
That separation matters because multi-tenant authorisation is rarely just role membership. You often need to answer questions like whether the user belongs to this tenant, whether the object is owned by that tenant, whether the action is allowed for the tenant’s subscription tier, and whether the request is happening in the right administrative boundary. Those are policy questions, not just role questions.
In practice, dynamic policy also makes change management easier. When a customer-specific rule changes, you update the policy once rather than editing permission logic across multiple views, serializers, services, or background jobs. If you are designing the role layer itself, NHIMG’s Role Mining and Role Design Guide is useful for keeping roles business-aligned and avoiding role explosion.
For teams building a fuller governance model, NHIMG’s IAM and IGA Basics is a helpful companion because it frames RBAC as part of a broader access-governance model rather than a code-only permission feature.
Why multi-tenant apps need policy-aware authorisation boundaries
Multi-tenant applications fail when “admin” or “editor” is treated as a universal privilege instead of a tenant-scoped one. A user may be an admin in Tenant A and a read-only collaborator in Tenant B. If the authorisation layer cannot distinguish those scopes clearly, you risk horizontal privilege escalation across tenants or over-broad access within a shared service.
Dynamic RBAC is also a better fit when the resource model is not flat. Shared platforms often need exceptions for delegated admins, support users, partner accounts, or tenant-specific service roles. A policy-driven model can encode those exceptions centrally without embedding special cases in every endpoint. That is the difference between a permission system that merely authorises actions and one that actually enforces tenancy boundaries.
For the broader security pattern behind this, the OWASP API Security Top 10 is relevant because broken authorisation remains one of the most common failure modes when tenant scoping is weak or inconsistently applied.
Where tenant boundaries also intersect with identity lifecycle and entitlement review, NHIMG’s NHI Lifecycle Management Guide gives a useful governance lens for provisioning, recertification, and offboarding discipline.
Standards & Framework Alignment
This section maps relevant standards and security frameworks to the operational risks and controls described in this guidance.
OWASP API Security Top 10 addresses the attack and risk surface, while OWASP ASVS, CIS Controls v8 and NIST SP 800-53 Rev 5 set the governance and control requirements practitioners need to meet.
| Framework | Control / Reference | Relevance |
|---|---|---|
| OWASP API Security Top 10 | API5 — Broken Function Level Authorization | Multi-tenant role checks fail when actions are not properly scoped by tenant context. |
| Recommendation — Enforce function-level checks centrally so tenant-specific actions cannot bypass authorisation. | ||
| OWASP ASVS | V8 — Authorization | The question is fundamentally about how access decisions are designed and enforced. |
| Recommendation — Implement a centralised authorisation model that evaluates roles, resources, and context consistently. | ||
| CIS Controls v8 | CIS-6 — Access Control Management | Tenant-aware RBAC depends on managing who can access which resources and under what conditions. |
| Recommendation — Review and constrain access rights so each tenant only receives its intended permissions. | ||
| NIST SP 800-53 Rev 5 | AC-3 — Access Enforcement | Dynamic RBAC for multi-tenant apps requires enforced access decisions at the system boundary. |
| AC-6 — Least Privilege | Role scoping in multi-tenant systems must limit access to the minimum tenant-specific entitlement. | |
| Recommendation — Apply access enforcement at runtime so tenant context is evaluated before each protected action. Restrict roles to the minimum tenant-scoped permissions needed for each user or service. | ||
Practitioner Guidance
What to verify: Check whether every protected action is evaluated against tenant context, not just a global Django permission check. The important test is whether two users with the same role but different tenants can receive different decisions without branching application code in multiple places.
Decision rule: If the application must support tenant-specific rules, delegated administration, or resource-level scoping, treat Django’s built-in permissions as a baseline only and move the real authorisation decision into a central policy layer. Keep the static permissions for coarse-grained app functions, not for tenant enforcement.
Common mistake: Teams often model roles correctly but forget to model the tenant boundary itself. That creates the illusion of RBAC maturity while access still leaks through object queries, admin screens, export jobs, or background tasks that never consult the same policy path.
What good looks like: Role definitions are stable, tenant rules are configurable, and the same policy decision is reused consistently across the web app, APIs, and async workflows. The access model should be easy to review, easy to change, and hard to bypass.
Practitioner takeaway: Static permissions are acceptable when authorisation is simple; once tenancy changes the meaning of access, the control plane needs policy, not scattered conditionals.
Related resources from NHI Mgmt Group
- Guide: Entra ID Applications and Consent Guide
- RBAC Policy
- Why do multi-tenant apps strain basic authentication platforms?
- Why does RBAC break down in multi-tenant products with per-resource permissions?
- How should teams implement fine-grained authorization in multi-tenant apps that outgrow basic Firebase rules?
Deepen Your Knowledge
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.
Reviewed and updated by the NHIMG editorial team on November 5, 2026.
NHI Mgmt Group — the #1 independent authority on Non-Human Identity, IAM, and Agentic AI security. nhimg.org