The Flux Method

The 10-Vendor Problem

Pick any production SaaS app. Peel back the surface and you’ll find the same stack: Auth0 for authentication, Stripe for billing, LaunchDarkly for feature flags, Datadog for observability, and then a sprawl of hand-rolled systems patching the gaps between them. Add a secrets manager, a rate limiter, an API key service, a job queue. You’re at ten vendors before lunch.

This isn’t anyone’s fault. The vendor ecosystem evolved to solve individual problems well. Auth0 is excellent at auth. LaunchDarkly is excellent at flags. Stripe is excellent at payments. The problem isn’t any single vendor — it’s what happens when you glue them together.

Configuration sprawl. Ten dashboards. Ten API keys rotating on ten different schedules. Ten billing relationships, ten support contacts, ten sets of docs. Your team spends more time administering tools than building product.

Glue code. Hundreds of lines of middleware connecting systems that were never designed to talk to each other. Sync user billing status to your auth provider. Propagate plan tiers to your flag evaluations. Map API keys to rate limit buckets. None of this is your product — it’s plumbing, written by hand, owned by nobody, and tested last.

Inconsistent tenant context. Your auth provider doesn’t know what billing tier a user is on. Your feature flag system doesn’t know which tenant is making the request. Your rate limiter doesn’t know whether the calling API key belongs to a free user or an enterprise account. Every cross-cutting concern requires a round-trip to collect context that should already be there.

The Entitlements Gap

There’s one question every SaaS app answers thousands of times per second: can this user on this plan use this feature at this rate?

Today, answering it requires four separate API calls: one to verify identity, one to check billing status, one to evaluate the feature flag, one to check the rate limit. Four network hops, four failure modes, four places to be inconsistent. And even after all of that, the answer might be wrong — because the user’s billing status in vendor A doesn’t automatically propagate to vendor B.

This is the entitlements gap. It’s not a missing feature in any single tool. It’s the gap between tools — the space where your business logic lives, written in glue code, invisible until it breaks.

Flux closes this gap. Auth, billing, flags, and rate limits are a single system with a single source of truth for tenant context. The question “can this user do this?” is one call, with one answer, in under a millisecond.

Our Principles

1. Everything connects by default. Auth knows billing. Flags know tenants. Rate limits know API keys. When a user authenticates, their plan tier is already available. When you evaluate a feature flag, tenant context is already there. No glue code. No sync jobs. No eventual consistency between systems that should be consistent.

2. Invisible when working, obvious when not. Good infrastructure disappears. You don’t notice your database when queries are fast; you notice it when they’re slow. Flux should work the same way — you notice it when something’s wrong, never when it’s working. We measure success partly by how rarely our customers think about us.

3. Convention over configuration. Sane defaults cover 90% of SaaS apps. A standard multi-tenant auth model, a usage-based billing structure, per-plan feature gating, per-key rate limiting — these patterns are well-understood. Flux ships them out of the box. For the other 10%, every convention has an escape hatch.

4. Built for Rust, available everywhere. Rust powers the engine. No garbage collector pauses. No cold start penalties. No unpredictable latency spikes in the hot path. But Flux isn’t a Rust-only product — SDKs exist for every major language and framework. You get the performance benefits regardless of what you’re building in.

5. Fewer tools, less complexity. Every vendor you remove is a dashboard you don’t check, a bill you don’t pay, an on-call rotation you don’t page, and an integration you don’t maintain. Simplicity compounds. Five tools that talk to each other are dramatically simpler than ten tools that don’t.

The Result

One import. One dashboard. One bill.

You get auth with built-in SSO, MFA, and SCIM. Billing with entitlements that your flags and rate limiters already understand. Feature flags with per-tenant overrides and gradual rollouts. Observability with tenant-aware traces and metrics. API key management with usage tracking and per-key rate limits. All of it connected, all of it coherent.

Your app is enterprise-ready — SOC 2 controls, SCIM provisioning, RBAC, audit logs — and you didn’t hire a platform team to build it.

That’s the method. Not because it’s easy to build (it isn’t), but because it’s the right way for teams that would rather ship product than maintain infrastructure.