Skip to main content

Why Reliant

One platform. Every seam known.

Most stacks are stitched together: a framework from one vendor, CI from another, then hosting, logs, alerts, secrets and an AI assistant from five more. None of them knows what the others know, so every integration is glue you write and every agent works blind.

Reliant owns the whole path, so it knows your services, RPCs, schema, config, secrets, releases, metrics and alerts. Those standardized seams let us, and your agents, do what a stitched stack can’t.

The seams

A stitched stack vs one platform.

The seams are where one part of your software meets another: services, RPCs, schema, config, secrets, releases, metrics and alerts. In a stitched stack each vendor sees its own side of a seam. In Reliant every layer reads the same declarations.

A stitched stack

  • Framework
  • CI
  • Hosting
  • Logs
  • Alerts
  • Secrets
  • AI assistant

Seven vendors, seven data models. The glue between them is yours to write and keep working.

Reliant

  • Services
  • RPCs
  • Schema
  • Config
  • Secrets
  • Releases
  • Metrics
  • Alerts

One data model, read by the framework, the release pipeline, hosting, telemetry and every agent.

  • Services

    In a stitched stack: The framework defines them, the host sees containers, and the tracer sees whatever you remembered to instrument.

    In Reliant: Discovered from the code that declares them. Hosting, dashboards and lint read the same list.

  • RPCs

    In a stitched stack: Your monitoring sees URLs. It doesn’t know which ones are your API or what they return.

    In Reliant: Each RPC in the proto is one span, one metric and one log record, with no tracing code to write.

  • Schema

    In a stitched stack: Migrations live in one tool. The deploy tool doesn’t know they exist until pods crash.

    In Reliant: Migrations are the schema. A release records the ones it carries, and the deploy refuses them out of order.

  • Config

    In a stitched stack: Environment variables copied between dashboards, drifting quietly.

    In Reliant: Typed per-environment config in the repo, diffed between environments before a deploy.

  • Secrets

    In a stitched stack: Values pasted into CI, the host and, sooner or later, an agent’s context.

    In Reliant: Declared by reference and write-only on hosting. Agents use them in calls without seeing them.

  • Releases

    In a stitched stack: CI builds, the host deploys, and nothing records which bytes run where.

    In Reliant: Built once, promoted by digest, recorded in a ledger for every environment.

  • Metrics

    In a stitched stack: Dashboards you build by hand, with no idea a release went out.

    In Reliant: Generated dashboards with release markers, and each release judged against the window before it.

  • Alerts

    In a stitched stack: A page to a person, who opens five tabs to find out what changed.

    In Reliant: Default alerts that can start an agent workflow with no wiring, tied to the release that was running.

Configured for you

Features you’re paying for but not using.

