Skip to content
Engineering deep-divesAll articles

OpenFGA vs SpiceDB in 2026: ReBAC, Zanzibar & PG17 RLS TCO

Engineering and 36-month TCO teardown of OpenFGA vs SpiceDB alongside Cerbos and Permit.io in 2026: Google Zanzibar NewEnemy consistency, 50k-row ListObjects SQL joins, and PostgreSQL 17 FORCE RLS materialized ReBAC.

Artem Zaitsev
Artem ZaitsevCTO · Idealogic
Author: Artem ZaitsevPublished: Updated: Reading time: 18 minHow we write →
On this page
Idealogic 2026 engineering comparison of OpenFGA vs SpiceDB, Cerbos, and Permit.io covering Google Zanzibar ZedTokens, ListObjects reverse-index SQL joins, PostgreSQL 17 FORCE RLS, and 36-month TCO

The OpenFGA vs SpiceDB question (or SpiceDB vs OpenFGA, depending on who asks) usually comes up when flat admin / editor / viewer flags stop being enough, often next to Cerbos vs Permit.io. Enterprise buyers want nested folders, inherited teams, guest shares, clinical overrides, and temporary support access. Coarse RBAC can't express those without piling LEFT JOIN checks into every controller, so fine grained authorization becomes an architecture decision.

OpenFGA and SpiceDB are open-source Zanzibar-style authorization engines. Both store relationship tuples and answer "can user X do Y on object Z". SpiceDB adds ZedToken consistency control, while OpenFGA is the CNCF Incubating project behind Auth0 FGA.

Clerk vs Auth0 and WorkOS vs Auth0 cover authentication (AuthN) and SAML/SCIM. Relationship-Based Access Control (ReBAC), modeled on Google's Zanzibar paper, covers object access (AuthZ). Zanzibar authorization was designed for many datacenters and many storage systems. Run it next to a single-database SaaS and you take on two costs: dual-write outbox lag, and the ListObjects SQL join bottleneck on 50,000-row tables.

At Idealogic, our SaaS development, custom software development, JavaScript development, and product development squads build authorization engines across fintech and healthtech. This teardown compares OpenFGA, SpiceDB, Cerbos, and Permit.io, then an owned PostgreSQL 17 FORCE RLS engine with a materialized ReBAC closure, and ends with a worked 36-month TCO model at 80M checks and 5M feed queries a month. Vendor prices were checked in November 2026.

The short version

  • SpiceDB wins causal consistency (ZedToken); OpenFGA wins CNCF & Auth0 ergonomics: SpiceDB (Apache-2.0) implements Zanzibar zookie-style ZedTokens to avoid the New Enemy Problem. Managed options are AuthZed Cloud (from $2/hr, resource-based) and Dedicated Cloud. OpenFGA (Apache-2.0, CNCF Incubating since January 2026) powers Okta Auth0 FGA with readable DSL/JSON models. It has no revision token, so you choose per request between MINIMIZE_LATENCY and HIGHER_CONSISTENCY.
  • Cerbos & Permit.io solve a neighboring problem: Cerbos (Apache-2.0 stateless PDP + Cerbos Hub at $25 Dev / $933/mo Production including the first 5,000 Monthly Active Principals) runs local YAML/CEL ABAC and stores no tuple graph. Permit.io (free Community tier to 1,000 MAU, Startup to 25K MAU, then Pro and Enterprise) puts policy UIs over OPA and Cedar.
  • Watch the 50,000-row ListObjects join trap: A point check over gRPC is quick, typically low single-digit milliseconds. Paginating ORDER BY created_at DESC LIMIT 50 across 50,000 permitted rows is the slow part, because the permission set and the SQL index live in different systems.
  • At 80M checks + 5M feed queries/mo, owned PG17 ReBAC saves $32.1k to $153.6k in our model: Over 36 months with SOC 2 + HIPAA BAA controls, an owned PG17 FORCE RLS closure engine comes to $73,800 at CEE rates. OSS on EKS lands at $105,900, Auth0 FGA / Permit Enterprise at $200,700, and AuthZed Dedicated at $227,400. The managed monthly fees are our assumptions, since neither vendor publishes enterprise prices.

