Course contentsShow
← System Design
Lesson 934 of 1,91924. Authentication and Authorization at ScaleFree lesson

RBAC Implementation Patterns

Store roles in databases, cache role checks, and handle role hierarchies efficiently.

RBAC Implementation Patterns

You'll learn: How to efficiently store, check, and manage role hierarchies in production systems to make authorization both fast and maintainable.

The Challenge of Practical RBAC

You understand RBAC conceptually—users get roles, roles have permissions—but how do you implement it at scale? The naïve approach of checking databases on every request creates bottlenecks. Smart implementations balance correctness, performance, and flexibility.

Storage Strategy

Store roles in a relational database with clear tables:

  • users (user_id, name)
  • roles (role_id, role_name)
  • user_roles (user_id, role_id) — the many-to-many mapping
  • permissions (permission_id, resource, action)
  • role_permissions (role_id, permission_id)

This normalized structure keeps data consistent and queryable.

Caching Role Checks

Hitting the database for every authorization check is expensive. Instead:

  • Cache the complete role→permissions mapping in Redis or in-memory
  • Include roles and permissions in the JWT claims itself (for stateless verification)
  • Set reasonable TTLs (5-15 minutes) to balance freshness and performance
  • Invalidate cache entries when roles change for specific users

Think of caching like memorizing the guest list at a party instead of checking the master list at the door every time.

Handling Role Hierarchies

Roles often inherit from each other (Admin includes all Editor permissions). Implement this by:

  • Storing parent-child role relationships in a role_hierarchy table
  • Flattening the hierarchy at query time or cache-load time, so you store the complete permission set
  • Avoiding deep nesting (3-4 levels max) to prevent complexity

Pre-computing the flattened permissions means runtime checks are simple lookups, not recursive traversals.

Key Takeaway: Store RBAC data in normalized tables, aggressively cache permission checks with reasonable TTLs, and flatten role hierarchies to avoid runtime complexity—this makes authorization both fast and maintainable at scale.