Authorization as a Service: When RBAC Stops Being Enough
By: Evgeny Padezhnov
Every SaaS product ships an access control system, whether the team plans for it or not. Most start with a few hardcoded roles. That version works until the product grows, and then it becomes a maintenance tax nobody signed up for.
Warrant (YC S21) launched on Hacker News as authorization and access control as a service. The founders, Aditya and Karan, built access control systems at Lyft, Yahoo, AppLovin, and Medallia before starting the company. Their pitch is simple: authorization is necessary but tangential to core product work, so it should be standardized. This article breaks down the problem they target, the models involved, and when outsourcing access control makes sense.
Why home-grown access control decays over time
The first version of access control is almost always a home-grown solution or an open source library. Teams implement role-based access control (RBAC). Roles, attributes, and authorization logic get hardcoded, or tightly coupled with business logic.
That coupling is the root problem. Authorization rules live inside controllers, service functions, and database queries. Changing who can do what means changing code. As the product adds features, the access model must change with it, and every change requires a developer.
Common mistake: treating authorization as a static feature you build once. It is not. It is a living system that evolves with the product, the org chart, and compliance requirements. Teams that hardcode roles find themselves rewriting the same logic every quarter.
Broken access control is not a cosmetic issue either. It sits at the top of the OWASP Top 10 for 2021 as the most common web application security risk. A fragile, scattered authorization layer is exactly where these bugs hide.
Key point: the cost of a home-grown system is not the initial build. It is the years of maintenance as the product's requirements outrun the original design.
The three authorization models teams move through
Most products travel the same path. They start narrow and get pushed toward more expressive models. Understanding the three common models explains why so many teams eventually look for a dedicated service.
RBAC — roles and permissions
Role-based access control maps users to roles, and roles to permissions. An admin can do everything. A member can read and write. A viewer can only read. This model is well understood and documented in the NIST RBAC standard.
RBAC is enough for early products. It breaks down when access depends on more than a coarse role. A user might be an admin of one workspace and a viewer of another. RBAC alone struggles to express that.
In plain terms: RBAC answers "what kind of user are you?" It does not answer "what can you do with this specific document?"
ABAC — attributes and rules
Attribute-based access control decides access from attributes of the user, the resource, and the context. Examples: grant access if the user's department matches the document's department, or only during business hours, or only from a corporate IP range.
ABAC is more powerful than RBAC. It is also harder to reason about. Rules multiply, and testing every combination becomes difficult. Teams that need context-aware policies reach for ABAC and then struggle to keep it maintainable.
ReBAC — relationships and fine-grained resources
Relationship-based access control, often called fine-grained or resource-based authorization, models access as relationships between subjects and objects. "User X is an editor of document Y." "Team A owns folder B, and membership in Team A grants access to everything inside B."
This model powers products like Google Docs, where sharing happens per-resource. It is expressive enough for deep hierarchies and inherited permissions. The reference design is Google's Zanzibar paper, the system behind authorization across Google's products. Warrant's model draws directly on Zanzibar's ideas.
Key point: a data analytics product, a document editor, and a CRM all end up needing fine-grained, per-resource access. RBAC cannot express it cleanly, so teams rebuild.
What Warrant provides
Warrant offers APIs and infrastructure so teams do not build any of the above from scratch. The core idea is a centralized authorization service. Applications ask a single question at runtime: is this subject allowed to perform this action on this resource?
The service stores the authorization model and the access rules. It supports RBAC, ABAC, and fine-grained relationship-based access in one system. Changing the model or the rules does not require a code deploy, because policy lives in the service rather than in application logic.
This separation is the whole point. Product code calls a check API. The authorization decision happens in a dedicated system built for that job. Business logic stops carrying authorization concerns.
Tested in production: the centralized-authz pattern is not experimental. Zanzibar has run Google-scale traffic for years, and the founders operated similar systems at Lyft, Yahoo, AppLovin, and Medallia. The pattern is proven; the product packages it for teams without that scale.
The developer experience angle
Moving policy out of code changes the workflow. A product manager or security engineer can adjust access rules without a pull request. Developers integrate once, then stop touching authorization for routine changes.
Modern teams increasingly operate infrastructure from anywhere, including managing and debugging services outside the office. If a permission change breaks a flow at 2 AM, being able to inspect and iterate quickly matters. The same shift toward flexible, remote-first tooling shows up across the stack — even in running developer tools like Claude Code from a phone or a second machine. Centralizing authorization fits that direction: one place to change, one place to audit.
The adjacent problems it folds in
Access control rarely arrives alone. Once a product needs fine-grained permissions, a cluster of related problems shows up. Warrant's pitch is that these share the same underlying machinery.
- Multi-tenancy and data isolation. Each tenant's data must stay separated. This is an authorization question at its core: does this user belong to this tenant, and can they see this row?
- Pricing tiers and entitlements. Whether a user can access a paid feature is an access decision. Entitlement checks look exactly like permission checks.
- Feature flagging. Turning a feature on for specific users, plans, or accounts is another form of conditional access.
- Audit logging. Compliance requires a record of who accessed what and when. A centralized authorization service is the natural place to capture that log.
In plain terms: multi-tenancy, entitlements, feature flags, and audit trails are all "can this subject do this thing?" questions. Solving authorization well solves a surprising amount of adjacent product surface.
The founders' argument is that only large companies historically had the resources to build a system covering all of this. Smaller teams either skipped features or accumulated technical debt. A service levels that field.
Build versus buy: how to decide
Not every team should outsource authorization. The decision depends on complexity, scale, and how central access control is to the product.
Build in-house when:
- The access model is genuinely simple and stable. Three roles that never change do not need a service.
- Authorization is a competitive differentiator you want full control over.
- Regulatory constraints forbid sending authorization data to a third party.
- The team has the headcount to own the system long-term, including on-call.
Consider a service when:
- Requirements change often, and each change currently needs a developer.
- The product is moving from RBAC toward fine-grained, per-resource access.
- Multi-tenancy, entitlements, and audit logging are all landing at once.
- Access control is consuming engineering time that should go to core features.
Common mistake: buying a service to avoid understanding your own authorization model. A service does not remove the need to design the model correctly. It removes the need to build and maintain the enforcement infrastructure. The modeling work stays with the team.
There is an honest counterpoint. A centralized authorization service adds a network call to the hot path of many requests. Latency and availability of that service become part of your product's latency and availability. Caching and local decision replicas exist to soften this, but it is a real tradeoff. Teams should measure it, not assume it away. If a check call adds meaningful tail latency to every page load, that cost has to be weighed against the maintenance savings.
If it works — it is correct. Authorization is one domain where that engineering proverb needs a caveat. A permission check that returns the right answer in testing can still leak data through an untested path. Access control demands adversarial testing, not just happy-path verification. Whether built or bought, the model needs review.
What to try right now
Audit where authorization logic currently lives in your codebase. Search for permission checks scattered across controllers, services, and queries. Grep for role names and if user.role == patterns.
Try it: count how many distinct files contain authorization decisions. If the number is large and growing, the logic is coupled and hard to change safely. That count is the clearest signal that a centralized approach — built or bought — would pay off.
Then map your current model against the three types above. If you are hardcoding roles today but already fielding requests for per-resource sharing or per-tenant isolation, you are on the RBAC-to-ReBAC path the Warrant founders describe. Planning for that shift early is cheaper than rewriting under pressure later.
The broader lesson stands independent of any single vendor. Authorization is core infrastructure, not a feature you finish. Treat it as a system that evolves with the product, keep the policy separate from business logic, and test it adversarially. Whether the enforcement engine is a service like Warrant or something built in-house, that discipline is what keeps access control from becoming the most fragile part of the stack.
The original Launch HN discussion is on Hacker News, and the product lives at warrant.dev.
Information is accurate as of the publication date. Terms, prices, and regulations may change — verify with relevant professionals.