The system ops
runs on

Before any of the interface work, the thing had to hold. Most of my first years here went into the parts nobody demos: event-driven automation in Lambda that took manual steps out of the operations day, and the backend services behind the analytics several business units now open every morning.

The one I'm proudest of is completely unglamorous. A critical API was failing ECS health checks and dragging real-time processing down with it. I took it apart and got it 75 times faster, and the health failures stopped.

Around that sits an audit logging system — Lambda, DynamoDB, PostgreSQL — that tracks data changes for compliance, and a sync service that keeps search indexing near-real-time through Lambda and Algolia.

The operations tooling had grown the way internal tools usually do — fast, in every direction, by whoever needed something that week. Parts of it were still PHP and jQuery. It was slow to use and worse to maintain, and it sat directly between the company and its customers.

I moved those modules to React and TypeScript and rebuilt the whole thing as a proper API-driven system, then moved the team across without taking anything down. Nobody had a bad shift because of the migration, which was the only acceptance criterion that really mattered.

Support conversations arrive in two shapes: recorded phone calls and chat threads. Either way, the useful part — what the customer wanted, what we told them, what happens next — was locked inside them, and CX rebuilt that context by hand every time they opened a customer.

Now it summarizes itself. AssemblyAI transcribes the call audio, Amazon Nova Lite on Bedrock writes the summary, and it lands on the customer's timeline with the recording playable right there. Agents can roll several conversations into one summary when a case drags on across calls.

It runs across roughly 6,000 calls and several thousand chats a month for about $1.60 a day. Picking a small, cheap model and keeping the prompt tight mattered more than picking a clever one.

The dashboard was carrying four UI stacks at once. Migrating it by hand would have taken most of a year, so I built the thing that does the migrating instead — a work queue, a written playbook the agent follows screen by screen, and around fifteen mechanical gates it has to get green before anything ships.

The gates are the whole idea. Accessibility, visual hierarchy, scroll and overflow behavior, conformance against the design prototype, and a scope check that fails the run outright if it touched a file it had no business touching. An agent that can't prove it stayed inside the lines doesn't get to open a pull request.

It never merges its own work — every screen goes to a human for visual review, the diff stays additive, and rolling back is a one-line route change. That's what made it something the team would accept rather than something they'd have to trust.

56 screens have gone through it. Work that used to take days a screen now takes under an hour, and because every run writes what it learned back into the playbook, the later screens came through review without an escaped UI bug.