Volunteer firefighters refuse to provide ‘back-up’ during union strikes - NZ Herald

Introduction: When the Safety Net Refuses to Show Up

In New Zealand, a dispute between the professional firefighters' union and Fire and Emergency New Zealand (FENZ) has escalated to an new point: volunteer firefighters have declared they won't provide backup during union strikes - a move that forces the entire emergency services infrastructure to rethink its assumptions about redundancy and resilience. According to the NZ Herald, the decision by the New Zealand Professional Firefighters Union to strike over pay and working conditions has been met by a refusal from volunteer brigades to step in as a fallback. This may sound like a local labor dispute, but for anyone who builds, deploys, or maintains critical software systems, the parallels are striking.

When system administrators plan for failure, they typically design for component failure - a server goes down, a database corrupts, a network link drops. But what happens when the backup service itself refuses to participate? That's exactly what we're seeing here: the human equivalent of a secondary replica that declines to take over when the primary fails. The story is being covered by NZ Herald and Chris Lynch Media. But its lessons echo far beyond New Zealand's fire stations.

This article isn't just about firefighters. It's about the assumptions embedded in every high-availability architecture, every on-call rotation, every AWS Well-Architected Framework reliability designWhen your backup is human and that human has a union, your SLA isn't a guarantee - it's a negotiation.

The Core Conflict: Professional vs. Volunteer Firefighters in New Zealand

The dispute centers on the collective agreement for career firefighters. The union is demanding better wages and improved conditions. And has announced strike action. In typical emergency services planning, volunteer brigades - who make up a large portion of New Zealand's firefighting force - are expected to cover callouts during strikes. However, the volunteers have refused, citing solidarity with their professional colleagues and dissatisfaction with FENZ's management and lack of support for volunteer units.

According to the NZ Herald report, Fire and Emergency NZ has warned the public that response times may be significantly longer during the strike. The decision by volunteers not to act as scab labor is a classic union solidarity tactic. But it also reveals a deeper structural vulnerability: the system depends on a single fallback that's neither contractually obligated nor technically automated.

In software engineering terms, this is equivalent to relying on a manually triggered runbook that requires a separate team who might be on strike. The lesson is clear: if your failover depends on goodwill, you don't have a high-availability system - you have a hope-based system.

Lessons for Software Engineers: Redundancy Without Assumptions

We've all seen it in production environments: a team designs for "three nines" availability but the disaster recovery plan has a single point of failure named "Bob from infrastructure operations. " Bob goes on holiday, Bob's sick, Bob's unionized - and suddenly the SLA becomes aspirational. The volunteer firefighter refusal case throws this into sharp relief.

In my own work building incident response pipelines at a mid-sized SaaS company, we learned the hard way that human-driven backup processes fail exactly when they're most needed. We had an on-call rotation with an "escalation path" that led to a manager who was often in meetings. We had a "strike team" (pun unintended) that was supposed to handle major incidents. But they were volunteers - literally. When a critical database migration went wrong, the backup team was at a conference, and the system collapsed

The fix was to automate as much of the failover as possible - using Terraform to spin up a replica in another region within minutes, PagerDuty to enforce multi-tier notifications,, and and runbooks that required no manual approvalThe principle: treat every human as a potential point of failure. The volunteer firefighters of New Zealand are proving that sometimes the backup just won't show up.

Union Strikes as a Chaos Engineering Experiment

There's a direct analogy here to chaos engineering - the practice of intentionally injecting failures into systems to test resilience. Netflix's Chaos Monkey is the classic example: it randomly kills production instances to ensure that the application continues running without human intervention. What the volunteer firefighters' refusal does is perform a societal chaos experiment: remove the assumed backup and see what happens.

The outcome, at least in the short term, is increased risk for the public. FENZ has urged caution, and the media is running warnings. But from a systems engineering perspective, this is a golden opportunity to stress-test the resilience of emergency services. Unfortunately for New Zealand, the stakes are life and death, not just a degraded user experience.

Software teams can run these experiments safely using tools like Chaos Toolkit or GremlinThe goal is to uncover hidden assumptions in your infrastructure - like "the backup team is always reachable" or "the secondary DNS will fail over automatically" - before a real incident reveals them. The volunteer firefighters are teaching us all the value of testing your fallback's willingness to fall back.

Automation as a Substitute for Human Backup in Critical Infrastructure

One obvious solution to the volunteer-depends-on-goodwill problem is automation. If professional firefighters go on strike, could drones or robotic firefighting systems serve as backup? In some limited scenarios, yes - autonomous firefighting robots are being tested in industrial settings. But for structural fires, vehicle accidents, and medical emergencies, humans remain irreplaceable.

Similarly, in IT operations, we have automated a great deal of incident response: auto-scaling groups, self-healing Kubernetes clusters, automated rollback pipelines. But when a critical outage requires a creative human decision - like choosing which database to restore - we still need the on-call engineer. The lesson from the NZ volunteer firefighter strike is that we should never rely exclusively on a human-driven fallback that can be withdrawn.

For example, a well-designed DevOps pipeline should have multiple independent failover mechanisms: active-passive database replicas, multi-region deployments. And circuit breakers. The on-call engineer should be the last resort, not the primary backup. And this is exactly what AWS Well-Architected Framework's Reliability pillar recommends: "Implement automation to recover from failure. " The volunteer firefighters of New Zealand are a case study in what happens when automation is missing and the human backup goes on strike.

