Skip to main content
Ship tested code, skip the drama

WordPress CI/CD and DevOps

WordPress CI/CD without the guesswork: every change tested in Git before release, deploys with zero downtime, and rollbacks measured in minutes.

Hope is not
a deployment strategy

A client once described their deploy process to us in one sentence: open FileZilla, drag the changed file onto the server, hit refresh, and hope. That was the entire test plan. The change counted as shipped the moment the upload bar filled, with no record of what moved and no way back if it broke. WordPress CI/CD exists to retire that ritual and put machines in charge of checking code before customers ever meet it.

We inherit sites like this every month. The deploy history is one developer's memory, and that developer resigned last spring. Ask which plugin versions run in production and the honest answer is a guess. Every change becomes a small gamble, because nothing on the server can explain how it got that way or what depends on it.

The fix costs less than expected. Code lives in Git, every push triggers a test run, and a single command ships the result to production the same way each time. Two developers sharing a codebase is reason enough to bother. We treat this as the baseline for professional WordPress development rather than an add-on you have to request.

30+

Releases in an ordinary week

<15min

From git push to live, tested code

0s

Downtime visitors see per release

<5min

To bring the previous version back

The anatomy of a WordPress CI/CD pipeline

Tools come and go. The principle stays put: code that has not passed its tests does not reach production.
01 / 06

Git as the foundation

Themes and custom plugins live in version control with their full history attached. When you need to know who last touched a file in October and what they were fixing, the log has the answer years after everyone else has forgotten.
02 / 06

Composer-based WordPress

Core and all plugins are pinned as dependencies in composer.json, following the Bedrock model. A fresh environment comes up byte-for-byte identical to production, so the small drift that usually hides between local and live never gets the chance to surprise anyone.
03 / 06

Automated testing

Static analysis and PHPUnit run on each push. A Playwright-driven browser then clicks through the site the way a customer would, submitting forms and logging in, before the release moves any closer to visitors.
04 / 06

Staging that mirrors production

Identical PHP version and database engine, deliberately boring. Bugs get to surface in a place where they waste an afternoon at worst, never a sales day.
05 / 06

Blue-green deploys

The incoming release runs alongside the current one until health checks finish their rounds. Traffic moves when everything reports green, and moves back just as quickly if the new build acts up.
06 / 06

Monitoring and alerts

Response times and error rates are tracked across every release. If something turns slow or shaky, the alerting tells the team first — long before a customer writes in to ask what happened.

Zero downtime
is plumbing, not magic

The mechanism behind it is old and well understood: atomic deploys. Each release gets built to completion in its own directory on the server, with Composer packages installed and assets compiled, while the live version keeps answering traffic one folder over. No file is ever overwritten in place, so visitors never meet a maintenance screen.

Then the release has to prove itself. Health checks confirm that the application responds, that it can reach the database, and that the pages customers actually visit render correctly. Only once every check reports green does a symlink move, and from that instant all traffic flows to the new build without a single dropped request. Because the cutover takes milliseconds, shipping at noon on a Tuesday in the middle of a campaign is no braver than shipping at three on a Sunday morning.

When a release does fail, the recovery is equally quiet. Point the symlink back at the previous build and the site is exactly where it stood, within minutes, with no backup restore and no apology email to draft. Visitors only ever saw a website that worked. The whole arrangement is written up in our case study on zero-downtime deploys in practice.

The same deploy, two ways

Manual FTP
Deploy method
Files dragged into an FTP client
Time per deploy
15–45 minutes, manual
Rollback
Restore a backup, 30–60 min
Testing
Manually in the browser, maybe
Traceability
None
Who did what
Nobody knows
Downtime during deploys
Unpredictable
Teamwork
One person at a time
CI/CD pipeline
The PXL default
Deploy method
Automatic on git push
Time per deploy
2–5 minutes, automated
Rollback
One command — within minutes
Testing
Automated on every push
Traceability
Full Git history
Who did what
Name, timestamp and rationale
Downtime during deploys
0 seconds
Teamwork
Parallel feature branches

When is this overkill?

For some sites, frankly, it is.

A brochure site on a standard theme with a handful of proven plugins lives happily on wp-admin plus a maintenance agreement where somebody competent tests each update before it goes out. Wiring a full pipeline into that is buying a snowplough for a driveway in Spain. We say so. Loudly, if needed.

Revenue rewrites the calculation. A webshop taking orders around the clock cannot use production as its test environment, and neither can anything connected to Vipps or BankID, nor a codebase where several developers commit in the same week. From there on, each manual deploy carries a price tag. You learn the amount only after it detonates.

Our rule of thumb stays simple. When an hour of downtime costs more than NOK 10,000, or the site carries custom code meant to survive past its second birthday, the pipeline starts paying for itself. You build it once. The first broken release it stops usually settles the entire invoice.

How an existing site gets WordPress CI/CD

AssessmentWe start by tracing how a change actually lands in production today — the honest answer is usually more improvised than anyone admits out loud. Custom code gets separated from third-party plugins and themes.
Version controlThemes and in-house plugins move into Git with their history intact. Core and everything third-party turn into Composer dependencies, while passwords and API keys leave the codebase for environment variables.
Staging and pipelineA staging environment mirroring production goes up next, connected to a pipeline that runs static analysis and the test suite on each push.
Automated deploysAtomic releases gated by health checks, staging before production. Dashboard file editing gets switched off, and the last shortcut around the pipeline closes with it.
HandoverDocumentation and hands-on training for your team round things off. Operate the pipeline yourselves from there, or leave the routine work with us under a service agreement.

Frequently Asked Questions

SB
CG
JB
About us

What if the next release was just another Tuesday?

Describe how you ship changes today, in a sentence or two, and you'll get a straight answer on whether a pipeline is worth your money.