I'm smack-bang in the political centre, and I know how I'll vote in November - 1News

The Political centre Isn't a Cop-Out - It's the Most Engineering-Minded Position There Is

The headline stopped me mid-scroll: "I'm smack-bang in the political centre. And I know how I'll vote in November - 1News. " Not because I'm a political pundit - I'm a senior software engineer who spends most days balancing trade-offs between throughput and latency, cost and reliability, speed and safety. And that headline instantly resonated with how I approach my craft.

Politics, like engineering, is full of noisy extremes. On one side, a demand for radical disruption - move fast and break things, regardless of legacy systems. On the other, a cry for rigid conservatism - never change a running system, even when it's on fire. In between lies a messy, data-driven, pragmatic centre. It's not comfortable, and it's not trendyBut it's where real, sustainable progress happens, while The political centre isn't a lazy compromise - it's the hardest position to defend. And exactly the one we need in tech.

When I read that 1News article, I didn't just nod along as a voter. I saw my own engineering philosophy reflected back at me. In this post, I'll argue why being smack-bang in the centre is the most principled, evidence-driven stance you can take - and how that lesson applies directly to how we build software, design systems. And lead teams.

The False Dichotomy of Left vs. Right (and Monolith vs. Microservices)

In software architecture, few debates are as polarising as monolith vs, and microservicesThe "left" (if we stretch the metaphor) argues for extreme modularity: every function its own service, independent deployability, polyglot everything. The "right" argues for a unified codebase: one deployable unit, simpler debugging, no network overhead. Both sides have valid points, but neither is universally correct.

The engineering centre - what I call a modular monolith or a well-bounded domain decomposition - often outperforms both extremes. It acknowledges trade-offs: yes, microservices add latency and complexity, but they also enable team autonomy. Yes, monoliths simplify dev workflows, but they become scaling bottlenecks. The centrist engineer picks based on context, not ideology.

This mirrors the political centre's rejection of purity tests. The 1News story features a voter who has made up their mind despite not fitting neatly into a party mould. That's the same intellectual honesty we need when choosing a database, a CI/CD strategy. Or a testing framework. There are no silver bullets - only silver trade-offs,

What the Political Centre Teaches Us About System Design

System design is the art of balancing competing constraints? Low latency? Cache everything, and strong consistencyUse distributed consensus protocols. While both are valid goals. But you can't maximise both simultaneously. That's CAP theorem - and it's a centrist manifesto in disguise. You don't choose "availability forever" or "consistency always". You evaluate your use case and find the acceptable middle.

Political centrism operates the same way, and economic growth vssocial welfare. Individual liberty vs, since collective security. A centrist doesn't ignore these tensions; they weigh them against real-world data, adjust policy iteratively. And accept that no solution is permanent. That's exactly how we patch production systems, roll back features. And A/B test UI changes.

The voter in 1News' article "I'm smack-bang in the political centre, and I know how I'll vote in November" didn't land there by accident. They likely considered polling, candidate track records. And specific policy proposals - exactly the same evidence-based reasoning we apply when choosing between event sourcing and CRUD.

Why I'm Smack-Bang in the Political Centre (and How I'll Vote) - An Engineering Confession

I know it's trendy to call centrists fence-sitters. But in my decade of shipping code at startups and enterprises, I've learned that the centre is where you go when you understand the complexity of a system. Early in my career, I was a "rewrite everything in the latest framework" extremist. Every project was a fresh start, every library was the hot new thing. The result, and technical debt disguised as innovation

Later, I swung to the opposite extreme: freeze all dependencies, avoid any risk, never upgrade. That produced stable but ossified systems that couldn't adapt to changing requirement. The centre - incremental modernisation with careful rollback plans - is what finally worked, and it's not glamorousBut it ships.

That's exactly how I plan to vote in November. Not for a party that promises utopia through radical change, nor for one that promises safety through stagnation. I'll vote for the candidate who acknowledges trade-offs, presents evidence for their choices. And is willing to pivot when the data says otherwise. That's the candidate who thinks like an engineer.

The Data-Driven Centrist: Using Metrics to Guide Decisions

In software engineering, we have a powerful tool that politics often lacks: objective feedback loops. We can measure page load times, error rates, user engagement. We can run A/B tests, observe canary deployments, and adjust course within hours. Imagine a political system where every policy had a two-week experiment with control groups. The political centre would thrive.

That's not a pipe dream - it's already happening in some governments, and the US, and digital Service and the UK. But government Digital Service apply iterative, user-centred design to public services. They don't rely on ideology; they rely on data. My own experience building internal tools for a government contractor confirmed that cross-agency collaboration (another centrist idea) reduces duplication and improves outcomes. It's the same principle behind sharing a microservice's schema across teams instead of building from scratch.

The voter in the 1News article likely hasn't run a chi-squared test on voting patterns. But they've internalised a habit of weighing pros and cons with real information - the same discipline we use to decide between a GraphQL endpoint and a RESTful resource.

Avoiding the Extremes: Over-Engineering and Under-Engineering

Over-engineering is the architectural equivalent of an extreme ideology - you foresee every possible future requirement and build a cathedral of abstractions. Under-engineering is the opposite extreme: ship anything that works, ignore maintainability, and hope for the best. Both lead to failure. The centre - what we call "you ain't gonna need it" with a healthy dose of "don't repeat yourself" - produces systems that are just complex enough. And no more,

