Built so nothing depends on us.

Ratelane enforces policy — rate limits, route rules, CORS — from a copy cached on your own infrastructure, refreshed continuously in the background on a short interval. There is no live network call to Ratelane anywhere in your request path. Every enforcement decision is made locally, using whatever policy was last successfully synced.

This means your API's request-handling latency and reliability are never coupled to a round-trip to us. If a sync cycle is delayed or fails, enforcement continues exactly as before, on the last known-safe policy — and if a customer has configured an Emergency Profile, that fallback activates automatically once the sync gap passes a configurable threshold, then reverts automatically once syncing resumes.

Every connection between your infrastructure and Ratelane — policy sync, telemetry submission, and dashboard access alike — runs over TLS. Nothing is ever transmitted in plaintext, in either direction.

API keys issued to your account are hashed before they're stored — the plaintext value is never written to our database or logs. A key is only ever shown to you once, at creation. If our storage were ever compromised, an attacker would not walk away with usable credentials.

The middleware installed in your application is scoped narrowly to what it needs to do: enforce policy and report coarse telemetry. It doesn't execute arbitrary code sent from our side, and it doesn't request broad access to your infrastructure. The design goal throughout has been to keep the footprint as close to nothing as the job allows.

Ratelane is a multi-tenant platform, and every policy, instance record, and telemetry event is scoped strictly to its owning account at the data layer — not merely gated behind an application-level permission check. There is no code path in the product that reads across account boundaries.

Ratelane never touches your request or response data. The only information that leaves your infrastructure is route-level telemetry: which endpoint was called, how long it took, and what status code came back. Request bodies, response bodies, headers, and query parameters are never read, logged, or transmitted, and it never adds latency to a live request, however it's delivered.

Telemetry and log data are retained according to your plan's retention window and are deleted automatically once that window passes — we don't keep historical data indefinitely by default.

Administrative interfaces and internal tooling are not publicly exposed by default, and access to production systems is limited to what's operationally necessary. Credentials and secrets used by our own infrastructure are managed outside of application code and are not committed to source control.

We take routine backups of account and policy data as part of normal operational practice, so that a hardware or operational failure on our side doesn't translate into data loss on yours.

Ratelane is a young platform, and we want to be direct about where our security program stands today rather than overstate it. We have not pursued formal third-party certifications such as SOC 2 or ISO 27001 at this stage. What we do have is an architecture that minimizes what could go wrong in the first place — isolation, encryption, and minimal data collection are structural properties of the system, not add-on policies.

As Ratelane grows, we expect to invest in formal compliance certifications and a more extensive security program. If your organization has specific requirements — a security questionnaire, a data processing agreement, or something else — reach out and we'll work through it directly.