# Mergify

> Mergify keeps engineering teams shipping reliably by making CI faster and dependable: merge queue, CI and test insights with auto-retry and flaky-test quarantine, merge protections, and stacked pull requests. Works with GitHub and any CI provider.

## Overview

- [Make your CI faster. Keep it reliable.](https://mergify.com/)
- [Pricing](https://mergify.com/pricing): Every product. One plan. Zero compromises.
- [Integrations](https://mergify.com/integrations): Mergify works with your existing CI, monitoring, and developer tools.
- [Mergify ROI Calculator](https://mergify.com/calculator): Calculate what broken main and flaky tests cost your engineering team, and see what Mergify saves you.
- [Startup Program](https://mergify.com/startups): Go from Startup to Scaleup. Get our plan for free for a maximum of 12 months and 50 seats for your developers.
- [About](https://mergify.com/about): Meet the team behind Mergify. We're on a mission to make CI a joy, not a chore.
- [Discovery Call](https://mergify.com/discovery): Book a demo with our team to see how Mergify can help your engineering team.

## Products

- [Merge Queue](https://mergify.com/product/merge-queue): Keep main green. Always.
- [CI Insights](https://mergify.com/product/ci-insights): CI observability and auto-retry
- [Test Insights](https://mergify.com/product/test-insights): Detect, quarantine, and fix flaky tests
- [Merge Protections](https://mergify.com/product/merge-protections): Governance and scheduling
- [Stacks](https://mergify.com/product/stacks): Split big PRs into reviewable chains

## Compare

- [Compare Mergify](https://mergify.com/compare-mergify): See how Mergify compares to GitHub's merge queue, Aviator, and Trunk. Honest, detailed comparisons.
- [Mergify vs GitHub Merge Queue](https://mergify.com/compare/github-merge-queue): Compare Mergify and GitHub's built-in merge queue. See which features matter as your team scales.
- [Mergify vs Aviator](https://mergify.com/compare/aviator): Compare Mergify and Aviator for merge queue automation. See where the differences matter.
- [Mergify vs Trunk](https://mergify.com/compare/trunk): Compare Mergify and Trunk for merge queue automation. See where the differences matter.
- [Mergify vs Datadog CI Visibility](https://mergify.com/compare/datadog-ci-visibility): Compare Mergify CI Insights and Datadog CI Visibility. Mergify goes beyond dashboards with automated test quarantine, auto-retry, and native merge queue integration.

## Migration Guides

- [Outgrowing Bors? Migrate to Mergify](https://mergify.com/migrate/bors): Bors is deprecated. Mergify is the natural upgrade with advanced merge queues and CI-aware workflows.
- [Outgrowing Bulldozer? Migrate to Mergify](https://mergify.com/migrate/bulldozer): Bulldozer slows you down at scale. Try Mergify for advanced merging and smart CI workflows.

## Customer Stories

- [AheadComputing](https://mergify.com/customers/aheadcomputing.md): Optimizing Hardware CI Efficiency and Visibility with Mergify
- [Apex Fintech Solutions](https://mergify.com/customers/apex.md): Scaling Monorepo CI and Improving Delivery Reliability with Mergify
- [Back Market](https://mergify.com/customers/back-market.md): Optimizing the release process & improving the engineers' lives
- [Berkshire Grey](https://mergify.com/customers/berkshiregrey.md): Streamlining CI Efficiency and Merge Stability with Mergify
- [Botify](https://mergify.com/customers/botify.md): Scaling Developer Productivity and Release Confidence with Mergify
- [Cerebras](https://mergify.com/customers/cerebras.md): Scaling AI Hardware CI Throughput With Batch Merge & Two-Step CI
- [Contra](https://mergify.com/customers/contra.md): Improving developer velocity & efficiency through automation
- [DeepDrive](https://mergify.com/customers/deepdrive.md): Helping DeepDrive meet automotive software quality standards
- [Fundrise](https://mergify.com/customers/fundrise.md): Resolving CI pain points to sustain a high development velocity
- [Jane](https://mergify.com/customers/jane.md): From Spreadsheet Deploys to Parallel CI: How Jane Scaled Delivery with Mergify
- [Luminar](https://mergify.com/customers/luminar.md): Helping Luminar's developers save time and gain efficiency
- [Orca Security](https://mergify.com/customers/orca-security.md): Securing the main branch
- [PayFit](https://mergify.com/customers/payfit.md): Boosting Developer Velocity and CI Reliability with Mergify
- [Productboard](https://mergify.com/customers/productboard.md): Scaling and solving problems with continuous development
- [Prophesee](https://mergify.com/customers/prophesee.md): Optimizing the development process while lightening the developers' mental load
- [Zama](https://mergify.com/customers/zama.md): Stabilizing Main in a Blockchain Monorepo with Mergify

## Blog

- [Switching from npm to pnpm found 3 phantom dependencies in our React app](https://mergify.com/blog/npm-to-pnpm-phantom-dependencies.md): A pnpm migration meant to speed up installs ended up exposing three phantom dependencies our React app had been shipping without declaring.
- [A Markdown File Became Our Company-Wide On-Call Cheat Code](https://mergify.com/blog/markdown-file-oncall-cheat-code.md): How a staff engineer turned scattered tribal knowledge into a git repo with Claude Code that lets any team member run a six-system support investigation in two minutes.
- [Python 3.14 in Production: What PEP 649 Actually Breaks](https://mergify.com/blog/python-314-what-pep-649-actually-breaks.md): PEP 649 defers annotation evaluation. That's great until FastAPI tries to resolve your TYPE_CHECKING imports at runtime and every endpoint throws NameError.
- [How We Formally Verified Our Merge Queue with TLA+ (and Found Bugs That Tests Missed)](https://mergify.com/blog/how-we-formally-verified-our-merge-queue-with-tla-plus.md): We wrote a TLA+ specification for our merge queue state machine. TLC explored 468,000 states and found two bugs that our test suite and years of production traffic had missed.
- [Diving into pytest Finalizers](https://mergify.com/blog/diving-into-pytest-finalizers.md): While building pytest-mergify, we hit a wall with fixture teardown during test reruns. The fix was two helper functions and a trick borrowed from pytest-rerunfailures.
- [Your Monorepo's Merge Queue Has a Concurrency Problem](https://mergify.com/blog/monorepo-merge-queue-concurrency-problem.md): How scoped parallel queues turn a serial bottleneck into a DAG, so your frontend team stops waiting for backend CI to finish.
- [How a Dashboard Arms Race Put Me on the App Store](https://mergify.com/blog/dashboard-arms-race-app-store.md): It started with a shell script on Slack. Four days and 31 commits later, I had a native macOS app built entirely with Claude Code in a language I'd never touched.
- [The Day My AI Agent Deleted 29 Git Worktrees](https://mergify.com/blog/the-day-my-ai-agent-deleted-29-git-worktrees.md): What happens when you rubber-stamp an AI agent's suggestion to 'clean up' your git worktrees, and the agent uses --force on all of them.
- [When GitHub Webhooks Lie: How an Empty Array Broke Our Merge Queue](https://mergify.com/blog/when-github-webhooks-lie-how-an-empty-array-broke-our-merge-queue.md): GitHub webhooks can deliver structurally valid payloads with stale data. We traced a customer incident to out-of-order delivery and built action-aware upserts to protect against it.
- [The Comfortable Room](https://mergify.com/blog/the-comfortable-room.md): Software engineering was a walled garden. AI just copied the key. The data is messy: 19% slower in trials, 30% more warnings, 322% more vulnerabilities. But the baseline wasn't pristine either. What's left isn't coding: it's judgment, taste, and knowing which room to build.
- [How We Turned Claude Into a Cross-System Support Investigator](https://mergify.com/blog/how-we-turned-claude-into-a-cross-system-support-investigator.md): Support triage at Mergify meant juggling Datadog, Sentry, PostgreSQL, Linear, and source code. We built a repo with MCP servers and Claude Code that investigates tickets in   parallel — cutting triage from 15 minutes to under 5, with 75% first-pass accuracy.
- [Spinners Are the UX Equivalent of “TODO: Fix Later”](https://mergify.com/blog/spinners-are-the-ux-equivalent-of-todo-fix-later.md): We replaced a spinner with a chart-shaped skeleton and realized loading states are part of the layout contract. Bad skeletons cause layout shift. Good ones match the final UI exactly. Here's what we learned fixing ours — and why CLS is a UX problem, not just an SEO metric.
- [Claude Didn’t Kill Craftsmanship](https://mergify.com/blog/claude-didnt-kill-craftsmanship.md): AI doesn't remove craftsmanship: it moves it. The goal was never to protect the purity of the saw. It's to build good furniture. Engineers can now focus on intent, judgment, and product quality instead of translating tickets into code.
- [On LATERAL Joins](https://mergify.com/blog/on-lateral-joins.md): Our new API endpoint worked in dev but timed out in production. A naive SQL subquery was scanning 660K rows to return 50. Switching to LATERAL JOIN cut response time by 1000x. Here's how join order can make or break your PostgreSQL queries.
- [Detecting Blocking Tasks in Asyncio by Measuring Event Loop Latency](https://mergify.com/blog/detecting-blocking-tasks-in-asyncio-by-measuring-event-loop-latency.md): Asyncio only works if every coroutine cooperates. One blocking call can freeze your entire app. This post shows a simple watchdog coroutine that measures event loop latency, detects blocking tasks early, and turns invisible stalls into actionable metrics.
- [GitHub Merge Queue Was Step One. Real CI Orchestration Comes Next.](https://mergify.com/blog/github-merge-queue-was-step-one-real-ci-orchestration-comes-next.md): GitHub’s merge queue solved safety, not scale. As CI grows slower, costlier, and shared across teams, merging becomes a scheduling problem. Learn why large monorepos and Bazel users outgrow native queues and what real CI orchestration looks like.
- [Stop Lying to Your Dependency Resolver: The Real Rules for Python Dependency Management](https://mergify.com/blog/stop-lying-to-your-dependency-resolver-the-real-rules-for-python-dependency-management.md): Your Python app didn’t change: your dependencies did. This post explains why apps must pin dependencies, libraries must declare ranges, dev tools must be locked, and how to use lockfiles correctly with Poetry, PDM, and uv to avoid CI and production surprises.
- [Lessons From a Noisy Monitor](https://mergify.com/blog/lessons-from-a-noisy-monitor.md): Your database monitors keep firing even though nothing is wrong? We hit the same problem: noisy IOPS alerts caused by predictable jobs. This post explains how we replaced brittle thresholds with an SLO-based approach that restored signal, eliminated noise, and stopped the monitor from "crying wolf."
- [Monorepo CI for GitHub Actions: Run Exactly the Tests You Need, Nothing More](https://mergify.com/blog/monorepo-ci-for-github-actions-run-exactly-the-tests-you-need-nothing-more.md): Run only the tests that matter in your monorepo. Mergify Monorepo CI detects which parts of your repo each pull request touches and triggers the right GitHub Actions jobs, then aggregates them into a single CI gate for branch protection or Merge Queue.
- [await Is Not a Context Switch: Understanding Python's Coroutines vs Tasks](https://mergify.com/blog/await-is-not-a-context-switch-understanding-pythons-coroutines-vs-tasks.md): Python’s async model is misunderstood, especially by engineers coming from JS or C#. In Python, awaiting a coroutine doesn’t yield to the event loop. Only tasks create concurrency. This post explains why that distinction matters and how it affects locking, design, and correctness.
- [Updating Materialized Views (Without Worrying Too Much)](https://mergify.com/blog/updating-materialized-views-without-worrying-too-much.md): Materialized views are powerful but painful to change. Here’s how we safely version, refresh, and migrate them without locking production or timing out deployments, plus the approach we use to avoid dangerous DROP/CREATE migrations.
- [Goodbye Checklists, Hello AI Linters](https://mergify.com/blog/goodbye-checklists-hello-ai-linters.md): We turned our pull request rules into small AI-powered linters using GitHub’s new actions/ai-inference. Each linter enforces one rule: catching risky changes before humans do, without regexes, static analysis, or friction.
- [Origin and Evolution of the Globstar](https://mergify.com/blog/origin-and-evolution-of-the-globstar.md): Discover how the double-asterisk recursive glob pattern evolved: from Zsh’s early 1990s innovation to Bash’s globstar and beyond, spreading into Python, Ruby, Git, and modern build tools.
- [Shadow Shipping: How We Double-Executed Code to Ship Safely](https://mergify.com/blog/shadow-shipping-how-we-double-executed-code-to-ship-safely.md): How do you ship risky code without crossing your fingers? In this post, we explain how he ran old and new logic in parallel (“shadow shipping”) to validate behavior in production before rollout. Learn how this simple pattern turned feature-flag anxiety into data-driven confidence.
- [Why PostgreSQL Ignored Our Index (and What the Planner Was Thinking)](https://mergify.com/blog/why-postgresql-ignored-our-index-and-what-the-planner-was-thinking.md): PostgreSQL doesn’t "ignore" your indexes, it just does the math differently. We dive into how the planner weighs cost, why it sometimes chooses sequential scans, and how we tuned our queries to make peace with it.
- [The Magic (and Mayhem) Behind Our Config Deprecation Transformers](https://mergify.com/blog/the-magic-and-mayhem-behind-our-config-deprecation-transformers.md): We built a "self-healing" system that fixes deprecated configs by opening PRs automatically. It worked like magic, until it didn't. Here's what we learned about the thin line between elegant automation and uncontrollable complexity.
- [TypeScript's import type: The Flag That Makes Builds Honest](https://mergify.com/blog/typescripts-import-type-the-flag-that-makes-builds-honest.md): TypeScript doesn’t run your code, but your bundler might think it does. Learn why marking your type imports with import type (and enabling `verbatimModuleSyntax`) makes your builds faster, cleaner, and more predictable.
- [Should We Still Write Docs If AI Can Read the Code?](https://mergify.com/blog/should-we-still-write-docs-if-ai-can-read-the-code.md): AI can explain what code does — but not why it does it. This post explores how documentation is evolving in the age of AI, and why writing down human intent is becoming one of the most practical forms of AI alignment.
- [Why WARNING Has No Place in Modern Logging](https://mergify.com/blog/why-warning-has-no-place-in-modern-logging.md): Most systems drown in meaningless WARNING logs. They waste money, obscure real errors, and help no one. Here’s why your next logging cleanup should start by deleting WARNING — and how structured logs make your production systems clearer, cheaper, and safer.
- [AI Won't Replace Code Reviews, But It Can Fix Them](https://mergify.com/blog/ai-wont-replace-code-reviews-but-it-can-fix-them.md): Code reviews often fail not because the code is wrong, but because no one knows why it was written that way. This post explores how AI-generated comments can add missing intent to pull requests—making both human and AI reviews smarter, faster, and more effective.
- [Friends Don't Let Friends Use :latest](https://mergify.com/blog/friends-dont-let-friends-use-latest.md): Floating versions like :latest, ^, and ~ promise convenience but deliver broken builds, hidden regressions, and supply chain risks. Here we explain why they undermine reproducibility and security and shows how to pin GitHub Actions, Docker images, and dependencies safely.
- [Application vs. Database: Where Should Permissions Live?](https://mergify.com/blog/application-vs-database-where-should-permissions-live.md): Permissions drift is real: scattered checks, forgotten filters, and data leaks. PostgreSQL’s Row Level Security (RLS) flips the script: pushing verification into the database for stronger safety, but with trade-offs in debugging and performance.
- [The Origin Story of Merge Queues](https://mergify.com/blog/the-origin-story-of-merge-queues.md): From Bors and Homu to Bulldozer, Kodiak, Mergify, and now GitHub and GitLab, merge queues have shaped how we keep main branches green. This article traces their history, why they emerged, and how they became a standard in modern software development.
- [What I Learned Building My First Jenkins Plugin](https://mergify.com/blog/what-i-learned-building-my-first-jenkins-plugin.md): Building a Jenkins plugin sounded simple — until it became a crash course in Java, Jenkins internals, and community code review. Here’s what I learned, why the process surprised me, and how it now powers Mergify CI Insights.
- [Pull Request Management: Streamline Your Workflow with Automation](https://mergify.com/blog/pull-request-management-streamline-your-workflow-with-automation.md): Pull requests are essential, but they don’t scale without automation. Learn PR basics, best practices, and how to automate reviews, tests, and merges with GitHub Actions or Mergify.
- [Trunk-Based Development vs Gitflow: Which Branching Model Actually Works?](https://mergify.com/blog/trunk-based-development-vs-gitflow-which-branching-model-actually-works.md): Trunk-based vs Gitflow: which branching model really works for modern CI/CD? We compare both, share trade-offs, and argue why trunk-based (with automation like merge queues) usually wins for teams that care about speed, reliability, and flow.
- [Feature Branch Workflow: A Practical Guide for Git](https://mergify.com/blog/feature-branch-workflow-a-practical-guide-for-git.md): A feature branch workflow is one of Git’s most popular strategies. Learn how it works, its pros and cons, and how modern automation (like merge queues) keeps feature branches fast, safe, and frustration-free.
- [Looking for a Bulldozer Alternative? Meet Mergify.](https://mergify.com/blog/looking-for-a-bulldozer-alternative-meet-mergify.md): Bulldozer is fine for simple PR automation, but it struggles as teams grow. In this post, we break down its pain points and show how Mergify’s merge queues, flexible rules, and templates make it the smarter choice for modern development workflows.
- [Stop Abusing .gitignore](https://mergify.com/blog/stop-abusing-gitignore.md): .gitignore is one of Git’s most abused features. Here’s what it’s actually for, why you shouldn’t commit your editor junk into it, and how to use a global ignore file instead.
- [Code Review: Culture, Flow, and Practices That Drive Team Performance](https://mergify.com/blog/code-review-culture-flow-and-practices-that-drive-team-performance.md): A practical guide to modern code review—from reducing friction to building team culture. Tips for writers, reviewers, and leads to turn code review into a source of clarity, speed, and collaboration instead of delay and frustration.
- [Mergify CI Insights Now Supports Jenkins](https://mergify.com/blog/mergify-ci-insights-now-supports-jenkins.md): Mergify CI Insights now supports Jenkins. With one plugin install, you get dashboards for flaky jobs, slow builds, reruns, and job costs in hours. Turn your Jenkins pipeline from a black box into clear visibility — and ship with confidence.
- [CI Sucks (and That’s OK)](https://mergify.com/blog/ci-sucks-and-thats-ok.md): CI is supposed to help developers move faster — but too often, it does the opposite. In this post, Julien Danjou, Mergify CEO, reflects on why CI feels broken, how teams lose trust in it, and what we can do to bring clarity, observability, and confidence back into the software delivery process.
- [GitHub's Merge Queue Isn't Enough for Large Teams](https://mergify.com/blog/github-s-merge-queue-isn-t-enough-for-large-teams.md): Why large engineering orgs quickly hit the limits of GitHub's queue — and what they actually need.
- [CI Failures Don’t Just Break Builds: They Break Focus](https://mergify.com/blog/ci-failures-don-t-just-break-builds-they-break-focus.md): CI always breaks at the worst time — slowing fixes, killing flow, and leaving teams rerunning jobs by ritual. We built CI Insights to show which jobs flake, where time is lost, and why your pipeline hurts. Real visibility, zero YAML edits.
- [Handling Candidate Rejection: A Delicate Balancing Act](https://mergify.com/blog/handling-candidate-rejection-a-delicate-balancing-act.md): At Mergify, we reject with respect. This post shares how we handle one of hiring’s hardest parts: saying no. Why we keep it short, when we go deeper, and how we try to balance honesty, kindness, and efficiency — for your sake and ours.
- [The Mechanics of Mergify’s Project-Driven Workflow](https://mergify.com/blog/the-mechanics-of-mergify-s-project-driven-workflow.md): How Mergify evolved from lightweight Agile to a project-driven workflow that balances ownership, clarity, and autonomy. Briefs, leads, and deadlines keep us motivated, aligned, and shipping without bureaucracy.
- [Aligning Project Management with Team Culture at Mergify](https://mergify.com/blog/aligning-project-management-with-team-culture-at-mergify.md): At Mergify, we learned the hard way that process should serve the team—not the other way around. Here’s how we moved beyond rigid Agile rituals to a lightweight, culture-driven workflow that respects autonomy, fosters ownership, and keeps our remote team shipping.

## Legal

- [Privacy Policy](https://mergify.com/privacy)
- [Terms of Service](https://mergify.com/tos)