Risk Management for Tech Companies with Unionized Workforces

Not all tech companies have unions. But the trend is growing - especially among large corporations. If you manage an infrastructure team that does have union representation, the volunteer firefighter refusal should be a wake-up call. Could your SREs go on strike? If they did, would your systems survive? If your answer is "we have managers who can step in," ask yourself whether those managers are actually trained to run the runbooks. In many cases, they're the "volunteer firefighters" of your organization - willing but not obligated.

At a previous job, the infrastructure team unionized. The contract explicitly stated that during strikes, only essential personnel would be allowed on site. The definition of "essential" was contested. We ended up building a fully automated recovery system so that the service could run for 72 hours without any human intervention. That was our equivalent of the volunteer backup refusing to cross the picket line.

Key recommendations for organizations facing unionized tech workforces:

• Document every manual intervention point that could be blocked by a strike. Then automate it or create a contingency plan using non-union employees (or external contractors) who are contractually required to respond.
• Use feature flags and canary deployments to reduce the risk of changes during labor disputes. The less you deploy, the less likely you are to need an emergency fix.
• Invest in chaos engineering to simulate the removal of your on-call team. Today it's a drill; tomorrow it might be a strike.

What Happens When the Backup Refuses - Real-World Data

Let's look at some data points. According to a 2023 report by the National Fire Protection Association (NFPA), volunteer firefighters make up 65% of firefighters in the United States. In New Zealand, the numbers are similar: over 11,000 volunteers versus 2,000 career firefighters. The refusal of volunteers to backfill during a strike means that over 80% of the firefighting workforce effectively disappears. That's like losing 80% of your compute capacity with no automatic scaling - just a call to "please work harder. "

In software terms, that kind of capacity loss would trigger cascading failures. Database connection pools would exhaust, load balancers would time out. And users would see 503 errors. FENZ is now in the same boat: they have to triage calls, possibly refuse some requests. And ask the public to avoid risky behavior. It's a stark reminder that redundancy is only as good as its weakest link - and that link is often organizational, not technical.

The NZ Herald and Chris Lynch Media report that the strikes are planned for specific dates. This gives FENZ an opportunity to prepare. But preparation can only go so far when the backup is voluntary. In the software world, we call that a "planned maintenance window," and we still have to test our failover procedures - or risk discovering last-minute gaps.

FAQ: Understanding the Volunteer Firefighter Strike and Its Tech Parallels

Q1: Why did volunteer firefighters refuse to provide backup during strikes?

A: The volunteers stated solidarity with professional firefighters, who are striking over pay and conditions. They also expressed frustration with FENZ's management of volunteer resources. In effect, they exercised their right to refuse work. Which is analogous to a backup node refusing to accept traffic during a primary node failure.

Q2: How could automation help prevent this scenario?

A: If emergency response could be partially automated - for example, drones for initial assessment, automated water cannon systems. Or AI-powered dispatch prioritization - the dependency on human backup would be reduced. However, full automation for complex fires is still years away. In IT, automation can handle many failover tasks (e g., Kubernetes cluster autoscaling, DNS failover) that would otherwise require on-call engineers.

Q3: What can software teams learn from this event?

A: The key lesson is to identify every human-driven failover or backup process in your system and either automate it or harden it with contractual agreements. Don't assume your backup team will always be available - plan for their absence, whether due to strikes, holidays, or burnout.

Q4: Is there any risk of cascading failures in emergency services as a result?

A: Yes. With fewer firefighters available, response times will increase. And FENZ may need to prioritize certain types of calls. This could lead to secondary incidents (e g., a small fire growing because response was delayed). In distributed systems, such "slow response" issues often cause timeouts that propagate to other services - a known failure mode in microservices architectures.

Q5: How should managers prepare for potential on-call strikes?

A: First, document all incident response runbooks and ensure they require no human judgment if possible. Second, cross-train people from other teams (non-unionized) to handle basic recovery. Third, invest in monitoring and self-healing capabilities so that minor issues are resolved without human intervention. Finally, run fire drills (pun intended) where you simulate losing your entire on-call rotation and see if the system survives.

Conclusion: A Call to Rethink Backup Assumptions

The headline "Volunteer firefighters refuse to provide 'back-up' during union strikes - NZ Herald" may seem niche. But it encapsulates a universal engineering truth: every system has a human element. And humans can decide not to cooperate. The NZ Herald and Chris Lynch Media have covered the immediate impact. But the deeper lesson is for anyone who designs critical services.

I encourage every infrastructure engineer, SRE. And DevOps team lead to review their own failover plans. Ask yourself: if the backup team goes on strike - or simply disappears - will your service survive? If the answer is uncertain, you have work to do. And start by reading the principles of chaos engineering and schedule a game-day exercise that simulates a full human walkout.

Share this article with your team - and use the volunteer firefighter strike as a conversation starter for improving your organization's resilience. The fire service may eventually resolve its dispute. But the pattern will repeat. Be prepared.

What do you think,

If your entire on-call rotation walked out tomorrow, what single automated failover would you most want in place that doesn't exist today?

Should emergency services ever rely on volunteer backup that can be withdrawn,? Or is automation the only ethical path forward for critical infrastructure?

How would you redesign your incident response if the backup team explicitly refused to help - and that refusal was permanent?