> ## Documentation Index
> Fetch the complete documentation index at: https://docs.reliantlabs.io/llms.txt
> Use this file to discover all available pages before exploring further.

# Reliant hosting: services, workers, static sites and Postgres

> What Reliant hosting runs for a forge project, what it costs, what a queued deploy means, and what it refuses

A new forge project is set up to deploy to Reliant's own hosting. Its `staging` and `prod` environments already point there, so publishing is one command from the project directory, with no cluster, registry or DNS to arrange first:

```bash theme={null}
reliant forge env deploy staging               # build, push, cut a release, show the plan, deploy it
reliant forge env deploy prod --from staging   # ship exactly what staging runs
```

Ask the agent in your project to "deploy it" and it takes this same path. The `dev` environment stays on your machine; only `staging` and `prod` are hosted. How releases, plans and promotion work is the same on every target and is covered in [Environments & deploys](https://docs.reliantlabs.io/forge/environments-and-deploys.md); this page is about what hosting itself provides.

## What gets hosted

Hosting runs three kinds of workload: **services**, **workers** (background processors) and **jobs** (one-off tasks such as the database migration that runs before each rollout). In a hosted environment, every service and worker in your project runs in one workload called `api` (the binary's `server` command), so the browser reaches every service at one origin with one sign-in cookie. Your frontend is published separately as a **static site** on Reliant's static hosting and CDN. Every workload and site gets a generated hostname the moment it deploys.

Your app's database is a **managed Postgres**: a dedicated database the platform creates for the environment, and deleted with it, data included, unless you delete the environment with `--keep-data`. Your services receive its connection string automatically, and it is reachable only from inside the platform, so migrations run as part of the deploy rather than from your laptop. [Managed Postgres](https://docs.reliantlabs.io/hosting/managed-postgres.md) covers backups, point-in-time restore and read-only queries.

Because the frontend is served as static files, a hosted frontend must be a static export. New forge frontends are scaffolded that way, and `forge lint --static-export` names anything in your code that the export cannot serve (a dynamic `[id]` route, a server action, `cookies()`). A frontend that needs a server at request time ships as a workload instead.

Two files in a site's own build change how it is served. A `_headers` file at the root of the build (the Netlify and Cloudflare Pages format) adds response headers, such as a `Content-Security-Policy`, though not the ones the platform owns (`Cache-Control`, `Set-Cookie`, `Strict-Transport-Security`, `Content-Type`). A `404.html` turns on real 404s: without one, a path with no file extension gets `index.html` with a 200 so a client-side router can draw it; with one, that path gets `404.html` with a 404. A missing file with an extension, such as `/missing.js`, is always a 404. [Inside Reliant hosting](https://docs.reliantlabs.io/deep-dives/inside-reliant-hosting.md#the-static-edge-and-origin) has the details.

Telemetry is collected from the first deploy too: see [Observability](https://docs.reliantlabs.io/hosting/observability.md).

## Any app, any language

A workload does not have to be forge-generated Go. Hosting runs any container image, so an existing Node, Python, Rails or Java app deploys from its own Dockerfile, and third-party software deploys from its published image. To bring an existing app, run `forge project new --in-place --kind app` in its directory (add `--dry-run` first to see what it detected): it reads the Dockerfile and compose file and writes `forge.yaml` and `deploy/kcl/` declaring the app, much like the declarations below, with its environments, a managed database and secrets, and changes none of your files. [Deploy an existing app from its Dockerfile](https://docs.reliantlabs.io/guides/forge/bring-existing-app-any-language.md) walks through it, and `forge agent skill load adopt` takes your agent through the tiers after it. See also [Adopt an app that already exists](https://docs.reliantlabs.io/forge/deploy/escape-hatches.md#adopt-an-app-that-already-exists).

```python theme={null}
# Your app, built from its own Dockerfile (any language).
api = fw.Workload {
    name = "api"
    kind = "service"
    image = "api"   # bare: forge pushes it to your organization's registry path
    build = forge.DockerBuild {dockerfile = "Dockerfile"}
    ports = [fw.Port {name = "http", port = 3000, expose = True}]
    probes = tiers.Probes {readinessPath = "/", livenessPath = "/"}
    env = {JWT_SECRET = forge.ManagedSecret {name = "JWT_SECRET"}}
    runtime = forge.OnHosted {}
}

# A third-party image, unchanged: no build, registry host included.
whoami = fw.Workload {
    name = "whoami"
    kind = "service"
    image = "docker.io/traefik/whoami:v1.10.3"
    args = ["--port", "8080"]
    ports = [fw.Port {name = "http", port = 8080, expose = True}]
    runtime = forge.OnHosted {}
}
```

The platform pulls only from its own registry, and forge handles both cases for you:

* An image forge **builds** (`forge.DockerBuild`, `forge.ShellBuild`, Go) is written bare. Forge pushes it to `registry.reliantapi.com/<your org>/<project>/<image>`, using your Reliant sign-in, with no registry to configure.
* A **third-party image** (no `build`) is written in full, with its registry host. When a deploy cuts a release, forge copies it registry to registry into `registry.reliantapi.com/<your org>/<project>/<its path>` (here `.../traefik/whoami`), and the release pins that copy by digest. The digest is the upstream image's own, every platform of a multi-architecture image is included, and a later push to the upstream tag changes nothing until your next release. A private image is read with the credentials `docker login` stored for its registry. `docker.io/traefik/whoami` must name `docker.io`: a bare `traefik/whoami` would mean an image in your own registry path.

Such an app reads its credentials from environment variables, so deliver each one in the workload's `env` from the environment's secret store (`forge.ManagedSecret`, set with `forge env secret set --env <env> <NAME>`; see [Secrets](https://docs.reliantlabs.io/hosting/secrets.md)). A name listed in a workload's `config_secrets` that its `env` does not deliver fails `forge env render` and the deploy, rather than letting the app start on a fallback value. More on non-forge workloads, including what they give up: [Deploy code forge never compiled](https://docs.reliantlabs.io/forge/deploy/escape-hatches.md#deploy-code-forge-never-compiled).

## Billing

Paid app hosting requires an independent, organization-wide **pay-as-you-go usage billing agreement**, authorized explicitly by an owner or admin under **Settings → Billing → Usage & invoices → App hosting billing**. There is no base fee and no machine purchase is required. CPU, memory and storage are billed from first use at the displayed usage rates; machine subscriptions include no separately spendable app hosting allowance.

Choose a positive **monthly admission budget** and accept the displayed policy before continuing to checkout. A saved card, AI wallet credit, machine subscription or checkout return alone does not activate hosting: the server must verify the agreement's funding. The budget controls admission and suspension against measured usage, not a guaranteed maximum invoice. Enforcement can lag and in-flight workloads can keep accruing charges; storage is not deleted. Changing the consented budget is not currently supported in the app.

Hosting authorization does not add an observability allowance or unlock longer product-event retention; [observability billing](https://docs.reliantlabs.io/hosting/observability-billing.md) remains separate.

Static sites are the exception. They run no process, just files behind the CDN, so they get a free tier when the organization has no plan:

* **One static site per person**, counted across all of the environments of every organization that person owns without app hosting billing. A second organization you create does not add a second free site, and an organization you only belong to counts against its owner's. Deploying a second site is queued like any other billing hold (below) until you remove a site or enable independent app hosting billing.
* **1 GiB of storage.** Reliant keeps a release's files three times (live, its archive and the previous release), so in practice a release of about 340 MiB or less fits. A larger one is held with the size in the message; shrink the site or subscribe.
* **10 GiB of traffic per calendar month** (UTC) for the organization. The organization's owner is notified at 80% and 100%, and past the limit the site answers `429` until the month rolls over.

A project that is only a qualifying free static site, such as a landing page, can therefore be published without paid hosting authorization. A hosted backend needs the independent usage agreement, even though its frontend is static.

## Queued deploys

You do not have to set up billing before your first deploy. If required app hosting billing is not active, the deploy is **queued, not refused**. Reliant builds and records the release as usual, then holds it. Nothing is running yet, and nothing needs to be re-run: once billing is set up, the hold is released automatically and the deploy goes live. In the meantime:

* `forge env deploy` prints one block (what it waits on, why, what to do, a link, and that there is nothing to re-run) and exits with code **7**. Seven means "queued on a person", not "failed", so a CI job can treat it differently from a real error. `--json` reports the same facts, and `forge env status <env>` also exits 7 while the deploy is queued.
* `forge env deploy --wait` (or `forge env status <env> --wait`) blocks until the deploy is live.
* The environment's page in **Apps** (**Environments → \<env>**) shows a "Waiting on billing" banner. Someone who can manage billing gets a **Set up billing** button that returns them to the environment afterwards; anyone else is told that only an admin can set it up, with a **Copy link** button to send along. The environment is marked queued in the Apps navigation, and a desktop notification tells you once when the deploy goes live or fails.
* A newer deploy to the same environment replaces a queued one.

Some deploys are refused rather than queued, with the reason printed: when a resource limit is exceeded, funding cannot be determined, or the admission budget has been reached. Follow the reported action; a budget refusal must not be treated as authorization to retry unattended.

## Stopping and deleting an environment

`forge env stop <env>` suspends a hosted environment's workloads (they stop running and stop costing compute) and `forge env start <env>` resumes them. `forge env delete <env>` tears the environment down, and **its managed database is deleted with it, data included; this cannot be undone**. It asks you to type the environment name first. To keep the database, run `forge env delete <env> --keep-data`: it keeps running, is billed as storage, and stays until you purge it, and a later deploy of the same name creates a new environment that does not reattach it. Releases older than forge v1.0.5 (Reliant v1.8.10 and earlier) do not have `--keep-data`, and their prompt wrongly says the data is kept. Upgrade before deleting an environment whose data you want to keep. These act on the hosted environment, unlike `forge env down`, which only stops the local processes `forge env up` started.

## What hosting does not run

Hosting shares machines between customers, so it refuses anything that needs control over the cluster. The deploy tells you before publishing, naming the workload and the field.

| Not available on hosting | Why |
| - | - |
| Cron-kind workloads | Not metered yet; a worker that runs its own scheduler (`forge scaffold worker <name> --kind cron`) is fine |
| Operators, RBAC, CRDs | No Kubernetes API access on shared machines |
| Sidecars, volumes, security-context and pod overrides | The platform builds the pod itself |
| Node selectors, tolerations, priority classes | The platform decides placement |
| Domains written into the workload spec | Domains are managed separately: see [Custom domains](https://docs.reliantlabs.io/hosting/custom-domains.md) |
| Outbound connections other than TCP 80 and 443 to public addresses | A hosted workload reaches the internet only over HTTP and HTTPS, plus its own managed database. SMTP, a Postgres or Redis server outside hosting, and any other port are unreachable; use a provider's HTTPS API instead |

For any of these, bind that one workload to a cluster you operate and keep the rest hosted; see [Connecting a cluster you operate](https://docs.reliantlabs.io/forge/deploy/environments.md#connecting-a-cluster-you-operate) and [What gets deployed](https://docs.reliantlabs.io/forge/deploy/what-gets-deployed.md) for the objects forge renders there.

## Related topics

[Environments & deploys](https://docs.reliantlabs.io/forge/environments-and-deploys.md), [Managed Postgres](https://docs.reliantlabs.io/hosting/managed-postgres.md), [Preview environments](https://docs.reliantlabs.io/hosting/preview-environments.md), [Secrets](https://docs.reliantlabs.io/hosting/secrets.md), [Custom domains](https://docs.reliantlabs.io/hosting/custom-domains.md), [Forge sign-in](https://docs.reliantlabs.io/forge/sign-in.md), and **Settings → Billing** in the app for plans and spend caps.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.