Glossary #
On this page
Definitions are grouped by subject, with links to the relevant guides and references.
The application and its environments #
Application #
An application is the record Turn Zero Cloud keeps for your backend, with its manifest, environments, version history, and size, owned by the account that created it (Applications and environments).
Environment #
An environment is an application's separate production or development deployment, with its own hostname, secrets, files, and version history. create_environment adds optional hosted development beside production (Environments).
Running copy #
An environment's running copy, or deployed copy, is the compute that runs its serving version, with the settings it started with. A deploy, a promote, or a platform redeploy replaces it (A deployed app's settings). Its server listens on the port the PORT setting names. Its own disk holds only what its deploy built when it starts, so a file the code writes there is lost when the copy is replaced or stops (Bring an existing application).
Local run #
A local run is your application running on your computer under the settings turnzero provision writes, or using test doubles for tests without a platform connection (Run your app on your computer). A run against your own PostgreSQL is a separate way to run the application on your computer, outside this definition.
Manifest #
The manifest is the JSON document that declares an application's services, health path, region, outbound hosts, audience, and library entries, which submit_manifest records and provisions (The manifest).
Audience #
The audience is the manifest member that sets who may reach an application: public, invited, or workforce. Under invited and workforce, the serving router refuses a request with no end-user session, except on the paths session_free_paths lists (The audience kinds).
Setting #
A setting is a named value the platform places in a deployed copy's environment, which your code reads from process.env (A deployed app's settings). The manifest's settings member gives one a value that is not secret as {"value": "<text>"} (Set a value that is not secret). It also binds a stored name to one (Bind a stored value to a setting), and declare_outbound_api's sdk_settings member names those an unchanged SDK reads (An unchanged SDK).
Hosting cell #
A hosting cell, or cell, is the set of platform servers that hosts an application's environments and databases, which read_status reports as cell (Environments).
Cell #
Cell is the short form of hosting cell.
Placement #
An environment's placement is the platform's record of its hosting cell and its compute, which the serving router reads to forward each request.
Hostname label #
The hostname label is the first part of an environment's hostname: <label> for production and <label>-dev for development. Appending .ai.host gives the full hostname (The development hostname).
Grain and development group #
An environment's grain, grain in read_status, is how its compute runs. A container is compute of its own, as Shared 1 GB production has. A pod belongs to a group on shared compute. A development group holds development environments; a production group holds Shared 0.5 GB environments (Where each environment runs).
Container app and pod #
A container app is the compute of an environment on the container grain, and a pod is the compute of one on the pod grain, on shared compute (How the sizes differ technically).
Halted environment #
A halted environment keeps its version, data, and credentials but serves nothing, every path returning 503 environment_halted, until halt_environment with resume: true ends the halt, or for development a deploy does too. The platform halts development seven days after the later of its serving version's deploy and its last resume (The halted state).
Releases #
Artifact #
An artifact is the zip of your application's built code that a deploy installs and runs (What the deploy zip holds).
Deploy #
A deploy puts a built artifact into an environment as a new version, which serves after passing the deployment checks. Your AI tool calls deploy_command and runs its returned command, or uses deploy_files without a CLI (Deploy from your computer).
Line #
A line is a shell command a management action returns. Most run the turnzero command. When your AI tool runs a returned line, it first uses command_npx, or command_npx_windows on Windows, once, exactly as given. Neither needs a global installation.
If npx can't run here, use the installed form (command, or command_windows on Windows) when turnzero --version responds. Otherwise, for a deploy use deploy_files within its limits, then the upload route past them. Install the command only if the person wants to keep it. A person or a job may use any of the four forms. A line reserved for the person's own terminal stays theirs to run.
Upload #
An upload sends the deploy zip to the platform: the turnzero command the deploy line runs receives a short-lived upload grant, writes the zip under it, and starts the deploy.
Authorized computer #
An authorized computer is one whose turnzero command keeps a 30-day account token, which list_tokens marks authorized_computer, so a deploy line run there needs no other credential (Authorize this computer for deploys). A person creates it with turnzero login and browser approval, or a signed-in AI tool creates it through turnzero authorize and reports the authorization. The turnzero command's credential says when the command uses it.
Health check and health path #
The health path is the manifest's health member, a path of your server that responds 503 while it starts and exactly 200 once ready. The health check requests it at every deploy, promote, and platform redeploy before traffic moves (The deploy health check).
Control probe #
A control probe is a request without the router mark that the platform sends a new copy during its health check, to check whether your own process responds (When the check ends early).
Promote #
A promote applies a version from the history to production, with production's own settings and a new production platform credential, on an application with development turned on (Turn on development and promote).
Roll back #
A roll back puts an earlier version back in production as a promote of that version. It restores that version's code, setting bindings and plain values. The platform takes no snapshot of your data (Manage versions and environments).
Platform redeploy #
A platform redeploy re-creates a running copy from the same version with the platform's current settings, started by restart_application or by the platform, and recorded as a restart row (Manage versions and environments).
Version history #
The version history is the application's record of every deploy, promote, and platform redeploy, one row each, which list_versions returns newest first (The version history).
The account and its people #
Account #
An account, your Turn Zero account, belongs to one person, a builder, and owns each application that person creates (Your account).
Standing #
An account's or an end user's standing is active or suspended, and a suspension ends every session; an unused invitation's state and a read_library entry's standing share the name (Read the standing).
Builder #
A builder is a person with a Turn Zero account who builds applications, a user of the platform's own builder realm, separate from every application's realm.
End user #
An end user is a person who uses your application, signed in on its realm, without needing a Turn Zero account. An end-user session grants no access to management actions (Add sign-in to your app).
Realm #
A realm is one separate list of users in the accounts service, with their sessions, passkeys, and invitations; an application with sign-in has one per environment (Manage end users).
Sign-in method #
A sign-in method is one way to sign in that a realm offers, such as google, github, the emailed code, or passkey, set in configure_app_sign_in's sign_in_methods. Some pages call one a route (Offer other sign-in methods).
Creation policy #
A realm's creation policy, its creation setting, sets whether a first sign-in creates an end user: open for anyone, invited only with an invitation (Make sign-up invitation-only).
Sizes and usage #
Size #
An application's size chooses its production compute: Shared 0.5 GB or Shared 1 GB, stored as shared-0.5gb or shared-1gb. Development uses Shared 0.5 GB and sleeps when idle. Size and usage explains choosing the size and production's sleep setting.
Monthly item #
A monthly item is a shared database, custom domain, 30-day log option or tzTrack AI reviews option, charged at the start of each calendar month. Adding one charges for the days left; removing it returns nothing. Items already in place at the switch are first charged on the following month's first day. A database covers production and development together and stays charged until the application is deleted (Size and usage).
Free Allowance #
Free Allowance is the amount every account receives each UTC calendar month, shared by its applications and paid options and used before prepaid credit. There is no "free plan" or plan tier to choose.
Free Allowance is enough for most static websites and for a small app with a shared database on Shared 0.5 GB that sleeps when idle. The Static website and Small app examples in the calculator fit without the introduction bonus. A server that stays awake all month can exceed the Free Allowance. Other apps and paid options share the same Free Allowance.
No server size is the free one. To keep a server's costs down, use Shared 0.5 GB with its default sleep setting. When Free Allowance runs out and the account has no live credit, applications pause until the next UTC month begins.
A static website on its platform address can run without payment while its data transfer fits the remaining Free Allowance. It has no server, per-request or file storage charge. A custom domain, where available, is a separate monthly item.
Open the pricing calculator for Static website. It compares a fixed example's full month with Free Allowance and, while its box is ticked, the introduction bonus. The pricing page also lists the rates.
Balance #
The balance is the account's amount available for usage this UTC month. Application usage and paid options draw it at the rates on the pricing page. Warnings arrive at 50%, 80% and 100% used. At 100%, the account's applications pause until the next UTC month.
Pause #
A pause stops an account's applications when its month's balance is used up, until the next UTC month begins. Their data is kept, and the owner's sign-in and export paths stay open. Applications start again automatically when that month begins (Size and usage).
Warm floor #
The warm floor, warm_floor in read_status, is how many copies an idle environment keeps running. It is 0 for development. Production's is 0 while sleeping is on or the account is paused, and 1 otherwise. The size act's answer does not carry it (Size and usage). A stop loses the copy's memory and disk writes, while database records, stored files, secrets and settings stay (Running copy).
AI calls #
An application has no monthly AI allowance. Calls on the platform's AI route draw the account's balance at the provider's published price plus the markup on the pricing page. Calls on the application's own stored key carry no markup and post nothing to that balance (Use your own AI keys).
Credentials and sessions #
Native client #
A native client is a mobile or desktop app, declared on each realm, that signs its users in through the realm. It calls your backend with the session token as a bearer token (Sign in from a native app).
Development build #
A development build is a debug build of a native client, used to test sign-in because Expo Go's own exp:// redirect is outside the redirect rule (Sign in from a native app).
Credential #
A credential is what a caller presents with a request: the browser's cookies, your AI tool's connection, a minted token, the platform credential, or an end-user session (Sign-in, sessions, and tokens).
Grant #
A grant is a named permission a credential holds beyond its scope, such as destructive or issues (Mint it). The word also names the short-lived transfer grant and secret grant.
Platform credential #
The platform credential is the credential an environment's running copy receives as TURNZERO_CLOUD_APP_TOKEN, which your backend presents to the platform's own services (The platform credential).
Platform-minted credential #
A platform-minted credential is one of the values the platform mints and stores under its own names, which store_secret refuses: credential-<application id>, database-<application id>, and issue-tracking-<application id> (The platform's own names).
Egress key #
An egress key is the stand-in key an unchanged SDK sends to the gateway, which replaces it with your stored key (An unchanged SDK). It works only on its upstream's route, and it lasts only as long as the copy, or until its upstream is ended.
Minted token #
A minted token is the credential for unattended work, such as a continuous integration (CI) job, limited to your account or one application, which mint_token creates and revoke_token ends (Mint a token).
Token code #
A token code is the one-time code a mint_token call returns inside a line in place of the token. For an authorized computer, the line carries the mint's id and no code; the command completes with its verifier.
The platform's sign-in page for the CLI, /approve/computer, also mints one after approval. Ordinary turnzero login receives it by browser callback or pasted code. With login --device, the platform holds the approval while the requesting computer polls with its verifier.
That approval lasts an hour from approval, never past the approving session's end; the requesting computer also needs a living pending request. Only the computer with the matching verifier can claim it (The command's credential).
Account-scoped token #
An account-scoped token is a minted token for the whole account, scope_kind account, refused where a call needs one application's credential (Mint it).
Bearer token #
A bearer token is a credential sent in a request's Authorization header, as your AI tool's connection, a minted token, and the platform credential are (Sign-in, sessions, and tokens).
Session #
A session is the signed-in state one sign-in creates on the platform's site and in your AI tool's connection, which Sign out everywhere ends on every device (Sign-in, sessions, and tokens).
Session token #
A session token is the short-lived signed value, valid for an hour and renewed while the session lasts, that confirms an end user's session to your backend (Verifying an end user).
Verification route #
The verification route, POST /accounts/v0/verify, is where a backend checks an end user's session under its platform credential (The verification route).
Copy interval #
The copy interval is how often each serving router copies a realm's signing keys and revocation list, 30 seconds, so every serving router treats an ended session as ended within sixty seconds (Current values).
Passkey ceremony #
A passkey ceremony is the exchange in which a device creates a passkey or signs in with one, on the realm's own hostname, so the passkey works only there (Passkeys for your users).
Stranded passkey #
A stranded passkey is still listed but cannot sign in on the hostname the sign-in page now uses. For example, renaming an application can leave a passkey bound to its previous hostname (Register and remove passkeys).
Custody #
Custody is the platform's store of your secret values, each stored by name with store_secret, none ever returned to you or your code unless the manifest binds it to a setting (Store a secret).
Realm vault #
The realm vault is the accounts service's store for a realm's provider credentials, such as Apple's signing key, moved there from custody by configure_app_sign_in (Add work-account or Apple sign-in).
Authority and approval #
AI coding tool #
An AI coding tool is a program that uses AI to write or run code at your direction. It connects to Turn Zero Cloud through Model Context Protocol (MCP) so you can build and operate applications (Connect your AI assistant).
Management action #
A management action is one entry of the platform's action catalog, such as deploy. An AI coding tool calls it as a Model Context Protocol (MCP) tool; a script calls the HTTP address its action reference gives.
Act #
An act is an operation, such as an action call or CLI step. The relay sends an act to an issue space.
Management action tier #
A management action tier says whether an action needs your approval. An observe action reads, a reversible one runs at once, and a destructive one waits for approval in the browser (What happens without asking).
Pending action #
A pending-action record tracks a destructive request from approval through completion. Read it with read_approval_status (The pending action).
Refusal #
A refusal is the platform's response when it does not do what a request asked: a name such as environment_unavailable, an HTTP status, and a detail that says what to do. A refused management action call also includes a reference to quote when you report it, and help, the address of the refusal's row in the refusals reference.
Rule code #
A rule code is the identifier of a statement in the platform's specification. The answers and refusals of the platform's management actions, and its skills, carry none. You meet rule codes in the specification reads, in this documentation, and in some answers a product's own service gives; you can look one up as Searching says.
Page address #
A page address is the page member of a response, such as https://turnzero.ai/cloud/guides/plan-and-usage/, which your AI tool passes unchanged to read_documentation; the response's detail gives the section that applies.
Status #
A status is the HTTP status code of a response, such as 202 or 409; an environment's condition, such as deployed or halted, is its state (read_status).
Member #
A member is a named field of a JSON object, such as services in the manifest, wait_seconds in a call, or state in a response (Action reference).
The platform processes #
Control plane #
The control plane is the platform's own running system, apart from the applications it hosts, which handles and records every management action (What is recorded).
Serving router #
The serving router is the platform process that receives every request to your hostnames, checks the session your audience requires, and forwards the request to your compute (Egress firewall and request limits).
Runtime harness #
The runtime harness is the platform's code that runs in your process, loaded before your server starts. It checks the router mark, sends outbound calls through the egress proxy, logs under the source harness, and keeps a pod's last console lines (Node.js Runtime).
Router mark #
The router mark is a secret header the serving router adds to each request it forwards, without which the runtime harness refuses a request 403 router_mark_required (The router mark).
Scheduled run and due instant #
A scheduled run is one request the serving router sends to a schedule declaration's path at each due instant of its cron expression, the time sent in x-turnzero-cloud-schedule-due (Run scheduled work).
Log source and store source #
A log source is who wrote a log record, the source of read_logs: one of the five store sources the logging service keeps, or container for the compute's console (Choose the log source).
Direct read #
The direct read is the platform's read of a container app's console straight from its running instances, which returns a container read's newest lines at once (How log records arrive).
Fallback output #
The fallback output is where the Logging package's client writes records the logging service did not accept, standard output by default (Logging).
Wire #
A wire is the set of calls a platform service accepts over the network, with their request and response shapes (Issue Tracking).
Egress firewall and request limits #
Egress firewall #
The egress firewall is the platform's control of a deployed backend's outbound network access (Egress firewall and request limits).
Request limits #
The request limits are the controls on a deployed backend's incoming requests, such as each request's time limit and the per-address limits (Egress firewall and request limits).
Execution window and grace interval #
The execution window limits a request's duration. At the deadline, the router returns 504 window_ended or cuts an already-started response. The grace interval gives the handler time to stop before the runtime terminates its process (The execution window).
Egress #
Egress is a backend's outbound traffic, sent through the HTTPS tunnel or gateway.
HTTPS tunnel #
The HTTPS tunnel carries a backend's outbound HTTPS connections. In enforce mode, destinations must be declared in the manifest's egress list (The HTTPS tunnel).
Egress gateway #
The egress gateway is the route /egress/v0/<upstream>/<path>, which adds your stored key from custody to a backend's call before it forwards it (The gateway).
Declared upstream #
A declared upstream is an external application programming interface (API) your application declares by name, base URL, and stored key, then calls through the gateway. Call an external API with an API key declares one and calls it.
Observe and enforce modes #
Observe and enforce are the egress proxy's two modes: observe records and allows undeclared hosts, and enforce refuses them egress_undeclared (Observe before enforce).
The database #
Database and owner role #
An environment's database is the PostgreSQL database the platform provisions for it while the manifest declares the database kind, and its owner role is the role that owns it (Add a database).
Migration #
A migration is one numbered .sql file in the application's migrations/ folder, and the files together define its whole schema (Add a database).
Migration walk #
The migration walk is the Database package's run, at your application's start, of each migration file the ledger does not list, each in its own transaction (Database).
Ledger #
The ledger is the table schema_migrations, which records each applied migration file and its content hash. The next start skips an unchanged file and fails on an edited one (Add a database).
Developer network rule #
The developer network rule is the database servers' network rule. A development server's public endpoint accepts a connection from any address, so a local run needs no address registered (Add a database).
Storage #
Storage area #
A storage area is a named set of files bound to one application, with one set per environment (Store files).
Acting identity #
The acting identity is the string your application sends in X-Acting-Identity to record who made a storage write; it grants no access (Put, fetch, list, delete).
Transfer grant #
A transfer grant is a short-lived credential a backend mints at POST /storage/v0/grants so a browser can upload or download one named file; a native app and a backend can too (Store files). A deploy's upload grant goes to the turnzero command alone.
Secret grant #
A secret grant is a short-lived credential for one write of one secret, or for a local run's setup. A store_secret call with neither value nor generate returns one inside a line (Keep a secret value out of chat). A local run's grant has no value: the turnzero command presents the verifier it keeps on your computer as its bearer.
Deploy area and export area #
The deploy area, deploy-<application id>, holds an application's deploy zips, one pending upload per environment, and the export area, export-<application id>, its exports; the platform keeps both (The deploy area).
Issue tracking #
Issue-tracking space #
An issue-tracking space, or issue space, is the set of issues, reports, and checks one owner keeps, which an application gets by declaring issue_tracking (Issue Tracking).
Issue and report #
An issue is one tracked problem, such as #12 (Feedback). A report is one filing about it, in its filer's own words, and is never edited: to add to it, its filer files another report under the same problem_key, which joins the same issue.
Release line #
A release line is one named sequence of builds an issue space records, which a report's seen_in gives with its version and environment. Bind an application to the space says how the platform adds an application's line.
Grant level #
A grant level is what a token may do on an issue space, report, contribute, or owner, apart from the Issue Tracking package's own permission levels (Keep your own issue list).
Relay #
The relay is the management action relay_issue_act, which carries one act to an issue space your account holds under the space's own token (Feedback).
Monitored check #
A monitored check is a test a program runs repeatedly and records in an issue space under a stable key, and an issue opens from it only once its failures repeat (Issue Tracking).
The library #
Library #
The library is the catalog of published feature packages, vocabularies, fonts, and the documents that define the package format, which your account's credential reads through read_library (Use the library).
Feature package #
A feature package is a library entry for one capability, backend or front-end: its product statement, detailed contract, and guide, and an npm package where it has code (Know what an entry contains).
Product statement and detailed contract #
A feature package's product statement says what it does and for whom, and its detailed contract fixes the calls and shapes its code and tests follow (Know what an entry contains).
Vocabulary #
A vocabulary is a library entry that defines a shared design language rather than a capability, such as the style system (Use the library).
Closure and closure hash #
A library entry's closure is every file it lists, and its closure hash, closure_hash, is one hash over them, which your project records to check its copy (Check the download).
Public reads #
The public reads are read_library and read_context, which read what the platform publishes and need your account (Action reference). Without an account, the backend package pages, such as Database, describe the packages while the site is public.
Compatibility window #
The compatibility window is the five years an older contract version stays in service once replaced, and a version replaced before the first customer release has none. Raise the minimum version says how to declare the lowest client version your backend accepts, which is how to refuse older installed native clients.
Test double #
A test double is the stand-in a backend package ships at @turnzero/<name>/testing, so your tests run with no account or connection (Test your application locally).
Held copy and vendored copy #
A held copy, or vendored copy, is your project's committed copy of the library entries it uses, in system/ (Use the library).
tzTeam #
Turn Zero Team (tzTeam) is Turn Zero's companion plugin for keeping a project's requirements and issues in files and issue spaces you own.
Instance file #
An instance file is the record a tzTeam project keeps for each feature package it takes from the library, under requirements/app_features/ (Use the library). A package the platform installs for every application, such as Node.js Runtime, has none.
The connected tool #
Skill #
A skill is a procedure offered as an MCP prompt. An AI client that cannot list prompts reads a platform skill with read_context, using skill:<name> (The skills). For another product your connection offers, read skills:<product> to find its prefixed names, then read one with skill:<prefixed-name>. The individual product skill IDs are not listed in the catalog.
A long platform skill comes in pages read with limit set to 16000: its first page lists the others, such as skill:deploy:database. It prints Rules 19 to 27: skill:deploy:stored-key for a case page’s rules.
Resource #
A resource is readable context your AI tool loads before it starts work, such as context://manifest_schema, which a tools-only client reads with read_context (MCP resources and prompts).
Documentation tree #
A documentation tree is one set of published pages, such as /cloud/ for these, which read_documentation reads and search_documentation searches. A search that names no tree searches every tree your account can read (How an AI reads these docs).
Related #
- Turn Zero Cloud — what the platform provides.
- Applications and environments — the application, its environments, and its versions.
- Sign-in, sessions, and tokens — every credential and what ends it.
- What happens without asking — which actions run at once and which ask first.
- Action reference — members and refusals for management actions a customer can call.