You click "Update all" on twelve plugins. Five minutes later a client tells you the checkout button does nothing.

Most update guides end at "take a backup first" and "roll back if something breaks". Rolling back the whole batch works, but it also undoes eleven updates that were fine. Some of them may be security fixes you updated for in the first place.

Rolling back one plugin at a time is safer, but with twelve suspects it can take twelve tries.

There is a faster way: roll back half, test, and keep halving. Twelve updates take about four tests. This post shows how to do it with WP-CLI, and the one case where it gives a misleading answer.

Before you start: is it really one of the updates?

Spend two minutes on this. It saves an hour.

  1. Reproduce it on purpose. Write down the exact URL and steps, and whether it fails logged in, logged out or both. Clear the page cache and test again. If you can't make it fail on demand, you can't bisect it.
  2. Check what else changed. Did core update in the same window? The theme? The PHP version (hosts change it with an email you may have missed)? If yes, test those first.
  3. Read the log. With WP_DEBUG_LOG on, a fatal error usually names a file:
 grep "PHP Fatal" wp-content/debug.log | grep -oE "wp-content/plugins/[^/]+" | sort | uniq -c | sort -rn 

If one plugin folder is at the top, start there. If the log is empty (a JavaScript error, wrong output, a missing payment method), keep reading. That's the case bisecting is for.

Step 1: know what changed

You need the versions from before the update. WordPress doesn't keep a history, so this is easiest if you saved a list beforehand:

wp plugin list --fields=name,version --format=csv > before.csv 

If you didn't, you can usually rebuild it: your backup plugin or host snapshot has the old plugin folders (each main plugin file has a Version: header), and some managed hosts and update tools keep an update log.

From now on, run that command before every batch. It's one line and it turns "what did I update?" into a file.

Step 2: roll back half

Split the twelve updated plugins into two groups of six. Roll back group A to the old versions:

# rollback.sh: roll back the given plugins to the versions in before.csv for slug in "$@"; do v=$(awk -F, -v s="$slug" '$1==s {print $2}' before.csv) wp plugin install "$slug" --version="$v" --force done 
bash rollback.sh slug-1 slug-2 slug-3 slug-4 slug-5 slug-6 

Now test the broken flow.

  • Still broken? The cause is in group B. Update group A again (wp plugin update slug-1 slug-2 ...) and split group B.
  • Fixed? The cause is in group A. Keep group B updated and split group A.

Repeat: 12, 6, 3, 2, 1. Four tests.

Do this on a staging copy if you have one. On a live store, every rollback round is a real change visitors see.

Premium plugins: --version only works for plugins hosted on WordPress.org. For premium ones you need the old zip from the vendor's account page, then wp plugin install ./old-version.zip --force. Get those zips before you start, not in the middle.

Step 3: watch out for pairs

Sometimes bisecting points to plugin A, you roll A back, the site works, and A's support team says "can't reproduce".

They may be right. The bug can come from the combination: the new version of A together with the new (or old) version of B. Rolling back A hides the clash, but A alone isn't broken.

A quick check: with A rolled back and everything else updated, the site works. Now update A again and roll back the other half of the batch instead. If it works again, A only breaks next to something in that half, and you can keep halving that half to find B.

When you report the bug, give both plugins and both versions. That's the difference between a ticket that gets fixed and one that gets closed.

Step 4: fix forward, not backward

Once you know the update:

  1. Update everything else again. Don't leave eleven plugins on old versions because of one.
  2. Keep only the bad one on its previous version, and stop it from auto-updating back into the bug:
 wp plugin auto-updates disable slug-of-the-bad-one 
  1. Report it with versions, steps to reproduce, and the log line (I wrote about what makes a plugin bug report actionable).
  2. Put a reminder on the calendar to re-enable auto-updates when the fix ships. Pinned versions are easy to forget, and a forgotten pin becomes the next security problem.

Next time: smaller batches

The real fix is upstream:

  • Save before.csv before every batch.
  • Update checkout, payment, membership and form plugins on their own, and test those flows after each.
  • Batch the low-risk ones (SEO, admin tools, image optimizers) together.

A batch of four is two tests to bisect. A batch of thirty is five.

When you can't roll back

Rolling back versions tells you which update broke the site. Sometimes you only need to know which plugin is involved: there's no staging copy, rolling back a live store mid-day isn't an option, or you don't have the old premium zips.

In that case the same halving works with plugins switched off instead of rolled back. I built a free plugin for this, Culprit Finder (disclosure: it's mine). It switches plugins off only for your own logged-in browser, so visitors and orders keep working, asks you yes/no after each half, and catches the two-plugin case too. It doesn't change versions, so you'd still use the rollback above once you know which plugin to look at.

It's on WordPress.org: https://wordpress.org/plugins/culprit-finder/

How do you handle update batches? Do you update everything at once and deal with breakage, or split by risk?