Skip to main content

Video tutorials

Short videos of Merge Pilot working on real GitLab and Jira projects, from the first sign-in to the compliance report. English audio, English and Turkish subtitles.

Getting started

Create the company, connect GitLab and Jira, start from a policy template, watch first, then enforce.

Sign In and Create Your CompanyYouTube ↗

This first tutorial starts at the very beginning: sign in as the administrator, replace the temporary password, create your company and read its setup checklist. Then take the first step of the checklist: the Application URL, the address your Git platform and your issue tracker use to reach Merge Pilot.

Connect GitLabYouTube ↗

Merge Pilot works in GitLab as its own user: a bot account with a personal access token. This tutorial adds the GitLab connection to the company, tests it, and shows the bot in the GitLab group, where its Maintainer role lets it protect branches and approve merge requests.

Connect Jira for Change ApprovalsYouTube ↗

Every normal change gets a change approval in your tracker. This tutorial connects Jira: the project and issue type change approvals are created with, the project work items are read from, and the statuses that approve or reject a change. Then it links Jira to the GitLab connection and shows the Change Management board in Jira.

Your First Change Policies from a TemplateYouTube ↗

Change policies decide what a merge request needs before it may merge. A new connection starts with a single catch-all policy that refuses everything. This tutorial replaces it with the ITIL change management template: emergency changes that merge now and are reviewed afterwards, pre-approved standard changes for documentation, and normal changes that need a work item, a passing pipeline and an approval.

Watch Repositories Before You Enforce AnythingYouTube ↗

Start by watching: Merge Pilot records the merge requests of your repositories as change management would decide them, and does not get in their way. This tutorial registers five GitLab repositories in Watching mode, imports their recent merge requests, and shows that GitLab only received a webhook: no branch protection, no approval rule, no comment.

The Monitoring Report of Watched RepositoriesYouTube ↗

Before you enforce a merge gate, know what it would do. The monitoring report takes the merge requests Merge Pilot recorded while only watching your repositories and shows, by the current policies, how many would have been approved, how many would have waited for a change approval and how many would have been blocked, which control would have held them, and where: per policy and per repository.

Put a GitLab Repository Under Change ManagementYouTube ↗

This tutorial moves a watched repository to change management. Merge Pilot shows what it will write to GitLab and asks for your consent: it protects the target branch, adds its bot as a member, creates an approval rule that only the bot can meet, and keeps the webhook. Then GitLab shows the result: the approval rule on the merge request settings and the protected branch.

Sign In with GitLab and Link Your AccountYouTube ↗

Approvals only count when Merge Pilot knows who the approver is in GitLab. This tutorial turns on signing in with GitLab: OAuth on the GitLab connection, who may sign in for the company, and the company on the sign-in page. Then a maintainer signs in with GitLab for the first time: the account is created and the GitLab account is linked.

Move Many Repositories at OnceYouTube ↗

A company with hundreds of repositories does not move them one by one. This tutorial chooses watched repositories on the Projects page and moves them to change management in one bulk operation: Merge Pilot writes the setup to each repository in the background and shows the progress. One click reverts what was done, switching them back to watching.

Merge requests and the gate

One merge request from opening to merge: what it needs, what developers see, and how a change approval is decided.

Follow One Merge Request Through the GateYouTube ↗

This tutorial follows one change end to end. A developer opens a merge request in GitLab; the merge is blocked until Merge Pilot clears it. Merge Pilot runs the checks of the change policy and opens a change approval in Jira. The assigned approver approves it there, Merge Pilot’s bot approves the merge request in GitLab, the developer merges, and the change approval is closed: requested, checked, approved and merged, all on record.

Read the Merge Request PageYouTube ↗

One page tells the whole story of a change. This tutorial walks through the merge request list and then one open merge request: the clearance track, the policy card with every check and its reason, the change approval and who it is assigned to, the approvals still needed, the scans, the pipelines and the timeline that keeps the evidence, commit by commit.

What Developers See in GitLabYouTube ↗

Developers keep working in GitLab. This tutorial looks at a governed merge request from the developer’s side: the approval rule that only Merge Pilot’s bot can meet, the blocked merge, and the comments Merge Pilot writes — one status comment with a line per check, kept up to date, and the change approval with its next steps, also when a new commit makes an earlier approval obsolete.

Approve, Reject and Withdraw in Merge PilotYouTube ↗

A change approval does not have to be decided in Jira: approvers can vote inside Merge Pilot. This tutorial follows an approver on one merge request: the Approval card with its two decisions, why the author gets no buttons, a rejection with its reason, withdrawing that rejection, and the approval that clears the change. Jira follows every step with a status change and a comment per vote, and in GitLab Merge Pilot’s bot approves the merge request.

