A merge request can contain a careful discussion and passing checks, yet the change that eventually merges may be different from the one someone approved. A later commit, a direct push, or an exception for automation can leave part of the work without independent review.
The aim is to keep important changes on a path where the final result receives independent assessment. When that decision calls for human judgment, branch permissions and approval settings should support the agreed review. Required approvals can make review a condition of merging.1 On Free, teams can collect optional approvals and have the person merging check them, but GitLab doesn't block a merge for missing approvals.
Decide what the reviewer is responsible for
Released code is a natural starting point. The same attention often belongs on files that control delivery: .gitlab-ci.yml, shared components, CODEOWNERS, infrastructure, and signing or deployment configuration. A small change to one of those files can affect more than the application diff suggests.
A recent change helps the team agree which decisions require another person's judgment. "Security review" leaves a lot to interpretation. "Someone familiar with authentication reviews changes to how users sign in" gives the author a reason for the review and a way to find the right person. Other concerns, such as release readiness, may need a reviewer regardless of which files changed.
Each required review should answer a question someone is qualified to assess. More approvals can otherwise create a queue without adding understanding. Where human review is required, small teams don't necessarily need three different people to author, review, and merge a change; they do need someone other than its author or committers to assess it. The person merging remains responsible for checking that the review and required checks cover the current change.
Make the merge request the way changes reach the branch
Branch protection and approval rules work together. For a branch that should receive changes through merge requests, set Allowed to push and merge to No one, rather than leaving it unconfigured. Allowed to merge can then identify who may complete the merge request. Service accounts and write-enabled deploy keys deserve the same attention as ordinary users, because a direct push can skip merge request review.
Overlapping rules are easy to overlook. An exact main rule doesn't override a more permissive m* rule, and matching group and project rules are considered together. Push, merge, and force-push permissions generally take the most permissive result. Required Code Owner approval is different: it applies if any matching rule requires it.
Following one representative project through these settings is easier than changing every project at once. Include the people who author and review work, along with a maintainer who can explain automation and exceptions. An unexpected push permission may be an old workaround whose original purpose no longer applies.
Choose reviewers who can act independently
Approval rules need enough eligible people to work during absences as well as on an ordinary day. A rule requiring two approvals from a group with only one eligible member doesn't provide stronger review. GitLab can mark an unsatisfiable ordinary rule Auto approved, including when there are no eligible approvers. Policy-based rules behave differently and can block when invalid, so the actual merge request is worth inspecting.
Code Owners can connect specialist review to affected files.2 For required approval, the target branch must be protected and Require approval from code owners enabled. When you name a group in CODEOWNERS, only its direct members count, and they still need the appropriate project access. Paths, optional sections, and reviewer membership need attention when the code or team changes.
For independent review, Prevent approval by merge request creator and Prevent approvals by users who add commits cover different people. Both matter when a colleague contributes code to a merge request opened by someone else. Prevent editing approval rules in merge requests helps keep that agreement from being changed on the individual request. It doesn't, at project or group scope, stop a maintainer from changing the project's approval-rule list; that responsibility also belongs in the team's access and governance decisions.
Keep the review current as the change develops
An approval records a decision about what the reviewer saw. If the patch changes afterward, the reviewer needs to reconsider it. Resetting all approvals is a straightforward choice for important changes; selective Code Owner resets can reduce repeated review when only some owned files change. Focused merge requests make either approach less expensive for reviewers.
GitLab considers the changed patch when resetting approvals, rather than treating every push identically. Rebases deserve attention too: another person's rebase can rewrite committer information, potentially making a previous committer eligible to approve. A team using that workflow should still assign an independent reviewer and examine the final diff, rather than rely solely on the eligibility setting.
The merge request should explain the request, the checks performed, and any unresolved concerns. A decision made in chat can be summarized there so a future maintainer can understand it. Re-authentication for approval may be appropriate where identity assurance is required; it doesn't replace the review itself.3
Apply the same reasoning to policy and automation
Security policies are changes to how other teams work. Their project needs protected branches and review by the people responsible for the policy, with affected application teams helping assess the effect. Merge request approval policies can apply requirements across projects and restrict direct or force pushes.4 Because changes take time to synchronize, a representative merge request should show the intended requirement before the rollout expands.
An automation account or coding agent can prepare a branch and merge request through the same process. Giving it a direct-push permission or approval exemption simply to get an initial run working would remove the review you're trying to preserve. Agent-generated review comments can help a person investigate, but they don't take over that person's responsibility for accepting the change. Verified issue to MR illustrates this with a person reviewing the plan and final change.
For work that can proceed without an individual human approval, the independence has to come from the approved workflow. Its checks and merge conditions should be controlled separately from the account proposing the change. Someone remains accountable for that arrangement and for changes outside it. This isn't an exception an agent grants itself, nor permission to ignore an existing approval requirement. Choosing workflow autonomy explores when that approach fits and when human judgment should remain part of the work.
Urgent incidents may need an exception. Agreeing who can authorize it and how access is limited helps the team respond without inventing the process under pressure. The resulting change should record the reason, affected work, expiry of temporary access, and who will review it afterward. Platform rules and exceptions covers maintaining that process.
Try the review path with the people who use it
The first project should demonstrate both an ordinary contribution and the cases the rules are meant to prevent. A contributor's direct push should be rejected; an author or committer shouldn't satisfy their own required review. A change in an owned path should involve the intended Code Owner, while an unrelated change shouldn't wait for that specialist.
Adding a change after approval shows whether the chosen resets work as the team expects. An eligible reviewer should still be able to complete the process, including after the team's usual rebase operation. Automation should follow the same review path, and any authorized exception should leave a reason and follow-up with the change. These examples are more informative than a screenshot of enabled settings.
Links to those merge requests give maintainers something to revisit after changing membership, branch patterns, approval rules, or automation access. Recent delivery work can then show whether review is catching problems or mostly waiting for someone unavailable. The remedy for missing expertise is different from the remedy for an unnecessary approval.
Further Reading
Notes
-
Required approvals are available in Premium and Ultimate. Free supports optional approvals, but they don't block a merge. ↩
-
Code Owners is available in Premium and Ultimate. Required Code Owner approval also depends on protected branch settings and eligible owners. ↩
-
Merge request approval settings are available in Premium and Ultimate. They include author and committer restrictions, approval resets, and re-authentication options. Configuration scope and prerequisites differ by setting. ↩
-
Merge request approval policies are available in Ultimate. Project-level review doesn't depend on using these policies. ↩
- Protected branches explains push and merge permissions and required Code Owner review.
- Protection rules and permissions helps you understand overlapping rules.
- Merge request approvals describes reviewer eligibility and rules that can't be satisfied.
- Merge request approval settings covers approval resets, author and committer restrictions, and rule editing.
- Code Owners explains how to identify owners and require their review.
- Merge request approval policies covers policy rollout, fallback behavior, and bypass options.
- System notes lists the activity GitLab records with a change.