Beta

Who Can Do What, Answered in 5ms

Define roles, assign them to users, and check permissions with one API call. Inheritance and resource-level grants resolve automatically.

Authorization

Control access with roles and permissions

Create roles that bundle permissions. Assign roles to users or organization memberships. Check permissions with a single API call without building authorization logic from scratch.

Capabilities

Everything you need for access control

Role definitions

Create roles with named permission sets. Define viewer, editor, and admin roles or create custom roles for your application.

Permission inheritance

Roles can inherit permissions from other roles. An admin role automatically includes all editor and viewer permissions.

Resource-level permissions

Grant permissions on specific resources. A user can edit one project but only view another without separate role assignments.

Permission checking

Check if a user has a permission with one API call. Permission checks resolve role inheritance and resource-level grants.

Role assignment

Assign roles to users globally or within organization context. Track who assigned roles and when.

Policy evaluation

Define policies that combine permissions with conditions. Time-based access, IP restrictions, or custom logic evaluated at check time.

< 5ms
Permission check

Authorization evaluation time

Real-time
Permission updates

Changes take effect immediately

Full audit
Access history

Every check logged for compliance

Why it matters

Authorization without scattered if-else chains

Authorization without if-else chains

Authorization logic spread through code becomes unmaintainable. Conjoin Auth RBAC centralizes permission definitions and provides consistent checks across your application.
In practice

Before rendering a delete button, check if the user has the delete permission on that resource. The check returns true or false without evaluating role membership, inheritance, or resource grants in your code.

Roles that grow with your application

Starting with basic roles is easy, but adding fine-grained permissions later is hard. Conjoin Auth RBAC supports simple role checks at first and scales to resource-level permissions as needed.
In practice

Launch with admin, editor, and viewer roles. When customers need per-project permissions, add resource-level grants without changing how permission checks work. The same check API handles both.

Inheritance that makes sense

Admin users should have all editor permissions without listing them twice. Conjoin RBAC supports role inheritance so higher-level roles automatically include lower-level permissions.
In practice

Define a viewer role with read permission, an editor role that inherits viewer and adds write, and an admin role that inherits editor and adds delete. Admins automatically have read, write, and delete.

Built for Your Workflow

Ship faster with solutions designed for real-world needs

How Conjoin solves this

Define permissions centrally and check with a single API call. Conjoin resolves role membership, inheritance chains, and resource-level grants, returning a clear allow or deny decision.

Impact

Consolidate authorization logic into consistent permission checks that evaluate in milliseconds.

How Conjoin solves this

Define roles through the API or Conjoin Console with named permission sets. Roles can inherit from other roles, and permission changes take effect immediately without code deployments.

Impact

Update authorization rules at runtime without releasing new application versions.

Ship your application today

Start building with Conjoin today. Free tier includes everything you need to prototype and launch. Scale when you're ready.