What I do when one rule treats everyone the same.
- Home
- portfolio
- Product Management
- What I do when one rule treats everyone the same.
Fair to the platform
was not fair to the developer.
What I do
when one rule treats everyone the same.
one flat limit, two very different kinds of traffic →
A uniform rate limit built years earlier as an emergency fix protected uptime perfectly. It also throttled our best, fastest-growing customers exactly as hard as it throttled attackers, and it took a DevRel escalation for me to notice.
This is a Personal Anecdote, not a verified employer engagement. Written to show how I diagnose and structure a platform-fairness problem in Cloud/DevEx, the numbers below are original.
What I Check
A control that treats every user identically isn't fair, it's just uniform
The escalation that got my attention wasn't a page from the on-call rotation, it was a DevRel Slack thread from a developer who'd been a fan of the platform for two years and was now threatening to leave. That was the moment I stopped assuming the rate limiter was working just because uptime looked fine.
A defense built during an emergency tends to stay unquestioned long after the emergency passes, because it's quietly doing its job and nobody's incentivized to revisit it. So now, any time I inherit a uniform guardrail that's been untouched for years, I check whether it's still telling apart the people it was built to stop from the people it's now catching by accident. That's the whole practice. Everything else here is just the one time I finally ran that check.
Here's the limit that taught me to check, and the four things I built to act on it. 👀
The Case
Business problem
A flat, years-old rate limit was protecting uptime with zero incidents, while fast-growing enterprise integrators quietly churned because the same limit throttled their legitimate growth as hard as it throttled attackers.
Goals
Confirm the churn was tied to the rate limit, design a way to tell growth apart from abuse using signals already collected for security, and ship it without opening a new attack surface or adding new detection infrastructure.
The Tension
A flat rate limit stopped every attacker, and throttled our fastest-growing customers exactly as hard.
How do you protect the platform without punishing the customers doing exactly what you want them to do?
The flat per-key limit had been introduced years earlier as an emergency fix during an active abuse incident, and it worked, abuse traffic dropped to near zero overnight. Nobody had revisited it since, because it was quietly doing its job. But a rate limit that can't tell a growing legitimate customer from an attacker doesn't actually distinguish between them, it just punishes both equally, and only one of them deserved it.
I only found this because developer relations mentioned, almost in passing, that a few top-tier integrators had started building caching layers purely to dodge unpredictable throttling. That's not a security story. That's a customer building extra infrastructure to work around a system that was supposed to be helping them.
Two very different requests, one identical outcome
Different intent, different history, identical treatment the moment they hit the gate.
From One Signature to Two · how the problem statement first looked
Undifferentiated traffic · week 1
Split traffic signatures · the formal problem statement, week 2
A hunch isn't a case yet. Time to go find out if it holds up. 🔎
Research
What the data actually showed
[1] SUPPORT DATA
"Rate-limit tickets rising specifically among top-usage-tier developers, not the broad base."
[2] DEVREL FIELD NOTES
"Top integrators building caching layers purely to dodge unpredictable throttling."
[3] TRAFFIC SIGNATURE
"Abuse traffic is bursty with no auth-refresh, a signal already collected for security, unused in rate-limit decisions."
[4] COMPETITIVE SIGNAL
"A cohort of enterprise integrators began evaluating a competitor's API, citing 'unpredictable throttling' by name."
From One Signature to Two · how I thought through the data science angle
Undifferentiated traffic · week 2
Split traffic signatures · the analysis I actually ran
Illustrative, indexed for shape not scale
The anomaly detector already knew 👀
The security signal already told these two apart. The rate limiter just wasn't listening to it.
Rate-limit tickets per 1,000 keys
One tier is carrying the whole problem
Top-usage developers, exactly the ones we most want to keep, filed almost 3x the tickets of everyone else combined.
Problem statement
Uniform rate limiting can't tell a growing legitimate customer from an attacker, so it punishes the former to stop the latter.
North-star metric
Enterprise integrator retention.
Guardrail metrics
Platform incident rate, infra cost per request.
Non-goal
Rebuilding the gateway's core routing engine.
North Star, up close
- North star: enterprise integrator retention, trending into the healthy zone
- Guardrail: platform incident rate (must hold flat)
- Guardrail: infra cost per request (must not spike)
KPIs I actually tracked week to week
Enterprise integrator retention
Rate-limit support tickets
Platform incident rate
Infra cost per request
Caching-workaround traffic
Appeal-path usage
Four ways to fix it. Only one of them didn't require building something new. 🧠
Ideation & Decision
Weighing the alternatives
Raise the global limit uniformly. Reduces friction but increases abuse exposure, rejected.
Manual allow-listing for known-good keys. Doesn't scale as an ops process.
Behavior-aware tiered limiting using existing anomaly signals.Chosen Reuses signal already collected for security.
Pay-to-remove-limits SLA tier only. Effectively makes reliability pay-to-play, rejected as against platform trust principles.
From One Signature to Two · how I actually weighed this
Undifferentiated traffic · week 5
Split traffic signatures · the bubble chart I brought to the room, week 6
Scalability vs. Trust, sized by build complexity
Four options, three things that matter: does it scale, does it earn trust, and how much do we have to build? Allow-listing wins on trust alone but is an ops process, not a product, it can't scale past a few dozen keys.
The tiered model is the only option that scales AND earns trust, and once you see it on the chart, its build cost looks smaller than its bubble makes it feel.
Deciding was the easy part. Getting security comfortable exposing any of this was the real work. 🛠
Solution
What if the gate could tell growth from abuse?
Actors & Inputs
- Developers
- API gateway
- Existing anomaly signal service
- New rate-limit decision engine
System Change
- Anomaly score + tier history bucket each key
- Fast / normal / restricted lanes
- Coarse reason shown, not model internals
Outcome
- Legitimate growth stops being throttled
- Abuse still stopped cold
- One-click appeal path visible
From One Signature to Two · how I thought through the lane logic itself
Undifferentiated traffic · week 7
Split traffic signatures · the rule that actually shipped
Watch the response come back. Then toggle to see what the developer could actually do about it.
I underestimated one thing going in: security owned the anomaly signal and worried that exposing "why you were flagged" would help bad actors reverse-engineer detection. When I first proposed the dashboard, it read as a request to give away their playbook, not what I actually meant, giving legitimate developers just enough to self-correct.
Security wanted
Minimal disclosure, worried detail would help attackers reverse-engineer detection
DevRel wanted
Full transparency, developers were furious at being throttled with zero explanation
How the quarter actually went
Rate-limit ticket pattern noticed
Support tickets rising specifically among top-usage-tier developers, flagged during a routine review.
NoticedRoot cause traced to a blind flat limit, not abuse
DevRel field notes plus traffic-signature analysis confirmed these were growing customers, not attackers.
DiagnosedTiered lanes proposed, reusing the security signal
No new detection system, just a new decision made from data already being collected.
ProposedDashboard copy was too technical, simplified
Non-technical account admins couldn't parse the first version's jargon, rewritten in plain language.
AdjustedShipped across all tiers
Tiered limiting live gateway-wide; enterprise integrator churn signal dropped within the first month.
Shipped 🎉Proof
| Hypothesis | Developers who understand why they were throttled won't need workarounds and will stay. |
|---|---|
| Design | Staged rollout by usage tier, comparing rate-limit tickets and churn signal before and after. |
| Primary metric | Rate-limit support tickets, enterprise churn signal. |
| Guardrail | Platform incident rate. |
| Result | Support tickets down, churn signal down, incident rate flat. |
Shipped isn't the same as done. Here's what I'd actually keep, and what I'd do differently. 🕑
Learnings
Key takeaways
What worked
Reusing existing security signals meant no new detection system was needed, the fastest fixes reuse what already exists.
What didn't
The first dashboard copy exposed too much jargon, confusing non-technical account admins.
Next time
User-test dashboard copy with account admins before launch, not just with developers.
"Trust controls are guardrails, not speed bumps."
Principle carried forward"Build systems that make the next decision easier, the appeal path solved the trust gap, not the classification model alone."
Principle in practiceFrameworks & skills applied
Quick Answers
FAQ
Is this a real project from a specific employer?
I wrote this as a Personal Anecdote to show how I think through a platform-fairness problem in Cloud/DevEx, not to claim a specific past engagement.
Why not just raise the limit for everyone?
That reduces friction but increases abuse exposure across the board, it trades one fairness problem for a bigger security one.
Why not build a fully dynamic, ML-priced rate limit?
Too complex for a v1, and it risked feeling commercial ("pay more for more headroom") rather than protective, deliberately not built.
What would you do differently?
User-test the dashboard copy with non-technical account admins before launch, not just with the developers who file the tickets.