<?xml version="1.0" encoding="utf-8"?>
<rss version="2.0" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/">
    <channel>
        <title>Merge Pilot guides</title>
        <link>https://www.merge-pilot.com/guides</link>
        <description>Merge Pilot Blog</description>
        <lastBuildDate>Fri, 13 Nov 2026 00:00:00 GMT</lastBuildDate>
        <docs>https://validator.w3.org/feed/docs/rss2.html</docs>
        <generator>https://github.com/jpmonette/feed</generator>
        <language>en</language>
        <copyright>© 2026 CloudNativeWorks</copyright>
        <item>
            <title><![CDATA[Block a merge until the Jira change approval is approved]]></title>
            <link>https://www.merge-pilot.com/guides/block-merge-until-jira-change-approval</link>
            <guid>https://www.merge-pilot.com/guides/block-merge-until-jira-change-approval</guid>
            <pubDate>Fri, 13 Nov 2026 00:00:00 GMT</pubDate>
            <description><![CDATA[How to keep a GitLab or GitHub merge request blocked until its Jira change approval is approved, and what new commits, retargeting and emergencies do.]]></description>
            <content:encoded><![CDATA[<p>A change approval in Jira only matters if the merge waits for it. When the approval lives in one system and the merge button in another, a merge request can merge while its ticket is still open, or merge a commit nobody approved. This guide explains how Merge Pilot ties the two together on GitLab and GitHub, and what happens on the detours: new commits, a new target branch, a rejection and an emergency.</p>
<h2 class="anchor anchorTargetStickyNavbar_Vzrq" id="the-problem-two-systems-one-decision">The problem: two systems, one decision<a href="https://www.merge-pilot.com/guides/block-merge-until-jira-change-approval#the-problem-two-systems-one-decision" class="hash-link" aria-label="Direct link to The problem: two systems, one decision" title="Direct link to The problem: two systems, one decision" translate="no">​</a></h2>
<p>Many teams already open a change ticket for each release. The ticket is reviewed and approved in Jira, while the code is reviewed and merged in GitLab or GitHub. Nothing connects the two decisions:</p>
<ul>
<li class="">the merge request can merge before the ticket is approved;</li>
<li class="">the ticket can be approved for code that changed afterwards;</li>
<li class="">a merge request can be moved to another target branch after its ticket was approved for the first one.</li>
</ul>
<p>Merge Pilot closes those gaps by making the change approval part of the merge decision. A change policy decides whether a merge request needs a change approval at all, which checks must pass and who must approve. The result is written into the VCS as the <strong>merge gate</strong>, so GitLab or GitHub itself refuses the merge until the policy is met for the merge request's latest commit.</p>
<h2 class="anchor anchorTargetStickyNavbar_Vzrq" id="how-the-merge-gate-works-on-each-vcs">How the merge gate works on each VCS<a href="https://www.merge-pilot.com/guides/block-merge-until-jira-change-approval#how-the-merge-gate-works-on-each-vcs" class="hash-link" aria-label="Direct link to How the merge gate works on each VCS" title="Direct link to How the merge gate works on each VCS" translate="no">​</a></h2>
<p>The gate is set again after each evaluation, and it is always for one commit and one target branch. It takes one of three states: <strong>Can merge</strong>, <strong>Waiting</strong> or <strong>Blocked</strong>. See <a class="" href="https://www.merge-pilot.com/docs/merge-requests/merge-gate#the-decision">Merge gate</a> for the full rules.</p>
<h3 class="anchor anchorTargetStickyNavbar_Vzrq" id="on-gitlab">On GitLab<a href="https://www.merge-pilot.com/guides/block-merge-until-jira-change-approval#on-gitlab" class="hash-link" aria-label="Direct link to On GitLab" title="Direct link to On GitLab" translate="no">​</a></h3>
<p>On GitLab the gate is an approval rule named <code>Merge Pilot — &lt;branch&gt;</code> on each protected target branch, whose only approver is the connection's bot user. When the policy is met, the bot approves the merge request for the commit the decision is for. When the decision is <strong>Waiting</strong> or <strong>Blocked</strong>, the bot withdraws its approval. Nobody else can meet that rule.</p>
<p>The setup step <strong>Remove approvals when commits are added</strong> (on by default) makes GitLab remove the bot's approval as soon as a commit is pushed. Approval rules need GitLab Premium or Ultimate; the setup reports that when GitLab refuses the rule. See <a class="" href="https://www.merge-pilot.com/docs/connections/gitlab#change-management-setup-steps">GitLab change management setup steps</a>.</p>
<h3 class="anchor anchorTargetStickyNavbar_Vzrq" id="on-github">On GitHub<a href="https://www.merge-pilot.com/guides/block-merge-until-jira-change-approval#on-github" class="hash-link" aria-label="Direct link to On GitHub" title="Direct link to On GitHub" translate="no">​</a></h3>
<p>On GitHub the gate is the check <strong>Merge Pilot / change approval</strong>, reported by the connection's GitHub App on each pull request's head commit. A ruleset named <strong>Merge Pilot change management</strong> requires that check on the target branches, accepted from the App only. Success means <strong>Can merge</strong>, in progress means <strong>Waiting</strong>, failure means <strong>Blocked</strong>.</p>
<p>A new push has no check yet, so GitHub holds the new commit until Merge Pilot decides on it. See <a class="" href="https://www.merge-pilot.com/docs/connections/github#what-merge-pilot-writes-to-each-repository">What Merge Pilot writes to each repository</a>.</p>
<h3 class="anchor anchorTargetStickyNavbar_Vzrq" id="the-same-decision-on-both">The same decision on both<a href="https://www.merge-pilot.com/guides/block-merge-until-jira-change-approval#the-same-decision-on-both" class="hash-link" aria-label="Direct link to The same decision on both" title="Direct link to The same decision on both" translate="no">​</a></h3>
<table><thead><tr><th></th><th>GitLab</th><th>GitHub</th></tr></thead><tbody><tr><td>What holds the merge</td><td>Approval rule met only by the bot user</td><td>Required check from the GitHub App only</td></tr><tr><td>Can merge</td><td>Bot approves for that commit</td><td>Check run concludes success</td></tr><tr><td>Waiting</td><td>Bot approval missing</td><td>Check run in progress</td></tr><tr><td>Blocked</td><td>Bot approval missing</td><td>Check run concludes failure</td></tr><tr><td>New commit</td><td>Approval removed on push (by default)</td><td>No check on the new commit yet</td></tr></tbody></table>
<p>On both, Merge Pilot keeps one status comment on the merge request with the policy, one line per control and the commit the decision is for.</p>
<h2 class="anchor anchorTargetStickyNavbar_Vzrq" id="setting-it-up">Setting it up<a href="https://www.merge-pilot.com/guides/block-merge-until-jira-change-approval#setting-it-up" class="hash-link" aria-label="Direct link to Setting it up" title="Direct link to Setting it up" translate="no">​</a></h2>
<p>The order below assumes a Jira connection and a GitLab or GitHub connection already exist.</p>
<ol>
<li class=""><strong>Link the tracker.</strong> In the VCS connection's settings, choose the Jira connection as the <strong>Linked tracker connection</strong>. Without a linked tracker only standard changes can merge. See <a class="" href="https://www.merge-pilot.com/docs/connections/permissions#tracker">VCS connection settings</a>.</li>
<li class=""><strong>Set up the Jira side.</strong> In the Jira connection's tracker settings, choose the <strong>Project</strong> and <strong>Issue type</strong> change approvals are opened as, the <strong>Closing statuses</strong> (approve), the <strong>Rejection statuses</strong> and, if a policy will ask for more than one approval, the <strong>Reopen status</strong>. See <a class="" href="https://www.merge-pilot.com/docs/connections/jira#tracker-settings">Tracker settings</a> and <a class="" href="https://www.merge-pilot.com/docs/connections/jira#how-a-change-approval-moves-through-jira">How a change approval moves through Jira</a>.</li>
<li class=""><strong>Write a normal-change policy.</strong> Under <strong>Governance</strong> → <strong>Change policies</strong>, add a policy with the change type <strong>Normal change</strong>, its conditions on the <strong>Scope</strong> tab (for example the target branches <code>main, release/*</code>), and its approvers under <strong>Who must approve</strong>. The <a class="" href="https://www.merge-pilot.com/docs/policies/overview#templates">policy templates</a> are a quick start.</li>
<li class=""><strong>Try it.</strong> Use <strong>Which policy applies?</strong> to check which policy covers a described change, and <strong>Test run</strong> to try unsaved edits on a real merge request. See <a class="" href="https://www.merge-pilot.com/docs/policies/overview#trying-policies-out">Trying policies out</a>.</li>
<li class=""><strong>Put the repositories under change management.</strong> The setup shows each step it will write to the repository, required and optional, and asks for consent before writing anything. See <a class="" href="https://www.merge-pilot.com/docs/repositories/change-management#setup-steps-and-consent">Setup steps and consent</a>.</li>
</ol>
<p>From then on, every merge request into a covered branch is matched to a policy and gated.</p>
<h2 class="anchor anchorTargetStickyNavbar_Vzrq" id="when-the-change-approval-is-opened">When the change approval is opened<a href="https://www.merge-pilot.com/guides/block-merge-until-jira-change-approval#when-the-change-approval-is-opened" class="hash-link" aria-label="Direct link to When the change approval is opened" title="Direct link to When the change approval is opened" translate="no">​</a></h2>
<p>For a normal change, the change approval is opened in Jira once the enforced work items check out and no risk hold applies, and once enough people may approve it. CI and scans do not have to finish first; they run while approvers look at the change. See <a class="" href="https://www.merge-pilot.com/docs/merge-requests/change-approval#when-one-is-opened">When one is opened</a>.</p>
<p>The issue carries a summary and description from the tracker settings' templates (or a default record with the repository, branches, author and work items). It is assigned as the policy's <strong>Assign the change approval</strong> says (a random approver by default, never the author), and Merge Pilot comments on the merge request with the key and the next steps.</p>
<h3 class="anchor anchorTargetStickyNavbar_Vzrq" id="approving-it">Approving it<a href="https://www.merge-pilot.com/guides/block-merge-until-jira-change-approval#approving-it" class="hash-link" aria-label="Direct link to Approving it" title="Direct link to Approving it" translate="no">​</a></h3>
<p>An approval counts whether it is made in Jira or in Merge Pilot:</p>
<ul>
<li class="">Moving the issue to a closing status in Jira is an approval by whoever moved it.</li>
<li class=""><strong>Approve</strong> on the merge request's <strong>Approval</strong> card in Merge Pilot counts the same way, and Merge Pilot moves the issue in Jira once the change approval is decided.</li>
<li class="">When the policy asks for more than one approval, each partial approval in Jira sends the issue back to the reopen status for the next approver.</li>
</ul>
<p>Every decision is checked before it counts. The author's own approval is ignored and the issue goes back. A decision by someone who may not decide the change is ignored too. See <a class="" href="https://www.merge-pilot.com/docs/merge-requests/voting#decisions-made-in-the-tracker">Decisions made in the tracker</a>.</p>
<p>Once the policy's approvals are met, the <strong>Change approval</strong> line passes and, if every other enforced control has passed, the gate opens.</p>
<h3 class="anchor anchorTargetStickyNavbar_Vzrq" id="rejecting-it">Rejecting it<a href="https://www.merge-pilot.com/guides/block-merge-until-jira-change-approval#rejecting-it" class="hash-link" aria-label="Direct link to Rejecting it" title="Direct link to Rejecting it" translate="no">​</a></h3>
<p>One rejection is enough. Moving the issue to a rejection status, or <strong>Reject</strong> in Merge Pilot (with a reason of at least five characters), blocks the gate. The policy's <strong>Missing work items or a rejected change approval</strong> then decides the next step: <strong>Block until fixed</strong> (the default) keeps the merge request open and blocked; <strong>Close the merge request</strong> closes it. To go on after a rejection, push new commits or reopen the merge request; a new change approval is opened.</p>
<h2 class="anchor anchorTargetStickyNavbar_Vzrq" id="what-new-commits-do">What new commits do<a href="https://www.merge-pilot.com/guides/block-merge-until-jira-change-approval#what-new-commits-do" class="hash-link" aria-label="Direct link to What new commits do" title="Direct link to What new commits do" translate="no">​</a></h2>
<p>Every decision is for the latest commit, so a push always reopens the question. The gate waits again until the controls have passed for the new commit. What happens to the change approval is the policy's <strong>New commits after a change approval</strong> (Lifecycle tab):</p>
<table><thead><tr><th>Setting</th><th>The change approval</th><th>Approvals</th></tr></thead><tbody><tr><td><strong>Open a new change approval</strong> (default)</td><td>Superseded, commented as such, and replaced by a new one for the new commit, linked to the old one in Jira</td><td>Approved from scratch</td></tr><tr><td><strong>Reopen the change approval</strong></td><td>The same issue moves back to the reopen status and now covers the new commit</td><td>Votes cleared</td></tr><tr><td><strong>Keep the approval</strong></td><td>The issue now covers the new commit; each time is written to the audit log</td><td>Kept</td></tr></tbody></table>
<p>Whatever the setting, an approval made in Jira for older code does not count for the new commit, and decisions on a superseded change approval are ignored. See <a class="" href="https://www.merge-pilot.com/docs/merge-requests/change-approval#new-commits">New commits</a>.</p>
<p><strong>Keep the approval</strong> is a deliberate trade-off: it saves a second round of approvals for fixes pushed after approval, at the cost of an approval that no longer covers exactly what merges. If you use it, use it for policies where that is acceptable, and expect the audit log to show each time it applied.</p>
<h2 class="anchor anchorTargetStickyNavbar_Vzrq" id="what-retargeting-does">What retargeting does<a href="https://www.merge-pilot.com/guides/block-merge-until-jira-change-approval#what-retargeting-does" class="hash-link" aria-label="Direct link to What retargeting does" title="Direct link to What retargeting does" translate="no">​</a></h2>
<p>An approval into one branch is not an approval into another. When a merge request is moved to another target branch:</p>
<ul>
<li class=""><strong>A branch change management covers</strong>: the merge request is processed again under the policy for the new branch, its change approval is retired with the reason (<em>its target branch changed</em>), and a new one is opened when the new policy needs one. The gate waits again.</li>
<li class=""><strong>A branch it does not cover</strong>: the merge request leaves change management, and an undecided change approval is cancelled and moved to the tracker's cancelled status.</li>
<li class=""><strong>Moved back to a covered branch</strong>: it is gated again from the start, with a new change approval.</li>
</ul>
<p>See <a class="" href="https://www.merge-pilot.com/docs/merge-requests/scenarios#the-target-branch-is-changed">The target branch is changed</a>.</p>
<h2 class="anchor anchorTargetStickyNavbar_Vzrq" id="emergency-changes">Emergency changes<a href="https://www.merge-pilot.com/guides/block-merge-until-jira-change-approval#emergency-changes" class="hash-link" aria-label="Direct link to Emergency changes" title="Direct link to Emergency changes" translate="no">​</a></h2>
<p>Some changes cannot wait for a change approval. An <strong>Emergency change</strong> policy, usually matched by a label such as <code>emergency</code>, lets a change merge as soon as its other enforced controls pass. The change approval is opened for a review afterwards, due within the policy's <strong>Review deadline</strong> (72 hours unless the policy sets another).</p>
<ul>
<li class="">Whoever added the label declares the emergency. The declaration is recorded on the merge request, written to the audit log and announced.</li>
<li class="">The company, or the emergency policy itself, can limit who may declare one: only an approver pool, never the author, or a number of emergencies per repository in a window. When the rules are not met, the emergency policy does not match and the next policy covers the change as usual.</li>
<li class="">The review takes the same checks as any change approval: the author never decides it and only the policy's approvers count.</li>
<li class="">A review not decided by its deadline is reported once, as <strong>Emergency review overdue</strong>.</li>
</ul>
<p>See <a class="" href="https://www.merge-pilot.com/docs/merge-requests/scenarios#an-emergency-is-declared">An emergency is declared</a> and <a class="" href="https://www.merge-pilot.com/docs/policies/controls/approval#who-may-declare-an-emergency">Who may declare an emergency</a>.</p>
<h2 class="anchor anchorTargetStickyNavbar_Vzrq" id="what-if-someone-merges-anyway">What if someone merges anyway<a href="https://www.merge-pilot.com/guides/block-merge-until-jira-change-approval#what-if-someone-merges-anyway" class="hash-link" aria-label="Direct link to What if someone merges anyway" title="Direct link to What if someone merges anyway" translate="no">​</a></h2>
<p>An administrator on the VCS can bypass the gate. Merging cannot be stopped from outside the VCS, so Merge Pilot records what merged against its last decision for that commit and branch. A merge the gate had not opened is flagged as <strong>Merged without approval</strong>, written to the audit log and announced, and the Jira issue gets a warning comment. Approvals withdrawn in Jira after the merge are flagged as well. See <a class="" href="https://www.merge-pilot.com/docs/merge-requests/merge-gate#what-is-flagged-at-merge">What is flagged at merge</a>.</p>
<p>Merge Pilot also checks gated repositories regularly for loosened protection, such as an unprotected branch, an edited approval rule or a ruleset bypass, and reports new gaps. See <a class="" href="https://www.merge-pilot.com/docs/repositories/change-management#branch-protection-check">Branch protection check</a>.</p>
<h2 class="anchor anchorTargetStickyNavbar_Vzrq" id="lost-webhooks-and-outages">Lost webhooks and outages<a href="https://www.merge-pilot.com/guides/block-merge-until-jira-change-approval#lost-webhooks-and-outages" class="hash-link" aria-label="Direct link to Lost webhooks and outages" title="Direct link to Lost webhooks and outages" translate="no">​</a></h2>
<p>If a Jira or VCS webhook is lost, the periodic re-check reads the change approval's latest status and the CI runs again, and applies what it finds. When Jira cannot be reached while a change approval is being opened, the gate stays blocked and creation is retried; <strong>Resync</strong> on the merge request tries at once. An emergency change is not held by a tracker outage; its review change approval is opened once Jira is back.</p>
<h2 class="anchor anchorTargetStickyNavbar_Vzrq" id="next-steps">Next steps<a href="https://www.merge-pilot.com/guides/block-merge-until-jira-change-approval#next-steps" class="hash-link" aria-label="Direct link to Next steps" title="Direct link to Next steps" translate="no">​</a></h2>
<p>The <a class="" href="https://www.merge-pilot.com/features/merge-gate">Merge gate</a> feature page sums up the gate on both VCSs, and the <a class="" href="https://www.merge-pilot.com/docs/merge-requests/change-approval">Change approval lifecycle</a> page follows a change approval from opening to merge. To see the gate on your own GitLab or GitHub with your Jira workflow, <a class="" href="https://www.merge-pilot.com/contact">ask for a demo</a>.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[GitHub change management beyond required reviews]]></title>
            <link>https://www.merge-pilot.com/guides/github-change-management-beyond-required-reviews</link>
            <guid>https://www.merge-pilot.com/guides/github-change-management-beyond-required-reviews</guid>
            <pubDate>Fri, 13 Nov 2026 00:00:00 GMT</pubDate>
            <description><![CDATA[GitHub rulesets, required status checks, CODEOWNERS and merge queues explained, and where a change approval fits in as a required check on pull requests.]]></description>
            <content:encoded><![CDATA[<p>Required pull request reviews are where most GitHub teams start with change control. Rulesets, required status checks, CODEOWNERS and merge queues take it further, and together they can make a protected branch hard to change without review. What they do not provide by themselves is a change approval: a decision made in the organisation's change process, recorded in a tracker, and enforced at the merge button. This guide covers the GitHub features first, then shows where a change approval fits.</p>
<h2 class="anchor anchorTargetStickyNavbar_Vzrq" id="rulesets">Rulesets<a href="https://www.merge-pilot.com/guides/github-change-management-beyond-required-reviews#rulesets" class="hash-link" aria-label="Direct link to Rulesets" title="Direct link to Rulesets" translate="no">​</a></h2>
<p>A repository ruleset is a named set of rules that applies to chosen branches. Rulesets can be switched between active and disabled, they can name actors allowed to bypass them, and several rulesets can target the same branch: when they do, their rules add up and the strictest applies. On private repositories, rulesets need GitHub Team (or Pro) or Enterprise.</p>
<p>Rules commonly used for change control include:</p>
<ul>
<li class=""><strong>Restrict deletions</strong> and <strong>Block force pushes</strong>, so a branch's history cannot be removed or rewritten;</li>
<li class=""><strong>Require a pull request before merging</strong>, with its own options for required approvals, dismissing stale approvals when new commits are pushed, requiring review from code owners, and requiring approval of the most recent reviewable push by someone other than the person who pushed it;</li>
<li class=""><strong>Require status checks to pass</strong>, naming the checks that must succeed;</li>
<li class=""><strong>Require signed commits</strong> and <strong>Require linear history</strong>.</li>
</ul>
<p>Classic branch protection rules offer a similar set of options. Rulesets are the newer mechanism and can be layered.</p>
<h2 class="anchor anchorTargetStickyNavbar_Vzrq" id="required-status-checks">Required status checks<a href="https://www.merge-pilot.com/guides/github-change-management-beyond-required-reviews#required-status-checks" class="hash-link" aria-label="Direct link to Required status checks" title="Direct link to Required status checks" translate="no">​</a></h2>
<p>A required status check names a check that must report success on the pull request's head commit before it can merge. Two details matter for change control:</p>
<ul>
<li class=""><strong>Who may report it.</strong> A required check can be tied to a specific GitHub App as its source. Without that, any integration that can post a check or commit status with the same name could satisfy it.</li>
<li class=""><strong>Which commit it is for.</strong> Checks belong to a commit. A new push starts with no checks on its new head, so required checks hold the merge until they run again.</li>
</ul>
<p>That second detail is what makes a status check a natural place for an outside decision: it is commit-bound by design.</p>
<h2 class="anchor anchorTargetStickyNavbar_Vzrq" id="codeowners">CODEOWNERS<a href="https://www.merge-pilot.com/guides/github-change-management-beyond-required-reviews#codeowners" class="hash-link" aria-label="Direct link to CODEOWNERS" title="Direct link to CODEOWNERS" translate="no">​</a></h2>
<p>A <code>CODEOWNERS</code> file maps paths to owners, who can be users or teams. With review from code owners required, a pull request that changes owned files needs an approving review from an owner of each. GitHub reads the file from <code>.github/</code>, the repository root or <code>docs/</code>.</p>
<h2 class="anchor anchorTargetStickyNavbar_Vzrq" id="merge-queues">Merge queues<a href="https://www.merge-pilot.com/guides/github-change-management-beyond-required-reviews#merge-queues" class="hash-link" aria-label="Direct link to Merge queues" title="Direct link to Merge queues" translate="no">​</a></h2>
<p>A merge queue groups pull requests that are ready to merge, builds a temporary branch for each group with the target branch and the pull requests ahead of it, and asks the required checks to pass on that group's commit before merging. Workflows that should run in the queue listen for the <code>merge_group</code> event. The queue keeps the branch green when many pull requests merge in a short time.</p>
<h2 class="anchor anchorTargetStickyNavbar_Vzrq" id="what-these-features-answer-and-what-they-do-not">What these features answer, and what they do not<a href="https://www.merge-pilot.com/guides/github-change-management-beyond-required-reviews#what-these-features-answer-and-what-they-do-not" class="hash-link" aria-label="Direct link to What these features answer, and what they do not" title="Direct link to What these features answer, and what they do not" translate="no">​</a></h2>
<p>Together these features answer: <em>who reviewed the code, which checks passed, and whether the branch could be changed another way.</em> A change management process usually adds questions of its own:</p>
<ul>
<li class="">Was this change approved through the change process, by the people the organisation names for that kind of change?</li>
<li class="">Does a documentation fix take the same path as a database migration, or a lighter one?</li>
<li class="">Can an emergency merge now and be reviewed within a deadline?</li>
<li class="">Was the approval in the tracker made by someone allowed to make it, and not by the author?</li>
<li class="">Which version of the rules decided this change, and can it be shown for every change in a quarter?</li>
</ul>
<p>These are the questions a Merge Pilot change policy answers. The answer reaches GitHub as one required status check.</p>
<h2 class="anchor anchorTargetStickyNavbar_Vzrq" id="where-a-change-approval-fits">Where a change approval fits<a href="https://www.merge-pilot.com/guides/github-change-management-beyond-required-reviews#where-a-change-approval-fits" class="hash-link" aria-label="Direct link to Where a change approval fits" title="Direct link to Where a change approval fits" translate="no">​</a></h2>
<p>On GitHub, Merge Pilot works as a GitHub App. When a repository is put under change management, it writes one ruleset, <strong>Merge Pilot change management</strong>, after showing the steps and asking for consent:</p>
<table><thead><tr><th>Step</th><th>Ruleset rule</th><th>Required</th></tr></thead><tbody><tr><td><strong>Ruleset with Merge Pilot's required check</strong></td><td>"Require status checks to pass" with <strong>Merge Pilot / change approval</strong>, from the connection's App only, on the target branches, without requiring branches to be up to date</td><td>Yes</td></tr><tr><td><strong>Require a pull request</strong></td><td>"Require a pull request before merging", with no reviews required by it</td><td>No (on by default)</td></tr><tr><td><strong>Block force pushes</strong></td><td>"Block force pushes"</td><td>No (on by default)</td></tr><tr><td><strong>Block branch deletion</strong></td><td>"Restrict deletions"</td><td>No (on by default)</td></tr></tbody></table>
<p>The check is the merge gate. Merge Pilot reports it on each pull request's head commit: <strong>success</strong> when the change policy is met, <strong>in progress</strong> while something is pending, <strong>failure</strong> when an enforced control failed. Because it is accepted from the App only, no other App or person can satisfy it. See <a class="" href="https://www.merge-pilot.com/docs/connections/github#what-merge-pilot-writes-to-each-repository">What Merge Pilot writes to each repository</a> and <a class="" href="https://www.merge-pilot.com/docs/merge-requests/merge-gate#github">Merge gate on GitHub</a>.</p>
<p>The ruleset is separate from yours. Rulesets you already have, with their required reviews, CODEOWNERS and other checks, stay as they are, and the rules add up on the branch. Bypass actors that an administrator adds to Merge Pilot's ruleset are kept, and the setup warns how many there are.</p>
<h3 class="anchor anchorTargetStickyNavbar_Vzrq" id="what-the-check-stands-for">What the check stands for<a href="https://www.merge-pilot.com/guides/github-change-management-beyond-required-reviews#what-the-check-stands-for" class="hash-link" aria-label="Direct link to What the check stands for" title="Direct link to What the check stands for" translate="no">​</a></h3>
<p>The check's conclusion is the result of the whole change policy for that commit: the change approval in Jira or the built-in tracker, plus the controls the policy enforces, such as CI, code review, work items, secret and dependency scans. The check run's title names the first control that failed or is still pending, and its summary lists the policy and one line per control.</p>
<table><thead><tr><th>What the policy needs</th><th>How it reaches GitHub</th></tr></thead><tbody><tr><td>A normal change, waiting for approval or for a control still running</td><td>Check in progress</td></tr><tr><td>Approved, every enforced control passed</td><td>Check concludes success</td></tr><tr><td>Rejected, or an enforced control failed</td><td>Check concludes failure</td></tr><tr><td>A new commit pushed</td><td>No check on the new commit until Merge Pilot decides</td></tr></tbody></table>
<h2 class="anchor anchorTargetStickyNavbar_Vzrq" id="required-reviews-and-the-change-approval-side-by-side">Required reviews and the change approval side by side<a href="https://www.merge-pilot.com/guides/github-change-management-beyond-required-reviews#required-reviews-and-the-change-approval-side-by-side" class="hash-link" aria-label="Direct link to Required reviews and the change approval side by side" title="Direct link to Required reviews and the change approval side by side" translate="no">​</a></h2>
<p>Required reviews and a change approval are different decisions, and a policy can ask for both:</p>
<ul>
<li class=""><strong>Code review</strong> in the policy counts each reviewer's latest <strong>Approve</strong> review, but only when it was given on the head commit, from someone with at least the chosen repository role, never the author, Merge Pilot or a bot. A later <strong>Request changes</strong> can hold the merge. See <a class="" href="https://www.merge-pilot.com/docs/policies/controls/code-review">Code review</a>.</li>
<li class=""><strong>Change approval</strong> is decided in the tracker or in Merge Pilot by the people the policy's <strong>Who must approve</strong> names: the project's approver roles, approver pools, or the code owners of the changed files read from the same CODEOWNERS locations GitHub uses. Code owners are asked as people (<code>@login</code>); teams are not asked and are listed as <em>Not asked from …</em>. See <a class="" href="https://www.merge-pilot.com/docs/policies/controls/approval#code-owners">Code owners</a>.</li>
</ul>
<p>If GitHub's required reviews already cover peer review for you, leave them on and keep the policy's code review off or in report mode; the change approval then adds only the change-process decision.</p>
<h2 class="anchor anchorTargetStickyNavbar_Vzrq" id="which-checks-a-policy-trusts">Which checks a policy trusts<a href="https://www.merge-pilot.com/guides/github-change-management-beyond-required-reviews#which-checks-a-policy-trusts" class="hash-link" aria-label="Direct link to Which checks a policy trusts" title="Direct link to Which checks a policy trusts" translate="no">​</a></h2>
<p>The policy's <strong>CI</strong> control reads runs on the pull request's latest commit, and it is explicit about their source:</p>
<ul>
<li class="">GitHub Actions workflow runs always count.</li>
<li class="">Checks from another GitHub App count only when that App's slug is listed under <strong>Also count checks from these GitHub Apps</strong>. A check of the same name from another App does not count.</li>
<li class="">Commit statuses count only with <strong>Count commit statuses</strong> on, because anyone who may push can post one.</li>
<li class="">Merge Pilot's own check is never counted.</li>
</ul>
<p>Runs left out for their source are named in the control's message. See <a class="" href="https://www.merge-pilot.com/docs/policies/controls/ci#which-runs-count">Which runs count</a>.</p>
<h2 class="anchor anchorTargetStickyNavbar_Vzrq" id="merge-queues-with-a-change-approval">Merge queues with a change approval<a href="https://www.merge-pilot.com/guides/github-change-management-beyond-required-reviews#merge-queues-with-a-change-approval" class="hash-link" aria-label="Direct link to Merge queues with a change approval" title="Direct link to Merge queues with a change approval" translate="no">​</a></h2>
<p>When a pull request enters the merge queue, GitHub asks for the required checks on the merge group's commit. Merge Pilot answers with <strong>Merge Pilot / change approval</strong> on that commit. It passes only when change management approved the pull request at the commit it was queued with, and fails when Merge Pilot does not know the pull request, when its last decision is for another commit, or when that decision was not <strong>Can merge</strong>. The queue therefore never merges what change management did not approve. See <a class="" href="https://www.merge-pilot.com/docs/merge-requests/merge-gate#github-merge-queue">GitHub merge queue</a>.</p>
<h2 class="anchor anchorTargetStickyNavbar_Vzrq" id="keeping-the-setup-intact">Keeping the setup intact<a href="https://www.merge-pilot.com/guides/github-change-management-beyond-required-reviews#keeping-the-setup-intact" class="hash-link" aria-label="Direct link to Keeping the setup intact" title="Direct link to Keeping the setup intact" translate="no">​</a></h2>
<p>Repository administrators can add bypass actors, disable a ruleset or remove a rule. Merge Pilot checks gated repositories for such gaps (a missing or unenforced ruleset, a missing rule that was chosen, bypass actors) when the company's branch protection check is on, and writes new gaps to the audit log as <code>protection_weakened</code>. Pushes that reach a covered branch without a pull request, force pushes and deleted branches are recorded as <a class="" href="https://www.merge-pilot.com/docs/repositories/direct-changes">direct changes</a>. If an administrator merges past the gate, the merge is flagged as <strong>Merged without approval</strong>.</p>
<h2 class="anchor anchorTargetStickyNavbar_Vzrq" id="rolling-it-out-on-github">Rolling it out on GitHub<a href="https://www.merge-pilot.com/guides/github-change-management-beyond-required-reviews#rolling-it-out-on-github" class="hash-link" aria-label="Direct link to Rolling it out on GitHub" title="Direct link to Rolling it out on GitHub" translate="no">​</a></h2>
<ol>
<li class=""><strong>Create the GitHub App</strong> from its manifest, or use an existing one, and install it on the organisation's repositories. GitHub Enterprise Server 3.12 or newer is supported. See <a class="" href="https://www.merge-pilot.com/docs/connections/github">GitHub</a>.</li>
<li class=""><strong>Watch the repositories first.</strong> Nothing is written to a watched repository; Merge Pilot records what it would have decided.</li>
<li class=""><strong>Write change policies</strong>, for example from the <strong>ITIL change management</strong> template, and try them with <strong>Which policy applies?</strong>.</li>
<li class=""><strong>Move repositories to change management</strong>, choosing which optional ruleset rules to write.</li>
<li class=""><strong>Keep your rulesets.</strong> Required reviews, CODEOWNERS and other required checks stay where they are; the change approval check is added next to them.</li>
</ol>
<h2 class="anchor anchorTargetStickyNavbar_Vzrq" id="next-steps">Next steps<a href="https://www.merge-pilot.com/guides/github-change-management-beyond-required-reviews#next-steps" class="hash-link" aria-label="Direct link to Next steps" title="Direct link to Next steps" translate="no">​</a></h2>
<p>The <a class="" href="https://www.merge-pilot.com/features/merge-gate">Merge gate</a> feature page summarises the gate on GitHub and GitLab, and <a class="" href="https://www.merge-pilot.com/docs/repositories/change-management#setup-steps-and-consent">Setup steps and consent</a> describes what is shown before anything is written. To see a change approval check on your own pull requests, <a class="" href="https://www.merge-pilot.com/contact">ask for a demo</a>.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[GitLab change management: approval rules and beyond]]></title>
            <link>https://www.merge-pilot.com/guides/gitlab-change-management-options</link>
            <guid>https://www.merge-pilot.com/guides/gitlab-change-management-options</guid>
            <pubDate>Fri, 13 Nov 2026 00:00:00 GMT</pubDate>
            <description><![CDATA[GitLab's own change controls (protected branches, approval rules, CODEOWNERS, status checks, merge checks) and what a change policy adds on top of them.]]></description>
            <content:encoded><![CDATA[<p>GitLab ships with a solid set of controls for merge requests: protected branches, approval rules, code owners, merge checks and external status checks. For many teams they are enough. Organisations that run formal change management usually need a little more: a change approval in a tracker, different paths for different kinds of change, and evidence that ties it all together. This guide describes what GitLab offers natively, then what a Merge Pilot change policy adds and how the two fit together.</p>
<h2 class="anchor anchorTargetStickyNavbar_Vzrq" id="what-gitlab-offers-natively">What GitLab offers natively<a href="https://www.merge-pilot.com/guides/gitlab-change-management-options#what-gitlab-offers-natively" class="hash-link" aria-label="Direct link to What GitLab offers natively" title="Direct link to What GitLab offers natively" translate="no">​</a></h2>
<h3 class="anchor anchorTargetStickyNavbar_Vzrq" id="protected-branches">Protected branches<a href="https://www.merge-pilot.com/guides/gitlab-change-management-options#protected-branches" class="hash-link" aria-label="Direct link to Protected branches" title="Direct link to Protected branches" translate="no">​</a></h3>
<p>A protected branch limits who may push to a branch and who may merge into it, and whether force pushes are allowed. It is the foundation for everything else: without it, changes can reach the branch without a merge request at all. Protected branches are available on every GitLab tier.</p>
<h3 class="anchor anchorTargetStickyNavbar_Vzrq" id="approval-rules-and-approval-settings">Approval rules and approval settings<a href="https://www.merge-pilot.com/guides/gitlab-change-management-options#approval-rules-and-approval-settings" class="hash-link" aria-label="Direct link to Approval rules and approval settings" title="Direct link to Approval rules and approval settings" translate="no">​</a></h3>
<p>Merge request approval rules require a number of approvals from named users, groups or roles before a merge request can merge, and can target specific protected branches. Required approval rules are a GitLab Premium and Ultimate feature.</p>
<p>The project's approval settings tighten how approvals behave. Among them are settings that keep the author from approving their own merge request, keep people who added commits from approving it, stop approval rules from being edited inside a merge request, and remove existing approvals when new commits are pushed, so an approval never covers newer code.</p>
<h3 class="anchor anchorTargetStickyNavbar_Vzrq" id="codeowners">CODEOWNERS<a href="https://www.merge-pilot.com/guides/gitlab-change-management-options#codeowners" class="hash-link" aria-label="Direct link to CODEOWNERS" title="Direct link to CODEOWNERS" translate="no">​</a></h3>
<p>A <code>CODEOWNERS</code> file names the owners of paths in the repository. With code owner approval required on a protected branch, a merge request that changes owned files needs an approval from the owners. Sections group owners and can set their own number of approvals; optional sections need none.</p>
<h3 class="anchor anchorTargetStickyNavbar_Vzrq" id="merge-checks">Merge checks<a href="https://www.merge-pilot.com/guides/gitlab-change-management-options#merge-checks" class="hash-link" aria-label="Direct link to Merge checks" title="Direct link to Merge checks" translate="no">​</a></h3>
<p>Merge checks are conditions GitLab evaluates before it allows a merge, such as requiring the pipeline to succeed or all discussion threads to be resolved.</p>
<h3 class="anchor anchorTargetStickyNavbar_Vzrq" id="external-status-checks">External status checks<a href="https://www.merge-pilot.com/guides/gitlab-change-management-options#external-status-checks" class="hash-link" aria-label="Direct link to External status checks" title="Direct link to External status checks" translate="no">​</a></h3>
<p>External status checks send merge request data to a service outside GitLab, which reports back a passed or failed status. A project can require them to pass before merging. They are a GitLab Ultimate feature and the usual integration point for external systems that want a say in the merge.</p>
<h3 class="anchor anchorTargetStickyNavbar_Vzrq" id="merge-trains">Merge trains<a href="https://www.merge-pilot.com/guides/gitlab-change-management-options#merge-trains" class="hash-link" aria-label="Direct link to Merge trains" title="Direct link to Merge trains" translate="no">​</a></h3>
<p>Merge trains queue merge requests and run pipelines on the combined result of each merge request with the ones ahead of it, so the target branch stays green.</p>
<h2 class="anchor anchorTargetStickyNavbar_Vzrq" id="what-a-change-process-asks-beyond-that">What a change process asks beyond that<a href="https://www.merge-pilot.com/guides/gitlab-change-management-options#what-a-change-process-asks-beyond-that" class="hash-link" aria-label="Direct link to What a change process asks beyond that" title="Direct link to What a change process asks beyond that" translate="no">​</a></h2>
<p>GitLab's controls are built around the merge request in GitLab: who may push, who must review, which checks must pass. A change management process usually asks further questions, and these are the ones a change policy answers:</p>
<table><thead><tr><th>Question</th><th>What a change policy adds</th></tr></thead><tbody><tr><td>Was the change approved in our change process, not only reviewed?</td><td>A change approval in Jira or the built-in tracker, whose decision holds the merge</td></tr><tr><td>Do different kinds of change follow different paths?</td><td>Policies matched by branch, repository, author, labels, changed files and size, each with a change type</td></tr><tr><td>Can an emergency merge now and be reviewed later?</td><td>Emergency policies with a review deadline and limits on who may declare one</td></tr><tr><td>Was the ticket decision made by someone allowed to make it?</td><td>Every tracker decision checked against the policy's approvers and separation of duties</td></tr><tr><td>Did the security scans of this change pass?</td><td>Secret, dependency, license and other scans as policy controls, reported or enforced</td></tr><tr><td>Which version of the rules decided this change?</td><td>Each merge request records the policy version that decided it</td></tr><tr><td>Did anything reach the branch outside the process?</td><td>Direct changes and weakened protection reported, and a compliance report for a period</td></tr></tbody></table>
<p>None of this replaces GitLab's controls. Merge Pilot writes several of them for you and builds the change decision on top.</p>
<h2 class="anchor anchorTargetStickyNavbar_Vzrq" id="how-merge-pilot-uses-gitlabs-own-controls">How Merge Pilot uses GitLab's own controls<a href="https://www.merge-pilot.com/guides/gitlab-change-management-options#how-merge-pilot-uses-gitlabs-own-controls" class="hash-link" aria-label="Direct link to How Merge Pilot uses GitLab's own controls" title="Direct link to How Merge Pilot uses GitLab's own controls" translate="no">​</a></h2>
<p>When a GitLab project is put under change management, Merge Pilot writes these setup steps, after showing them and asking for consent:</p>
<table><thead><tr><th>Step</th><th>What it writes</th><th>Required</th></tr></thead><tbody><tr><td><strong>Protect the target branches</strong></td><td>A protected branch per target branch pattern: by default push allowed to no one and merge allowed to Developers and Maintainers (the connection sets both). An already protected branch is left as it is</td><td>Yes</td></tr><tr><td><strong>Add the bot user as a member</strong></td><td>The connection's bot user with the Developer role, unless it already has that role or higher</td><td>Yes</td></tr><tr><td><strong>Approval rule per target branch</strong></td><td>A rule named <code>Merge Pilot — &lt;branch&gt;</code> requiring one approval from the bot user only</td><td>Yes</td></tr><tr><td><strong>Remove approvals when commits are added</strong></td><td>Turns on the project setting of that name</td><td>No (on by default)</td></tr><tr><td><strong>Prevent editing approval rules in merge requests</strong></td><td>Turns on the project setting of that name</td><td>No (on by default)</td></tr><tr><td><strong>Prevent approval by the author</strong></td><td>Turns on the project's "Prevent approval by author"</td><td>No (on by default)</td></tr><tr><td><strong>Prevent approvals by users who add commits</strong></td><td>Turns on the project setting of that name</td><td>No (on by default)</td></tr><tr><td><strong>Project webhook</strong></td><td>Merge Pilot's project webhook</td><td>Yes</td></tr></tbody></table>
<p>The merge gate is the approval rule. When the change policy is met for the merge request's latest commit, the bot approves; otherwise it withdraws its approval. Nobody else can meet the rule, so GitLab refuses the merge until change management clears it. Because the gate is an approval rule, it needs GitLab Premium or Ultimate; when GitLab refuses the rule, the setup says so and leaves the project as it was. See <a class="" href="https://www.merge-pilot.com/docs/connections/gitlab#change-management-setup-steps">GitLab change management setup steps</a> and <a class="" href="https://www.merge-pilot.com/docs/merge-requests/merge-gate#gitlab">Merge gate on GitLab</a>.</p>
<p>Your own approval rules stay in place. A team that already requires two maintainer approvals keeps that rule; the Merge Pilot rule is added next to it.</p>
<h2 class="anchor anchorTargetStickyNavbar_Vzrq" id="peer-review-versus-change-approval">Peer review versus change approval<a href="https://www.merge-pilot.com/guides/gitlab-change-management-options#peer-review-versus-change-approval" class="hash-link" aria-label="Direct link to Peer review versus change approval" title="Direct link to Peer review versus change approval" translate="no">​</a></h2>
<p>A change policy separates two decisions that GitLab's approvals often carry together:</p>
<ul>
<li class=""><strong>Code review</strong>: peers check the code in GitLab. The policy's <strong>Code review</strong> control can require a number of approvals from people with at least a given role, and hold the merge while changes are requested. GitLab approvals carry no commit, so they are counted for the latest commit only when the project removes approvals on push; otherwise the control stays pending and says why. See <a class="" href="https://www.merge-pilot.com/docs/policies/controls/code-review#gitlab-and-github">Code review on GitLab and GitHub</a>.</li>
<li class=""><strong>Change approval</strong>: the change process signs off in the tracker. Who may approve is set by the policy's <strong>Who must approve</strong>: the project's approver roles, approver pools, or the code owners of the changed files.</li>
</ul>
<h3 class="anchor anchorTargetStickyNavbar_Vzrq" id="codeowners-in-a-change-policy">CODEOWNERS in a change policy<a href="https://www.merge-pilot.com/guides/gitlab-change-management-options#codeowners-in-a-change-policy" class="hash-link" aria-label="Direct link to CODEOWNERS in a change policy" title="Direct link to CODEOWNERS in a change policy" translate="no">​</a></h3>
<p>A <strong>Code owners of the changed files</strong> requirement reads the CODEOWNERS file on the target branch (<code>CODEOWNERS</code>, <code>docs/CODEOWNERS</code> or <code>.gitlab/CODEOWNERS</code>, the first found) and asks one approval from each set of owners, honouring a GitLab section's own count. Optional sections need no approval. Owners are people: user names, or the e-mail of a Merge Pilot user who linked their GitLab account. Groups and role entries are not asked, and the merge request lists them as <em>Not asked from …</em>. See <a class="" href="https://www.merge-pilot.com/docs/policies/controls/approval#code-owners">Code owners</a>.</p>
<h2 class="anchor anchorTargetStickyNavbar_Vzrq" id="pipelines-and-merge-trains">Pipelines and merge trains<a href="https://www.merge-pilot.com/guides/gitlab-change-management-options#pipelines-and-merge-trains" class="hash-link" aria-label="Direct link to Pipelines and merge trains" title="Direct link to Pipelines and merge trains" translate="no">​</a></h2>
<p>The policy's <strong>CI</strong> control reads pipelines on the merge request's latest commit. GitLab pipelines always count; external pipelines created for commit statuses count only when the policy turns on <strong>Count commit statuses</strong>, because anyone who may push can post one. A policy can name the pipelines it expects by their <code>workflow:name</code>.</p>
<p>Merge Pilot does nothing of its own for merge trains: the gate stays the bot's approval. Pipelines GitLab runs on a merge request's merged result or merge train count for the latest commit, so the CI control sees them. See <a class="" href="https://www.merge-pilot.com/docs/policies/controls/ci#gitlab-and-github">CI</a>.</p>
<h2 class="anchor anchorTargetStickyNavbar_Vzrq" id="keeping-the-setup-intact">Keeping the setup intact<a href="https://www.merge-pilot.com/guides/gitlab-change-management-options#keeping-the-setup-intact" class="hash-link" aria-label="Direct link to Keeping the setup intact" title="Direct link to Keeping the setup intact" translate="no">​</a></h2>
<p>A GitLab maintainer can loosen a project after it was set up: unprotect a branch, allow force pushes, edit the approval rule, unlock the approval settings. Merge Pilot checks gated projects for such gaps when the company's <strong>Check gated projects' branch protection and warn when it lets changes skip the merge gate</strong> is on (the default), every six hours by default. New gaps are written as <code>protection_weakened</code> and announced. <strong>Re-run CM setup</strong> writes the steps again. See <a class="" href="https://www.merge-pilot.com/docs/repositories/change-management#branch-protection-check">Branch protection check</a>.</p>
<p>Pushes that reach a target branch or the default branch without a merge request, force pushes and deleted branches are recorded as <a class="" href="https://www.merge-pilot.com/docs/repositories/direct-changes">direct changes</a>. Merge Pilot's own bot user is never reported.</p>
<h2 class="anchor anchorTargetStickyNavbar_Vzrq" id="a-practical-rollout-on-gitlab">A practical rollout on GitLab<a href="https://www.merge-pilot.com/guides/gitlab-change-management-options#a-practical-rollout-on-gitlab" class="hash-link" aria-label="Direct link to A practical rollout on GitLab" title="Direct link to A practical rollout on GitLab" translate="no">​</a></h2>
<ol>
<li class=""><strong>Create the GitLab connection</strong> with a bot user that has a personal access token with the <code>api</code> scope and the Maintainer role on the projects to be gated. See <a class="" href="https://www.merge-pilot.com/docs/connections/gitlab">GitLab</a>.</li>
<li class=""><strong>Watch first.</strong> Watched projects only get a webhook; Merge Pilot records what it would have decided without writing anything else. See <a class="" href="https://www.merge-pilot.com/docs/repositories/watching">Watching repositories</a>.</li>
<li class=""><strong>Write the policies</strong>, starting from a template, and check them with <strong>Which policy applies?</strong>.</li>
<li class=""><strong>Move projects to change management</strong>, one or in bulk, reviewing the setup steps before agreeing to them.</li>
<li class=""><strong>Keep your own rules.</strong> Leave existing approval rules, CODEOWNERS and merge checks in place; the change policy adds the change decision next to them.</li>
</ol>
<h2 class="anchor anchorTargetStickyNavbar_Vzrq" id="next-steps">Next steps<a href="https://www.merge-pilot.com/guides/gitlab-change-management-options#next-steps" class="hash-link" aria-label="Direct link to Next steps" title="Direct link to Next steps" translate="no">​</a></h2>
<p>The <a class="" href="https://www.merge-pilot.com/features/merge-gate">Merge gate</a> feature page describes the gate on GitLab and GitHub side by side. For the step-by-step behaviour of the gate, see <a class="" href="https://www.merge-pilot.com/docs/merge-requests/merge-gate">Merge gate</a>. To see a change policy gate a GitLab project of yours, <a class="" href="https://www.merge-pilot.com/contact">ask for a demo</a>.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Mapping ITIL change types to merge requests]]></title>
            <link>https://www.merge-pilot.com/guides/itil-change-types-merge-requests</link>
            <guid>https://www.merge-pilot.com/guides/itil-change-types-merge-requests</guid>
            <pubDate>Fri, 13 Nov 2026 00:00:00 GMT</pubDate>
            <description><![CDATA[How ITIL's standard, normal and emergency changes map to GitLab and GitHub merge requests: change policies, matching conditions and emergency rules.]]></description>
            <content:encoded><![CDATA[<p>ITIL sorts changes into three types: standard, normal and emergency. Each type has its own path to approval, and most change management processes in larger organisations are built on that split. Merge requests rarely are. This guide shows how to carry the three change types over to GitLab and GitHub merge requests with change policies, so a documentation fix, a production release and a hotfix each follow the path meant for it.</p>
<h2 class="anchor anchorTargetStickyNavbar_Vzrq" id="the-three-change-types-in-brief">The three change types in brief<a href="https://www.merge-pilot.com/guides/itil-change-types-merge-requests#the-three-change-types-in-brief" class="hash-link" aria-label="Direct link to The three change types in brief" title="Direct link to The three change types in brief" translate="no">​</a></h2>
<p>In general terms, ITIL describes the three types like this:</p>
<ul>
<li class="">A <strong>standard change</strong> is low risk, well understood and pre-authorized. It follows a known procedure, so it does not need a fresh approval each time.</li>
<li class="">A <strong>normal change</strong> is assessed and authorized before it is made, by whoever the organisation names as the change authority.</li>
<li class="">An <strong>emergency change</strong> must be made as soon as possible, often to restore a service. Its authorization is faster, and it is reviewed afterwards.</li>
</ul>
<p>The value of the split is proportion: approval effort goes where risk is, and routine work is not held up by the same process as a database migration.</p>
<h2 class="anchor anchorTargetStickyNavbar_Vzrq" id="how-a-change-policy-expresses-a-change-type">How a change policy expresses a change type<a href="https://www.merge-pilot.com/guides/itil-change-types-merge-requests#how-a-change-policy-expresses-a-change-type" class="hash-link" aria-label="Direct link to How a change policy expresses a change type" title="Direct link to How a change policy expresses a change type" translate="no">​</a></h2>
<p>In Merge Pilot, a <strong>change policy</strong> decides which merge requests it covers, what change type they are, and which controls must pass before the merge. Policies belong to a VCS connection and are tried from top to bottom; the first active policy that matches decides. A <strong>catch-all</strong> at the bottom covers everything the policies above it do not. See <a class="" href="https://www.merge-pilot.com/docs/policies/overview#how-a-policy-is-chosen">How a policy is chosen</a>.</p>
<p>Each policy has one of four outcomes, set on its <strong>Change type</strong> tab:</p>
<table><thead><tr><th>Change type</th><th>Change approval</th><th>Merge</th></tr></thead><tbody><tr><td><strong>Standard change</strong></td><td>None, unless <strong>Open a change approval as a record</strong> is on (then nobody has to approve it)</td><td>Merges once its enforced controls pass</td></tr><tr><td><strong>Normal change</strong></td><td>Opened in the tracker before the merge; must be approved by the people the policy asks for</td><td>Held until the change approval is approved and every enforced control passes</td></tr><tr><td><strong>Emergency change</strong></td><td>Opened for a review after the merge, within the <strong>Review deadline</strong></td><td>Merges once its enforced controls pass; the approval does not hold it</td></tr><tr><td><strong>Refuse</strong></td><td>None</td><td>Nothing it covers can merge; the policy's description tells the author what to do instead</td></tr></tbody></table>
<p>Controls apply to every change type. A standard change still waits for its enforced CI or secret scan; "pre-approved" means no person has to sign off, not that nothing is checked. See <a class="" href="https://www.merge-pilot.com/docs/policies/overview#change-types">Change types</a>.</p>
<h2 class="anchor anchorTargetStickyNavbar_Vzrq" id="deciding-which-merge-requests-are-which">Deciding which merge requests are which<a href="https://www.merge-pilot.com/guides/itil-change-types-merge-requests#deciding-which-merge-requests-are-which" class="hash-link" aria-label="Direct link to Deciding which merge requests are which" title="Direct link to Deciding which merge requests are which" translate="no">​</a></h2>
<p>The change type is only useful if the right merge requests land in it. A policy's conditions, on its <strong>Scope</strong> tab, can match on:</p>
<ul>
<li class="">target and source branches, such as <code>main, release/*</code> or <code>hotfix/**</code>;</li>
<li class="">repositories, such as <code>team/payments-*</code>;</li>
<li class="">the author: people only, bots only, or named accounts;</li>
<li class="">labels the merge request has, or must not have;</li>
<li class="">changed files: only these files changed, touches any of, touches none of;</li>
<li class="">the size of the change, in files or lines;</li>
<li class="">draft state.</li>
</ul>
<p>A merge request must meet every condition a policy sets. Patterns are globs, not regular expressions; a pattern that looks like a regular expression is refused when the policy is saved. See <a class="" href="https://www.merge-pilot.com/docs/policies/matching">Matching</a>.</p>
<h3 class="anchor anchorTargetStickyNavbar_Vzrq" id="a-worked-example">A worked example<a href="https://www.merge-pilot.com/guides/itil-change-types-merge-requests#a-worked-example" class="hash-link" aria-label="Direct link to A worked example" title="Direct link to A worked example" translate="no">​</a></h3>
<p>A typical ordered list for one VCS connection:</p>
<ol>
<li class=""><strong>Emergency changes</strong>: emergency change; labels <strong>Has any of</strong> <code>emergency</code>; authors <strong>People only</strong>; CI and secret scan enforced; review within 72 hours.</li>
<li class=""><strong>Documentation</strong>: standard change; <strong>Only these files changed</strong> <code>**.md, docs/**</code>; secret scan enforced.</li>
<li class=""><strong>Dependency updates</strong>: standard change; <strong>Bots only</strong>, listing <code>dependabot[bot], renovate[bot]</code>; CI, secret scan and dependency scan enforced.</li>
<li class=""><strong>Normal changes</strong> (the catch-all): normal change; work item required; CI and secret scan enforced; one approval from the project's approver roles.</li>
</ol>
<p>The built-in <strong>ITIL change management</strong> template sets up the first, second and fourth of these; the <strong>Dependency update bots</strong> template adds the third. Templates are a starting point and every policy stays editable. See <a class="" href="https://www.merge-pilot.com/docs/policies/overview#templates">Templates</a>.</p>
<h3 class="anchor anchorTargetStickyNavbar_Vzrq" id="things-to-watch-when-matching">Things to watch when matching<a href="https://www.merge-pilot.com/guides/itil-change-types-merge-requests#things-to-watch-when-matching" class="hash-link" aria-label="Direct link to Things to watch when matching" title="Direct link to Things to watch when matching" translate="no">​</a></h3>
<ul>
<li class=""><strong>Order matters.</strong> A policy with no conditions above others makes everything below it unreachable. The policy list warns about this, and about policies that can never be reached because one above always matches first.</li>
<li class=""><strong>Renamed files count twice.</strong> A file moved into <code>docs/</code> counts with both its old and new path, so moving code into <code>docs/</code> does not make it a documentation change.</li>
<li class=""><strong>Unknown diffs fall through.</strong> When the VCS cannot send the list of changed files (a very large change), a policy with a file or size condition does not match, and a later policy decides. A narrow standard policy cannot be proven to apply to a change nobody can read.</li>
<li class=""><strong>Bots only means bots.</strong> With <strong>Bots only</strong> and no bot listed, every bot account matches, including CI tokens and GitLab project or group access tokens. List the bots you mean.</li>
</ul>
<p>Before saving, <strong>Which policy applies?</strong> takes a described change through the saved policies and shows, for each one above the deciding policy, the first condition it fails. <strong>Test run</strong> tries unsaved edits on a real merge request. See <a class="" href="https://www.merge-pilot.com/docs/policies/overview#trying-policies-out">Trying policies out</a>.</p>
<h2 class="anchor anchorTargetStickyNavbar_Vzrq" id="normal-changes-the-change-authority">Normal changes: the change authority<a href="https://www.merge-pilot.com/guides/itil-change-types-merge-requests#normal-changes-the-change-authority" class="hash-link" aria-label="Direct link to Normal changes: the change authority" title="Direct link to Normal changes: the change authority" translate="no">​</a></h2>
<p>ITIL leaves the choice of change authority to the organisation. A normal policy expresses it in <strong>Who must approve</strong>: one or more ways to approve, each with requirements such as <em>1 of Security and 2 of Operations</em>, or <em>1 of the change advisory board</em> as an approver pool. Any one way met approves the change.</p>
<p>Two refinements bring this closer to how change authorities usually work:</p>
<ul>
<li class=""><strong>Approvals by risk level</strong> lets a requirement ask for a different number of approvals at low, medium, high and critical risk, so a larger or riskier change needs more sign-off under the same policy.</li>
<li class=""><strong>Code owners of the changed files</strong> asks the people the CODEOWNERS file names for the files that changed.</li>
</ul>
<p>The change approval is opened in Jira or the built-in tracker, assigned as the policy says (never to the author), and its decision holds the merge gate. See <a class="" href="https://www.merge-pilot.com/docs/policies/controls/approval#who-must-approve">Who must approve</a>.</p>
<h2 class="anchor anchorTargetStickyNavbar_Vzrq" id="standard-changes-pre-approved-still-checked">Standard changes: pre-approved, still checked<a href="https://www.merge-pilot.com/guides/itil-change-types-merge-requests#standard-changes-pre-approved-still-checked" class="hash-link" aria-label="Direct link to Standard changes: pre-approved, still checked" title="Direct link to Standard changes: pre-approved, still checked" translate="no">​</a></h2>
<p>A standard policy is for changes your organisation has agreed need no individual approval. Typical candidates are documentation-only changes and dependency updates from known bots, where the checks carry the weight: CI must pass, no secrets, no new high-severity vulnerabilities.</p>
<p>If your process wants a ticket for every change, even pre-approved ones, turn on <strong>Open a change approval as a record</strong>. A change approval is then opened for the record, and nobody is asked to approve it. See <a class="" href="https://www.merge-pilot.com/docs/policies/controls/approval#standard-changes">Standard changes</a>.</p>
<h2 class="anchor anchorTargetStickyNavbar_Vzrq" id="emergency-changes-merge-now-review-after">Emergency changes: merge now, review after<a href="https://www.merge-pilot.com/guides/itil-change-types-merge-requests#emergency-changes-merge-now-review-after" class="hash-link" aria-label="Direct link to Emergency changes: merge now, review after" title="Direct link to Emergency changes: merge now, review after" translate="no">​</a></h2>
<p>An emergency policy lets a change merge as soon as its enforced controls pass, without waiting for approval. A change approval is opened for the review afterwards, due within the policy's <strong>Review deadline</strong> (72 hours by default). The review uses the same <strong>Who must approve</strong> and the same checks as any approval: the author never decides it.</p>
<h3 class="anchor anchorTargetStickyNavbar_Vzrq" id="who-may-declare-an-emergency">Who may declare an emergency<a href="https://www.merge-pilot.com/guides/itil-change-types-merge-requests#who-may-declare-an-emergency" class="hash-link" aria-label="Direct link to Who may declare an emergency" title="Direct link to Who may declare an emergency" translate="no">​</a></h3>
<p>The person who declares an emergency is whoever added the label the policy matches on; for a policy that matches on something else, the author. By default anyone who may label the change may declare one, so a hotfix never waits. Every declaration is recorded on the merge request, written to the audit log as <code>emergency_declared</code> and announced.</p>
<p>Because an emergency skips the approval before the merge, it is the path most worth limiting. The company's <strong>Emergency changes</strong> settings, which an emergency policy can override with <strong>This policy sets its own rules</strong>, offer:</p>
<table><thead><tr><th>Rule</th><th>Effect</th></tr></thead><tbody><tr><td><strong>Who may declare one</strong></td><td>Anyone who may label the change, or only people of one approver pool</td></tr><tr><td><strong>The author may not declare their own change an emergency</strong></td><td>Someone other than the author must add the label</td></tr><tr><td><strong>Limit emergencies per repository</strong></td><td>Once a repository has had this many emergencies in the window, further ones are not emergencies</td></tr></tbody></table>
<p>When a rule is not met, or who added the label cannot be read from the VCS, the emergency policy does not match and the next matching policy (usually the normal one) covers the change. See <a class="" href="https://www.merge-pilot.com/docs/policies/controls/approval#who-may-declare-an-emergency">Who may declare an emergency</a> and <a class="" href="https://www.merge-pilot.com/docs/companies/approvals#emergency-changes">Emergency changes</a>.</p>
<h3 class="anchor anchorTargetStickyNavbar_Vzrq" id="when-the-review-is-late">When the review is late<a href="https://www.merge-pilot.com/guides/itil-change-types-merge-requests#when-the-review-is-late" class="hash-link" aria-label="Direct link to When the review is late" title="Direct link to When the review is late" translate="no">​</a></h3>
<p>When a quarter of the review time is left (at most a day before the deadline), <strong>Change approval due soon</strong> is sent. A review still undecided at its deadline is written as <code>emergency_review_overdue</code>, sent as <strong>Emergency review overdue</strong> and commented on the change approval. If an emergency change merged before its review change approval could be opened, for example while the tracker was unreachable, the review is opened afterwards for changes merged within the last 30 days.</p>
<h2 class="anchor anchorTargetStickyNavbar_Vzrq" id="change-freezes-and-the-three-types">Change freezes and the three types<a href="https://www.merge-pilot.com/guides/itil-change-types-merge-requests#change-freezes-and-the-three-types" class="hash-link" aria-label="Direct link to Change freezes and the three types" title="Direct link to Change freezes and the three types" translate="no">​</a></h2>
<p>A company's change calendar can hold merges during a freeze. The freeze mode decides how each type is treated:</p>
<ul>
<li class=""><strong>Hold merges</strong>: every merge is held, emergencies included.</li>
<li class=""><strong>Emergency changes only</strong>: changes under an emergency policy pass; every other change is held.</li>
<li class=""><strong>Raise risk only</strong>: nothing is held by the freeze; assessed changes score critical risk.</li>
</ul>
<p>Approvals go on during a freeze, so normal changes can be approved and merge once it ends. See <a class="" href="https://www.merge-pilot.com/docs/policies/controls/risk#change-freezes">Change freezes</a>.</p>
<h2 class="anchor anchorTargetStickyNavbar_Vzrq" id="rolling-it-out">Rolling it out<a href="https://www.merge-pilot.com/guides/itil-change-types-merge-requests#rolling-it-out" class="hash-link" aria-label="Direct link to Rolling it out" title="Direct link to Rolling it out" translate="no">​</a></h2>
<ol>
<li class="">Start from the <strong>ITIL change management</strong> template on a VCS connection, then adjust conditions and approvers.</li>
<li class="">Add the <strong>Dependency update bots</strong> template if bots open merge requests in your repositories.</li>
<li class="">Set the company's emergency rules before anyone relies on the <code>emergency</code> label.</li>
<li class="">Check the order with <strong>Which policy applies?</strong> for a docs change, a bot update, a labelled hotfix and an ordinary feature.</li>
<li class="">Watch repositories first if you want to see what the policies would do before they block anything; the <a class="" href="https://www.merge-pilot.com/docs/insights/monitoring-report">monitoring report</a> shows what change management would have held.</li>
</ol>
<h2 class="anchor anchorTargetStickyNavbar_Vzrq" id="next-steps">Next steps<a href="https://www.merge-pilot.com/guides/itil-change-types-merge-requests#next-steps" class="hash-link" aria-label="Direct link to Next steps" title="Direct link to Next steps" translate="no">​</a></h2>
<p>The <a class="" href="https://www.merge-pilot.com/features/change-policies">Change policies</a> feature page sums up matching, change types and controls. If your change advisory board works in an ITSM tool today, the <a class="" href="https://www.merge-pilot.com/compare/itsm-cab-vs-merge-gate">ITSM CAB and merge gate comparison</a> sets the two approaches side by side. To map your own change types to policies with us, <a class="" href="https://www.merge-pilot.com/contact">ask for a demo</a>.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Separation of duties on merge requests: what auditors check]]></title>
            <link>https://www.merge-pilot.com/guides/separation-of-duties-merge-requests</link>
            <guid>https://www.merge-pilot.com/guides/separation-of-duties-merge-requests</guid>
            <pubDate>Fri, 13 Nov 2026 00:00:00 GMT</pubDate>
            <description><![CDATA[What auditors look for in separation of duties on merge requests, and how a change policy enforces and records it on GitLab and GitHub, with evidence.]]></description>
            <content:encoded><![CDATA[<p>Separation of duties on code changes sounds simple: the person who writes a change should not be the one who approves it. In practice an audit asks more than that. Who else touched the change, who merged it, whether the approval in the ticket was made by someone allowed to make it, and whether the rules themselves could be loosened by one person. This guide walks through those questions and shows what Merge Pilot enforces and what it records for each.</p>
<h2 class="anchor anchorTargetStickyNavbar_Vzrq" id="what-auditors-usually-ask">What auditors usually ask<a href="https://www.merge-pilot.com/guides/separation-of-duties-merge-requests#what-auditors-usually-ask" class="hash-link" aria-label="Direct link to What auditors usually ask" title="Direct link to What auditors usually ask" translate="no">​</a></h2>
<p>Audits of change management on source code tend to come back to a handful of questions, whatever the framework behind them:</p>
<ul>
<li class="">Was every change to a production branch approved before it merged?</li>
<li class="">Was the approver someone other than the person who made the change?</li>
<li class="">Was the approved version the version that merged, or did code change after approval?</li>
<li class="">Who was allowed to approve, and how is that list controlled?</li>
<li class="">Could anyone bypass the process, and would you know if they did?</li>
<li class="">Who can change the rules, and is that change reviewed too?</li>
<li class="">Can you show all of this for a sample of changes in a given period?</li>
</ul>
<p>A VCS's own review settings answer part of this. The harder parts are the ones that span systems: an approval recorded in a ticketing tool, a merge in the VCS, and the policy that connected them.</p>
<h2 class="anchor anchorTargetStickyNavbar_Vzrq" id="the-author-never-approves">The author never approves<a href="https://www.merge-pilot.com/guides/separation-of-duties-merge-requests#the-author-never-approves" class="hash-link" aria-label="Direct link to The author never approves" title="Direct link to The author never approves" translate="no">​</a></h2>
<p>In Merge Pilot the merge request's author never approves, rejects, takes the change approval or accepts its risk. This is not a setting; it always applies.</p>
<p>The author is recognised by the VCS account each person links in <strong>My profile</strong>. A vote in Merge Pilot is refused from anyone who has not linked their account on the merge request's VCS, because without it Merge Pilot cannot tell whether they wrote the change. Authors see <em>You wrote this change, so you cannot vote on it.</em> instead of the buttons.</p>
<p>The same rule holds in the tracker. If the author moves their own change approval to an approving status in Jira or the built-in tracker, the approval is ignored, the change approval goes back, the merge request is told why, and the attempt is written to the audit log as <code>change_approval_self_approval_blocked</code>. See <a class="" href="https://www.merge-pilot.com/docs/merge-requests/voting#who-may-vote">Who may vote</a>.</p>
<h2 class="anchor anchorTargetStickyNavbar_Vzrq" id="people-who-committed-to-the-change">People who committed to the change<a href="https://www.merge-pilot.com/guides/separation-of-duties-merge-requests#people-who-committed-to-the-change" class="hash-link" aria-label="Direct link to People who committed to the change" title="Direct link to People who committed to the change" translate="no">​</a></h2>
<p>The author is not the only person with a stake in a change. Someone who pushed a fix to a colleague's branch is a co-author in all but name. The policy's <strong>People who committed to the change</strong> setting decides what they may do:</p>
<table><thead><tr><th>Option</th><th>Effect</th></tr></thead><tbody><tr><td><strong>May not approve</strong> (default)</td><td>Their approvals, in Merge Pilot and in the tracker, are refused, and they are not assigned the change approval</td></tr><tr><td><strong>May approve, flagged</strong></td><td>They may approve; the merge request and the compliance report show the flag</td></tr><tr><td><strong>May approve</strong></td><td>No restriction</td></tr></tbody></table>
<p>People are matched by their linked VCS account and their e-mail. The rule restricts approving only: a committer may still reject, because a rejection only stops a change. A stand-in for an approver who committed to the change is treated as a committer.</p>
<h2 class="anchor anchorTargetStickyNavbar_Vzrq" id="the-approver-who-merges">The approver who merges<a href="https://www.merge-pilot.com/guides/separation-of-duties-merge-requests#the-approver-who-merges" class="hash-link" aria-label="Direct link to The approver who merges" title="Direct link to The approver who merges" translate="no">​</a></h2>
<p>Some organisations also want the person who approved a change not to be the one who merges it. The VCS cannot be told to refuse a merge from a specific approver, and Merge Pilot does not pretend it can. The policy's <strong>An approver merging the change</strong> setting decides how such a merge is recorded:</p>
<ul>
<li class=""><strong>Allowed</strong> (default): nothing is flagged.</li>
<li class=""><strong>Allowed, flagged</strong>: the merge is flagged on the merge request and written as <code>mr_sod_flag</code>.</li>
<li class=""><strong>Non-compliant</strong>: the merge is marked non-compliant, written as <code>mr_sod_block</code>, and administrators are alerted with the <strong>Merged without approval</strong> notification titled <em>Separation of duties broken</em>.</li>
</ul>
<p>The settings are described in <a class="" href="https://www.merge-pilot.com/docs/policies/controls/approval#separation-of-duties">Separation of duties</a>.</p>
<h2 class="anchor anchorTargetStickyNavbar_Vzrq" id="decisions-made-in-the-tracker-are-checked">Decisions made in the tracker are checked<a href="https://www.merge-pilot.com/guides/separation-of-duties-merge-requests#decisions-made-in-the-tracker-are-checked" class="hash-link" aria-label="Direct link to Decisions made in the tracker are checked" title="Direct link to Decisions made in the tracker are checked" translate="no">​</a></h2>
<p>Many teams decide change approvals in Jira. A status move in Jira is an approval only if the person who made it was allowed to. Merge Pilot checks each decision before it counts:</p>
<ol>
<li class="">The tracker must name who made the move. An approval the tracker names nobody for never counts.</li>
<li class="">That person is matched to a Merge Pilot account by tracker account, e-mail or user name, as the company's People settings say. An identifier that matches more than one account counts for nobody.</li>
<li class="">The person must be allowed to decide the change: not the author, holding one of the requirement's roles, in the named approver pool or a code owner of the changed files, and not kept out by the committer rule.</li>
<li class="">A decision that fails these checks is ignored, the change approval goes back, the merge request gets a comment, and <code>change_approval_vote_ineligible</code> is written.</li>
</ol>
<p>Two company settings tighten this further. <strong>Approvals made in the tracker</strong> set to <strong>Only from people who linked their VCS account</strong> (the default) requires the decider to be an active user of the company with a linked VCS account. <strong>In Jira, only the change approval's assignee decides it</strong> ignores decisions in Jira by anyone but the assignee. Withdrawing an approval is checked the same way: only someone who may decide the change, or an administrator, can do it, and anyone else's move is undone. See <a class="" href="https://www.merge-pilot.com/docs/merge-requests/voting#decisions-made-in-the-tracker">Decisions made in the tracker</a>.</p>
<h2 class="anchor anchorTargetStickyNavbar_Vzrq" id="who-may-approve-and-how-that-list-is-controlled">Who may approve, and how that list is controlled<a href="https://www.merge-pilot.com/guides/separation-of-duties-merge-requests#who-may-approve-and-how-that-list-is-controlled" class="hash-link" aria-label="Direct link to Who may approve, and how that list is controlled" title="Direct link to Who may approve, and how that list is controlled" translate="no">​</a></h2>
<p>A policy's <strong>Who must approve</strong> lists one or more ways to approve. Each way has requirements, such as one approval from Security and two from Operations, drawn from:</p>
<ul>
<li class="">the project's approver roles (repository roles chosen on the VCS connection, less excluded users);</li>
<li class="">an <a class="" href="https://www.merge-pilot.com/docs/policies/approver-pools">approver pool</a>, a named group of people;</li>
<li class="">the code owners of the changed files, read from the CODEOWNERS file on the target branch.</li>
</ul>
<p>A requirement can ask for more approvals at higher risk levels. Votes are counted once per person, so someone in two pools cannot fill two seats. See <a class="" href="https://www.merge-pilot.com/docs/policies/controls/approval#who-must-approve">Who must approve</a>.</p>
<p>Two features address the human side of approving. <strong>Stand-ins</strong> let an approver who is away hand their seat to someone else for a period, within rules the company sets; the stand-in only fills requirements whose roles they hold themselves, and their vote is marked as standing in. <strong>Approval fatigue</strong> detection, when turned on, warns when one person approves many change approvals in a short period. It warns and never blocks. See <a class="" href="https://www.merge-pilot.com/docs/companies/approvals#stand-ins-for-approvers">Stand-ins for approvers</a> and <a class="" href="https://www.merge-pilot.com/docs/companies/approvals#approval-fatigue-guard">Approval fatigue guard</a>.</p>
<h2 class="anchor anchorTargetStickyNavbar_Vzrq" id="the-approved-version-is-the-version-that-merged">The approved version is the version that merged<a href="https://www.merge-pilot.com/guides/separation-of-duties-merge-requests#the-approved-version-is-the-version-that-merged" class="hash-link" aria-label="Direct link to The approved version is the version that merged" title="Direct link to The approved version is the version that merged" translate="no">​</a></h2>
<p>Separation of duties is weakened if an approved change can be altered before it merges. Every Merge Pilot decision is for the merge request's latest commit and target branch. By default a new commit supersedes the change approval and a new one is opened for the new code. On GitLab the bot's approval is removed when commits are pushed; on GitHub a new commit has no passing check until Merge Pilot decides on it.</p>
<p>The compliance report shows both commits side by side: <strong>Merged Commit</strong>, <strong>Approved Commit</strong> and <strong>Merged Commit Approved</strong>. A policy can choose <strong>Keep the approval</strong> instead, and each time that applies it is written as <code>change_approval_new_commits_kept</code>, so the choice is visible to an auditor.</p>
<h2 class="anchor anchorTargetStickyNavbar_Vzrq" id="bypasses-are-recorded">Bypasses are recorded<a href="https://www.merge-pilot.com/guides/separation-of-duties-merge-requests#bypasses-are-recorded" class="hash-link" aria-label="Direct link to Bypasses are recorded" title="Direct link to Bypasses are recorded" translate="no">​</a></h2>
<p>A VCS administrator can always bypass a merge gate. What matters to an audit is whether that is visible. Merge Pilot flags:</p>
<ul>
<li class="">merges the gate had not opened for the merged commit (<strong>Merged without approval</strong>);</li>
<li class="">merges during a change freeze that held them;</li>
<li class="">approvals withdrawn in the tracker after the merge;</li>
<li class="">approvers who merged, when the policy flags or forbids it.</li>
</ul>
<p>Changes that reached a covered branch without a merge request at all (a direct push, a force push, a deleted branch) are recorded as <a class="" href="https://www.merge-pilot.com/docs/repositories/direct-changes">direct changes</a>, marked as <strong>Violations</strong> on repositories under change management. Merge Pilot also checks gated repositories for loosened branch protection and records new gaps as <code>protection_weakened</code>. See <a class="" href="https://www.merge-pilot.com/docs/merge-requests/merge-gate#what-is-flagged-at-merge">What is flagged at merge</a>.</p>
<h2 class="anchor anchorTargetStickyNavbar_Vzrq" id="four-eyes-on-the-rules-themselves">Four-eyes on the rules themselves<a href="https://www.merge-pilot.com/guides/separation-of-duties-merge-requests#four-eyes-on-the-rules-themselves" class="hash-link" aria-label="Direct link to Four-eyes on the rules themselves" title="Direct link to Four-eyes on the rules themselves" translate="no">​</a></h2>
<p>Controls only hold if one person cannot quietly relax them. With <strong>Review control changes</strong> turned on (Company → <strong>Governance</strong>), changes to change policies, approver pools, risk settings and change freezes, sign-in settings and identity providers wait until a second person approves them.</p>
<ul>
<li class="">Nobody decides their own change.</li>
<li class="">An administrator whose account the requester created, gave its role or set the password of cannot decide it either.</li>
<li class="">Turning the review off is itself reviewed.</li>
<li class="">API tokens cannot approve or reject a waiting change.</li>
</ul>
<p>Every policy save is also a new version, and each merge request records the policy version that decided it. See <a class="" href="https://www.merge-pilot.com/docs/companies/governance">Governance tab</a> and <a class="" href="https://www.merge-pilot.com/docs/policies/overview#versions-and-history">Versions and history</a>.</p>
<h2 class="anchor anchorTargetStickyNavbar_Vzrq" id="evidence-in-the-compliance-report">Evidence in the compliance report<a href="https://www.merge-pilot.com/guides/separation-of-duties-merge-requests#evidence-in-the-compliance-report" class="hash-link" aria-label="Direct link to Evidence in the compliance report" title="Direct link to Evidence in the compliance report" translate="no">​</a></h2>
<p>Auditors usually ask for a period's changes and then sample them. The <a class="" href="https://www.merge-pilot.com/docs/insights/compliance">compliance report</a> puts a period's records in one CSV or PDF file. It can be exported by platform admins, company admins and auditors, and each export is itself written to the audit log.</p>
<table><thead><tr><th>What the auditor asks</th><th>Where it is in the report</th></tr></thead><tbody><tr><td>Was it approved, and by whom?</td><td><strong>Change Approval Key</strong>, <strong>Change Approval Status</strong>, <strong>Approved By</strong>, <strong>Approved At</strong>, <strong>Votes</strong> (with source: tracker or Merge Pilot)</td></tr><tr><td>Under which rules?</td><td><strong>Policy</strong>, <strong>Policy Version</strong>, <strong>Change Type</strong></td></tr><tr><td>Was the merged code the approved code?</td><td><strong>Merged Commit</strong>, <strong>Approved Commit</strong>, <strong>Merged Commit Approved</strong></td></tr><tr><td>Were duties separated?</td><td><strong>Separation Of Duties</strong> (exceptions noted), <strong>SoD Violation</strong></td></tr><tr><td>Was the gate bypassed?</td><td><strong>Merged Without Approval</strong>, <strong>Merged In Freeze</strong>, <strong>Approval Revoked After Merge</strong>; in the PDF the <strong>Gate</strong> column shows <strong>BYPASSED</strong>, <strong>SOD BROKEN</strong>, <strong>IN FREEZE</strong> or <strong>REVOKED</strong></td></tr><tr><td>Did anything skip the process?</td><td>The <strong>Changes Outside Change Management</strong> section</td></tr><tr><td>Who did what, when?</td><td>The <strong>Audit Trail</strong> section</td></tr></tbody></table>
<p>The <strong>auditor</strong> role is read-only: an auditor reads everything of their company, the audit log included, and exports the report, but changes nothing and cannot vote. See <a class="" href="https://www.merge-pilot.com/docs/platform/roles-and-users">Roles and users</a>.</p>
<h2 class="anchor anchorTargetStickyNavbar_Vzrq" id="a-note-on-frameworks">A note on frameworks<a href="https://www.merge-pilot.com/guides/separation-of-duties-merge-requests#a-note-on-frameworks" class="hash-link" aria-label="Direct link to A note on frameworks" title="Direct link to A note on frameworks" translate="no">​</a></h2>
<p>Merge Pilot does not make an organisation compliant on its own. It keeps records that can help produce evidence for the change management controls that frameworks such as SOX IT general controls, SOC 2, PCI DSS, ISO/IEC 27001 and the EU's DORA regulation describe. Which records your auditor accepts, and how they map to your control descriptions, is a conversation with them. The <a class="" href="https://www.merge-pilot.com/security#audit-evidence">Security</a> page lists those frameworks with the records that relate to each.</p>
<h2 class="anchor anchorTargetStickyNavbar_Vzrq" id="next-steps">Next steps<a href="https://www.merge-pilot.com/guides/separation-of-duties-merge-requests#next-steps" class="hash-link" aria-label="Direct link to Next steps" title="Direct link to Next steps" translate="no">​</a></h2>
<p>The <a class="" href="https://www.merge-pilot.com/features/approvals">Approvals &amp; separation of duties</a> feature page sums up the approval rules, and the <a class="" href="https://www.merge-pilot.com/features/insights">Insights</a> page covers the audit log and the compliance report. To walk through a sample audit with your own policies, <a class="" href="https://www.merge-pilot.com/contact">ask for a demo</a>.</p>]]></content:encoded>
        </item>
    </channel>
</rss>