The service that finally convinced me we needed a platform team was a payment reconciliation job that only one engineer knew how to deploy. When he went on paternity leave, we discovered the deploy involved SSH-ing into a box, running a shell script nobody had read in eighteen months, and manually clearing a Redis key if the script hung. It hung about a third of the time. That is not a deployment process. That is a hostage situation.
An internal developer platform, or IDP, is the answer to a specific problem: your engineers spend too much of their day fighting the machinery around their code instead of writing the code. In a regulated fintech shop that machinery is heavier than most, because every path to production has to carry audit trails, access controls, and change approvals. The platform's whole job is to make the paved road so much easier than the dirt track that nobody bothers with the dirt track anymore.
What a platform actually is, and what it isn't
Let me be blunt about a confusion I see constantly. A platform is not a Kubernetes cluster. It is not your CI pipeline. It is not a wiki page with forty runbooks. Those are ingredients. A platform is the thing that takes an engineer from "I have a new service idea" to "it is running in production, with logging, metrics, secrets, and a database, and I did not file a single ticket" — and does it in an afternoon rather than three weeks.
The test I use is simple. Can a mid-level engineer who joined last month ship a new service to production without asking anyone how? If the answer involves Slack-messaging the DevOps channel and waiting, you have infrastructure, not a platform. The difference is self-service. Everything else is detail.
I am also going to say something unpopular: most companies your size do not need to build one from scratch. If you have fewer than thirty engineers, the platform is probably a well-configured Heroku-style PaaS plus some conventions in a template repo. Building your own control plane before you feel the pain is the most expensive way I know to feel clever.
Design the golden path first
The single most useful artifact we produced was not a tool. It was a document called "the golden path" — one opinionated, blessed way to build a service at our company. .NET 8, PostgreSQL, our standard auth library, structured logging to the same sink, deployed the same way. Boring on purpose. When you standardize the ninety percent case, you free up real attention for the ten percent that is genuinely different.
Engineers push back on this. Good ones especially, because they have opinions and those opinions are often correct. My answer is that the golden path is a default, not a prison. You can leave it. But if you leave it, you own the parts you diverge on, and you write down why. That single rule killed most of the pointless divergence. People will happily accept a decent default when the alternative is maintaining their own snowflake forever.
The goal of a golden path is not to stop people from thinking. It is to stop them from thinking about the same solved problems every single time they start something new.
Self-service, or it doesn't count
The moment a platform requires a human in the loop for a routine action, it stops being a platform and becomes a bottleneck with a nicer logo. Provisioning a database, rotating a secret, spinning up a preview environment, adding a new service to the mesh — all of these have to be things an engineer does directly, guarded by policy rather than by a person's calendar.
We had a period where "provision a new Postgres instance" meant a Jira ticket to the infra team, which took on average four days. Four days to get a database. Engineers responded exactly how you would expect: they crammed new tables into whatever database was already there, because that was instant. We ended up with a single shared database holding eleven services' worth of tables, which is its own special horror when you need to reason about blast radius. Self-service provisioning did not just save time. It fixed an architectural rot that the ticket queue was actively causing.
A concrete slice of the paved road
Here is roughly what "create a new service" looks like from the engineer's side once the platform exists. One command, a few answers, and the scaffolding, pipeline, and infrastructure descriptors are generated and wired up.
// platform CLI: scaffold a compliant service in one step
public async Task<int> CreateServiceAsync(ServiceRequest req)
{
// 1. Generate repo from the golden-path template
var repo = await _templates.RenderAsync("dotnet-service", new
{
Name = req.Name,
Team = req.OwningTeam,
DataClass = req.DataClassification // drives encryption & retention
});
// 2. Provision backing store with tags the auditors expect
if (req.NeedsDatabase)
await _infra.ProvisionPostgresAsync(req.Name, tags: new[]
{
$"owner:{req.OwningTeam}",
$"pci:{req.DataClassification == DataClass.Cardholder}"
});
// 3. Register in the catalog so on-call & ownership are never unknown
await _catalog.RegisterAsync(repo.Slug, req.OwningTeam);
return repo.PullRequestNumber; // engineer reviews, merges, ships
}
Notice what is baked in. The data classification the engineer picks drives encryption and retention automatically. The PCI tag is set from the same answer, so nobody has to remember to flag it later — which is exactly the kind of thing that gets forgotten right up until an audit. The service is registered for ownership before it exists, so we never end up with a running process nobody claims at 3am.
Enjoying this article?
Get more like it in your inbox — practical engineering leadership, fintech, and AI. No spam, unsubscribe anytime.
Treat the platform as a product, with real users
The platform teams that fail treat the platform as infrastructure to be maintained. The ones that succeed treat it as a product with internal customers who can, and will, route around it. Your users are your own engineers, and they are the most demanding, most opinionated users you will ever serve. They will find every rough edge and they will complain about it in the exact channel you read most.
So we ran it like a product. We had a backlog prioritized by how much time a fix saved across the org, not by what was interesting to build. We did quarterly surveys and, more usefully, we tracked adoption. If a capability we shipped had three users after two months, that was a signal we built the wrong thing or explained it badly, and we treated it as a defect rather than blaming people for not reading the docs.
A few things we measured, and actually looked at:
- Time from empty repo to first successful production deploy — our north star, dragged from around eleven days to under one.
- Percentage of services on the current golden-path template versus drifting old versions.
- How many deploys per week happened without any platform-team involvement — the pure self-service rate.
- Change-failure rate, because a faster paved road that ships more incidents is not progress, it is just faster regret.
Bake compliance in, don't bolt it on
This is where fintech platforms earn their keep. In a regulated environment, controls are not optional and they will be examined by people whose job is to find gaps. The lazy approach is to make compliance a gate at the end — a review, a checklist, a sign-off. That approach guarantees that engineers see compliance as the enemy, because it shows up only to say no.
The better approach is to encode the controls in the paved road itself, so that doing the easy thing is also doing the compliant thing. Segregation of duties enforced by the pipeline, so the person who wrote the change cannot be the sole approver. Secrets that can only come from the vault, never from an environment file. Audit logs emitted by the platform automatically rather than remembered by each team. When I sat down with an auditor and could show that our deployment control was code, version-controlled, and identical for every service, the conversation went from a two-week evidence hunt to an afternoon. That was worth more than any single feature we shipped.
The team, and the trap of the ivory tower
You need a small, senior team that has actually operated services in production and felt the pain personally. Platform work done by people who have never been paged is theoretical, and it shows. It produces elegant abstractions that solve problems nobody has while ignoring the grubby ones everybody has.
The trap, and I have fallen into it, is the platform team disappearing into an ivory tower and emerging six months later with a beautiful thing that solves last year's problem. The cure is embedding. For a stretch, I had each platform engineer spend one day a week working inside a product team, shipping a real feature using the platform they built. Nothing sharpens your priorities like being forced to use your own tools under a deadline. Half our best improvements came from a platform engineer swearing at their own creation on a Thursday afternoon.
Buy the boring parts, build the parts that are you
Do not build a CI system. Do not build a secrets manager. Do not build an observability backend. These are commodity, they are done better by companies whose entire business is that one thing, and every hour you spend maintaining your own is an hour stolen from the work only you can do. I have watched a talented team pour a year into a homegrown deployment tool that was, at best, a worse version of something they could have bought for the price of one of their salaries.
What you build is the connective tissue — the specific way these bought pieces snap together to reflect how your company works, your compliance posture, your service catalog, your golden path. That glue is genuinely yours and no vendor sells it, because it encodes decisions only you can make. Get religious about that line. Everything commodity, buy or adopt open source. Everything that encodes your particular judgment, own it.

Start by watching, not building
If I were starting again tomorrow, I would resist the urge to build anything for the first two months. I would sit with three engineers and watch them ship a service end to end, writing down every moment they had to stop and ask someone or wait on a queue. That list, ranked by how much collective time each item burns, is your roadmap. It will be more honest than any architecture diagram, and it will point at unglamorous work — a database that takes four days to get, a deploy only one person understands — rather than the shiny control plane you were itching to build. Build the platform your engineers are already begging for with their frustration, not the one you want to put on a conference slide. The frustrated ones are telling you the truth for free.
Get new posts in your inbox
Occasional, practical notes on engineering leadership, fintech, and building with AI. No spam, unsubscribe anytime.
Comments (0)
Leave a Comment
No comments yet. Be the first to comment!
