An access review can become a list of names and roles that everyone approves because nothing looks unusual. Yet a former team member may still have access through a parent group, while a maintainer keeps a broad role because nobody has examined the one task they need it for.
A stronger review connects access to work. Can someone carry out their responsibility, and can they reach or change anything they no longer need? That question works for people and automation, whether you're reviewing one project or a larger group.
Choose a place where access is difficult to explain
A project with frequent access requests, several collaborating teams, or sensitive release work is a good starting point. Its maintainers can explain the work, while group and identity administrators can help trace how access is granted. Reviewing it together is more informative than asking one owner to approve an unfamiliar export.
The first comparison is between responsibilities and actions. Someone who contributes code, someone who manages project settings, and someone who only needs to follow an issue may need different access. Job titles and seniority don't establish those needs. GitLab's permission tables let you check the actions involved instead of treating every role as a step on one ladder.
For each questionable grant, a short note can hold the responsibility, the access path, the decision, and any change to follow up. An existing access-review issue is enough. The record should help the next reviewer understand why the access remains, not create a second directory of every employee.
Trace the paths before changing the role
The project's Members page shows direct and inherited membership. Following the source of a grant helps explain why an edit at the project level may have no effect. A person with the Maintainer role through a parent group remains a Maintainer even if their direct project role is Developer.
Invited groups add another path. Their maximum role limits the invitation, but doesn't cancel a broader grant elsewhere. Eligibility also matters: a project invitation and a group invitation don't include the same sets of source-group members. The sharing documentation explains those differences when the membership list isn't what you expected.
Identity synchronization, where configured, needs to be included in the review. A grant managed through an identity provider may return after a manual edit in GitLab. Conversely, a separate direct or shared grant may remain after someone leaves a synchronized group. The people maintaining that connection can help identify which change will persist.
The resulting picture may suggest a smaller fix than reorganizing the project. For example, if a contributor's parent-group role exists only to support one service, a narrower grant can replace it. Because changing the parent also affects other projects, review that person's remaining responsibilities before removing it. A group structure that fits your teams covers cases where the hierarchy itself keeps creating broad access.
Make the change without breaking the work
An access change has two things to establish: the intended work still succeeds, and the unnecessary access is gone. A maintainer should be able to perform their agreed tasks with their normal account, not through an administrator acting on their behalf. For sensitive actions, use a harmless check in an appropriate test project rather than attempting a destructive operation on live work.
Custom member roles can help when someone needs a specific administrative permission without the rest of a broader role.1 They add permissions to a base role; they don't subtract permissions from it. Choosing a high base role and giving it a narrower name won't reduce the access.
A recurring need is often better represented by a maintained group than by many individual grants. That group still needs an owner who understands membership changes and where it's invited. If the sharing is too complicated for the next reviewer to follow, the administrative convenience is hiding a maintenance problem.
Include the automation people depend on
An integration may keep working long after the person who created its token has changed teams. For each credential supporting the project, its maintainers should be able to find the purpose, owner, resources, permissions, expiry, and replacement procedure. Those details can live with the integration's operating instructions; the secret itself should be in a secure credential store, not an issue or committed file.
Token choice depends on what the integration does. A project access token can fit an API integration that works within one project, while a deploy token may fit a narrower repository or registry task.2 Pipeline jobs may already have an appropriate short-lived credential. The token overview helps compare those options; copying a maintainer's personal token into automation can give it far more reach than the task needs.
Both the identity's access and the token's permissions matter. A token scope that sounds appropriate doesn't by itself establish which projects the credential can reach. A review should follow one normal operation and consider what else the same credential could do.
Rotation is easier when dependencies are known before a token expires. The replacement procedure should explain who updates the consuming system, how they check that it works, and when the old credential can be revoked. If an integration stops after the change, its owner needs a way to recover without leaving the old broad credential in place indefinitely. Replacing long-lived pipeline credentials develops the pipeline-specific choices.
Keep access aligned with changes in responsibility
Joining, changing teams, leaving, and completing a temporary assignment should all prompt an access decision. A recent departure is a good way to examine the process: were all relevant grants removed, and did someone take over the person's automation and operating responsibilities? An absent name on one membership list doesn't answer both questions.
Temporary and emergency access deserve a clear ending. The person approving it should know what work it permits, who will remove it, and when the team will review its use. Where an expiry is configured, confirm it applies to the intended grant and check for other access paths. Emergency procedures also need practice before an incident, including what happens if the normal identity service is unavailable.
A regular review catches changes missed by those events. Its frequency can reflect how sensitive the access is and how often responsibilities change; a release-administration group may need attention more often than a stable read-only collaboration. Repeated exceptions or access requests point to something worth improving in the role, group structure, or instructions. The outcome should be fewer unexplained grants and fewer interruptions to legitimate work, not just a completed review record.
Further Reading
Notes
-
Custom roles are available in Ultimate. They let you add selected permissions to a base role. Teams on other tiers can still review membership paths and narrow where existing roles are granted. ↩
-
Project access tokens are available in Premium and Ultimate on GitLab.com, and across tiers on GitLab Self-Managed. They're also available on GitLab Dedicated. Other token types have different capabilities and availability. ↩
- Project membership explains how to inspect, change, and remove membership.
- Sharing projects and groups explains invitation limits and which members receive access.
- Roles and permissions helps you match access to the actions someone's work involves.
- GitLab token overview helps you choose credentials for the integration you're maintaining.