Technical Blog
20 years of real-world engineering — from writing C for Microsoft to running AI-assisted workflows at Freddie's Flowers. No fluff, just experience.
2026
2 postsAI Editor Wars: Cursor vs Claude Code vs Kiro — An Honest CTO's Comparison
I've used Cursor daily for over a year, experimented extensively with Claude Code, and evaluated Kiro since its launch. Here's my honest take — not a marketing comparison, but a practitioner's view from a CTO who still writes code.
AI Adoption Strategy for Engineering Teams: How to Do It Without Losing Quality
Introducing AI tooling to an engineering team is easy. Getting the team to use it well — maintaining quality, developing good intuitions about AI output, not creating a dependency — is hard. Here's our approach.
2025
1 post2024
7 postsPlatform Replatforming at Freddie's Flowers: The Decision Framework
Replatforming a production subscription e-commerce business without disrupting operations is one of the most complex engineering programmes a CTO can run. Here's the decision-making framework we used at Freddie's Flowers.
Winning the Pennies Unsung Hero Award: What Micro-Donations Mean in Tech
In October 2024, I received the Unsung Hero Award from Pennies at their 5th Annual Awards ceremony. This is what micro-donations look like from the engineering side — and why it matters.
TypeORM vs Prisma: Choosing Your ORM for a TypeScript Migration
During a platform replatforming, we ended up using two different ORMs in the same project — TypeORM for the core backend API, Prisma for the admin panel. Here's why, and what each is genuinely better at.
Multi-Repo vs Monorepo: A Practical Decision Framework for Small Teams
The monorepo vs multi-repo debate generates more heat than light. Here's the framework I used — and why multi-repo won for a subscription platform replatforming with four applications and a lean team.
The Two-Tier Feature Flag Strategy: When LaunchDarkly Is Overkill
Feature flags are non-negotiable for safe deployments. But commercial feature flag platforms have convinced teams that a £50K/year SaaS is the only way. Here's the two-tier approach that covers 95% of use cases at a fraction of the cost.
Queue Everything: How SQS-Based Architecture Improved Our API Response Times
The most impactful architectural decision in our replatforming wasn't the language choice or infrastructure — it was systematically moving everything non-critical out of the synchronous request path and into SQS queues.
The Working Relationship Between Product and Engineering: A CTO's Perspective
The tension between product and engineering is one of the most commonly cited challenges in tech companies. After 22 years — and a lot of hard-won lessons — here's what I've come to believe about getting this relationship right.
2023
8 postsServerless vs Containers vs EC2: Choosing Infrastructure for a Lean Engineering Team
The infrastructure decision for a replatforming project forces you to answer a question with no universal answer: what's right for your specific team, workload, and economics? Here's the framework I used — and why serverless won.
How to Run a CTO Infrastructure Review That Stakeholders Actually Trust
A platform infrastructure review that produces the right technical answer but fails to bring stakeholders with it is a failed review. Here's the process I use — structured to produce decisions that the board, product leadership, and engineering teams can all trust.
PHP to TypeScript: Why We Migrated a Production Subscription Platform
Migrating a production subscription platform from PHP to TypeScript is not a decision taken lightly. Here's the honest case for why we did it, the alternatives we rejected, and what the migration actually delivered.
Build vs Buy: A CTO's Framework for Platform Decisions
Every CTO faces the build vs buy decision repeatedly. After 22 years of making these calls, I've developed a framework that goes beyond the surface-level cost analysis most teams do.
Transaction Fees: The Hidden Cost That Makes Platform Economics Counterintuitive
When teams evaluate SaaS e-commerce platforms vs custom builds, they focus on the obvious costs: subscription fees, development time, staff. The number that actually swings the decision is almost always the one buried in the small print: transaction fees.
Core Web Vitals as a Replatforming Success Metric: Real Before and After Numbers
When running a platform infrastructure review, you need objective metrics to evaluate options and measure success. Core Web Vitals gave us exactly that — here are the actual before/after numbers from a full replatforming, and why they mattered more than we expected.
Build vs Buy for Subscription E-Commerce: A Detailed Cost Analysis
After running a rigorous build vs buy analysis for a subscription e-commerce platform, the numbers told a clear story. Here's the full framework, the cost breakdown, and why 'just use Shopify' is the wrong answer for complex subscription models.
The Monolith Tipping Point: 6 Signs Your Platform Needs More Than a Patch
Every monolith reaches a tipping point — the moment when the next patch costs more than it saves. I've run several platform reviews at this point. Here are the six signals that tell you incremental improvement is no longer the right answer.
2021
1 post2020
4 postsHome Office Ergonomics: What Engineers Actually Need
Six months into remote work, half the team had back pain. We learned the hard way that kitchen tables aren't workstations. Here's the equipment list that actually matters.
Maintaining Engineering Culture When You Can't See Each Other
Engineering culture is built through hundreds of small interactions. When those interactions moved to Slack and Zoom, we had to be deliberate about preserving what made us us.
Remote Pair Programming: Making It Actually Work
Pair programming is hard enough in person. Remote pair programming seemed impossible until we figured out the right tools, practices, and rhythms. Here's our playbook.
The Overnight Shift to Remote: Engineering Leadership During COVID-19
In March 2020, we sent everyone home with 48 hours notice. Here's what we learned about leading engineering teams through sudden, fundamental change — and what stuck permanently.
2019
2 postsCommon Kubernetes Pitfalls on EC2 (And How to Avoid Them)
After two years of running Kubernetes on EC2, here are the failure modes that caught us out — OOMKilled pods, node pressure, IMDS conflicts, and more. Save yourself the pain.
Building a Data Platform with Redshift, Looker, and dbt
In 2018-19, TouchNote needed to move from ad-hoc SQL queries to a proper analytics platform. Here's how we built our data stack with Redshift, Looker, and dbt — and what we'd do differently.
2018
2 postsObservability in Production: Grafana, NewRelic, and What Actually Matters
After running production services across AWS and Kubernetes, I've developed strong opinions about what monitoring actually helps during incidents. Here's the setup that's worked for us.
Kubernetes on EC2 Before EKS: What We Got Wrong (And Right)
We ran Kubernetes on bare EC2 instances from 2017. EKS launched in 2018. The things we learned self-managing Kubernetes are things EKS users take for granted — hard-won lessons worth sharing.
2017
1 post2014
1 post2013
1 post2012
2 postsAWS Load Balancers and MySQL Replication: What Nobody Tells You
Running MySQL replication and AWS ELB in production teaches you things the documentation doesn't cover. Here are the hard-won lessons from scaling TouchNote through the 2012 Olympics period.
London Olympics 2012: Handling 100K Transactions Per Hour on AWS
During the London 2012 Olympics, Samsung ran a major digital campaign on TouchNote. We processed 100K transactions per hour at peak. Here's the AWS architecture that made it possible — and what nearly failed.
2011
2 postsZendMVC and Rebuilding TouchNote: A PHP Architecture Story
Rebuilding a production platform while the business keeps running is one of engineering's hardest challenges. Here's how we used ZendMVC and AngularJS to transform TouchNote's architecture without breaking it.
Why API and Website Isolation Is Not Optional
In 2011, rebuilding TouchNote's architecture to support iOS, Android, and HP webOS taught me a lesson I've never forgotten: your website and your API must be independent systems. Here's why.
2010
1 post2009
1 post2007
2 postsThe Developer's Guide to IPTV: What I Learned at TCS
IPTV in 2007 was engineering at the intersection of telecoms, media, and software. My stint at TCS's IPTV Centre of Excellence was a masterclass in the complexity of real-time media delivery at scale.
SQL Server Continuous Data Protection: Real-Time Backup in Practice
Continuous Data Protection promised zero-RPO recovery. Building it for SQL Server at Microsoft taught me the gap between a promising architecture and a production-grade implementation.
2006
2 postsBuilding Resilient Software with C: Enterprise Patterns for Disaster Recovery
Working on Microsoft's disaster recovery platform in C taught me lessons about reliability engineering that I still apply at every level of the stack — from kernel modules to cloud-native applications.
File-Based vs Volume-Based Disaster Recovery: The Fundamentals
Early in my career at Inmage Systems, I worked on enterprise disaster recovery software. Here's what I learned about the two fundamental approaches to DR — and why the distinction still matters today.