If you’re reading this, you probably just got handed the keys to your team’s Provarity account and now you’re supposed to “set up user permissions.” Maybe you’re a team lead, an admin, or just the person who’s good with software. Either way, you want to keep things secure and organized without creating a mess you’ll regret later. This guide is for you.
I’ll walk you through the basics, flag the stuff that actually matters, and help you avoid traps that waste time or make life harder down the road.
Why user permissions matter (even if you’re small)
Quick reality check: user permissions aren’t just for big companies or paranoid IT folks. Even with a handful of users, it’s easy for things to get out of hand—accidental deletions, people seeing stuff they shouldn’t, or chaos when someone leaves the team. Setting up permissions in Provarity is about keeping your data safe and your team working smoothly, not making things complicated.
Step 1: Get familiar with Provarity’s permission model
Before you start clicking around, it’s worth understanding how Provarity actually handles permissions. Here’s the honest rundown:
- Roles-based, mostly: Provarity uses roles to group permissions (think Admin, Editor, Viewer). You assign users to roles, and the roles control what they can do.
- Some granular overrides: For certain projects or resources, you can tweak permissions more specifically, but most teams just stick with roles.
- No magic “undo” button: If you give someone more access than you meant to, there’s not always a quick fix. Plan before you assign.
The default roles (and what they actually mean)
- Admin: Full control. Can add/remove users, change settings, and see everything. Only trust admins who need to be admins.
- Editor: Can create, edit, and (sometimes) delete content, but can’t change user settings or global configs.
- Viewer: Read-only. Can see stuff but can’t mess with it.
Pro tip: Don’t make everyone an Admin “just in case.” That’s a recipe for disaster.
Step 2: Make a quick list of who needs what
This step feels boring, but it’ll save you from headaches and awkward “why can’t I see this?” emails later.
- Write down (or spreadsheet out) your team members and what they actually need to do in Provarity.
- Ask yourself: Who really needs editing power? Who just needs to see reports?
- For contractors or temps, err on the side of less access.
If you’re not sure, start with less access—you can always add more later.
Step 3: Add users to Provarity
Let’s get people into the system.
- Go to Settings > Users: This is where you manage your team.
- Hit “Add User” or “Invite User”: The button name might differ, but it’s usually obvious.
- Enter their email address: Double-check spelling; typos here are a pain to fix.
- Assign a role: Pick from Admin, Editor, or Viewer.
- Send the invite: The user gets an email to join.
A few things to know: - People don’t get access until they accept the invite. - If someone doesn’t get the email, check spam, or resend. - You can’t assign more than one role per user (unless your org pays for advanced features).
Step 4: Fine-tune permissions for sensitive projects
Not everyone needs to see everything. If you’ve got client data, confidential projects, or sensitive info, use Provarity’s granular permissions.
- Navigate to the project/resource: Find the thing you want to lock down.
- Look for “Manage Access” or “Permissions”: This is usually a tab or option in the project settings.
- Add/remove users or roles: You can give specific people access, or exclude certain roles.
- Save changes: Don’t forget this part (yes, obvious, but you’d be surprised).
Honest take: Most teams skip this step and regret it later. If you’re dealing with anything private, take five minutes to set this up now.
Step 5: Review and test access (don’t skip this)
You’d be amazed how often people think permissions are set up… only to get frantic calls when someone clicks into the wrong project.
- Log in as a non-admin user (or ask a teammate to): See what they can actually do.
- Try to access something they shouldn’t: If they can, go back and fix it.
- Check for “View Only” vs “Edit” rights: Sometimes the UI looks the same even if the permissions aren’t.
Pro tip: Do this before you roll out to the whole team or a new client. Better safe than sorry.
Step 6: Set up permission hygiene for the future
Setting things up once isn’t enough. Permissions should be reviewed every so often—especially when people join, leave, or change roles.
- Remove users who leave: Don’t just deactivate, actually remove them.
- Downgrade roles if responsibilities change: Not everyone needs to stay an Editor forever.
- Mark your calendar: Check permissions every quarter. It takes five minutes and saves you from bigger problems.
What to ignore: Don’t bother with super-complicated permission setups unless you’re a giant company or have strict compliance rules. Keep it simple.
Common pitfalls to avoid
Here’s where most people trip up:
- Making everyone an Admin “just to get started.” This is bad. People rarely get demoted later.
- Not removing ex-employees or contractors. Orphaned accounts can be a security risk.
- Ignoring project-level permissions. If you work with clients or private data, don’t skip this.
- Assuming the system is secure by default. It’s only as secure as you set it up to be.
When you need advanced features
Provarity’s standard roles work for most teams, but if you need things like:
- Audit logs
- Custom roles (beyond Admin/Editor/Viewer)
- Integration with your company’s SSO or user directory
…you’ll need to talk to their support or upgrade your plan. Be honest about whether you really need this, or if it’s just “nice to have.” Most small teams don’t.
Quick troubleshooting
- Invites not arriving? Double-check the email, ask them to check spam, or resend.
- User can’t see a project? Check project-level permissions. They might only have global Viewer rights.
- Locked yourself out? If there’s another Admin, ask them to restore your access. If not, contact support.
Keep it simple (and don’t overthink it)
Setting up user permissions in Provarity isn’t rocket science, but it does matter. Start with the basics: assign roles based on what people actually need, make sure sensitive stuff is locked down, and check your work before going live. Don’t get sucked into endless permission tweaks—keep it simple, review every so often, and fix things as your team changes.
You’ll save yourself a lot of headaches, and your team will thank you for not turning user management into a nightmare.