skip to content

In GitLab, what does marking a merge request as a draft do, and how do you mark it and later make it ready?

level: juniorimportance: should knowfreq 38%

answer

  1. blocks the merge, not the review
  2. three title spellings, at the start
  3. a quick action each way
  4. commit-message route is one-way

basics

~20 s

A GitLab draft merge request cannot merge until its Draft flag is removed, even when every other check passes. Set it with a Draft: title prefix, Mark as draft or /draft; clear it with Mark as ready or /ready.

solid answer

~40 s

In GitLab, **Draft** is a merge-blocking flag on a merge request: people can still read, comment on and review it, and it runs the same pipelines as a ready merge request, but it cannot merge until the flag is cleared, however many other checks pass. You set it by starting the title with `Draft:`, `[Draft]` or `(Draft)`, with **Mark as draft**, or with the `/draft` quick action. A commit whose message starts with `draft:`, `Draft:`, `fixup!` or `Fixup!` also marks it, but only one way: a later commit like that never marks it ready. You clear it by removing the prefix, with **Mark as ready**, or with `/ready`, and GitLab notifies the participants and watchers. Teams use it to open a merge request early for feedback without any risk of an accidental merge.

go deeper

for a junior

Recall the one hard effect, a blocked merge, and the everyday ways to set and clear it: the Draft: title prefix, Mark as draft and Mark as ready, and the /draft and /ready quick actions.

for a middle

Explain what a draft leaves untouched (review, pipelines, visibility) and the one-way commit-message route with draft: and fixup!, which surprises people when a merge request silently becomes a draft.

for a senior

Show you treat the draft flag as an author's signal, not a control: protection and approval rules decide what may merge, while drafts keep early merge requests safe to open and discuss.

for a principal

Frame drafts as a workflow convention: encouraging early merge requests improves visibility and review latency, and the merge block makes that safe without extra branch rules.

## What a draft merge request is A **merge request** in GitLab is the proposal to merge a source branch into a target branch, together with its diff, its review threads, its approvals and its pipeline results. A **draft** merge request is one carrying the **Draft** flag. The flag has one hard effect: the merge request **cannot be merged** until the flag is removed, even if it has every approval it needs, its pipeline passed and nothing else stands in the way. Everything else keeps working. The merge request is visible in the project's list, reviewers can open the diff and leave comments, and the pipelines that run for it are the same ones that run for a merge request marked ready. That combination is the point: you can open the merge request on day one, show the direction of the work and collect feedback, and nobody can merge half-finished code by clicking the wrong button. ## Ways to mark a merge request as a draft | Route | What you do | Toggles back? | |---|---|---| | Title prefix | Start the title with `Draft:`, `[Draft]` or `(Draft)` | Yes: remove the prefix | | Checkbox | **Mark as draft** below the title when creating or editing | Yes: clear it | | Merge request actions | **Mark as draft** from the merge request's actions menu | Yes: **Mark as ready** | | Quick action | Comment `/draft` | Yes: comment `/ready` | | Commit message | Start a commit message on the source branch with `draft:`, `Draft:`, `fixup!` or `Fixup!` | **No** | Two details trip people up: - The prefix must be at the **beginning** of the title. `Add rate limiting (Draft)` is an ordinary title, not a draft. - The commit-message route is **not a toggle**. A `fixup!` commit can turn a ready merge request into a draft, but pushing another such commit does not turn it back. Someone has to mark it ready explicitly. ## Making it ready To remove the flag, delete the prefix from the title, clear the checkbox, select **Mark as ready**, or comment `/ready`. Users with the Developer, Maintainer or Owner role also get a **Mark as ready** button at the bottom of the description. When the merge request becomes ready, GitLab notifies its participants and watchers, so marking it ready doubles as the signal that review can start in earnest. ## What a draft does and does not change - **It blocks the merge.** No role overrides it; a Maintainer sees the merge blocked just like a Developer does. - **It is one of the merge checks.** If someone has set the merge request to auto-merge, *not being a draft* is among the conditions GitLab waits for. - **It does not stop pipelines.** Drafts run the same pipelines as ready merge requests. Skipping pipelines for drafts is a choice made in the project's pipeline configuration, which is CI/CD material rather than a merge request setting. - **It does not hide the merge request.** Drafts appear in lists; the merge request list can be filtered to include or exclude them. - **It does not replace approvals or protection.** A draft is a signal from the author. What decides who may merge into a protected branch, and how many approvals are needed, is the branch protection and the approval rules. ## How teams use drafts 1. Open the merge request as soon as the branch exists, with a `Draft:` prefix, so the work is discoverable and linked to its issue. 2. Ask for early feedback on direction while the code is still changing. 3. When the author considers it complete, mark it ready; reviewers are notified and the formal review starts. 4. If a late `fixup!` commit flips it back to a draft, mark it ready again once the fix is in. In an interview, the answer that lands is short: a draft is the author saying "not yet", enforced by GitLab as a merge block, and set or cleared through the title, a button or a quick action.

  • A commit whose message starts with fixup! turned your GitLab merge request into a draft. Will the next fixup! commit make it ready again?
    No. The commit-message route only marks a merge request as a draft; it is not a toggle, so further `fixup!` or `draft:` commits leave it a draft. You make it ready explicitly: remove the title prefix, select **Mark as ready**, or comment `/ready`.
  • Does a GitLab draft merge request skip its CI/CD pipelines?
    No. Draft merge requests run the same pipelines as ready ones. If a team wants to save compute on drafts, it has to exclude them in the project's pipeline configuration; the draft flag itself only blocks merging.

  • A draft merge request in GitLab runs no pipelines until it is marked ready
  • A Maintainer can merge a draft because their role overrides the flag
  • Putting (Draft) at the end of the title marks the merge request as a draft
  • Pushing a second draft: commit toggles the merge request back to ready
  • Drafts are hidden from reviewers until the author marks them ready