How to release stacked pull requests safely
A stack is a set of related pull requests that split one large change into smaller ones, so each can be reviewed on its own and then merged together. GitHub made stacked pull requests generally available on 6 October 2026, on all github.com plans. This guide covers what that changes when you release, and a safe way to do it.
What GitHub says about merging a stack
- Only the asynchronous merge API can merge a stacked pull request. GitHub's documentation says the older synchronous merge endpoint does not support stacked pull requests or merge queues.
- Merging a pull request in a stack through that API includes all of the open pull requests below it.
- With a merge queue, a stack lands as one merge group. With the merge-commit method, GitHub still creates one merge commit per pull request.
- Someone who is allowed to bypass repository rules can merge the lowest unmerged pull request in a stack.
- The Rebase stack action keeps approvals on code that did not change, even in repositories that normally dismiss approvals when new commits arrive. The replacement commits are signed, and the original authorship is kept.
- If the stack's base branch is deleted, GitHub moves the stack to a new base instead of closing the bottom pull request.
Why releasing a stack needs care
- Merging one pull request can merge several. Check what sits below it before you press merge or schedule it.
- Commit IDs change when a stack is rebased. Anything that was pinned to an old commit, such as an approval you were relying on or a scheduled merge, no longer matches.
- A stack that stops halfway leaves production on a mix of changes. Every pull request in it should be safe to deploy on its own.
- Reverting the top pull request does not undo the ones below it.
A safe order
- Review each pull request by itself, then decide as a team which ones must go live together.
- Make every pull request backward compatible: add before you remove, and put risky behaviour behind a flag, so stopping between two of them is harmless.
- Merge from the bottom. If your repository uses a merge queue, let the whole stack land through it.
- Wait for each deploy to go green before the next pull request reaches production, or accept that they ship together and plan for that.
- After a rebase or any push, check the commit again before you ship.
- Decide the rollback before you start: revert in reverse order, top first, and test that each revert deploys cleanly.
Doing it outside working hours
Everything above applies at night too, with one extra rule: pin the exact commit you approved. If someone rebases the stack or pushes after you schedule, the merge should be skipped, not shipped.
How Merge Scheduler handles stacks
Merge Scheduler merges with GitHub's asynchronous merge API, the one GitHub recommends. It does not treat a stack as one release: you schedule a pull request by its own head commit, and if that commit changes after you schedule, the merge is skipped and you schedule again.
In practice, schedule the lowest pull request in the stack. New repositories start with only their default branch allowed, so a pull request that targets another feature branch is not scheduled by accident. For several pull requests that must go in a set order, ordered releases (Pro) can wait for each deploy to go green before the next one merges, and the revert switch can roll back the earlier ones if a later one fails.
Do this in Merge Scheduler: Release a backend and a frontend in order
Related: Why a scheduled merge should pin the commit you approved · How to release a backend before the frontend (and roll both back)