Skip to main content
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:
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; 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 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 has the details. Telemetry is collected from the first deploy too: see Observability.

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 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.
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). 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.

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 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. For any of these, bind that one workload to a cluster you operate and keep the rest hosted; see Connecting a cluster you operate and What gets deployed for the objects forge renders there. Environments & deploys, Managed Postgres, Preview environments, Secrets, Custom domains, Forge sign-in, and Settings → Billing in the app for plans and spend caps.