Permissions and Roles

September 15, 2026
Outcomes
Adoption: Project Editor role assignment went from 20 to 140 in 30 days
Pushed migration from legacy platform from 60% to over 80% at launch
Delivered project permissions and custom roles coherently
My roles

UX, UI, Research, Prototyping, Product decisions (PM on leave)

Opportunity

How might we let admins give the right people the right access at every level — org, team and project — without having to memorize what each role can do?

Solution

A scoped access model with a centralized permission drawer, an additive rule for how roles stack, and a role/permission chart that sits right where admins assign roles.

Team: Pod 5 — EM Jeff DeWitt; engineers Giu, Jacob, Jessica; QA Adam

Timeline: 3 cycles, Q2–Sep 2026 (Cycles 5–7)

Project summary

Document Crunch 2.0 only let admins grant access at the org or team level. Enterprise customers couldn't limit a project manager to just their projects, so they stayed on 1.0. Two of the five customers I interviewed named this as the single thing blocking their migration.

"It's kind of the one thing that's holding us from moving over to the 2.0... just the permission access." — Kristen Ortiz, Hill & Wilkinson

The pitch framed it as "add project-level access." In reality, access level and permissions were tangled together, and the scope turned out much larger than the PRD suggested.

Outcome

Migration from legacy platform to 2.0 improved drastically as we gradually rolled out project level roles and permissions; adoption was also steadily climbing.

Challenges
  • Two projects became one: Mid-project, I took over Custom Roles from a designer who went on sabbatical. It turned out permissions and custom roles were the same system seen from two sides.
  • No PM in the room: Our PM went on leave during the cycle, so I made many of the scope and product calls with engineering.
  • A rigid hierarchy: Our system only supported top-down roles. A child's role could never override a parent's.
  • Not everyone wants granularity: Boldt (300–400 users) had abandoned per-project access in 1.0 as "a management nightmare," so the design had to stay simple for coarse setups too.
How was it done?

I started with my usual process — stakeholders, customers, then a prototype — and let each round of feedback reshape the scope.

  • Separate scope from capability: I split the model into access levels (org, team, project) and roles (Admin, Editor, Viewer, Custom). This gave us an "opinionated but flexible" foundation.
  • Three personas:
    • Ops manager: "I want to verify the right people have the right access in one view."
    • Contract admin: "I want our teams to manage their own users."
    • Project manager: "I only want to see projects I'm working on."
  • Cycle 5 prototype: Following the pitch, I built a simple flow to invite users at any level and assign them to teams and projects, including picking several projects at once.
  • Feedback changed the brief: Customers liked it, but asked for one place to see what access each person has.
The permission drawer

Admins wanted a centralized view, so I designed a permission drawer: one panel showing a person's access from org down to each team and project.

"A couple hundred users... it would be very time-consuming to click on a person's name, see what projects they have access to." — Daniel Jaimes, Balfour Beatty

Customers praised its vertical, high-to-low layout over the horizontal or tabbed layouts in other tools. But putting every level in one view also exposed how complex our role hierarchy really was.

Hard call #1: Hide roles that can't apply

Our system was top-down, so a child's role could never override a parent's. Rather than fight the architecture, I tested whether it was a problem at all.

  • Validated quickly: I checked the top-down model with 6 users. They were fine with it, as long as the rules were clear.
  • Decision: Hide roles with fewer permissions than the parent's. If someone is an Editor on a team, you can't assign them Viewer on that team's projects.
  • Result: Fewer dead-end choices, and no role that silently does nothing.
Hard call #2: An additive model for custom roles

Then I learned about Custom Roles. With custom permission sets, there's no "higher" or "lower" role, so my hide-the-lower-roles rule fell apart.

A project role can add permissions but never take any away, so a lower role simply changes nothing — and we say so.

  • Decision: Working with engineering, we told users plainly that permissions are additive. A child role only adds permissions on top of its parent's role.
  • No silent failures: When a role adds nothing new, the UI says "No additional permissions" right where it's applied.
  • Design grids: We mapped every scenario: what an assigner with each role sees, and can do, to users with each role. These grids became the shared spec for design, engineering and QA.
Surprise finding

Users understood the permission model better than I expected. The people who manage users tend to be more tech-savvy, and every participant read our "dash = no role assigned" convention correctly on first try.

The real problem was memory: "I don't remember which role can do what."

The role/permission chart

In Cycle 7, I designed a role/permission chart that opens right where admins assign or edit a role. It shows exactly which role can do what, at which level, so admins never have to guess or leave the flow.

User research and testing

I ran 5 moderated sessions from June 29 to July 22, 2026, with customers ranging from a 6-person compliance team to a general contractor consolidating about 1,000 users.

  • Migration blocker: 2 of 5 orgs named project-level permissions as the reason they hadn't moved to 2.0.
  • Hidden but loved: Group-by-project was validated by all 4 participants who saw it, but none found it on their own.
  • Reassign, not invite: The common case was moving existing users to new projects, not inviting new users to many projects at once.
  • Action-level control: Two orgs had real incidents (an accidental delete, a non-compliant upload) caused by roles that were too broad.
Design decisions

Cycle 7 focused on usability, guided by feedback from CS and Sales:

  • Visual and content clarity: Clearer hierarchy and copy, so the many options in custom roles feel less daunting.
  • Do, undo, redo: A way to add someone back, since removing all of a user's roles made them disappear.
  • Make users feel smart: An alert before consequential actions, like giving someone access to every project in a team.
  • Context everywhere: Subtext and tooltips that explain why an action is or isn't available.
  • Bonus: Custom project fields, so admins can declutter the project creation modal.
Collaborations

With our PM on leave, I worked directly with EM Jeff DeWitt and engineers Giu, Jacob and Jessica to make scope calls each cycle. The additive model came out of working sessions with engineering, and the design grids gave us one shared source of truth. QA tested the grid scenarios one by one.

‍

Process

Yes, the dreaded coming soon...

Visual designs

No items found.

More projects

Never stop learning
Whenever I have some time, which isn't often as a father, I like to learn something new. Here are some of my latest certificates.