Skip to content

Architecture

ZStrike separates authorization into a control plane (where you manage policies and data) and a data plane (where decisions are made). The two are connected by continuous, one-directional sync.

You & your team Your applications
│ │
▼ ▼ POST /authorize
┌───────────┐ REST ┌───────────────┐ sync ┌───────────────┐
│ Console │ ────────▶ │ Control Plane │ ───────▶ │ Policy │
│ │ │ API (PAP) │ │ Decision │
└───────────┘ └───────────────┘ │ Point (PDP) │
▲ ▲ └───────┬───────┘
│ live stream │ history queries │ every decision
│ │ ▼
│ ┌──┴────────────────────────────────┐
└──────────────── │ Audit │
└───────────────────────────────────┘

The Control Plane API is the system of record. Organizations, projects, schemas, policies, entities, tokens, and audit history all live here. The Console is a client of this API — anything you can do in the UI, you can do programmatically.

Crucially, the control plane never makes runtime authorization decisions for your applications. It administers the model; decisions happen in the data plane.

The Policy Decision Point is a regional service that keeps your project’s policies, schema, and entities in memory and answers POST /authorize in milliseconds. It pulls from the control plane:

  • Policies and schema refresh continuously (about every 20 seconds).
  • Entities sync incrementally from a change feed, with a full resync every 24 hours as a safety net.
  • Snapshots on disk let a PDP restart and serve immediately, even if the control plane is unreachable.

Because sync is pull-based and cached, the data plane keeps answering — with last-known-good data — through control-plane outages. A PDP failure mode never widens access: errors always resolve to Deny.

Every decision the PDP makes becomes an audit event: principal, action, resource, decision, and the policies that determined it. Events are batched, spooled durably at the PDP, and delivered at-least-once to the audit service, which:

  • streams them live, per project, over WebSocket — this is the Console’s live request log;
  • archives them as Parquet files in organization-scoped object storage (when enabled);
  • makes history queryable through the Control Plane API’s audit endpoints.
  • Tenant isolation — everything is scoped Organization → Project, enforced at the data layer.
  • No principal injection: principals, their attributes, and their group memberships come only from the synced entity store. A request can never supply them. The one exception to “synced data only” is narrow. A caller holding an app token with the inline_entities grant may attach the request’s resource and its ancestors, and nothing else (details).
  • Environment-scoped service identity — the components authenticate to each other with short-lived, environment-bound credentials; a staging credential can never act in production.
  • Fail closed — missing keys, invalid tokens, unparseable policies, and evaluation errors all resolve to Deny or to serving last-known-good data, never to open access.