Writing

Joining a launch two weeks out with the date immovable. Most of the work was deciding what not to build — and noticing which of the existing cuts were wrong.

Stripe holds the pricing, the subscription and the cancellation; our service listens. That hands pricing decisions back to the people who make them, and leaves exactly one new problem.

One button buys a phone number. Behind it is a sequence of steps against systems that fail occasionally, and the worst failure is the one that produces no error at all.

Nobody had specified what the support team would need. Low traffic is not the same as low stakes: one customer nobody can help is still a bad launch day.

Rewriting a provisioning server from Python to Kotlin, and cutting thousands of desk phones over to it by DNS. The rewrite was the easy half.

Removing newlines from a valid XML document took out desk phone directories across an entire handset range. The XML stayed valid; the line length did not.

Digest authentication worked fine on a single Python process. Running several instances behind a load balancer turned a local variable into a distributed systems problem.

You can abstract the transport. You cannot abstract the semantics. Notes on writing one provisioning interface across six manufacturers' firmware.

Splitting a monolith stopped any one service holding a whole directory in memory. It also made large directories slow to assemble — and the slowest client sets the limit.

Give every phone the same check-in interval and they synchronise. The obvious fix — random jitter — would have rebooted the estate on every cycle.

You cannot move a live platform to a new database in one step. Dual writes are how you make the migration boring — and most of the work is in the failure handling.

Rolling tracing and structured logging across a platform. The instrumentation was the easy half; making the output mean something took longer.

Two overlapping models had grown up for the address that determines where a 999 call is routed. Consolidating them meant deciding which one had ever been true.

Moving a phone number between providers is a regulated, document-backed handover between competitors, and the failure mode is a business losing the number on its van.

Toll fraud costs real money by the minute. The useful controls turned out to be graduated ones — risk scores that trigger verification rather than walls that block.

Building real-time calling into a mobile app means the operating system, your app and a websocket all hold an opinion about whether a call is happening. They disagree.

The little light showing whether a colleague is free looks like one bit. It is a composite of registration, call state, do-not-disturb and queue availability, delivered to every client.

Building a chat client inside a phone app over three years, and moving it from UIKit to SwiftUI in a single commit nobody scheduled.

Shipping one codebase as several branded apps through two app stores. Release is not a deployment step, it is a dependency with its own deadlines and its own opinions.

Maintaining the internal portal a company runs on. Your users sit near you, nothing is ever prioritised until it breaks, and it is the union of every other system you own.

Single sign-on assumes an identity maps to an account. In a white-label platform it often maps to four, and the login flow has to cope before the user has proved anything.

Adding granular permissions to a portal that grew up without them, and keeping the interface honest about what a user can actually do.

Building call reporting end to end. The queries are the easy part; the hard parts are recurrence, drilldowns and deciding what a number means.

Selling hardware, numbers and contract addons through partners. What you can order depends on who you are, what you already have, and how long you signed up for.

Replacing the helpdesk your support team works in, without them stopping. The migration is the easy half; turning the old one off is the part that counts.