Require a Work Item on Every ChangeYouTube ↗

Every change should trace back to a piece of work. This tutorial shows the Work items check of a change policy: where it is enforced, where Merge Pilot looks for the tracker key, and what happens to a merge request without one. A developer opens a merge request with no work item: GitLab shows why it cannot merge. The developer adds the Jira key to the title, the check passes, and Merge Pilot opens the change approval in Jira, linked to the work item.

New Commits After an ApprovalYouTube ↗

An approval covers the code that was approved. This tutorial shows what happens when a developer pushes another commit to an approved merge request: in GitLab the approval is withdrawn and Merge Pilot explains why, a new change approval is opened for the new code, the earlier one is kept as history and linked in Jira. Then the setting behind it: the change policy’s Lifecycle options for new commits — open a new change approval, reopen the same one, keep the approval while the change is the same, or keep it.

When a Merge Request Looks Stuck — ResyncYouTube ↗

Merge Pilot follows GitLab and Jira through their webhooks; if one never arrives, a merge request can look stuck. This tutorial switches the Jira webhook off on purpose, approves a change approval in Jira, and shows the merge request still waiting in Merge Pilot — until Resync reads the change approval again and the merge request moves on. A periodic re-check also recovers lost events by itself.

Change policies

Which merge requests a policy covers, what kind of change it is, which checks hold the merge, and how policies are versioned and reviewed.

Scope a Policy by Branch, Files and LabelsYouTube ↗

Not every change needs the same treatment. This tutorial adds a change policy and gives it a scope: merge requests into main that touch the Kubernetes manifests or the Dockerfile. Conditions can also look at the source branch, the repository, the author, labels, the files changed, the size and the draft state, and a merge request must meet all of them. Policies are evaluated top to bottom, so a deployment change is caught by the new policy while a code change still falls through to the catch-all — in Merge Pilot and in the comment on the GitLab merge request.

Standard Changes — Pre-Approved, Still RecordedYouTube ↗

Some changes are safe enough to be approved in advance: documentation, for example. This tutorial looks at a Standard change policy and turns on "Open a change approval as a record". A developer then opens a merge request that only adds a document: nobody is asked, Merge Pilot’s bot approves it in GitLab at once, the developer merges, and Jira still holds a change approval for it — opened as a record and moved to Done by the merge.

Emergency Changes — Merge Now, Review AfterYouTube ↗

When production is down, the fix cannot wait for an approval — but it should not escape review either. This tutorial follows an emergency change: a developer labels a hotfix merge request "emergency", Merge Pilot lets it merge as soon as its checks pass, and opens a change approval that must be reviewed within 72 hours. After the merge the record stays open in Jira until an approver reviews it there; then Merge Pilot closes it. Fix first, review after, all on record.

Refuse Changes by PolicyYouTube ↗

Some changes should not merge at all, however many people approve them. This tutorial adds a Refuse policy for environment files: any merge request that touches a .env file is stopped. The policy’s description is the message the author gets. A developer then tries it: GitLab shows Merge Pilot’s refusal in the policy’s own words and keeps the merge blocked, and Merge Pilot opens no change approval — nobody is asked to approve something that cannot merge.

Checks — Off, Report or EnforceYouTube ↗

Each check of a change policy — work items, code review, CI, secret scan, dependencies, licenses — can be off, reported or enforced. This tutorial shows the difference with a merge request whose pipeline fails: with CI enforced it cannot merge; switched to Report, the failed pipeline is still shown on the merge request and in GitLab, but it no longer holds the merge. Report is the safe way to introduce a check: watch what it would stop, then enforce it.

Which Policy Applies?YouTube ↗

With several policies, which one takes a given merge request, and why? This tutorial uses two tools that answer it without touching anything. "Which policy applies?" takes a description of a merge request — its branches, labels, changed files — and lists every policy in order with the reason it matches or not. The policy editor’s Test run tries your unsaved edits on a real merge request and shows the checks it would have to pass, before you save.

Policy Order, Versions and HistoryYouTube ↗

Change policies change, and every change to one must be traceable. This tutorial edits a policy and saves it: Merge Pilot keeps the earlier version, judges the open merge requests again and shows which version decided each of them. The history lists every version with who changed it. Then the order: policies are tried top to bottom and the first match decides, so a policy that refuses something has to stand above the ones that would let it through — checked with "Which policy applies?" before and after moving it.

Let Dependency Bots Through SafelyYouTube ↗

