Reasons Why You Should Already Be Using Crate

Most companies treat their API gateway like a fixed cost — slow, expensive, and invisible until something breaks.

Crate is built on the opposite premise: the gateway should be the fastest, cheapest, most observable layer in your stack, not the most painful one.

Here’s what that looks like in practice.

1. Performance you can actually measure

Modern cloud gateways are slow because they’re stacked: VMs inside orchestrators inside shared VPCs. Every hop adds latency.

Crate runs compiled Go binaries directly on bare metal hardware with a zero-copy routing engine. Requests are inspected and forwarded without buffering entire bodies, which keeps memory footprint low even under heavy file-transfer load.

Outcome for your team:

• Sub-millisecond gateway overhead
• Predictable tail latency
• Headroom that doesn’t evaporate under bursts

2. A decoupled control plane that doesn’t take your API down with it

The Crate Gateway is stateless and fails open. Configuration lives in a separate control plane backed by CockroachDB, and every gateway node caches the routes, rules, and certificates it needs to run autonomously.

If the dashboard, billing API, or control plane is ever offline, your traffic keeps flowing. That’s an architectural guarantee, not an SLA promise.

3. SSL that installs itself

Crate implements a custom ACME flow with Let’s Encrypt:

• The gateway hijacks /.well-known/acme-challenge/ on port 80
• Challenges are tunneled to the control plane
• Once issued, certificates are broadcast to every gateway node

Point a domain at Crate, and you get a green lock in under 60 seconds. Renewals, strict TLS versions, and modern cipher suites are handled for you.

4. Rate limiting that actually limits

Per-node rate limits are approximations. At scale, they leak.

Crate uses atomic Redis Lua “check-and-increment” scripts to enforce limits globally across the cluster. If you set 1,000 req/sec, you get 1,000 req/sec — not “roughly that times however many nodes are live.”

This turns rate limiting from a best-effort feature into a real backend protection mechanism.

5. A plugin pipeline at the edge

A lot of logic that lives in your backend doesn’t belong there. Crate’s plugin engine handles it at the gateway:

• JSONata request/response transforms
• CORS
• API key validation
• IP allow/deny
• Payload size limits
• Mock responses

Plugins can be authored, simulated, attached, and reordered on domains and rules without redeploying backends. That shortens the distance between “we need to change X” and “X is live.”

6. Hot-swapped config with version history

Routing rules and certificates are loaded directly into gateway RAM. When you update a rule, the gateway updates its internal map instantly via a Redis broadcast — no restarts, no dropped connections.

Equally important: every change is versioned. Configs can be exported, imported, and rolled back. Regressions become reversible instead of incidents.

7. AI Shield for the bandwidth-draining bots

LLM scrapers are the new DDoS — they’re polite, persistent, and expensive. Crate includes a per-domain AI Shield to block them at the edge, before they hit your origin or your bill.

8. Bandwidth pricing, not per-request pricing

Most gateways tax efficient architectures. IoT heartbeats, polling clients, and high-frequency services get punished with per-request fees that have nothing to do with infrastructure cost.

Crate’s model:

• No per-request fees. Send 100 requests or 100 million — if they fit your tier, the price is the same.
• Bandwidth-based tiers. You pay for the pipe, not the packets.
• $0.01/GB overage. No throttling, no error pages, no outage for being successful.
• Throughput = ingress + egress, billed transparently.

For teams on serverless, this doubles as a financial firewall: you can cap, filter, and hybrid-route traffic before it blows up a cloud bill.

9. Multi-tenant governance without a detour

Crate ships the organizational layer most teams eventually have to build themselves:

• Organizations, invites, and roles
• Personal API keys for automation
• Audit logs of control-plane actions
• Alert rules and notifications
• A usage dashboard with requests, latency, error rate, bandwidth, and top routes

The result is a gateway you can hand to a team — not just an operator.

The takeaway

If your current gateway is slow, costs scale with request count, or disappears when the vendor’s dashboard hiccups, that’s not the state of the art. That’s just what you’ve been paying for.

Crate is the version where:

• Performance is a hardware decision, not a pricing tier
• Reliability is architectural, not contractual
• Cost tracks bandwidth, not behavior

That’s why teams that try it tend to stop comparing.

Launch the console at app.crate.cc.