Skip to main content

Solutions · Bring an existing app

Deploy any app you already have, in any language, without a rewrite.

Bring Node, Python, Ruby, Java, Go: anything with a Dockerfile, a container image or a static site. Forge declares it in a few files without changing yours, then gives it environments, releases promoted by digest, managed Postgres, preview environments and monitoring. Adopt one tier at a time and stop wherever you like.

The problem

Why moving a working app usually means a rewrite.

Most platforms want your app shaped their way: a buildpack, a framework, a config dialect of their own. Moving off a Heroku-style host or a hand-built server means rewriting the deploy, re-plumbing secrets and rebuilding monitoring, all before you ship anything new.

Then the pieces do not talk. CI knows what it built, the host knows what is running, the error tracker knows what broke, and none of them agree on which release that was. Your agent sees only the repository, so “what changed in prod?” has no single place to be answered.

How it works

How it works on Reliant.

Your code stays as it is. Forge writes declarations beside it, and every deploy after that is the same deterministic path.

  1. You

    Point Forge at the repository

    forge project new --in-place --kind app --dry-run reads your Dockerfiles and compose file and prints what it would write. None of your files change, apart from a block appended to .gitignore.

  2. Forge · deterministic

    Declare what runs

    It writes forge.yaml and dev, staging and prod environments naming your services, ports, a managed Postgres, a migration job and secrets. A Vite or Next.js app adopts in place as a static site.

  3. Agent

    Let an agent finish the move

    Ask your agent to get the first deploy green, or run the Move to Forge workflow and let it do the move. You review each change like any pull request.

  4. Forge · deterministic

    Build once, promote by digest

    A deploy builds one release and shows the plan; staging and prod get the exact same bytes. Every deploy waits for the app to be healthy, and a failed one never replaces what is serving.

  5. Forge · deterministic

    Judge every release

    Logs, traces, metrics and errors arrive over standard OpenTelemetry. After a deploy, forge obs check compares the release with the window before it and names what regressed, or says it could not prove it good.

  6. You

    Add preview environments to your CI

    forge env preview create --pr 123 --ttl 72h gives a pull request its own environment that expires. You wire create into your pipeline and delete on close, so nothing runs that you did not ask for.

terminalExample
# see what adopting writes, then adoptforge project new --in-place --kind app --dry-runforge project new --in-place --kind app --name shopforge env deploy staging# prod gets exactly what staging runsforge env deploy prod --from staging # or keep your deploys; add monitoring onlyforge obs initforge release record --env prod --version v1.4.0

Who does each step

  • You
  • Forge · deterministic
  • Agent

Start anywhere

Adopt in tiers. Stop after any one.

Each tier works without the next, in any language and with any CI.

  • Monitoring only

    forge obs init registers each environment and prints standard OTEL variables. No deploy through Forge, no code changes beyond your exporter. Requires signing in.

  • Record your own deploys

    forge release record, run from the pipeline you already have, marks each deploy, so release verdicts and new errors tie to the version that shipped.

  • Deploy through Forge

    Environments, releases, managed Postgres, domains, secrets and previews, on Reliant hosting or your own Kubernetes cluster.

  • Generate what you add next

    A new service can be a generated Go service over Connect RPC, deployed beside the code you brought, in the same environments.

What you get

What you get.

The parts of a platform team, declared in your repository.

  • Any language, any container

    A Dockerfile, an existing image or a static site, including third-party software you did not write.

    Deploy any language
  • Release promotion by digest

    Build once, deploy that release to staging, then promote the same bytes to prod. Redeploy any earlier release by name.

    Releases and promotion
  • Preview environments

    A copy of a template environment per pull request, deleted when it expires or when your CI closes it.

    Environments and deploys
  • Managed Postgres

    A database per environment with 7-day point-in-time recovery, its connection string handed to your services.

    Hosting guide
  • Custom domains and secrets

    HTTPS issued and renewed for you. Secrets encrypted at rest and write-only: set once, never read back.

    Custom domains
  • Monitoring for any app

    Logs, traces, metrics, dashboards, alerts to Slack or PagerDuty, and errors grouped into issues, from anything that exports OpenTelemetry.

    Run features
  • Release verdicts

    Each promotion is judged against the window before it. Missing telemetry is reported as undetermined, never as a pass.

    Release features
  • Coming

    Release candidates promoted after a soak

    A built-in workflow that cuts a release candidate and promotes it once it has soaked and its verdict is good. Today you promote with Forge’s commands and gates, from your CI or by hand.

    Release status
  • Your own cluster when you want it

    Rebind any workload, or all of them, to your own Kubernetes, Docker Compose or hosts; the same releases deploy there.

    Self-hosted delivery

Why one platform

Why this takes one platform.

A host, a CI service and an error tracker each hold one piece of the answer to “is this release healthy?”. When the same platform records the release, runs it and receives its telemetry, the answer is one command: the release is a digest, the deploy is recorded against it, and every error and latency change is tied to that version. That is also what your agents read, so the first question in an incident is already answered before anyone asks it.

Honest limits

What it does not do, and what stays yours.

Published so you can decide before you move.

  • Code generation and bug-class lint are for Go. An app in another language gets deploys, environments, releases and monitoring, not generated handlers.

  • Reliant’s static hosting serves static exports only. An app that renders on the server deploys as a container, like any other service.

  • Hosting runs in one region, us-central1, and does not run Kubernetes operators or cron-kind workloads: bind those to your own cluster and keep the rest hosted.

  • Preview environments are not automatic. You add create and delete to your CI.

  • There is no automatic rollback. You redeploy an earlier release, and a rollback floor stops anyone deploying a release older than a breaking migration.

  • Monitoring requires signing in; there is no anonymous path.

Questions

What people ask first.

  • Is this a Heroku alternative?

    For most apps, yes: declare your Dockerfile and get a live URL, managed Postgres, custom domains with HTTPS and secrets, pay as you go with no base fee. What comes with it is the difference: environments declared in your repo, releases promoted by digest, preview environments and monitoring that judges every release.

  • Do I have to deploy through Forge to get monitoring?

    No. forge obs init registers your environments and prints standard OpenTelemetry variables for an app in any language, deployed any way. forge release record, run from your existing pipeline, marks each deploy so errors and release verdicts tie to it. Monitoring requires signing in.

  • Can I keep my CI?

    Yes. Run forge env deploy from it, or keep deploying your own way and record each deploy. Preview environments work the same way: you add the create and delete commands to your pipeline.

  • How long does moving take?

    About an hour for a typical app with a Dockerfile. A dry run prints every file adoption would write before anything changes, and the Move to Forge workflow can do the move for you.

Keep reading

Related.

  • Start a new app

    A production-shaped app from the first commit, deployed by your agent.

  • Automate PR review to merge

    Agents review every pull request and answer comments; gates decide what merges.

  • Turn alerts into fixes

    An alert becomes an investigated issue; once a person approves, an agent opens the fix.

  • Hosting

    Managed Postgres, static hosting, domains, previews and secrets.

  • Forge

    The open-source framework: codegen, checks, environments and releases.

  • Why Reliant

    One platform that knows every seam, so your agents can too.

  • All features

    Every capability by stage of the lifecycle, each with its status.

Bring your app over.

Try it in Reliant, or deploy free from your own agent. Your first static site is free.

Deploy any language ↗