Dependency updates arrive every day. Asking a person to approve each one wears the process out; letting them through unchecked is worse. This tutorial adds the "Dependency update bots" template: merge requests opened by the bot become standard changes — no work item, no change approval — but the pipeline must pass, no secret may be added and no vulnerable dependency may come in. The same update opened by a person still takes the normal path.

Four-Eyes Review of Control ChangesYouTube ↗

Policies guard the changes, but who guards the policies? With "Review control changes" on, a change to the controls themselves — a policy, an approver pool, risk settings, how people sign in — waits until a second person approves it. This tutorial turns it on, has an administrator loosen a check, and shows that nothing happens until a policy manager approves the change. Both names end up in the audit log.

Change FreezesYouTube ↗

Before a quarter-end close or a big launch, changes should wait. This tutorial adds a change freeze on the company’s change calendar: during it every merge is held, even an approved one, in Merge Pilot and in GitLab. The policy lets an approver release one held change with a reason that goes to the audit log, and that change may merge.

Risk Assessment and Risk HoldsYouTube ↗

Not every change carries the same risk. This tutorial turns on risk assessment for a company: every merge request gets a risk score from its timing, the service it touches, the kind of files it changes and its size. Changes at or above the chosen level are held. A database migration is held for risk; an administrator accepts the risk with a reason that goes to the audit log, and the change continues to its change approval.

Require a Code Review in GitLabYouTube ↗

A change approval says the change may go out; a code review says a colleague read the code. This tutorial asks for one approving review on the latest commit, from someone with at least Developer on the repository: a merge request waits until a maintainer approves it in GitLab, and Merge Pilot reads the approval at once.

Approvers

Who may approve a change, how many approvals it needs, who it is assigned to, and separation of duties.

Approver RolesYouTube ↗

Who may approve a change? Merge Pilot takes the answer from the roles people already have in the repository. This tutorial sets the approver roles of a GitLab connection to Maintainer and Owner, compares them with the members page in GitLab, and gives one critical project its own, stricter roles. A new merge request is then assigned to the only Owner, and a Maintainer who opens it is offered no vote. The author of a change never counts.

Approver PoolsYouTube ↗

Repository roles say who may approve in general. For some changes you want particular people: a change advisory board, the release managers, the database team. This tutorial adds an approver pool, names it in a change policy, and follows a deployment change: its change approval is assigned to a member of the pool in Jira, that member approves it there, and Merge Pilot clears the change. Approvals from anyone outside the pool do not count for that policy.

Code Owners as ApproversYouTube ↗

The people who own a file are the ones who should sign off a change to it. This tutorial shows a repository’s CODEOWNERS file in GitLab, sets a change policy to ask its approval from the code owners of the changed files, and follows a change to an owned file: its change approval is assigned to the owner in Jira, the owner approves it there, and Merge Pilot clears the change.

Separation of DutiesYouTube ↗

The person who wrote a change should not be the one who approves it. This tutorial shows the separation of duties in a change policy: the author never votes, people who committed to the change may not approve it, and an approver who merges the change is flagged. An approver pushes a commit to a colleague’s merge request and loses the vote; the change approval goes to someone else, who approves it in Jira and then merges it in GitLab — and Merge Pilot flags the merge request and writes it to the audit log.

More Approvals for Riskier ChangesYouTube ↗

Some changes deserve more than one pair of eyes. This tutorial adds a second approval requirement to the policy for deployment changes: one approval from the release managers and one from the project’s approvers. A deployment change then waits for two different people: the first approves in Jira, Merge Pilot records it and hands the change approval back for the next approver, the second approves, and the change is cleared.

Who Gets the Change ApprovalYouTube ↗

Every change approval is assigned to someone who may decide it. This tutorial shows the choices a change policy offers — a random approver, approvers in turn, the least busy approver, or nobody — sets the approvers in turn, and follows two changes that go to two different people. Then an approver takes over a change approval assigned to a colleague, and Jira shows the new assignee.

Stand-Ins for Approvers Who Are AwayYouTube ↗

When the only person who may approve a kind of change is on leave, changes should not pile up. This tutorial has the release manager name a colleague as stand-in in My profile; a deployment change that would wait for the release manager goes to the stand-in, who approves it in Jira, and Merge Pilot counts the approval in the release manager’s place.

Jira and the built-in tracker

Change approvals as Jira issues or in Merge Pilot’s own tracker, shaped to your workflow.

Shape the Jira Change ApprovalYouTube ↗

The change approvals Merge Pilot opens in Jira should read the way your change process expects. This tutorial edits the Jira connection’s templates: a summary built from variables such as the change type, the repository and the merge request, and a field — Jira labels — filled from the same variables. Merge Pilot checks the settings against Jira’s create screen, and the next change approval is opened in Jira exactly that way.

