CRM permissions: how to decide who sees what
The short answer: start with a table that says, for every role, which records it sees, which fields it sees and which fields it can edit. Enforce that table in the database itself, and prove it with tests that check what each role can't see. Everything else follows from those three moves.
One of the most recent systems we built belongs to a field organisation: 4 permission levels, about 30 branches spread over about 60 locations, and a master list of about 11,500 contacts with sensitive personal data. Most of what's below we learned there, and in our own internal systems.
Last updated: November 17, 2026
What are CRM permissions?
CRM permissions are the rules that decide, for each user, which records they see, which fields inside those records they see, and what they're allowed to change. In most businesses it starts as "who sees whose customers" and gets complicated the moment you add branches, managers and sensitive data.
There are three separate decisions in there, and it pays to keep them apart:
- Records: which slice of the table a user sees at all. A rep sees their own accounts, a regional manager sees the region.
- Fields: inside a record they can see, which columns show. A branch coordinator sees a phone number and never sees an ID number.
- Actions: what they can do with what they see. View, edit, delete, export.
Most permission messes we walk into started when someone tried to solve all three with a single checkbox called "Manager".
How many user roles does a CRM need?
Most organisations get by with 3 to 5 roles. If you've ended up with 9, some of them are probably the same role covering a different area, and the area belongs on the user as data.
The field organisation came out at 4 levels, each defined by scope and by what it may touch:
| Role | Sees | Edits |
|---|---|---|
| System admin | Everything, including the audit log | Users, roles, settings, any record |
| Area manager | Every branch in their area, all fields except the most sensitive | Branch assignments, statuses, tasks in the area |
| Branch coordinator | Only their branch's contacts, without sensitive identifying fields | Contact details, status, notes on their branch's people |
| Field member | The work list assigned to them, with the fields needed to do it | The task outcome only |
Look at the middle column. We didn't make most of those calls. The client sent us a spreadsheet where every row was a field and every column was a role, with "sees", "edits" or blank in each cell. We asked for that sheet before writing a line of code, and it became the permissions spec almost unchanged.
If you're just starting, that's the first thing to prepare: a fields-by-roles sheet, filled in by the people who know the work.
Record-level or field-level permissions: which do you need?
You almost always need both. Record-level permissions answer "whose customer is this", field-level permissions answer "what about this customer may be shown". A system with only one of them leaks through the other.
An example from the field build: a branch coordinator has to see every contact in their branch to do the job. They don't need sensitive identifying data about those people. Without field-level rules, we'd have had to choose between a coordinator who can't work and a coordinator who sees everything.
Field-level permissions are also where off-the-shelf tools tend to run out. In some, the restriction is only on the top plans. In others, it hides the field on screen while an export or an API call still returns it. Check that specifically before you pick a tool.
Where should role-based access be enforced?
In the database. If a permission only exists in the screen, every bug in a screen, every new report and every outside integration is a possible leak.
In the field organisation's system, rows are filtered inside Postgres with row-level security. When a branch coordinator runs a query, the database returns only their branch's rows, whichever screen or API the query came from. A developer who builds a new screen tomorrow and forgets the branch filter gets, at worst, a screen that shows less than they meant. Rows from another branch stop at the database.
Of everything here, this is the decision that matters most. It decides whether a programmer's mistake becomes a bug or a breach.
What should you ask before building the data model?
Ask what each unit in the organisation actually does in the system: is it something you report on, or only an access boundary? The answer changes the tables, so you need it before anything gets built.
For us the unit was the "branch". If a branch is only an access boundary, it's a column on the contact and on the user, and that's it. If people report on it (targets per branch, results per branch, branch against branch), it needs its own table, a history of reassignments, and reports built around it. That question held up the data model until we had an answer, and rightly so. Had we guessed, we'd have rebuilt half the tables.
The same question comes back wearing other names: "team", "region", "a business customer with several users". Before you define permissions, ask of each one whether anybody will ever want a report on it.
How do you test that CRM permissions actually work?
You test that each role can't see what it shouldn't, on top of testing that it sees what it should. These are called denial tests, and without them you have no evidence your permissions exist.
A normal test checks that a branch coordinator sees their contacts. A denial test logs in as the coordinator of branch A, asks for a contact from branch B, and checks the answer comes back empty. We write one for every role and every kind of sensitive data, and they run on every code change.
One more lesson, from our own systems: a security check written as optional doesn't run. In one of our internal tools, a scope check on the user was something every route was "supposed to" call. 11 routes shipped without it. We caught it and made the check required at the framework level, so a route without a scope check doesn't build.
Why do you need an audit log, and who should read it?
An audit log records who viewed what and who changed what, and the system admin should be able to open it and read it without a developer. An audit table that stays shut inside the database protects nothing.
In the field organisation's system, access to the data required a signed NDA first, and only then did the account open. From that point every view of a sensitive record and every change is logged. The admin area has a page that shows the log in plain words ("Dana updated the phone number of a contact in branch 12"), filtered by person and by area. When something looks off, the admin finds the answer themselves without asking a developer to dig through tables.
It's worth writing the log in the database too, in the same operation as the change. A log written from the screen misses exactly the changes that didn't come through the screen.
How do you explain roles to the team?
Put the explanation where the role gets picked. On the Users page, next to the list where you choose a role for a new user, show what each role can open and do, in a sentence or two.
A separate "about roles" page just adds a second window for one question. The moment someone needs the explanation is the moment they're granting access, and that's where it should be waiting. We generate the text from the same source the permissions come from, so it doesn't go stale the next time someone changes a role.
What does Israel's Amendment 13 mean for CRM permissions?
Amendment 13 to Israel's Protection of Privacy Law, in force since August 2025, widened the enforcement powers of the Privacy Protection Authority and raised the cost of careless handling of personal data, especially sensitive data. This isn't legal advice, and how it applies to your organisation is a question for a privacy lawyer.
What we can say from the technical side: an organisation that can show who may see what, where that's enforced, and who actually looked at what is in a far better place than one whose data sits in a shared spreadsheet. Permissions, the audit log and denial tests are exactly the things you can put on the table when someone asks. If you also work with European customers, see our guide to the EU AI Act and ISO 42001.
How do permissions fit into the build-or-buy decision?
Permissions are one of the most common reasons to build a CRM. If you hold sensitive data, have several layers of scope (branch, region, organisation) and need to prove who saw what, test that against any tool before anything else.
We cover the full decision in our guide to building or buying a CRM, and the ready-made options in monday vs Fireberry vs HubSpot. If you already know you're building, that's our custom CRM development work.
FAQ
Can monday or Fireberry do this?
Some of it. Both have roles and permissions, and set up properly they can limit what each user sees. Field-level restrictions sometimes depend on the plan, and filtering rows by branch or region often needs workarounds. With sensitive data and several layers of scope, check what happens in exports and the API as well as on screen.
How many roles do we need?
Usually 3 to 5. Start with how much each person needs to see (their own, their team, their area, everything), then who needs to edit what. If two roles differ only by the area they cover, they're one role with an area assignment.
What's the difference between record-level and field-level permissions?
Record-level permissions decide which customers or contacts a user sees at all. Field-level permissions decide which details about each of them the user sees or edits. Almost every system we've built needed both.
What about managers who need to see everything?
Give them a role whose scope is the whole organisation, and keep them in the audit log like everyone else. A manager who sees everything usually needs to edit very little, so separate broad viewing from broad editing. And ask whether they really need the sensitive fields, or just the numbers.
Can external users like clients or suppliers get access?
Yes, as a separate role scoped to their own organisation's records, with the fields you've chosen to show them. External users are exactly where database enforcement and denial tests matter most, because they're the first person who'll try changing a number in the URL.
Next step
If a spreadsheet is already doing the job of your customer system and you're not sure who sees what in it, talk to us. We'll go through the roles and fields with you and tell you whether you need a new system or just some order in the one you have.



