Technical Blog
20 years of real-world engineering, from writing disaster recovery software in C at InMage to leading AI-assisted engineering teams. No fluff, just experience.
Series
2026
22 postsOver Six Years at Freddie's Flowers: What I Built, What I Learned and Why I Stayed
After over six years as CTO at Freddie's Flowers, I've moved on. This is an honest look back: the team, the platform, the cost-centre problem, the board seat, and why I stayed two years longer than I first planned.
GEO in Practice: Optimising a Next.js Site for AI Answer Engines
Generative engine optimisation sounds like a new discipline, but most of what gets you cited by ChatGPT, Perplexity or AI Overviews is classic indexing done properly. Here is what I actually changed on this site, what I skipped, and how I check whether any of it works.
Agentic Commerce: Making a Subscription Store Usable by AI Shopping Agents
AI assistants are starting to browse, compare and buy on behalf of people. For a subscription business that raises awkward questions about data, APIs, consent, payments and cancellations. Here is how I would prepare without betting the roadmap on standards that are still settling.
Apache Iceberg with Snowflake: Open Table Formats Without the Hype
Apache Iceberg promises one copy of your data that any engine can read, with Snowflake as just one of them. The promise is real, but so is the bill for operating it. Here's how Iceberg works, how Snowflake supports it, and when a mid-size business should actually bother.
When AI Writes Most of the Code, Review Becomes the Bottleneck
AI agents have made writing code cheap, but they have not made understanding it cheap. The constraint in most teams I work with has moved from generation to review, and the teams that cope are the ones that redesign review on purpose rather than hoping it scales.
Running an LLM Gateway in Your Business: Keeping Context and Code In-House (and How It Differs from Bedrock)
Once more than a handful of people use AI tools, you need to know which models are being called, with what data, at what cost. An LLM gateway gives you that control point. Here's how to configure one so your code and context stay under your control, and why it's a different thing from Amazon Bedrock.
AI Coding Accuracy and Spec-Driven Development: What Works at Startup, Scaleup and Enterprise
AI coding tools are only as accurate as the context you give them. After two years of rolling them out, the single biggest accuracy lever I've found isn't the model, it's the spec. Here's how to do spec-based development without drowning in process, at each stage of company growth.
Ingress, Istio Service Mesh and API Gateway Explained: What Each Does and When to Use It
Ingress controllers, service meshes and API gateways all sit in the path of your traffic, and their feature lists overlap enough to confuse anyone. This is a plain-English knowledge article on what each one is for, how they fit together, and when you actually need them.
EventBridge vs SNS: When to Use Which (and When to Use Both)
EventBridge and SNS both deliver a message to multiple subscribers, so teams often treat them as interchangeable. They aren't. One is a high-throughput notification pipe; the other is an event router with rules, schemas and third-party integrations. Here's how I choose.
Claude Fable 5.1 vs GPT-5.6: My Take as a CTO Who Still Ships Code
The comparison everyone asks me about this year is Anthropic's Claude Fable 5.1 against OpenAI's GPT-5.6. Both are genuinely frontier models. The right choice depends less on benchmarks and more on the shape of your work, your budget and the tooling around the model.
CloudWatch as Your Observability Backbone: Native Dashboards, Grafana, or Something Else?
If you run on AWS, CloudWatch is already collecting your metrics and logs whether you like it or not. The real question is whether to build your observability on top of it, pipe it into Grafana, or pay for a third-party platform. The answer depends heavily on stage and budget.
Terraform at a Startup: When It Pays Off and When It's Premature
Every startup infrastructure debate eventually arrives at Terraform. Some teams adopt it on day one and drown in modules; others click through the AWS console for three years and can't rebuild their own production. Here's how I decide.
RDS Postgres to Snowflake: Migration Patterns and Choosing the Right Approach
Getting data from an RDS Postgres database into Snowflake sounds like a solved problem. It mostly is, but there are at least five patterns to choose from, and the wrong one will cost you in freshness, money or on-call pain. Here's how I think about each.
Deploying an LLM Gateway with LiteLLM: Virtual Keys, Budgets and Routing Claude Code Through It
A hands-on guide to running LiteLLM as an internal LLM gateway on AWS: architecture, configuration, per-team virtual keys and budgets, PII guardrails, and pointing developer tools like Claude Code at it.
Spec-First AI Development in Practice: Kiro, Plan Modes and Spec Kit Compared
'Vibe coding' works for prototypes and falls apart on production systems. The tools have responded with spec-first workflows: Kiro's requirements-design-tasks flow, plan modes in Claude Code and Cursor, and GitHub's open-source Spec Kit. Here's how each works and how to choose.
OpenTelemetry in Practice: Instrument Once, Switch Observability Vendors with Config
Observability vendor lock-in rarely comes from the dashboards. It comes from proprietary agents and SDKs scattered through your code. OpenTelemetry and the OTel Collector let you instrument once and route telemetry anywhere. Here's a practical setup.
Snowpipe Streaming: Getting Data into Snowflake in Seconds, Not Minutes
Classic Snowpipe loads files from cloud storage and is measured in minutes. Snowpipe Streaming writes rows directly into tables with seconds of latency, and its newer high-performance architecture changes both the throughput ceiling and the pricing model. Here's when it's worth it.
Ingress-NGINX Is Retired: A Practical Migration to the Kubernetes Gateway API
The community ingress-nginx controller reached end of maintenance in March 2026. If it's still routing your production traffic, you're running an unpatched edge proxy. Here's how the Gateway API differs from Ingress, and a pragmatic path to migrate.
EventBridge Pipes and Scheduler: Deleting the Glue Lambdas
Every serverless codebase accumulates small Lambdas whose only job is to move data from A to B or run something on a timer. EventBridge Pipes and EventBridge Scheduler replace most of them with configuration. Here's where each fits and what to watch.
AI 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.
Istio Ambient Mode: A Service Mesh Without the Sidecar Tax
For years the honest answer to 'should we run Istio?' was 'probably not, unless you have a platform team'. Ambient mode changes the cost side of that equation. Here's how it works, what it gives you, and when I'd now consider a mesh.
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
15 postsGTM vs Segment: Tag Manager or Customer Data Pipeline (and Why Many Teams Run Both)
Google Tag Manager and Segment get compared as if they were alternatives. They solve different problems: one decides which tags fire in the browser, the other is a pipeline for your event data. Here's how I think about each, the costs, and when to use both.
Engineering Owns What Happened, GTM Owns Where It Goes: A Tracking Architecture That Scales
Most analytics problems aren't tool problems, they're ownership problems. Here's the principle I now use for front-end tracking, and the thin tracking module with adapters that makes it work today with GTM and tomorrow with Segment.
npm Supply Chain Attacks in 2025: Hardening a Node.js and TypeScript Codebase
In September 2025 a phished maintainer led to malware in chalk and debug, then a self-replicating worm spread through hundreds of npm packages. Here's what happened and how I'm hardening our Node.js codebases.
Serverless 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.
Platform Engineering Without a Platform Team: Golden Paths for Small Organisations
You don't need a platform team or a developer portal to get most of the benefits of platform engineering. For small organisations I focus on a few golden paths: a service template, shared CI, shared Terraform modules and a catalogue that lives in the repositories.
AWS Cost Optimisation for a Mid-Size Business: Where the Money Actually Goes
AWS bills rarely grow because of one big mistake. They grow through dozens of small defaults nobody revisited. This is the checklist I work through: Graviton, commitments, rightsizing, storage, networking, logs and a FinOps cadence that keeps it from drifting back.
CrUX vs Core Web Vitals: Metrics, Data Sources and When to Use Which
Teams often talk about 'CrUX' and 'Core Web Vitals' as if they were the same thing. One is a set of metrics; the other is a dataset of real Chrome users. Knowing the difference, and where lab tests and your own RUM fit, changes how you measure and fix performance.
From Autocomplete to Agents: How Agentic Coding Changed Our Workflow in 2025
In the first half of 2025 AI coding tools stopped finishing our lines and started finishing our tickets. Here's what I've learned about which tasks suit agents, how to set a repository up for them, and why code review matters more now, not less.
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.
Data Contracts: Stopping Application Changes from Breaking the Warehouse
Most broken dashboards I've seen weren't caused by bad SQL. They were caused by a perfectly reasonable application change that nobody told the data team about. Data contracts are how I stop that happening, and they're less bureaucratic than they sound.
Major PostgreSQL Upgrades on RDS with Blue/Green Deployments
Major version upgrades are the database change teams put off longest. RDS Blue/Green Deployments turn a risky maintenance window into a rehearsed switchover measured in seconds to minutes, as long as you understand what logical replication won't copy for you.
Measuring Engineering Productivity in 2025: DORA, SPACE, DX Core 4 and the AI Problem
Every board eventually asks how productive engineering is. I've found the frameworks useful, the pitfalls predictable, and AI assistants have made the whole question harder. Here's how I think about what to measure, who sees it, and what never to do.
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.
Model Context Protocol Explained for Engineering Leaders
MCP, announced by Anthropic in November, makes connecting assistants to your tickets, docs and databases easy. That's exactly why engineering leaders need to think about the security model before their teams do it anyway.
Two Decades in Tech: What I've Actually Learned About Building Engineering Teams
From writing disaster recovery software at InMage (later acquired by Microsoft) in 2006 to running AI-assisted engineering workflows at Freddie's Flowers in 2025: here's what two decades have actually taught me about building engineering teams.
2024
14 postsA Year of AI Coding Assistants: What I've Learned Rolling Them Out in 2024
2024 was the year AI coding assistants went from clever autocomplete to something closer to a pair programmer. Here's how I'd roll them out, the guardrails I'd insist on, and how to measure impact without falling for vanity metrics.
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 20 years, and a lot of hard-won lessons, here's what I've come to believe about getting this relationship right.
Platform 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.
Incident Management for Small Engineering Teams: A Practical Playbook
Small teams don't need an SRE department to handle incidents well. They need clear severity levels, an on-call rota people can live with, one person in charge, and postmortems whose actions actually get done. Here's the playbook I use.
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.
One Team, Two Countries: Running UK and Offshore Engineering Without 'Us and Them'
Most offshore engineering problems aren't about talent or cost. They're about structure. Here's how I organise UK and offshore engineers into one team: ownership by domain, protected overlap hours, written decisions and fair career paths.
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.
Next.js App Router in Production: Lessons from Moving Off the Pages Router
The App Router is a different mental model, not just a new folder. Here's what I've learned running it in production on Next.js 14: Server Components, the caching defaults that surprise everyone, server actions, and how to migrate route by route.
SCA, 3D Secure 2 and Recurring Payments: An Architect's Guide for Subscription Platforms
Strong Customer Authentication changed how subscription businesses take card payments. Here's how I think about 3D Secure 2, merchant-initiated transactions, exemptions and keeping PCI DSS scope small now that v4.0 is the only version in town.
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.
Involuntary Churn: The Engineering Behind Recovering Failed Subscription Payments
Some of the customers a subscription business loses never chose to leave. Their card simply failed. I treat failed-payment recovery as an engineering system: smart retries, decline handling, card updaters and dunning, all built on idempotent, observable queues.
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.
Peak Trading Readiness: How We Prepare a Subscription Platform for Valentine's Day
For a flower subscription business, Valentine's Day is our Black Friday. Here's the readiness playbook I use: load testing, capacity planning, change freezes, kill switches, runbooks and a calm war room.
2023
5 postsHow 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.
Build vs Buy: A CTO's Framework for Platform Decisions
Every CTO faces the build vs buy decision repeatedly. After nearly two decades 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.
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 postsThe Overnight Shift to Remote: Engineering Leadership During COVID-19
In March 2020, we sent everyone home with 48 hours' notice. Nine months on, here's what we've learned about leading engineering teams through sudden, fundamental change, and what we intend to keep.
Home 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.
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, New Relic, 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've run Kubernetes on bare EC2 instances since 2017, and Amazon's managed EKS is on its way. The things we've learned self-managing Kubernetes are things managed-service users will 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
2 postsThe Developer's Guide to IPTV: What I Learned at TCS
IPTV in 2008 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.
Kannel: The Open Source SMS Gateway That Could
At Airhub in Hyderabad, I ran our bulk SMS infrastructure on Kannel: a C-based open source gateway that could handle extraordinary throughput on modest hardware. Here's what made it exceptional.
2007
1 post2006
2 postsBuilding Resilient Software with C: Enterprise Patterns for Disaster Recovery
Working on InMage's disaster recovery platform in C is teaching me lessons about reliability engineering that apply at every level of the stack, from kernel modules to web applications.
File-Based vs Volume-Based Disaster Recovery: The Fundamentals
Early in my career at InMage Systems (later acquired by Microsoft), 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.