Jira Statuses and Your WorkflowYouTube ↗

Your Jira workflow has its own statuses. This tutorial shows how the Jira connection maps them: which statuses approve or reject a change approval, and where Merge Pilot moves it itself — back for another approval, to Done when the change merges, to Cancelled when it is closed. A change approval then goes through an intermediate review status that decides nothing, is approved, and moves to Done when the change merges.

Only Eligible People Decide in JiraYouTube ↗

In Jira, anyone with access can move an issue to Approved — including the person who wrote the change. Merge Pilot counts a decision only from someone who may decide the change approval. This tutorial has the author approve their own change approval in Jira: Merge Pilot moves it back, says why in Jira and on the merge request, and keeps the merge blocked until an eligible approver decides.

Change Approvals Without JiraYouTube ↗

Not every team runs Jira. This tutorial sets up Merge Pilot’s built-in tracker: a tracker connection with a project for change approvals, linked to a GitLab connection. A merge request then gets its change approval in the built-in tracker; the approver ticks the required reviews, moves it to Approved, and the merge request may merge.

A Required Field Before ApprovalYouTube ↗

The built-in tracker’s workflow is yours to shape. This tutorial adds a custom field to the tracker project — a rollback plan — and makes it required before a change approval may enter Approved. The next approver is asked for the plan, together with the required reviews, before the change is approved and may merge.

Shape the Tracker Workflow — States and MovesYouTube ↗

The built-in tracker’s workflow is yours: its states, and which moves people may make between them. This tutorial adds a “Security review” state and allows approval only from it. The next change approval cannot be approved straight away: it goes through security review first, then is approved, and the change may merge.

Security checks

Secrets, vulnerable or deprecated dependencies, licenses, sources, images, infrastructure, CI configuration and signed commits — checked before the merge.

Catch a Leaked Secret Before It MergesYouTube ↗

A key committed by mistake should never reach the main branch. This tutorial follows a change that puts cloud credentials into the code: Merge Pilot’s secret scan finds them, blocks the merge request and tells the developer in GitLab which file and line — without repeating the value. The developer moves the credentials to environment variables, the scan runs again on the new commit, and the block is gone.

Block Vulnerable DependenciesYouTube ↗

A new dependency can bring known vulnerabilities with it. This tutorial sets the change policy’s dependency scan to enforce from high severity, then follows a merge request that adds a vulnerable library version: Merge Pilot looks the version up, blocks the merge request and lists the vulnerabilities with the version that fixes them, in Merge Pilot and on the merge request in GitLab. After the upgrade the scan is clean.

Keep Unwanted Licenses OutYouTube ↗

A dependency’s license can oblige you to share your own code. This tutorial turns the change policy’s license check from report to enforce: the company denies strong copyleft licenses such as GPL and AGPL. A merge request that adds an AGPL-licensed package is held, in Merge Pilot and on the merge request in GitLab, until the developer switches to an MIT-licensed package.

Keep Deprecated Packages OutYouTube ↗

Not every risky package has a known vulnerability: some are deprecated by their own authors, some were published only days ago — when a hijacked release is usually still unnoticed. This tutorial sets the package health check to enforce, then follows a merge request that brings in a deprecated package: Merge Pilot holds it and shows the registry’s reason, until the package is replaced.

Stop Dependency Confusion with Allowed RegistriesYouTube ↗

A vulnerability scan looks at which package version is used; the dependency sources check looks at where it comes from. This tutorial enforces it, then follows a merge request whose lockfile fetches a package from an unknown host — the classic dependency confusion attack: Merge Pilot holds it and names the package and the host, until the lockfile points at the public registry again.

Container Images and Infrastructure ChecksYouTube ↗

A Dockerfile’s base image ships its operating system packages, and a Kubernetes manifest decides how much a container may do. This tutorial enforces two checks for deployment changes: the container image scan, which pulls new images and looks their packages up for known vulnerabilities, and the infrastructure check, which finds misconfigurations such as a privileged container. A change that moves to an outdated base image and runs privileged is held until both are fixed.

Check Changes to the CI ConfigurationYouTube ↗

CI jobs run with the project’s secrets and deploy access, so a change to the CI configuration deserves a check of its own. This tutorial turns on the CI configuration check in a change policy, then follows a merge request that switches on debug logging — which would print every variable of the job: Merge Pilot holds it, names the file, line and rule, and lets it through once the line is removed.

Require Signed CommitsYouTube ↗

A commit’s author name can be anything; a signature proves who made it. This tutorial enforces signed commits in a change policy: a merge request with an unsigned commit is held, and GitLab shows no verified badge. The developer pushes the same change signed with their SSH signing key, GitLab verifies it, and Merge Pilot lets it through.

