Skip to content
Tutorials Center
My learning

Topics

Lesson 29 of 37 ยท Previews and Teams

Teams and Permissions

Organize work with teams on Vercel and Netlify: roles, inviting members, Git provider access, protecting production, audit logs, SSO and tokens for automation, with a role-check model.

A personal account is fine for a hobby site. The moment two people work on one project you need a team (Vercel) or a team/organization (Netlify): a shared owner for projects, domains, billing and secrets, with different members allowed to do different things. This lesson covers how access is organized and how to keep it safe.

The dashboards cannot run here. Role names and plan limits change, so treat the lists below as a guide and check the current documentation. The runnable code is a JavaScript stand-in that models a permissions matrix.

What a team owns

  • Projects (sites) and their deployments.
  • Domains and DNS records managed on the platform.
  • Environment variables and integrations.
  • Billing, usage and plan limits.
  • Members, invitations, and access tokens.

Moving a project into a team also affects Git: the team connects to a Git organization or user, and builds run with the team's permissions. On Vercel the Hobby plan is for personal, non-commercial use, so company projects belong on a Pro or Enterprise team. Netlify's free plan has its own team limits. Check terms before launching something commercial on a free tier.

Roles

Typical roles, from most to least powerful (names vary by plan):

Role Typical abilities
Owner everything, including billing, deleting the team and managing owners
Admin / Member create and edit projects, manage domains and variables
Developer / Contributor deploy and trigger previews, view logs; limited access to secrets and settings
Viewer / Billing read-only access, or only billing pages

On Vercel, Pro teams include Owner, Member, Developer, Billing and Viewer-style roles, with finer-grained controls on Enterprise. The principle matters more than names: least privilege. A developer needs to push code and look at previews, but does not need to delete the production domain or read production secrets.

Roles in a team

Owner Billing and everything else.
Admin Projects, domains, variables.
Developer Deploy and read logs.
Viewer Read-only access.

Give people the least access they need.

1 / 2

Who can deploy production?

Deployment permission comes from two places: the platform role and the Git repository. Anyone who can merge to the production branch can effectively deploy to production. So protect the branch in your Git host: require pull requests, reviews and passing checks. Some teams go further and set the project so that only certain members can promote or redeploy (see Rollbacks and Promotions). Forked pull requests from outsiders should not receive secrets; both platforms withhold environment variables from builds triggered by forks unless you allow it.

Checking permissions in code

A permission matrix is just a table, and checking it is a lookup. Implementing it as data keeps behavior easy to review.

JS Role matrix stand-in

Press Run (or Ctrl + Enter) to see the console output here.

No output.

Auditing who has too much

Over time permissions accumulate. This stand-in reports members whose role is stronger than their recent activity needs, a simple review you might run each quarter.

JS Access review stand-in

Press Run (or Ctrl + Enter) to see the console output here.

No output.

Identity: SSO, 2FA and sign-in

  • Turn on two-factor authentication for everyone, and require it team-wide where the plan allows.
  • SSO/SAML (Enterprise or business plans) ties access to your company identity provider, so offboarding someone removes platform access automatically.
  • Sign in through the Git provider only if that account is itself protected; a compromised GitHub account can mean a compromised deployment.

Tokens and automation

CI scripts and the CLI use access tokens instead of passwords. Create one per purpose, with the smallest scope available, name it (ci-deploy-2030), store it as a secret in your CI system, and rotate it on a schedule or when anyone with access leaves. Never commit tokens to a repository: scanners find them in minutes. Deploy hooks (a secret URL that triggers a build) deserve the same care; regenerate one if it leaks.

Audit logs and activity

Higher plans keep an audit log of who changed what: domain edits, variable changes, member invitations and deployments. Even without a log, the deployment list shows who triggered each deployment (a person, a Git push, or an API). Review it when something unexpected goes live.

Practical checklist

  1. Two owners at least, so one person leaving never locks the team out.
  2. Branch protection on the production branch.
  3. Production secrets visible only to roles that need them.
  4. 2FA on, SSO if available, stale members removed.
  5. Tokens scoped, named and rotated.

Check your understanding

Quick check ยท 4 questions

of 4 answered You scored / 4 ยท perfect!

  1. 1. What does least privilege mean for team roles?

    Narrow access limits the damage from mistakes and compromised accounts.
  2. 2. Why does branch protection in Git matter for production safety?

    The platform deploys what lands on the production branch, so control of the branch is control of production.
  3. 3. How should a CI access token be handled?

    Tokens are credentials. Keep them out of code and rotate them.
  4. 4. Why have at least two owners?

    A single owner is a single point of failure for billing and recovery.

Summary

  • Teams share projects, domains, variables, billing and members.
  • Roles should follow least privilege; names differ by plan.
  • Production access is gated by both platform roles and Git branch rules.
  • Enable 2FA, use SSO where possible, and review members regularly.
  • Scope, name and rotate tokens; keep two owners.

Next: Rollbacks and Promotions