Skip to main content
bex.co
419

Open-source PaaS · Public alpha

Deploy from Git. Operate through APIs.

Bex builds and runs apps from Git or container images. Manage supported services through the dashboard, REST, GraphQL, or MCP, on hosted Bex or infrastructure you operate.

Try the public alphaRun Bex locally

Apache-2.0 · Self-hostable

Bex is in active development and is not ready for production workloads. APIs and configuration can change. Project status

Read platform docsView source on GitHub
hello-node / render.yamlRepository example
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)"
View example on GitHub

Native runtimes and Dockerfiles

Node.jsPythonGoRubyRustElixirDocker
Explore Bex

A measurable price advantage

A smaller price for outbound traffic.

Paid service compute is 30% less across the compared Render tiers. See how your usage and included allowances change the estimate.

Calculate my costs

Of Render’s outbound unit rate

~1/10

Bex
$0.015/GiB
Render
$0.15/GB

Outbound unit rates: Bex per GiB; Render per GB beyond included usage. Total savings depend on your workload and plan.Rates checked Sep 5, 2026.BexRender

Meet your control plane

Your services. All in view.

Manage services, inspect deployment history, and read logs and metrics in the dashboard. REST, GraphQL, and MCP expose supported operations for scripts and agents.

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.

Product UI screenshots, not live service status.

Agent-native

Deploy. Operate. Observe.

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

01

Deploy

Create a service from a Git repository or container image. Configure a native build or Dockerfile, then follow the deployment in the dashboard or API.

02

Operate

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

03

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

Apps, jobs, and databases.

Run web apps, workers, scheduled jobs, static sites, and Postgres. Check the capability matrix for current coverage.

Web Services

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

Background Workers

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

Cron Jobs

Scheduled tasks using the same Git-backed service definitions.

Static Sites

Ship frontends and docs, built straight from your repo.

Managed Postgres

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

Private Services

Internal services reachable only inside your own network.

Your deployment, your choice

Hosted or self-hosted.

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

Managed path

Hosted Bex

$0.00/ monthFree service compute

This covers service compute only. Workspace plans and build, bandwidth, storage, disk, or sandbox usage may add charges.

Create an account to explore the hosted public alpha. Bex operates the platform; the project is not ready for production workloads.

Free service tier: 0.1 CPU · 512 MiB

Paid compute example: 0.5 CPU and 512 MiB costs $4.90/month at 730 hours. Check the dashboard for your plan and actual charges.

Try the public alphaSee full pricing and estimator →

Owned path

Self-hosted Bex

Apache-2.0

Open-source license

Run the Apache-2.0 platform on infrastructure you control. The linked quickstart sets up a local evaluation cluster.

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.

Run Bex locally

Start with a real example

Start with a repository example.

Explore five examples from the Bex repository. Registration does not deploy them; use a manifest to create your service.

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

  1. Create a hosted account in the live Bex dashboard.
  2. Connect your repository and create a service or Blueprint using the inspected manifest.
  3. 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 the right starting point.

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

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 ↗

Recently shipped

View changelog →

Choose your path

Try Bex with a small project.

Create an alpha account, inspect a repository example, or run the local cluster to explore the open-source platform.

Try the public alphaRun Bex locally

Latest

Stay in the loop

View more news →
Same Cluster API, Different Bill: What Vultr's CAPI Support Proves About the Standard (and the Metal)
Kubernetes

Same Cluster API, Different Bill: What Vultr's CAPI Support Proves About the Standard (and the Metal)

Vercel Sandbox's Active-CPU Meter vs a €4.99 Hetzner Box: the Breakeven Is 8 Sessions a Day
PaaS

Vercel Sandbox's Active-CPU Meter vs a €4.99 Hetzner Box: the Breakeven Is 8 Sessions a Day

Vercel Pulls Away From Netlify: What a $9.3B vs Shrinking-Rival Split Means for Where Self-Hosting Actually Competes
PaaS

Vercel Pulls Away From Netlify: What a $9.3B vs Shrinking-Rival Split Means for Where Self-Hosting Actually Competes

Upsun Bills You Four Times for One App: What a Typical API + Postgres + Redis Stack Really Costs vs. a €4 Hetzner Box
PaaS

Upsun Bills You Four Times for One App: What a Typical API + Postgres + Redis Stack Really Costs vs. a €4 Hetzner Box

Replace Is a Disaster on Bare Metal: What Talos Linux's In-Place Philosophy Means for Your Cluster API Fleet
self-hosting

Replace Is a Disaster on Bare Metal: What Talos Linux's In-Place Philosophy Means for Your Cluster API Fleet

Paying $4,700 for a $1,999 GPU: What the RTX 5090 Street Premium Does to Self-Hosted Inference Math
self-hosting

Paying $4,700 for a $1,999 GPU: What the RTX 5090 Street Premium Does to Self-Hosted Inference Math