Political centrism applies the same principleIt resists the urge to redesign the entire social contract in one term (over-engineering) while also rejecting the do-nothing stance that lets critical infrastructure decay (under-engineering). It favours legislative incrementalism: small, measurable improvements that compound over time. As a senior engineer, I'd rather have a team that ships three well-tested features per quarter than one that unveils a grand rewrite that's buggy and late.

The November election is a perfect opportunity to apply this lens. Which candidate is promising a rewrite? Which is promising to patch the existing system with evidence-based improvements. And i'm betting on the patcher

How to Build Consensus in a Polarised Codebase (and Country)

Consensus building is arguably the hardest engineering skill? RFC 7282 of the IETF explicitly documents that consensus isn't unanimity - it's the absence of sustained objection. That's a centrist mechanism. It doesn't require everyone to agree with the final design; it requires that no one is willing to block it. The result is a decision that can move forward without leaving the group that disagrees entirely disenfranchised.

In politics, this translates to coalition governments, cross-party committees. And even ranked-choice voting. The centre is where these compromises are forged. A polarised codebase - one team wanting GraphQL and another demanding REST - can only unify when both sides concede something. The centrist architect proposes a hybrid: a thin GraphQL layer over a stable REST backend that both teams can support.

I've used this technique in production environments to end "tabs vs, and spaces" style debatesBy framing the decision not as a winner-takes-all vote but as a search for a design that minimises total objection, we produced solutions that were actually better than either original proposal. The 1News article's voter likely used a similar mental model - not choosing "the lesser evil" but "the option with the fewest unacceptable drawbacks. "

Novembers Are for Reflection: Lessons from Release Cycles

Every November (or whenever elections occur), we collectively perform a retrospective on the last political term. That's exactly what agile teams do at the end of a sprint. What worked, and what didn'tWhat should we start/stop/continue? The centrist voter does this with deliberate honesty - they don't blindly support their party; they evaluate outcomes.

In software, we call this the "inspect and adapt" loop. I'd love to see every voter approach their ballot like a post-mortem: "The infrastructure spending bill (code PR #242) had a defect that caused delays. But the education reform (feature flag: early-literacy) showed strong metrics, and adjusting my support accordingly"

The voter who says "I'm smack-bang in the political centre. And I know how I'll vote in November" has already done this work. They've closed the feedback loop on last term's promises and match them against actual data. That's more than most teams do in post-sprint reviews.

The Hidden Cost of Purity Tests in Open Source and Politics

Purity tests - demanding that a candidate or a library meet every single ideological criterion - are toxic in both domains. In open source, we've seen communities split over licensing, code of conduct enforcement. And even coding style. The result is maintainer burnout and forked projects that duplicate effort. The centrist approach: accept that no package is perfect, contribute improvements. And don't block others from adopting a "good enough" solution while you wait for perfect.

Politics is no different. The voter who refuses to vote for any candidate who isn't 100% aligned on every issue effectively disenfranchises themselves. The centrist understands that a vote is a tactical signal, not a love letter. They'll vote for the candidate who aligns most closely on their highest-priority issues, even if they disagree on a few secondary ones. That's the same tolerance we show when we adopt a framework with one feature we don't like but that otherwise solves our core needs.

The 1News article makes clear that the writer has done this calculus. They're not voting with blind party loyalty. They've weighed the trade-offs,? And that's the engineering mindset in action

FAQ: Common Questions About Centrism and Engineering

• Isn't centrism just fence-sitting - avoiding hard decisions? No. Centrism requires actively engaging with opposing data points and synthesising a decision that works in practice, not just in theory. That's harder than picking an extreme.
• How do I apply centrist thinking to my team's architecture decisions? Start by listing the concrete trade-offs for each option. Then use a weighted scoring system based on your actual constraints (team size, latency requirements, deployment frequency). Avoid ideological labels like "microservices are always better. "
• Can centrism lead to stagnation - endless compromise? It can, if you lack a decision-making framework. Use time-boxed debates, decision records (ADRs), and a clear escalation path. The goal isn't to please everyone but to move forward with consent.
• What if the data supports an extreme position? Then go extreme - but only if the evidence is overwhelming and the risks of the opposite extreme are well-understood. Centrism doesn't forbid outliers; it requires justification for them.
• Does the 1News article suggest voting is like debugging? In a way. You identify symptoms, hypothesise root causes - test solutions, and iterate. Voting is just the deployment step - and you need the whole pipeline of reflection before and after.

Conclusion: Ship the Ballot, Then Iterate

The phrase "I'm smack-bang in the political centre. And I know how I'll vote in November - 1News" isn't just a voter's declaration. It's a design philosophy. It acknowledges that no system is perfect, that every choice has consequences. And that the best way forward is informed by evidence, not dogma.

As engineers, we can learn from that mindset. When we next face a heated debate over technology stack, methodology. Or team structure, let's resist the pull of extreme camps. Instead, let's be smack-bang in the engineering centre - where we evaluate, balance. And decide with integrity. And then we ship, because the system won't improve itself,

Your next ticket isn't an ideologyIt's a problem to solve. Solve it with the same disciplined centrism that a thoughtful voter brings to the ballot box. That's how we build robust systems - resilient democracies, and a future neither left nor right can claim exclusively.

What do you think?

Do you believe political centrism is truly analogous to evidence-based software engineering,? Or do you see it as a compromise that dilutes principles?

In your own work, have you encountered situations where a "centrist"