What is a space

A space is an independent tenant living on its own subdomain — {slug}.ctxr.app. From the moment it is created it is fully autonomous: there is no runtime coupling back to the platform, and none to any other space. The platform helps a space come into being and can serve it updates if you ask, but it never reaches in while the space is running. A space stands on its own feet.

Three layers, one tenant

Conceptually a space is made of three layers, each with a different owner:

  • Content — the typed JSON nodes that make up the site. This is what editors create and approve through the editing interface. They never touch templates.
  • Settings — the space’s identity, its actors, its plan, its configuration. This is reached through the management layer, not by hand-editing files.
  • Build — the templates, styles, scripts and assets that turn content into HTML. This is the developer’s domain, and the one place where the platform’s defaults give way entirely to your own work.

Of these three, build/ is the only layer a developer works with directly as a folder. Its structure — how a theme is laid out, how templates read content — is the subject of the Build & customize reading journey. Content and settings are not folders you edit; they are surfaces you work through.

Among the settings is the space’s own identity — an Organization node with the space’s name, URL and owner. The owner is a special actor: they always hold full rights over the space, regardless of what any individual person record says. Everyone else is governed by the permissions they’re granted (see the security model).

content   →  edited by editors      (through the editor)
settings  →  managed by the owner   (through management)
build/    →  built by developers     (the theme you write)

Isolation is the architecture

A space cannot see, query or touch another space. This is not a permission rule layered on top — it is the shape of the system. The platform resolves which space a request belongs to from the subdomain before any other code runs, and everything downstream is scoped to that one tenant. There is no shared database, no global user table, no cross-space query to accidentally leave open. For the full picture of how this is enforced, see Isolation and security.

Why autonomy

Autonomy is a simplification, not a limitation. A self-contained tenant is easier to reason about: there is no question of what happens “across” spaces, because nothing crosses. It scales cleanly, because spaces don’t contend over shared state. And it frees you from being locked to the platform’s release schedule — once your space exists, a platform update is something you choose to adopt, never something that is pushed onto you mid-flight. The space is yours, and it keeps working whether or not anything else changes.