Your host, your APM and your error tracker all offer these. Each one waits for you to turn it on, wire it up, pay for it separately or instrument your own code, so most of them never get done. Forge writes them into your app instead, so they’re on from the first deploy, and your agents use all of them.

  • Traces and per-RPC metrics

    On a stitched stack: Install an OpenTelemetry SDK, wrap your handlers and clients, and pick a vendor to send it to.

    • SDK install
    • Code changes
    • Separate vendor

    On Reliant: Every RPC is a span, a metric and a log record, and every service call and query a child span.

    Why it’s on: Forge generated the handlers, so it generated the instrumentation with them.

  • Dashboards

    On a stitched stack: Build them by hand in your APM, then rebuild them each time your API changes.

    • Separate vendor
    • Config by hand

    On Reliant: A dashboard per service with a row for every RPC, with each release marked on it.

    Why it’s on: Generated from the services you deployed, and shipped with every release.

  • Alerts

    On a stitched stack: Write rules for error rate, latency, crash loops and certificates, then route each one somewhere.

    • Separate vendor
    • Config by hand

    On Reliant: Default rules for error rate, latency, silent services, frontend errors, crash loops, failed deploys, uptime and expiring certificates, sent to the app, Slack or PagerDuty.

    Why it’s on: Forge knows every service and frontend, so it declares the rules as code beside them.

  • Error tracking

    On a stitched stack: Add your error tracker’s SDK to every service and frontend, and upload source maps from CI.

    • SDK install
    • CI wiring
    • Separate vendor

    On Reliant: Errors grouped into issues with real stacks, each tied to the release that opened it.

    Why it’s on: Forge’s error layer and the release ledger are the same platform.

  • Release health

    On a stitched stack: Eyeball dashboards after each deploy, or wire a canary-analysis tool into your pipeline.

    • CI wiring
    • Separate vendor

    On Reliant: Every promotion is judged against the window before it, per service, and a regression raises an alert naming the release. One declaration gates prod on staging’s verdict.

    Why it’s on: Forge knows your RPCs, and hosting knows which release is serving.

  • Preview environments

    On a stitched stack: Script an environment, a database and its teardown per pull request in CI.

    • CI wiring
    • Config by hand

    On Reliant: A full environment per pull request, copied from a template env and deleted when it expires; you add two commands to your CI.

    Why it’s on: A preview is an ordinary environment, so every deploy and monitoring feature works on it.

  • Secrets

    On a stitched stack: Copy values between dashboards and .env files, or add a secrets manager and its client.

    • Separate vendor
    • Config by hand

    On Reliant: Declared once as references and bound per environment. Hosted values are write-only, and a workflow you allow with forge secret allow uses a secret in HTTP calls without the agent seeing it.

    Why it’s on: The config schema is generated, so every secret has one declared place.

  • Sign-in

    On a stitched stack: Choose an auth vendor, install its SDK and guard each route by hand.

    • Separate vendor
    • SDK install
    • Code changes

    On Reliant: Passwords, passkeys, magic links and social sign-in, and every RPC requires a signed-in caller unless its proto says otherwise. Who may do what is still your code.

    Why it’s on: Auth is declared per RPC in the proto, so a forgotten check fails closed.

  • Continuous profiling

    On a stitched stack: Add a profiling agent to each service and a vendor to store the profiles.

    • SDK install
    • Separate vendor

    On Reliant: CPU and heap profiles from every process: on in local dev, one line of config for a hosted environment.

    Why it’s on: Forge renders the telemetry pipeline, so profiles travel with traces and logs.

  • Slow-query analysis

    On a stitched stack: Turn on query statistics in your database and read EXPLAIN plans in a separate tool.

    • Separate vendor
    • Config by hand

    On Reliant: Capture every query shape your tests run, then EXPLAIN them with one command; pending migrations are measured for locks on a real copy.

    Why it’s on: Forge generated the ORM, so it knows every query and the call site behind it.

  • Product analytics

    On a stitched stack: Install an analytics SDK, add it to every page and send events to another vendor.

    • SDK install
    • Code changes
    • Separate vendor

    On Reliant: A hosted app gets product analytics dashboards with no code: visitors, channels, sign-ups, active and new users, retention, goals and funnels, counted without cookies.

    Why it’s on: Product events ride the same telemetry pipeline as everything else.

Compare with Vercel, feature by feature

Because we know the seams

What a platform that knows your app can do.

