September 14, 2026 - 6 min read

Why growing platforms end up with no real authentication strategy

An engineer's field notes on why growing platforms lose track of authentication — and the order in which to actually fix it.

Why growing platforms end up with no real authentication strategy

The problem with "it works"

I've reviewed enough multi-service platforms now to notice a pattern: the ones that get authentication wrong almost never get it wrong on purpose. Every individual decision, taken by itself, looks reasonable. A new internal service doesn't need auth because "only other services call it." An API key gets stored as-is because hashing it felt like overkill for an MVP. A role check gets written inline because there wasn't a shared library yet. None of these choices is a mistake in isolation. Stack a dozen of them across services built over a couple of years, and you get a platform that never actually had an authentication strategy — just a pile of local ones that happen to coexist.

That's the part worth sitting with before I get into what I actually found, because the specifics change every time but the pattern doesn't. If you run more than two or three services behind a shared product, I'd bet nobody in your company can currently draw the complete authentication picture on a whiteboard — every service, every key, every role, in one place. Not because anyone was careless. Because it was never anyone's job.

What I actually found

I recently spent a few days going through the authentication layer of a platform built from several backend services sitting behind a shared entry point. I wasn't there to hunt for problems — I was reviewing the architecture — and, as usually happens once you actually trace how the pieces call each other instead of trusting the diagrams, the gaps showed up on their own.

Roughly in order of how much each one worried me:

  • A key-creation endpoint that let a caller mint privileges above what it should have had. This is the one that keeps me up at night — a privilege escalation path isn't a "nice to fix," it's a today item.
  • API keys stored as plain text in the key-value store behind the platform. Not encrypted, not hashed, just sitting there, readable by anyone with access to that store.
  • Role and permission logic reimplemented independently in every service, with no shared source of truth for what a given key was actually allowed to do.
  • No rate limiting anywhere in the request path.
  • A handful of services reachable directly from outside, with zero authentication, protected only by the fact that nobody had guessed the URL yet.

What actually struck me wasn't any single item on that list — it was that the platform had been running fine the entire time it accumulated all of them. No incidents, no complaints, no dashboard turning red. "It works" and "it's secure" get answered by completely different instruments, and most teams I've worked with only built instruments for the first one.

Fix the bleeding before you fix the architecture

When you hand someone a list like that, the instinct is to want to rebuild the whole authentication layer immediately. Resist that. A privilege escalation path and a missing gateway are not the same size of problem, and treating them the same way means the actual emergency waits behind a redesign that will take months.

Here's the order I'd actually work in.

This week. Close the privilege escalation — it doesn't go on a backlog. Hash every key at rest the same way you'd hash a password; it costs almost nothing and turns a leaked database dump from "a set of working credentials" into noise. Rotate anything that was ever stored in plaintext, because "probably nobody read it" isn't a control. And put rate limiting on whatever entry point already exists, even something crude — it buys you time against the open endpoints you haven't found yet.

This quarter. Go find every service reachable from outside your cluster and check, for each one, whether "internal" is actually enforced or just assumed. I've seen this exact assumption break more than once: someone builds a service that's "only called by other services," which is true right up until someone points a browser at the URL directly and it just answers. This is also where I'd start replacing static, long-lived API keys with short-lived tokens for anything that's really just a login or a session — we do this in our own finance tooling: instead of a permanent key sitting in a config file waiting to be leaked, the caller gets a token that expires on its own, so a leak becomes a bounded problem instead of an open-ended one. And put role logic in one place. Five services with five slightly different implementations of "can this key do X" isn't a design, it's an accident waiting for someone to notice the fifth implementation was wrong.

If it's worth it, over the following months. Decide on purpose whether you actually need a unified gateway in front of everything, owning authentication once instead of five times. Kong, Envoy, whatever fits your stack — the point isn't the product, it's that "does this request carry a valid identity" becomes a question answered in exactly one place. For anything a human logs into, move toward single sign-on against one identity provider instead of every app rolling its own login screen and session logic — we built our own invoicing tool, territorial-invoices, this way: one login, one identity source, every downstream service trusting the same signed session instead of reinventing "who is this." For service-to-service traffic, look at mutual TLS or a service mesh, and swap the general-purpose key-value store for an actual secrets manager with automatic rotation — Vault, or your cloud provider's equivalent. None of this is exotic. It's the standard answer the rest of the industry landed on once "every service manages its own secrets" stopped being sustainable for anyone.

Why I don't think this is a checklist problem

I want to push back a little on my own advice here. It's tempting to read the above as a checklist and feel done once every box is ticked. I don't think that's the real fix. The real fix is having someone whose job includes asking "does this still hold together" every time a new service gets added — because the next service will make its own locally reasonable decision too, and without someone owning the whole picture, you're back to square one in eighteen months.

That person doesn't need to be a dedicated security hire on every team. It just needs to be whoever owns the platform architecture treating authentication as part of that architecture, not as a per-service implementation detail figured out by whoever happens to be building this week.

What this is worth knowing before someone else finds it

None of what I found was visible from outside. The platform served traffic every day without interruption the entire time it accumulated these gaps, which is exactly why nobody had looked. That's the uncomfortable part of this kind of work — a system can run cleanly for a long time on an authentication model with real holes in it, because uptime and security get measured with different instruments, and most teams only ever built the first one.

If nobody at your company could draw that whiteboard picture — every service, every key, every role, in one place — that's worth finding out on your own terms. It's the kind of review we do as its own piece of work, separate from any build: not to rewrite what's working, but to tell you exactly where the gaps are and which ones actually need fixing first. If that's a question you've been putting off, I'm happy to talk about it.

Keep reading