Open-source PaaS · Hosted public alpha · Self-hostable

Deploy services from Git — hosted or self-hosted

Bex is an open-source platform for developers and AI agents: connect a repo, build it, and run an HTTPS service through the dashboard, API, or MCP.

Hosted Bex is a public alpha. Evaluate it before using it for production workloads.

Create hosted accountTry the self-hosted quickstart

Read platform docs →View source on GitHub →

Git deploys · Custom domains + TLS · Postgres · REST, GraphQL + MCP

bex · deployillustrative deploy flow

$ repo https://github.com/your-org/service

▸ build cloud-native buildpack

▸ tls example HTTPS route

✓ live service ready

phaseRunning

revision<revision>

url<generated URL>

Optional dashboard

A dashboard for humans. APIs for automation.

Inspect deploys, logs, metrics, and supported resources in one place. REST, GraphQL, and MCP coverage varies by capability; the parity ledger records current gaps.

Open the dashboard →

bex dashboard project overview showing two running services — Workspace resources in one view
Services, datastores, and environment groups stay organized by project and environment.

bex dashboard showing a live deployment and its status timeline — Deploy with confidence
Trace a revision from build to ready, inspect its logs, and use the rollback controls available for that resource.

bex dashboard showing memory and CPU charts for a running service — See what your services are doing
Follow CPU, memory, requests, latency, bandwidth, and deploy events from the same service view.

Agent-native

Built for agents, not dashboards

Deploy and operate supported resources through documented APIs and MCP. Check the parity ledger for current coverage and optional-service requirements.

01/deploy→

Deploy

An agent pushes a repo or calls MCP. Cloud-native buildpacks or your Dockerfile turn it into a running HTTPS service.

02/operate→

Operate

Use documented API operations to suspend, resume, restart, and scale supported resources.

03/observe

Observe

Machine-readable state — phase, revision, url — that an agent can read back and act on.

Included

Core service capabilities for developers and agents

✓Deploy from Git — buildpacks or Dockerfile
✓Custom domains with automatic TLS
✓Managed PostgreSQL
✓MCP server for agent control
✓REST + GraphQL, with compatibility tracked in the parity ledger
✓Apache-2.0 — self-host on your own hardware

Bring a documented runtime or Dockerfile

Use a documented native runtime, or bring a Dockerfile for another stack. Check the parity ledger before relying on a specific build path.

Node.jsPythonGoRubyRustElixirDocker

What you can run

Service types Bex supports today

Evaluate web, private, worker, cron, static, and PostgreSQL resource models; inspect the parity ledger for exact interface coverage and gaps.

Web Services

web

Long-running HTTP services with deploy history, custom domains, and automatic TLS.

Background Workers

worker

Run queues, consumers, and long-running jobs right next to your services.

Cron Jobs

cron

Scheduled tasks using the same Git-backed service definitions.

Static Sites

static

Ship frontends and docs, built straight from your repo.

Managed Postgres

postgres

Provision PostgreSQL through supported API and dashboard workflows; backing services require configuration.

Private Services

private

Internal services reachable only inside your own network.

Fit + economics

Hosted speed or self-hosted control

Choose the operating model that matches your team today. Both paths use the same open-source Bex platform.

Managed path

Hosted Bex

Bex runs the platform for you. The hosted service is a public alpha, best for evaluation and early workloads rather than production-critical systems.

Free service tier: 0.1 CPU · 512 MiB

Starter example: 0.5 CPU and 512 MiB is $4.90/month at 730 hours. Build, bandwidth, and storage usage are metered separately.

Create hosted accountSee full pricing and estimator →

Owned path

Self-hosted Bex

Run the Apache-2.0 platform on infrastructure you control and keep the API-driven deploy workflow.

There is no Bex platform fee for the open-source software. You still pay for and operate servers, storage, networking, backups, upgrades, and on-call coverage.

Try the self-hosted quickstart

Start with a real example

Choose a path, then inspect the artifact

Pick hosted evaluation or self-hosting first. Then explore one of five examples that ship in the Bex repository—without pretending registration auto-deploys it.

Evaluate the managed path

The dashboard is the shortest path to evaluating Bex. Registration is live; production-critical workloads should wait until the public alpha matures.

Choose a starter

Node.js hello

Node.js 20+ · Docker

A minimal Node.js HTTP service built from the example Dockerfile.

Inspect full source on GitHub

What you do next

Create a hosted account in the live Bex dashboard.
Connect your repository and create a service or Blueprint using the inspected manifest.
Follow build logs, then inspect the service phase, revision, and generated URL.

The selected example is not carried through registration and is not auto-deployed. Keep this source page open while creating the service.

Create hosted account

Selected manifest

Inspect and copy before you start

examples/hello-node

render.yaml

yaml

# render.yaml — Node.js hello-world web service.
# Replace repo/rootDir with your own checkout; bex builds from the Dockerfile and
# returns a live https URL. A git push redeploys automatically via the push webhook.
services:
  - name: hello-node
    type: web
    runtime: docker
    repo: https://github.com/bex-co/bex # replace with your fork/checkout
    rootDir: examples/hello-node
    branch: main
    plan: free
    healthCheckPath: /
    envVars:
      - key: MESSAGE
        value: "hello from bex (node)"

Expected product state

phase: Running
revision: <revision>
url: <generated URL>

These values describe the documented result shape. Revision and URL are illustrative placeholders, not live output or a deployment-time promise.

Find your fit

What to try now — and what to verify first

Choose the smallest useful evaluation path. Production-sensitive teams should inspect current evidence before expanding scope.

Hosted evaluation

A good fit for evaluating the managed dashboard and early workloads in the working public alpha; not for production-critical systems yet.

Create hosted accountCheck evidence ↗

Self-hosted local evaluation

A good fit for platform engineers who can run the documented local Cluster API prerequisites and want to inspect the open-source control plane.

Open the quickstartCheck evidence ↗

Agent and API experiments

A good fit for exploring documented REST, GraphQL, and MCP workflows on supported resources; interface coverage varies by capability.

Read the API docsCheck evidence ↗

Production-sensitive workloads

Wait or verify first. Bex is not ready for production workloads; inspect each required capability and current project state before accepting operational risk.

Inspect parity ↗Contact the project ↗

Choose your path