<!-- section: Platform · status: building · source: docs/platform/01-index.md -->

> A control plane that provisions independent services into a project, and the reasoning behind that shape.


# What xplatform is

xplatform provisions independent services — files, auth, commerce, marketing —
into a customer's project, and gives them one account, one bill and one console
across all of them.

The services do not talk to each other. They do not share a database. What they
share is the control plane.

## Why this shape

Two of these services were built separately, and both independently arrived at the
same primitives: a project as the unit of isolation, an API key per project,
hashed and shown once, a dashboard, a docs site, metered usage.

When two systems converge on the same shape without coordination, the
abstraction is real rather than speculative. Building that control plane a
third and fourth time is the cost this project exists to remove.

## What a service is

Not a library the platform calls into. A service is anything that satisfies the
contract:

- it can be **provisioned** for a project, idempotently and resumably
- it **reports** what it used
- it can be **suspended** and later resumed
- it can be **deprovisioned**, completely

Everything else about it — how files are stored, how sessions are signed, what
an order costs — is that service's own business and no concern of the platform's.

## Separation, and what it buys

Each service owns its database, its storage and its credentials. The control plane
has its own and never queries a service's.

The link between a project and a service's resources is an **address, not a join**.
Nothing in the control-plane database references a service's rows by foreign key.

The consequence is worth stating plainly, because it is bought deliberately and
it has a price:

- no cross-service query is possible
- no cross-service transaction exists
- an outage in one service is not an outage in another

Anything that spans two services has to be composed at the edge rather than joined
in a database. That is the trade, and it is the right one for services that are
meant to be independently deployable.

## Where enforcement lives

The platform owns entitlement — balance, plan, limits. The **tool** enforces it,
synchronously, in its own request path, from a cached copy.

The platform is never a hop inside a service's request. If it were, one
component's latency would be everyone's latency and one component's outage
would be everyone's outage.
