Panagiotis Siatras

Methodology

I identify the debt, understand how it builds up and where it comes from, and then split it into pay-once, distinct components that stay out of each other's way. In other words: where there are no foundations, I will them into existence.

0 · Foundations

Buy the rails, once

Most of what systems pay for, again and again, is found below their function. Their parts almost always end up solving the same things (lifecycle, telemetry, data access, the contracts between them) over and over, each in its own way, and every new way adds friction and piles onto the debt.

I shape these concerns into reusable, well-documented components, deleting any layer that serves no purpose along the way.

Where components meet, I split where one side has no reason to know about the other, and turn what crosses the line into one common shape at the edge. Each side can then scale, and be rewritten, on its own.

What's left are rails that engineers and LLMs build on rather than around. From then on, systems grow only in what they need to do, not in how they go about doing it.

A tailored application framework I delivered, now on its fifth major version, runs tens of Go services. My fleet platform rework left Rails blind to the hardware underneath it.

1 · Identify

See the platform in its entirety

I work to understand the whole platform, not individual services, because debt rarely lives in one place. Before deciding what to pull out, I trace where it builds up and why.

Thirty Go services exported nothing past stock Kubernetes metrics. Instead of instrumenting them one by one, I changed how they get built, baking telemetry into their foundations.

2 · Measure

Measure the baselines

Before changing anything, I instrument what exists, so napkin math isn't the only source of data. Every change is then measured against these baselines, to see whether it paid off.

In my TypeScript to Go port, each service first went out as a passthrough proxy that gave it its first metrics and traces.

3 · Iterate

Batches building to a whole

I deliver work in digestible batches, preferably starting with prototypes teams can pull apart rather than whiteboards to argue over. Each batch is self-contained, bringing along whatever tooling and platform-wide changes it needs.

These batches are cornerstones. Once enough of them are in place, the foundations become visible and measurable, seemingly out of nowhere. The system gets easier to see into, harder to break, by engineers and LLMs alike, and faster to shape. New debt shows up early, while it's still cheap to pay off.

The tenant cache started as a prototype the team went through over a few technical sessions. It went on to peak at 300k requests per second on two vCPUs.

4 · Cutover

Stealth rollouts

I roll out my work behind whatever it takes (proxies, flags, and so on), so consumers notice nothing but the benefits. Few plans survive contact with production, though, so every rollout ships with its rollback at the ready.

The fleet platform cut over without taking a single vehicle off the street, and the callers of the TypeScript services never knew they had been ported to Go.

If you're shopping for the kind of foundational work I do, drop me a line at [email protected].