Role-based access control (RBAC) means giving people access through roles instead of one by one: you define a role such as "Engineer", attach to it the permissions that job needs, and then assign people to the role. When someone joins, moves or leaves, you change which role they hold, not a long list of individual permissions.
For a small company, the hard part is not the concept. It is that every tool you use has its own roles, with its own names, and none of them know what an "Engineer" is at your company. This post covers the model properly, how it differs from ABAC and access control lists, and how a 20-person company writes its first role matrix.
RBAC in plain terms
RBAC has a small vocabulary. Every term is worth getting right, because vendors use them loosely.
A user is a person (or sometimes a service) who needs access. A permission is the right to perform an operation on an object: "read this repository", "approve an expense", "invite a member". Permissions are the actual capabilities. A role is a named set of permissions that matches a job function. "Support agent" is a role; "Sam" is not.
Two assignments connect them. User assignment says which users hold which roles, and a person can hold more than one. Permission assignment says which permissions each role carries. Users never get permissions directly; they get them through roles.
The point of the indirection is that jobs change much less often than people do. You decide once what a support agent needs. After that, onboarding a support agent is one assignment, and changing what every support agent can do is one edit to the role, not twenty edits to twenty people.
Two further ideas complete the model. A role hierarchy lets a senior role inherit a junior role's permissions: "Engineering lead" is "Engineer" plus a few things, so you define only the plus. Separation of duty says some combinations of roles should never sit with one person: the person who adds a new supplier should not also be the one who approves paying them. RBAC can express that as mutually exclusive roles.
The model was formalized by David Ferraiolo and Rick Kuhn, at the US National Institute of Standards and Technology (NIST), in a 1992 paper. A unified NIST model followed in 2000 and was adopted as the standard ANSI/INCITS 359-2004, revised in 2012, according to NIST's RBAC project page, which we read on 27 October 2026 (the project is now archived). The standard defines a reference model of users, roles, permissions, operations and objects, and a functional specification for systems that implement it. You do not need to read it to run RBAC in a small company, but when a tool says it "supports RBAC", this is the yardstick.
RBAC vs ABAC vs ACL
RBAC is one of three common ways to decide who can do what. Most real systems mix them.
| Model | How a decision is made | Good at | Weak at |
|---|---|---|---|
| ACL (access control list) | Each object carries a list of who can do what to it | Sharing one specific thing with one person | Answering "what can Sam reach?" across thousands of objects |
| RBAC (role-based) | The person's roles carry the permissions | Repeatable access by job; easy onboarding | Exceptions and conditions; can sprawl into too many roles |
| ABAC (attribute-based) | Rules evaluate attributes of the person, the object, the action and the context | Conditions: department, device, location, data label | Hard to write, test and explain; needs good attribute data |
ACLs are the oldest and the most familiar. A shared Google Drive file with its list of people and their access is, in effect, an ACL. They are fine for one-off sharing and terrible for auditing, because access is scattered across every object.
ABAC is described in NIST Special Publication 800-162, Guide to Attribute Based Access Control (ABAC) Definition and Considerations, published in January 2014. Access is decided by evaluating attributes against policies: "people in finance, on a managed device, may open payroll reports". Identity providers' conditional access rules are ABAC in spirit. It is powerful and much harder to get right.
For a small team the practical answer is: RBAC for the baseline, a few conditions where your tools offer them, and ACL-style sharing for genuinely one-off cases, recorded so you can undo them.
RBAC and least privilege
RBAC and least privilege are related but different. The principle of least privilege is the goal: each person has only what their job needs. RBAC is one mechanism for reaching it. You can run RBAC badly, with a fat "Everyone" role that hands out admin rights, and violate least privilege completely. You can also reach least privilege without RBAC, by deciding every person's access by hand; it just stops scaling at about the point where you can no longer remember everyone's access.
Company roles vs tool roles
Here is the problem small companies actually hit. RBAC works neatly inside one system. You run thirty systems, and each has its own idea of a role.
As each vendor's documentation described them on 27 October 2026:
| Tool | Its roles | Note |
|---|---|---|
| Slack | Primary Owner, Workspace Owners, Workspace Admins, full members, guests (multi- and single-channel), channel managers | Extra "system roles" such as Security Admin on Business+ (limited) and Enterprise (source) |
| GitHub organization | Owners, members, moderators, billing managers, security managers, outside collaborators; per repository: Read, Triage, Write, Maintain, Admin | Custom organization and repository roles need Enterprise Cloud (source) |
| Google Workspace (admins) | Prebuilt admin roles such as Super Admin, User Management Admin, Help Desk Admin, Groups Admin, Services Admin | Custom admin roles can be created (source) |
| Figma | Seat types: Full, Dev, Collab, each priced differently | Here the "role" that matters most is also a billing decision (source) |
Notice the pattern. The tool's roles describe the tool's own powers: who can delete the workspace, who can push code. Your company's roles describe jobs: engineer, designer, account executive. Neither maps cleanly onto the other. And the flexible part, custom roles, is often on the expensive plan: GitHub's custom roles are Enterprise Cloud only.
Some tool roles are also billing decisions in disguise. In Slack, multi-channel guests are "billed as regular members" while single-channel guests are free, up to five per paid active member, per Slack's guest help article as we read it on 27 October 2026. Choosing the role is choosing the invoice.
So "doing RBAC" in a small company does not mean buying an RBAC system. It means writing down, for each company role, which role it gets in each tool.
Mapping one to the other: your first role matrix
A role matrix is a table with company roles down the side, tools across the top, and the tool role in each cell. It is the single most useful access document a small company can own. Here is how a 20-person company writes its first one in an afternoon.
List the tools. All of them, from the finance tool to the one-off analytics account. The list of third-party apps connected to Google Workspace, in the admin console, and your company card statements will remind you of the ones you forgot. Shadow IT covers the tools nobody told you about.
List the jobs, not the people. Group people by what they do: engineering, design, sales, support, operations. Add a baseline row, "Everyone", for what every employee gets.
Fill each cell with the least the job needs. Member, not admin. Viewer, not editor, where viewing is enough. Leave the cell empty if the job does not need the tool.
Mark paid seats. So nobody adds an expensive seat by following the matrix.
Keep admin out of job roles. Admin rights go to named people, two per critical tool so you are never locked out, and are listed separately with the reason.
Give each tool an owner. The person who answers "should Sam have this?" for that tool.
A first version might look like this:
| Company role | Google Workspace | Slack | GitHub | Figma | HubSpot | Help desk |
|---|---|---|---|---|---|---|
| Everyone | User, all-staff group | Full member | — | — | — | — |
| Engineer | + engineering group | + #eng channels | Member, engineering team (Write) | Collab seat | — | — |
| Designer | + design group | + #design channels | — | Full seat | — | — |
| Sales | + sales group | + #sales channels | — | — | Sales seat | Viewer |
| Support | + support group | + #support channels | Read, docs repository only | — | View-only | Agent |
Admins, by name: Google Workspace Super Admin: two named people. Slack Workspace Owner: two. GitHub organization owner: two. Each with a one-line reason.
Notice that the "Everyone" row is a role hierarchy in miniature: each job row inherits it and lists only the additions, marked with a plus. That keeps the matrix short and makes a change to the baseline a single edit.
How many roles a small company should have
As few as describe the distinct jobs. A baseline plus one per team is the normal start, so a company with five teams has six rows. If you find yourself with more roles than teams, you are probably describing individual people, which is the problem the section on keeping roles current is about.
Contractors, guests and shared accounts
Contractors are not a job; they are a relationship. Give them the job role that matches their work, narrowed where the tool allows it (a guest instead of a member, one project instead of all), and an end date. Do not create a "Contractor" role that means something different in every engagement. Contractor access management covers the rest.
Shared logins break RBAC outright, because the account's role applies to everyone who knows the password and the tool cannot tell them apart. If a tool forces a shared account, list it in the matrix with a named owner. Shared accounts has the fix.
Bundles
A role matrix is a document. A bundle is the same row, made executable: the list of tools and tool roles that "Engineer" means, applied in one action when someone takes the role.
Bundles are where RBAC pays off for small teams. A joiner gets the bundle for their role. A mover gets the difference between the old bundle and the new one: added access on day one, old access removed after a handover period (the JML process covers movers in detail). A leaver loses everything in every bundle, plus whatever they collected outside it. The hub on user provisioning has more on running bundles day to day.
Keeping roles current
Roles rot in two ways.
Role explosion. Every exception becomes a new role. "Engineer", then "Engineer with billing access", then "Engineer with billing, London". Before long you have nearly as many roles as people, and RBAC has turned back into per-person access with extra paperwork.
The cure is structural. Keep base roles coarse and stable. Use a small number of add-on roles that combine with any base role, such as "On-call" or "Billing admin", instead of crossing every base role with every extra. Treat true one-offs as named exceptions: a person, a tool, a reason, an end date, recorded but not baked into a role. And when the same exception keeps appearing for several people, promote it to an add-on role.
Role drift. The matrix says one thing; the tools say another. People were given things outside their role, roles were changed in one tool but not the rest, a new tool was adopted and never added to the matrix.
Three habits keep the two aligned. Add every new tool to the matrix before anyone gets access to it. Change a role in one place, then apply it to everyone who holds it, because editing the role and leaving the existing holders alone is how drift starts. And review on a schedule: compare each tool's actual members and roles with the matrix, every quarter or so. The user access review post has a process and a template.
Where SmashSSO fits
SmashSSO turns the role matrix into something that runs. Its access bundles are company roles mapped to tool roles: "Engineer" can mean GitHub member, Slack full member, Figma Collab seat, and so on. Assigning a bundle invites the person to every tool in it with the right role; changing roles and removing access run the same way. It reads your people from Google Workspace and shows an access grid of who has which role in each tool, so drift from the matrix is visible, and accounts that match nobody in your directory are flagged.
Changes go through a tool's member API where you have added a token, or an agent in your own Chrome, in tabs where you are already signed in as an admin, which needs that browser open. Paid seats pause for approval, and every change is recorded in an audit log. It works within each tool's existing roles: it cannot create a custom role a tool's plan does not offer. And it is not SSO. It costs a flat fee from $199 a month billed annually (pricing).