Over 10 years we helping companies reach their financial and branding goals. Onum is a values-driven SEO agency dedicated.

LATEST NEWS
CONTACTS
What I Do When One Rule Treats Everyone the Same | Siva Balasubramanian
Personal Anecdote 04

Fair to the platform
was not fair to the developer.

04
Cloud Platform · Developer Experience · Personal Anecdote

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.

same gate, two crowds 🔍reuse > rebuild 💡quietly on fire 🔥
Personal Anecdote

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.

0
Infra engineers
0
% lift, integrator retention
0
Traffic lanes introduced
0
New detection systems built
Ch. 01 · The Check

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. 👀

Ch. 02 · The Case

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?

plot twist 🌊wait, what? 😱

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

GROWING integrator ATTACKER FLAT LIMIT THROTTLED THROTTLED

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

?why are our BEST customers building workarounds
?that's backwards

Split traffic signatures · the formal problem statement, week 2

Blind spot: Growing legitimate integrators
Root cause: One limit, two very different causes
Confirmed via tickets + DevRel pattern, not a data artifact

A hunch isn't a case yet. Time to go find out if it holds up. 🔎

Ch. 03 · The Detective Work

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

?just heavier usage
?coordinated abuse ring
?request shape tells the difference

Split traffic signatures · the analysis I actually ran

✕ Ruled out: "Just heavier usage"
✕ Ruled out: Coordinated abuse ring
Confirmed: Request shape distinguishes them cleanly
Reused existing security anomaly signal, no new detection built

Illustrative, indexed for shape not scale

The anomaly detector already knew 👀

Day 1 Day 2 Day 3 Day 4
Legitimate developer , cyclical, business hours
Attacker , bursty, no auth-refresh

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

82 28 9 Top tier Mid tier Low tier

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.

connect the dots 🔍

North Star, up close

AT RISK HEALTHY ENTERPRISE RETENTION
  • 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

+27%, improving

Rate-limit support tickets

sharply down

Platform incident rate

flat (guardrail)

Infra cost per request

flat (guardrail)

Caching-workaround traffic

disappearing

Appeal-path usage

healthy

Four ways to fix it. Only one of them didn't require building something new. 🧠

Ch. 04 · The Fork in the Road

Ideation & Decision

Weighing the alternatives

1

Raise the global limit uniformly. Reduces friction but increases abuse exposure, rejected.

2

Manual allow-listing for known-good keys. Doesn't scale as an ops process.

3

Behavior-aware tiered limiting using existing anomaly signals.Chosen Reuses signal already collected for security.

4

Pay-to-remove-limits SLA tier only. Effectively makes reliability pay-to-play, rejected as against platform trust principles.

Accepted riskA behavior-based model could occasionally misclassify an unusual-but-legitimate pattern (batch jobs). Mitigated with a visible appeal/adjustment path instead of silent throttling.
Deliberately not builtA fully dynamic, ML-priced rate limit ("pay more for more headroom"), too complex for v1 and risked feeling commercial rather than protective.

From One Signature to Two · how I actually weighed this

Undifferentiated traffic · week 5

?scalability vs trust vs effort, three axes on a napkin is hard

Split traffic signatures · the bubble chart I brought to the room, week 6

Tiered limiting (chosen): Scales, trusted, modest build
✕ Allow-listing (rejected): Trusted, doesn't scale
Bubble size = build complexity, now visible at a glance
bullseye decision 🎯mic drop 🎤
My Mental Model

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.

SCALABILITY → TRUST → 1. Raise limit 2. Allow-list 3. Tiered limits 4. Pay-to-play
Chosen Considered Rejected

Deciding was the easy part. Getting security comfortable exposing any of this was the real work. 🛠

Ch. 05 · The Build

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

?if anomaly score low and tier history good, fast lane
?if score high, restrict and explain

Split traffic signatures · the rule that actually shipped

Fast lane: Low anomaly score, clean history
Normal lane: Default, unclassified traffic
Restricted lane: High anomaly score, coarse reason shown
Owned jointly by PM + security, one-click appeal always visible

Watch the response come back. Then toggle to see what the developer could actually do about it.

POST /v2/orders → 429 Too Many Requests
⚡ 429 Too Many Requests
Rate limit exceeded. No reason given, no path forward.
✅ Normal lane · 340/500 req/min
Burst pattern flagged, not blocked
Appeal in one click

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

vs.

DevRel wanted

Full transparency, developers were furious at being throttled with zero explanation

Resolved by: coarse categories, not model internals
Instead of asking security to give up detail, I asked them to define the minimum information a legitimate developer needed to self-correct, turning "how much do we expose" into "what does self-correction actually require."How I led

How the quarter actually went

WK 1 Signal noticed WK 3 Root cause found WK 6 Lanes proposed WK 9 Copy simplified WK 12 SHIPPED 🎉
WEEK 1

Rate-limit ticket pattern noticed

Support tickets rising specifically among top-usage-tier developers, flagged during a routine review.

Noticed
WEEK 3

Root cause traced to a blind flat limit, not abuse

DevRel field notes plus traffic-signature analysis confirmed these were growing customers, not attackers.

Diagnosed
WEEK 6

Tiered lanes proposed, reusing the security signal

No new detection system, just a new decision made from data already being collected.

Proposed
WEEK 9

Dashboard copy was too technical, simplified

Non-technical account admins couldn't parse the first version's jargon, rewritten in plain language.

Adjusted
WEEK 12

Shipped across all tiers

Tiered limiting live gateway-wide; enterprise integrator churn signal dropped within the first month.

Shipped 🎉

Proof

HypothesisDevelopers who understand why they were throttled won't need workarounds and will stay.
DesignStaged rollout by usage tier, comparing rate-limit tickets and churn signal before and after.
Primary metricRate-limit support tickets, enterprise churn signal.
GuardrailPlatform incident rate.
Result Support tickets down, churn signal down, incident rate flat.
Behavior-aware rate limit
Fewer legitimate developers build workarounds
Higher trust in platform reliability
Lower enterprise integrator churn

Shipped isn't the same as done. Here's what I'd actually keep, and what I'd do differently. 🕑

Ch. 06 · The Rear-View

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.

real talk 💬lesson locked in 🔒

"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 practice

Frameworks & skills applied

Platform trust & fairness design Signal reuse over rebuild Cross-functional alignment (security) Staged rollout & guardrail metrics Developer experience Scalability vs. trust trade-offs Platform trust & fairness design Signal reuse over rebuild Cross-functional alignment (security) Staged rollout & guardrail metrics Developer experience Scalability vs. trust trade-offs
Ch. 07 · The Fine Print

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.

Turning ambiguous platform problems into fair, scalable systems.

Say hi →