Each of these joins layers that live with different vendors in a stitched stack. None of them is a feature you could add to one layer alone.

  • Because Forge reads your proto and your migrations

    Your agent generates the plumbing instead of spending tokens writing it.

    One proto definition generates the Connect handlers, CRUD wiring, typed frontend hooks and tests, so the API, server and UI cannot disagree. Mark a message as an entity and one command writes its migration, CRUD RPCs, ORM, lifecycle test and pages. The agent’s effort goes into your product’s logic.

  • Because Forge generates every RPC and Reliant hosts the telemetry

    Every release gets a verdict, and prod can wait for staging’s.

    Every RPC is measured at the edge from day one. forge obs check compares the window after a promotion with the equal window before it, per service, and lists what the release opened: new and regressed issues, firing alerts, restarts. On Reliant hosting, an opt-in health gate holds a prod promote until staging’s verdict for that release is a pass.

    Judging a deploy with forge obs

    Joins: Forge + Observability + Hosting

  • Because Forge knows your migrations and the releases that carry them

    A migration that would lock prod is caught before it ships.

    forge db analyze runs pending migrations on a disposable copy of a real Postgres database and reports the locks they took and the tables they rewrote. Every migration runs with a lock timeout, so one slow reader cannot wedge prod. We roll forward, and a rollback floor stops anyone rolling an environment back past a breaking migration.

    Migration rules

    Joins: Forge + Hosting

  • Because Reliant both ships the release and collects its errors

    An error arrives tied to the release that caused it.

    Errors group into issues with the culprit, frames, trace, events per version and suspect commits. Resolving an issue --in next ties the fix to a release, so the error coming back counts as a regression. On hosting, a release that fails its verdict raises a ReleaseRegressed alert naming the release and its commit range.

    Issues and releases

    Joins: Observability + Forge

  • Because the alerts are ours

    An alert reaches an agent with no URL or token to set up.

    A webhook: {source: alerting} automation receives your hosted alerts and new, regressed or spiking error issues. Autopilot’s on-call agent turns each into one deduplicated GitHub issue and investigates it read-only. A person approves the fix, an agent opens the pull request, and you decide when it merges.

    Alerting webhooks

    Joins: Observability + Agents & Workflows

  • Because the schema drives the API, the ORM and the pages

    Who may write a column is declared once, and lint holds the code to it.

    Markers such as forge:read-only, forge:computed, forge:immutable and forge:version declare who may write a column. Lint holds the code to them: a read-only or computed field that nothing writes fails the build instead of shipping a silent zero in every row.

  • Because Forge knows which columns hold secrets

    Production data, read without reading your secrets.

    forge db query runs one statement in a read-only transaction as a role that Postgres itself refuses on forge:secret columns. A column named like a credential that nobody has marked fails lint. On hosting, a query needs the organization’s grant, runs under a person’s sign-in and leaves an audit record.

    Reading the database

    Joins: Forge + Hosting

  • Because the secrets and the agents run on one platform

    Agents use secrets without ever seeing them.

    Integration steps and http/request@1 call an API with a saved credential the agent never sees. Hosted secrets are write-only: set once, never read back, scoped to one environment, and each lists the workflows that may use it (forge secret allow).

    Calling any API

    Joins: Agents & Workflows + Hosting

  • Because every RPC is declared in one place

    Auth fails closed, and lint finds RPCs that ignore the caller.

    Every RPC needs a valid credential unless its proto opts it out, so a forgotten annotation never publishes an endpoint. An audit lists signed-in RPCs that never check who is calling, and an owner column scaffolds row scoping for you to build on.

    Sign-in

    Joins: Forge

  • Because we know what evidence should exist

    Missing telemetry is undetermined, never green.

    When a service sent no traces, metrics or logs, forge env status reports it as undetermined, and forge obs check answers “could not tell” with its own exit code. A skipped check is never reported as a pass, to you or to an agent deciding what to do next.

    Observability for agents

    Joins: Forge + Observability

Why Forge

The same argument, from Forge’s own registry.

Forge keeps its reasons next to its benefits, and a test checks every benefit’s evidence against the forge binary, so a reason cannot claim what Forge does not ship. Each one is open-source Forge unless it is tagged.

Each reason in full on the Forge page

Opinionated defaults, no walls

Start with any piece. Leave any time.

The defaults are opinionated because the seams only work when they are standard. None of them is a wall.

  • Start anywhere, in any repo

    Adopt an existing app in any language without a rewrite, send only its telemetry, or record the deploys your own CI already does.

  • Bring your own pieces

    Point at your own database, identity provider or OpenTelemetry backend in config. Every generated file has a file of yours beside it to change what it does.

  • Deploy where you like

    The same declaration deploys to Reliant hosting, your own Kubernetes cluster, Docker Compose or plain host processes.

  • Leave with everything

    Forge is open source, the code it writes is yours, and your schema, config and environments are files in your repo.

The limits, stated plainly

  • Hosted frontends are static exports: no server rendering on Reliant hosting.
  • Generated backends are Go. Apps in other languages deploy and are monitored, without the codegen.
  • Hosting runs in one region, us-central1.
  • Hosted backends run the replica count you declare; they do not autoscale.
  • Hosted profiling is opt-in: one line in the env turns it on.
  • Hosted URLs, previews included, are public: no team sign-in in front of a deployment.
  • Hosting runs services, workers and jobs. Cron-kind workloads and operators need a cluster you run.
  • A deploy made without an account expires after 72 hours unless you claim it.

The platform

Four products, one data model.

Use one, or all four. Each reads the same seams, so each is better for the others being there.

Start from the job

Every feature, with its status

See the seams at work.

The feature catalog walks the lifecycle from build to fix, with a status on every row.