2026 engine internals: OpenFGA vs SpiceDB vs Cerbos vs Permit.io

Three things decide which authorization engine fits: the consistency you need after a revocation, how many databases your data lives in, and whether your traffic is point Check calls or paginated ListObjects joins.

Four architectural and TCO boundaries separating OpenFGA, SpiceDB, Cerbos, Permit.io, and an owned PostgreSQL 17 materialized ReBAC engine in 2026

OpenFGA vs SpiceDB at a glance

SpiceDBOpenFGA
LicenseApache-2.0Apache-2.0
GovernanceAuthZedCNCF Incubating (donated by Auth0/Okta)
Consistency controlZedToken plus at_least_as_fresh, at_exact_snapshot, fully_consistent, minimize_latencyMINIMIZE_LATENCY or HIGHER_CONSISTENCY per request, no revision token
DatastoresCockroachDB, Spanner, PostgreSQL, MySQLPostgreSQL, MySQL, SQLite
Managed offeringAuthZed Cloud, Dedicated CloudOkta Auth0 FGA
Conditions languageCEL CaveatsCEL Conditions

1. SpiceDB (authzed.com): .zed schemas, CEL Caveats & ZedToken fencing

Built by AuthZed under Apache-2.0, SpiceDB closely tracks Google's Zanzibar design:

  1. Causal ZedToken consistency: Say an admin revokes Dr. Smith's access to chart:991 at t=1 and adds confidential notes at t=2. A cache still serving the t=0 graph would leak the t=2 notes. That's the New Enemy Problem from the Zanzibar paper, which solves it with tokens it calls zookies. SpiceDB returns a ZedToken on every write. Store it on chart:991, pass at_least_as_fresh(token) on the next check, and SpiceDB evaluates against a snapshot at least as new as that write.
  2. Consistent-hash dispatch & CEL Caveats: SpiceDB routes graph sub-problems across K8s pods via consistent hashing, so repeated sub-checks land on a pod that already cached them. Google CEL Caveats evaluate runtime ABAC rules (ip_cidr, time_window, approval_limit) on tuple edges.
  3. AuthZed pricing: The pricing page lists self-service AuthZed Cloud from $2/hr, resource-based, which is about $1,460/mo if it runs continuously. Dedicated Cloud is priced on reserved vCPU capacity and adds isolated VPC peering, HA CockroachDB, and BAAs. AuthZed doesn't publish a Dedicated number. We budget $4,500 to $8,000+/mo for it as a modelling assumption.

2. OpenFGA (openfga.dev & Auth0 FGA): CNCF ecosystem & consistency trade-offs