Vulnerability Inventory and SBOMYouTube ↗

Merge-time checks stop new problems; the code already merged needs watching too. This tutorial runs a project analysis on a repository’s main branch: its dependencies, their known vulnerabilities and licenses. It exports a software bill of materials in CycloneDX format and opens the company-wide vulnerability list that follows every project.

Accept a Finding with a ReasonYouTube ↗

Not every finding is real: a key in a test fixture, a vulnerability in code that is never called. Instead of turning a check off, Merge Pilot lets a policy manager accept one finding — with a reason, for a limited time, recorded in the audit log. This tutorial accepts a test-fixture secret on a merge request, which then goes ahead, and marks a vulnerability as not affected in the vulnerability inventory.

Users, operations and automation

Roles, self-service GitLab operations, direct changes, notifications, the REST API and the people who run it.

Users and RolesYouTube ↗

Who may do what? This tutorial shows the Users page and the five roles: platform admin, company admin, policy manager, auditor and user. An administrator adds a local account for an auditor with a temporary password; the auditor signs in, replaces the password, and gets a read-only Merge Pilot: every merge request, policy and audit entry, but no vote, no resync and no settings. The same merge request page, seen as an administrator, shows the difference.

Catch Direct ChangesYouTube ↗

Not every change comes through a merge request: someone with the rights can push straight to the main branch, force-push or delete a branch. This tutorial pushes a commit directly to the main branch of a watched repository and finds it in Merge Pilot’s Direct changes: who pushed it, which commit, and that change management would have blocked it.

Self-Service GitLab Operations with GuardrailsYouTube ↗

Developers often need a CI/CD variable or a branch protection changed, and wait for a maintainer to do it. Merge Pilot can do such operations with its own account, under rules the company sets. This tutorial lets developers manage their repository’s CI/CD variables: a developer adds a variable from the project page, Merge Pilot creates it in GitLab, and the audit log records who asked and which rule allowed it.

Protect a Branch and Create a Deploy Token, Self-ServiceYouTube ↗

Protecting a release branch or creating a deploy token takes a maintainer in GitLab. With Merge Pilot, the company decides who may ask for it: here, any developer of the repository. A developer protects a release branch and creates a read-only deploy token for the staging server — Merge Pilot does both with its own GitLab account, shows the token once, and records who asked.

Notifications for the Right PeopleYouTube ↗

Every change approval, held merge and security finding can be announced — to the people who care about it. This tutorial adds a notification route: new change approvals of the payments repository go by email to the release team. A merge request then opens a change approval, and the message arrives in the team’s mailbox. Routes can also go to Slack, Microsoft Teams or a signed webhook.

Send Events to Your Own Systems with Signed WebhooksYouTube ↗

Your SIEM, ticketing tool or chat bot can get Merge Pilot’s events as they happen. This tutorial adds a webhook route that sends “secrets found in a merge request” to a security endpoint: a merge request with a leaked key triggers it, the endpoint receives signed JSON and verifies the signature, and the route’s delivery log shows the delivery. Deliveries are stored and retried until the endpoint accepts them.

Automate with the API and Service TokensYouTube ↗

A release pipeline can ask Merge Pilot which merge requests may merge. This tutorial makes a service API token with the read-only Auditor role, calls the REST API with it to list the open merge requests and their gate, and revokes it: the same call is refused at once. The token is shown only once and every token starts with mpt_, so a leaked one is easy to find.

Insights, audit and compliance

DORA metrics, the change calendar, service health, the audit log and the compliance report.

DORA Metrics and AnalyticsYouTube ↗

Change management should not slow delivery down, and you can measure whether it does. This tutorial opens Merge Pilot’s DORA metrics — deploy frequency, lead time for changes, change failure rate and time to restore — company-wide and per project, then the analytics that show how long merge requests take each week, which stage holds them up, and how the review load is spread.

The Change Calendar View and Service HealthYouTube ↗

The change calendar view puts the company’s change windows and freezes next to what actually merged, day by day, with the high-risk merges and merge collisions. Service health shows whether Merge Pilot reaches GitLab and Jira, how fast, and how reliably over the last day.

Audit Log and Compliance ReportYouTube ↗

When an auditor asks who approved a change, who released it during a freeze or who accepted a risk, the answer is already recorded. This tutorial searches Merge Pilot’s audit log for those decisions — each with the person and the reason — opens what changed in a policy edit, and exports the compliance report for a period as a PDF.

See it on your own repositories

Ask for a demo on your own GitLab or GitHub repositories.