Dataverse gives you three access-control primitives that combine into a permission model: business units (BUs), security roles, and teams. On paper they are simple. In practice, every project that runs for more than a year develops the same failure mode: the security model grows by accretion - a new role for every department, a new team for every project, a new business unit every time someone says "but we need regional data separation." By year three, the model has twenty roles nobody remembers the purpose of, and access audits take a week.

We have walked three projects through a security restructure. The first took five weeks because we waited too long. The last took a week because we caught it at month three. Here is the pattern.

What the primitives actually do

Business unit: the hierarchical container for users and records. A row in Dataverse is owned by a user or team, which sits in a BU. BUs form a tree from the root down.

Security role: a set of privileges per table (Create / Read / Write / Delete / Append / Append To / Assign / Share) and per scope (User / Business Unit / Parent:Child / Organization). Users get one or more roles.

Team: a group of users that can own records collectively and can have roles assigned to the team (all members inherit).

The common misreading is thinking of roles as job titles ("Sales Rep") and BUs as departments ("Sales"). The native mapping is actually:

• BUs for data isolation (regions, countries, acquired companies whose data should not mix)
• Roles for capability (Read accounts, Edit opportunities, Export to Excel)
• Teams for cross-BU collaboration and shared ownership of records

When you try to use roles for data isolation ("a Europe Sales Rep role vs a US Sales Rep role") instead of BUs, you end up with N copies of the same role for each N regions. When you try to use BUs for capability ("a Read-Only BU") you get nonsense trees.

The symptoms of accretion

A project's security model has drifted when we see:

• Ten or more custom roles with names like "Sales Rep v2", "Sales Rep Special Cases", "Sales Rep US Mountain Region"
• Users who have four or five roles stacked on one account to get the right combined access
• Teams created to hold users that do not actually share record ownership (used as a proxy for group assignment)
• A BU tree deeper than three levels
• Business owners who cannot answer "who can see this record?" without an engineer running a query

We inherited all five symptoms at a client last year, and the fix below is what we ran.

The restructure in eight steps

1. Inventory what exists. Export the security role matrix to a spreadsheet. Every role, every table, every privilege. This single document is the starting point of every conversation.

2. Group roles by intent. Look at the column of privileges per role and find clusters. Most "custom roles" actually map to 3-5 intents: Read-Only, Standard User, Power User, Admin, System Admin. Anything more granular is almost always a slight variation.

3. Define capability roles. Replace the cluster from step 2 with 3-5 canonical roles:

• acme_read_only - read on every business table, no write
• acme_standard_user - read + write on assigned records (User scope)
• acme_power_user - read + write + append + assign on BU scope
• acme_admin - all privileges, Organization scope
• Plus one optional: acme_integration for service principal integrations

1. Identify real data isolation requirements. Most projects need ZERO BUs beyond the root. Ask concretely: "If a user sees a record they should not, does the business have an audit or compliance problem?" For most internal CRMs, the answer is no. For multi-country businesses with data residency rules, the answer is yes and you need one BU per country.

2. Collapse the BU tree. If you have seven BUs and zero of them have a compliance rationale, move all users to the root BU and delete the others. This is the biggest unlock - most "BU-scoped access" issues disappear when the tree flattens.

3. Use teams for ownership, not assignment. A team should own records that multiple users share responsibility for (a deal desk queue, a support triage pool). Do not create teams to hold users who share a role - that is what the role is for.

4. Migrate users to the new role set. Assign the new canonical roles; remove the old custom roles one by one and verify nothing breaks. Do this in a UAT mirror first, not in Prod.

5. Lock further role creation. New security roles require an explicit ticket and justification. "We need a new role for X" usually maps to "we need to add a capability to an existing role." Making the default answer "no" keeps the model clean for the long run.

The quarterly access review we run

Even a clean model drifts. Every quarter:

• Export the role-to-user assignment matrix
• Flag users with three or more roles (possible consolidation opportunity)
• Flag roles with only one user (possible deletion)
• Spot-check ten users: "can they see what they should and nothing more?" Walk their access in the UI
• Review the team membership: do all the teams still exist for their original purpose?

45 minutes per quarter, one engineer. The output is either "no changes" or a ticket to consolidate a role. Either outcome is healthy.

One gotcha that catches teams out

Changing a security role that is actively assigned to users does not always propagate immediately. Role changes take effect on the next user action or after a cache refresh, which can be up to fifteen minutes.

If you remove a privilege from a role expecting the change to apply now, and a user who has that role does something in the window between your change and their cache refresh, the old privilege is still in effect.

For non-urgent changes: ignore it, the cache will clear. For security-critical revocations (compromised account, departing employee): disable the user account, not the role. Account disable is immediate; role changes are eventually consistent.

What to do if you are in the accretion phase now

If your project is six months in and you already see four custom roles with overlapping purpose: stop adding, don't restructure yet. Let the scope settle for another month, note every "new role" ticket that comes in without approving it, then run the eight-step restructure at month three. One week of focused work saves four weeks later.

If your project is two years in and unmaintainable: block out a dedicated two-week window, do the full restructure, treat it as a one-time debt payment, and then install the quarterly review. The pain does not go away on its own.