Donated by Auth0/Okta as a CNCF Incubating Apache-2.0 project, OpenFGA (github.com/openfga/openfga) runs a Go binary over PostgreSQL, MySQL, or SQLite:

  1. Readable DSL + JSON & CEL Conditions: Modular schemas (define viewer: [user, group#member] or editor from parent_folder) and CEL Conditions plug cleanly into TypeScript CI/CD and Okta Auth0 FGA docs.
  2. No ZedToken equivalent: OpenFGA doesn't expose a ZedToken-style revision token on Check calls. You pick a consistency mode per request instead: cached MINIMIZE_LATENCY reads, which can be briefly stale after a revocation, or uncached HIGHER_CONSISTENCY reads that hit the database.
  3. Commercial Auth0 FGA: The managed service is built on OpenFGA. It comes with a free developer tier and custom Okta Enterprise contracts, and the Enterprise rates aren't public.

3. Cerbos vs Permit.io & the 50,000-Row ListObjects Join Bottleneck

  • Cerbos vs Permit.io: Cerbos runs a stateless Go PDP sidecar that evaluates YAML/CEL policies locally, with no network hop to a central service, and its PlanResources call emits SQL AST filters. Cerbos Hub has a free tier, $25/mo Dev, $933/mo Production including the first 5,000 MAPs, and custom Enterprise. Permit.io (Community free to 1,000 MAU, Startup to 25K MAU, Pro to 50K, Enterprise) puts visual RBAC/ReBAC editors over OPA and Cedar and syncs them with OPAL.
  • Why external ReBAC stalls on SQL pagination: On GET /loans?status=underwriting&order=created_at.desc&limit=50 across 50,000 workspace rows, external gRPC engines either stream 50,000 UUIDs via ListObjects into ANY($1::uuid[]) or run N+1 Check loops. Materialize the permissions inside PostgreSQL and the same query enforces OWASP API1:2023 BOLA and ORDER BY created_at DESC LIMIT 50 in one index scan.
DimensionSpiceDB / AuthZedOpenFGA / Auth0 FGACerbos Hub / Permit.ioOwned PG17 ReBAC + RLS
License & gov.Apache-2.0 (AuthZed)Apache-2.0 (CNCF Incub.)Cerbos Apache-2.0; Permit SaaSOwned (PG17 + TypeScript)
Causal fencingZedToken (New Enemy safe)HIGHER_CONSISTENCY vs cacheStateless PDP / OPAL syncSame-tx ACID (0 ms lag)
50k-row SQL feedNeeds Materialize add-on / syncNeeds ListObjects or your own syncCerbos AST (ABAC only)Native B-tree semi-join
Commercial entry$2/hr Cloud; Dedicated by quoteFree developer tier, then Okta Ent.$933/mo Cerbos; Permit Startup to 25K MAU~$350/mo Aurora/RDS delta
HIPAA & PCIDedicated Cloud Ent. BAAOkta Ent. contractEnterprise tier BAAVPC Day 1 & PCI DSS v4.0.1

OpenFGA vs SpiceDB vs Postgres RLS: PG17 materialized ReBAC closure blueprint

Most B2B SaaS and enterprise software development teams we meet keep nearly everything in PostgreSQL. For them there's a third option besides OpenFGA and SpiceDB: a materialized permission closure maintained in the same transaction as the data. There's no outbox to lag, no gRPC hop, and the feed query filters and sorts in one place. We target PostgreSQL 17 here, and the same SQL runs on 18. Nothing below is new to 17 either: FORCE ROW LEVEL SECURITY has been around since 9.5 and restrictive policies since 10.

The blueprint rests on cycle-guarded PostgreSQL WITH RECURSIVE CTEs and PostgreSQL row-level security. A restrictive policy builds the tenant wall, and a permissive policy checks the actor's view bit in the materialized closure. The core of it fits in two policies, with row-level security forced on the table so even its owner role is bound by them. The restrictive policy ties every row to the tenant set in the session. The permissive policy lets a SELECT through only when the actor has the view bit, with an unexpired grant, in the materialized closure. The feed query itself carries no permission logic.

With both policies in place, a plain "latest 50 documents" feed query enforces the tenant wall and Zanzibar-style visibility through one B-tree semi-join. If either session variable is unset, it returns zero rows instead of leaking. That's the property multi-tenant SaaS and API integrations need, and we cover the wider pattern in multi-tenant SaaS architecture.

Design decisions behind the owned ReBAC engine

DecisionHow the blueprint handles itWhat it buys you
Tenant isolation lives in the databaseEvery table (tuples, closure, documents) has FORCE ROW LEVEL SECURITY with a restrictive tenant policy, and the app role has no BYPASSRLSA missing WHERE clause in a controller can't leak another tenant's rows
Permissions are a materialized bitmaskOne closure row per user and document: 1 = view, 2 = edit, 4 = manage, so owner is 7, editor 3, viewer 1Feeds, exports, and aggregates filter with an indexed join instead of a gRPC call per row
Revocation rebuilds the closure in the same transactionDeleting a tuple and recomputing that document's closure commit together, serialized by a per-document advisory lockNo later in-database check can read the stale edge. Permissions cached in your app outside PostgreSQL aren't covered, so don't cache them
Graph walks are cycle-safeThe recursive walk over parent folders and group membership tracks visited IDs and stops at 12 hopsA Group A inside Group B inside Group A loop can't spin the CPU
The app binds identity per transactionMiddleware verifies the token, then sets the tenant and actor as transaction-local settings before any query runsPooled connections never carry one request's identity into the next
Writes and break-glass access are checked and time-boxedGranting or revoking needs the manage bit, and support access is an upserted viewer tuple that expires (30 minutes by default)Repeated grants stay idempotent, and expired access drops out at the next check (HIPAA-compliant software development)
Hitting ListObjects latency walls on OpenFGA or steep Dedicated quotes on SpiceDB?
Share your workspace hierarchy depth, Check/ListObjects volume, and DB stack. Our architects will benchmark SpiceDB, OpenFGA, and a PostgreSQL 17 ReBAC closure engine.
Audit your authorization architecture

OpenFGA vs SpiceDB cost: worked 36-month TCO benchmark (80M checks, 5M ListObjects)

Model a B2B SaaS or health/fintech platform over 36 months: 2,500 workspaces, 80,000,000 Check calls/month, and 5,000,000 paginated ListObjects queries/month, under private VPC isolation, SOC 2 Type II, and a HIPAA BAA. Every input is an assumption you should replace with your own quotes. The Option A and B monthly fees in particular are our estimates, because AuthZed and Okta price those tiers by quote. For the wider build budget, see SaaS development cost.

Labor compares Idealogic's $75/hr Senior CEE vs $165/hr US agency rates (2.2x), with Eurostat's hourly labour cost levels (lc_lci_lev) and the O*NET Software Developers (15-1252.00) occupation profile as background for the regional gap:

  1. Option A: AuthZed Dedicated Cloud (assumed $5,500/mo VPC SpiceDB + HA DB + BAA):
    • Setup (140h @ $75/hr CEE = $10,500; $165/hr US = $23,100): .zed schema, CDC outbox sync, ZedToken middleware, and reverse-index sync.
    • 36-mo Dedicated Cloud ($5,500/mo x 36 = $198,000): Private VPC peering, multi-AZ SpiceDB + CockroachDB, and SLA/BAA + 7h/mo (252h) sync ops ($18,900 CEE / $41,580 US) = $227,400 ($262,680 US).
  2. Option B: Okta Auth0 FGA / Permit.io Enterprise (assumed $4,800/mo 85M ops + sync + BAA):
    • Setup (120h @ $75/hr CEE = $9,000; $165/hr US = $19,800): Tuple dual-writes, ListObjects sync or OPAL webhooks, and CEL conditions.
    • 36-mo Managed FGA ($4,800/mo x 36 = $172,800): Enterprise tier + HIPAA BAA + 7h/mo (252h) sync ops ($18,900 CEE / $41,580 US) = $200,700 ($234,180 US).
  3. Option C: Self-Hosted OpenFGA / SpiceDB on EKS (Apache-2.0 + Multi-AZ DB):
    • Setup (260h @ $75/hr CEE = $19,500; $165/hr US = $42,900): EKS Helm, Envoy hash ring, Multi-AZ CockroachDB/RDS, CDC outbox, and OTel alerts.
    • 36-mo EKS + Dedicated DB ($1,350/mo x 36 = $48,600): Multi-AZ DB ($780/mo), Graviton4 gRPC pods ($420/mo), and NLB/OTel ($150/mo) + 14h/mo (504h) SRE ops ($37,800 CEE / $83,160 US) = $105,900 ($174,660 US).
  4. Option D: Owned PG17 FORCE RLS + Materialized ReBAC Engine (Primary RDS/Aurora PG17):
    • Turnkey build (600h @ $75/hr CEE = $45,000; $165/hr US = $99,000): Cycle-safe closure SQL, AS RESTRICTIVE + AS PERMISSIVE PG17 policies, ABAC caveats, React sharing UI, SIEM logs, and shadow QA.
    • 36-mo Primary PG17 Delta ($350/mo x 36 = $12,600): Closure index IOPS/storage ($230/mo) + S3 audit logs ($120/mo) + 6h/mo (216h) policy ops ($16,200 CEE / $35,640 US) = $73,800 ($147,240 US).
Worked 36-month authorization TCO ($k) at 80M checks + 5M feed queries/mo: Owned PG17 ReBAC saves $32.1k vs OSS EKS, $126.9k vs Auth0 FGA / Permit, and $153.6k vs AuthZed Dedicated
36-month line item (80M checks + 5M feeds)Option A: AuthZed Ded.Option B: Auth0 FGA / PermitOption C: OSS ReBAC EKSOption D: Owned PG17 ReBACEconomic driver
1. Setup / build (@ $75/hr CEE)$10,500 (140h; $23.1k US)$9,000 (120h; $19.8k US)$19,500 (260h; $42.9k US)$45,000 (600h; $99k US)Closure SQL & Admin UI
2. 36-mo SaaS / AWS Infra$198,000 ($5,500/mo)$172,800 ($4,800/mo)$48,600 ($1,350/mo)$12,600 ($350/mo)Zero separate DB/gRPC
3. 36-mo Sync & SRE Ops$18,900 (7h/mo; 252h)$18,900 (7h/mo; 252h)$37,800 (14h/mo; 504h)$16,200 (6h/mo; 216h)Zero CDC outbox drift
Total 36-Month TCO$227,400$200,700$105,900$73,800 (CapEx incl.)Saves $32.1k to $153.6k
Year-2+ Run-Rate$72,300/yr$63,900/yr$28,800/yr$9,600/yrSaves $19.2k to $62.7k/yr
Feed Join & Lock-InExternal syncProprietary cloudExtra HA DB + EnvoySame-tx ACID join + no vendor lock-inSingle PG17 tx

Sensitivity check: Polyglot fleets vs single-DB payback

  • When SpiceDB or OpenFGA wins: The OpenFGA vs SpiceDB choice is the right one to be making once you run 15+ polyglot services (Go, Java, Python, Rust) over separate datastores (Postgres, DynamoDB, MongoDB, S3). Nothing inside one database can see all of that. Run SpiceDB or OpenFGA on EKS ($105,900 36-mo) or AuthZed Cloud (from $2/hr).
  • Postgres-centric SaaS payback: At $75/hr CEE, Option D's $34,500 extra CapEx over AuthZed Dedicated ($45,000 - $10,500) divided by $5,225/mo OpEx savings ($6,025/mo vs $800/mo) pays back in 6.60 months (7.96 months vs Auth0 FGA / Permit: $36,000 / $4,525/mo; 15.94 months vs OSS EKS: $25,500 / $1,600/mo). At $165/hr US labor the owned build costs $147,240, still under OSS EKS ($174,660), Auth0 FGA / Permit ($234,180), and AuthZed Dedicated ($262,680). The gap to EKS is thin at US rates, though.

2026 fine-grained authorization & ReBAC build costs (Senior CEE vs US)

Our SaaS development, JavaScript development, and custom software development squads ship fixed-milestone builds at $75/hr senior CEE vs $165/hr US agency rates (2.2x):

Engagement tierTimelineHoursSenior CEE ($75/hr)US Agency ($165/hr)Deliverables
SpiceDB / OpenFGA Sprint2 to 3 wks120 to 180h$9,000 to $13,500$19,800 to $29,700.zed / FGA DSL, outbox & SDK
Zanzibar EKS Cluster4 to 6 wks240 to 360h$18,000 to $27,000$39,600 to $59,400EKS Envoy hash ring, HA DB & OTel
Owned PG17 ReBAC (600h)8 to 11 wks520 to 720h$39,000 to $54,000 ($45k)$85,800 to $118,800 ($99k)PG17 closure, FORCE RLS & Admin UI
Polyglot Mesh + ABAC11 to 15 wks840 to 1,120h$63,000 to $84,000$138,600 to $184,800SpiceDB + Cerbos sidecars & SIEM
Dedicated PodOngoing240h/mo (2)From $18,000/moFrom $39,600/moTypeScript, PostgreSQL & Security QA

Inside the worked 600-hour ($45,000 CEE vs $99,000 US) owned ReBAC build

Worked model, assumptions in text: 600-hour ($45,000 at $75/hr CEE vs $99,000 at $165/hr US) owned PostgreSQL 17 Zanzibar tuple store, cycle-safe permission closure, FORCE RLS policies & B2B sharing UI
  • 1. Tuple Schema & FORCE RLS (25% / 150h / $11,250 CEE vs $24,750 US): Composite (tenant_id, ...) tuple tables, AS RESTRICTIVE tenant walls, AS PERMISSIVE actor bitmasks, and NOBYPASSRLS roles.
  • 2. Closure & Cycle SQL (25% / 150h / $11,250 CEE vs $24,750 US): Incremental folder/team triggers, visited cycle guards (depth < 12), and covering-index joins across 50,000+ rows.
  • 3. ABAC Caveats & SDK (20% / 120h / $9,000 CEE vs $19,800 US): Typed Next.js/Node.js transaction middleware, IP CIDR / dollar-limit / break-glass TTL caveats, and SCIM group sync.
  • 4. Admin UI & SIEM Log (20% / 120h / $9,000 CEE vs $19,800 US): React sharing modal, role matrix builder, access-path graph inspector, and immutable SOC 2 / HIPAA audit logs.
  • 5. Shadow Diff & BOLA QA (10% / 60h / $4,500 CEE vs $9,900 US): Dual-read shadow diffing, automated OWASP API1:2023 fuzzing, and k6 p99 benchmarks.

Google built Zanzibar because YouTube, Drive, and Cloud ran on separate storage engines across continents. When your SaaS data already lives in PostgreSQL 17, calling gRPC to filter fifty rows turns a sub-millisecond B-tree join into a distributed consistency tax.

Artem Zaitsev · CTO at Idealogic

Shipped Idealogic proof

Two Idealogic projects in production show what these access rules look like in regulated products:

  • Clinical consent scoping (AddMed): Clinician, caregiver, and patient boundaries with HL7/FHIR sync across zero-incident HIPAA and GDPR pilots.
  • Banking permissions (C-Bank): Account-level transaction, loan, and reporting checks under OWASP MASVS and PCI DSS v4.0.1, lifting launch-quarter downloads +30%, MAUs +40%, and cross-service usage +25%.

OpenFGA vs SpiceDB: 5-step decision checklist

Five questions settle OpenFGA vs SpiceDB, and whether Cerbos, Permit.io, or your own database is the better fit. Stop at the first yes.

  1. Do you run 15+ polyglot services across separate databases and need New Enemy safety? SpiceDB, on EKS or AuthZed Cloud/Dedicated.
  2. Are you standardized on Auth0 Organizations and want a CNCF ReBAC DSL? OpenFGA fits better, self-hosted on EKS or as Okta Auth0 FGA.
  3. Are your rules attribute or YAML based, with no deep tuple graph? You don't need a Zanzibar engine. Deploy Cerbos PDP sidecars.
  4. Does a product manager need a no-code policy UI, and you're under 25K MAU? Permit.io's Startup tier covers that.
  5. Do 80%+ of your tables live in PostgreSQL, with sorted LIMIT 50 feeds or HIPAA/PCI VPC rules? Build the owned PG17 FORCE RLS ReBAC engine ($73,800 36-mo TCO in our model). Contact our team for a 48-hour authorization TCO audit.
Debating OpenFGA vs SpiceDB or fixing slow ListObjects pagination in PostgreSQL?
Send your object hierarchy model, query latency targets, and compliance requirements. Our senior CEE architects will return a PostgreSQL 17 ReBAC blueprint and fixed-milestone quote within 48 hours.
Request a 48-hour authorization TCO audit

Occasional field notes on building software, no spam

Protected by Cloudflare Turnstile · Privacy · Terms

Artem Zaitsev
Artem ZaitsevCTO · Idealogic Development OÜ

CTO and Co-founder at Idealogic. Directing engineering, systems architecture, security, and full-stack delivery across web, mobile, and blockchain.

Frequently asked questions

  • Choose SpiceDB when strict Google Zanzibar causal consistency matters, because its ZedTokens (the Zanzibar paper calls them zookies) let a check right after a revocation run on data at least as fresh as that write, and its consistent-hash dispatch keeps deep relationship graphs cacheable. Choose OpenFGA when your stack already centers on Auth0 by Okta, you prefer a CNCF Incubating Apache 2.0 runtime with readable JSON and DSL models, or you want a gentler learning curve over PostgreSQL.

  • The New Enemy Problem occurs when an owner removes Alice from a confidential folder and immediately pastes sensitive secrets into a document inside that folder, while a stale replica or cache node still evaluates Alice's old tuple and leaks the new content. SpiceDB returns an opaque ZedToken revision on every write, so later Check calls can pass at_least_as_fresh and read data no older than that write. OpenFGA doesn't expose a ZedToken-style revision token. Callers pick per request between cached MINIMIZE_LATENCY reads and uncached HIGHER_CONSISTENCY datastore reads.

  • Neither one is a Zanzibar tuple store. Cerbos is an Apache 2.0 stateless policy decision point that evaluates YAML and CEL rules locally and stores no relationship tuples. Cerbos Hub adds a free tier, a $25 Development plan, Production from $933 per month including the first 5,000 Monthly Active Principals, and custom Enterprise. Permit.io is a managed control plane with visual policy editors over Open Policy Agent and AWS Cedar, kept in sync by its OPAL project. Its pricing page lists a free Community tier to 1,000 MAU, Startup to 25,000 MAU, Pro to 50,000 MAU, and Enterprise.

  • Point authorization checks (can user X edit document Y) take single-digit milliseconds over gRPC, but filtered index pages (show the latest 50 active invoices user X can view out of 50,000 workspace rows sorted by created_at DESC) create a distributed join bottleneck. Streaming 50,000 object IDs from ListObjects into a PostgreSQL ANY array on every page view saturates network buffers, whereas materializing effective permissions inside PostgreSQL resolves the sorted LIMIT 50 query in one indexed B-tree join.

  • AuthZed's pricing page lists self-service AuthZed Cloud from $2 per hour with resource-based billing, Dedicated Cloud priced on reserved vCPU capacity, and licensed self-hosted SpiceDB. Dedicated pricing is quote only. Okta sells Auth0 FGA, which is built on OpenFGA, with a free developer tier and custom Enterprise contracts, and it doesn't publish Enterprise rates.

  • User-managed folder sharing and nested B2B team memberships can accidentally introduce cyclic edges, such as Group A containing Group B while Group B is added back into Group A. In PostgreSQL 17 recursive common table expressions and closure triggers, tracking an explicit visited UUID array path with NOT (child_id = ANY(visited_path)) alongside a hard hop depth cap (such as depth below 12) prevents runaway CPU loops.

  • No, they enforce complementary defense-in-depth layers against OWASP API1:2023 Broken Object Level Authorization. Application middleware validates OIDC tokens, coarse route scopes, and contextual caveats such as IP allowlists or step-up MFA timestamps, then binds verified app.current_tenant_id and app.current_actor_id session variables via SET LOCAL so PostgreSQL 17 FORCE ROW LEVEL SECURITY blocks cross-tenant or unauthorized row reads inside SQL joins, aggregations, and exports.

  • External Zanzibar engines excel when dozens of polyglot microservices across Go, Java, Python, and Rust each own separate databases and share one global permission graph. When 80% or more of your domain entities live in PostgreSQL, the math flips. In our worked model, a 600-hour senior CEE build at $75 per hour ($45,000 CapEx, or $99,000 at $165 per hour US rates) comes to a $73,800 36 month TCO across 80 million monthly checks. That's $32,100 less than self-hosted EKS clusters and $126,900 to $153,600 less than the managed enterprise clouds as we priced them.

Still unanswered
Ask us directly

A senior engineer replies under 4 hours.