A live preview URL for every branch you push
Nexos turns every git branch into a running copy of your app — complete with its own Postgres, Redis, and storage — in under 60 seconds. Stop sharing one staging server. Start reviewing real working software on every pull request.
No credit card required · $5 in free credits · Live URL in under a minute
$ git push origin feature/new-checkout
[nexos] webhook received
[nexos] building image on node eu-west-2
[nexos] provisioning postgres · redis · s3
[nexos] restoring seed (v3-with-orders) 4.2 MB
[nexos] container started · health check passed
preview → https://feature-new-checkout-acme.nexos.rs
ready in 47sShipping software without preview URLs is a tax on your team
Most teams know they should have previews. Most teams do not, because the tooling makes it painful. Here is what that costs:
Waiting on staging
Your team shares one staging server. Every code review blocks on the last person who deployed — and nobody tested their branch in isolation.
Preview URLs cost a fortune
Spinning up a full stack on AWS for every pull request burns thousands of dollars a month on idle compute. Most teams give up and ship blind.
Databases reset on every push
You set up test data, find a bug, push a fix — and watch your seed wipe everything. Preview environments are unusable without persistent data.
Preview environments that actually act like production
A preview environment is a full, running copy of your application — not a static build, not a frontend-only deploy, but the actual stack. Your app container, your database with seeded data, your cache, your object storage — all wired together at a URL you can share.
Nexos gives every git branch its own preview environment, automatically, the moment you push. No pipelines to author. No Kubernetes manifests to maintain. A webhook fires, a container starts, a URL goes live.
And because you only pay for what actually runs — per-second billing on CPU, RAM, and build time, with zero charges for paused environments — full-stack previews cost a fraction of what they do on AWS or GCP. You can afford one per branch, not one per team.
From git push to live URL in three steps
You write code. Nexos does the rest.
Push to a branch
A GitHub webhook fires the moment you push. No CLI, no YAML pipelines, no extra config.
We build and provision
The scheduler picks a node with free capacity. BuildKit builds your image. Postgres, Redis, and storage come up in parallel.
Share the URL
Drop the preview link into a PR or Slack. Reviewers, designers, and QA all click through the real app — live data and all.
No DevOps. No pipelines. No infra to maintain.
Spinning up a Nexos project is one config file — nexos.yaml at the root of your repo. It captures your Dockerfile, your port, the services you need, and your migrations. Nexos reads it on every push and does the rest.
Don't want to write it yourself? Hand your AI assistant this link — nexos.rs/docs/nexos-yaml/ai — and ask it to configure the project. The page is a self-contained spec written for AI agents. They detect your stack, generate the YAML, and (when your existing Dockerfile isn't preview-ready) create a Dockerfile.nexos that meets our requirements.
name: my-app
build:
dockerfile: ./Dockerfile
app:
port: 3000
services:
postgres: true
redis: true
hooks:
on_deploy: npx prisma migrate deployCommit it. Push. You have a preview URL.
$ git commit -am "tweak checkout" && git push
[nexos] syncing workdir → feature/new-checkout
[nexos] next.js detected change · hot reloading
ready in 1.3s
preview → https://feature-new-checkout-acme.nexos.rsA loop fast enough for humans — and AI agents
Flip an environment into dev mode and Nexos runs a hot-reload dev server with your source bind-mounted instead of rebuilding an image. The first push cold-starts; every push after syncs the checkout and your framework's file watcher reloads — no rebuild.
Iteration time drops from minutes to seconds. That makes Nexos the natural target for AI coding agents: point one at a live, full-stack environment with a real database and let it iterate with instant feedback — not against mocks.
- Hot reload on every push — no image rebuild
- Real Postgres, Redis, and storage, persisted across syncs
- Per-PR policy: draft PRs hot-reload, ready-for-review compiles
- Migrations re-run only when their files change
What you do with a URL per branch
Preview environments unlock workflows that are impossible with a single shared staging server.
Pull request reviews
Every PR gets a URL. Reviewers click through working changes instead of squinting at diffs.
Bug reproduction
Reproduce a customer bug on their exact seed data, fix it on a branch, share the fixed URL back.
Designer handoff
Designers see the real app on the real data, not a Figma mock. Feedback lands in hours, not sprints.
QA verification
QA sets up a test scenario once and verifies fixes across every subsequent push — data persists.
AI coding agents
Point an agent at a live, full-stack environment and let it iterate against a real database — not a mock.
Product demos
Show a WIP feature to stakeholders from a branch URL. Throw the environment away when you are done.
Everything a real preview environment needs
Not a static build. Not a frontend-only deploy. The full stack.
60-second deploys
Push to any branch. A live URL with your app, database, and storage is ready before you can finish your coffee.
Full-stack previews
Every branch gets its own Postgres, Redis, and any managed addon you enable — wired up automatically to your app container.
Persistent databases
Incremental deploys rebuild only your app container. Your data, user sessions, and test state survive every push.
Encrypted secrets
Environment variables are AES-256-GCM encrypted at rest with per-value initialization vectors. Never stored in plaintext.
Pay only for what runs
Per-second billing for CPU, RAM, and build minutes. No idle charges when an environment is paused. See every charge on your invoice.
Live build logs
Stream BuildKit output and container logs into your dashboard over WebSocket. See exactly what is happening as it happens.
Priced by projects and environments, not seats
Pick a plan based on how many projects you ship and how many branches you keep open per project. Compute and build time are billed as usage on top, per second, with credits that never expire.
Free
For personal projects and weekend hacks.
- 1 project
- 5 active environments per project
- 10 new environments / week
- Full-stack previews (app + Postgres + Redis)
- Encrypted env vars
- Community support
Includes $5 in starter credits for CPU / RAM / build minutes.
Pro
For solo developers who want to bring their own compute.
- 3 projects
- 10 active environments per project
- 30 new environments / week
- Connect one of your own nodes
- Auto-pause idle environments
- Encrypted env vars
Usage billed on top at per-second rates. $10 credits included.
Team
For small teams shipping previews on every branch.
- 5 projects
- 20 active environments per project
- 100 new environments / week
- Invite members and manage your team
- Custom domains
- Auto-pause idle environments
- Connect one of your own nodes
Usage billed on top at per-second rates. $20 credits included.
Enterprise
For engineering orgs that need higher ceilings and SLAs.
- Higher project, environment, and node limits
- Dedicated compute and shared-pool priority
- SSO & audit logs
- SLA + dedicated support
- Invoice billing
- Custom contracts
Volume pricing on compute + 99.9% uptime SLA.
How usage is billed. The plan price covers your project and environment quota. Running environments consume credits at per-second rates for CPU and RAM; builds consume credits per build minute. Pause an environment and usage billing stops immediately. The “new environments / week” number is a velocity guardrail — not a billing lever — so a runaway CI loop can't accidentally spin up hundreds of branches. See resource limits for the full rate card.
Questions, answered
The things teams ask before their first deploy.
What can I deploy on Nexos?
Anything with a Dockerfile — Node, Python, Go, Rails, Elixir, you name it. No framework lock-in. Multi-service projects (app plus background workers, plus Postgres and Redis) work too.
Do my databases really persist across pushes?
Yes. Incremental deploys rebuild only the app container. Your Postgres, Redis, and object storage survive every push until you reset or destroy the environment — so test data and sessions stick around.
How do database migrations run?
Declare them as hooks in nexos.yaml (for example, on_deploy: npx prisma migrate deploy). They run automatically on each deploy. In dev mode, migrations re-run only when their files actually change.
Can I bring my own compute or self-host?
Yes. The node agent is a single Go binary you run on any server — join the shared global pool or keep nodes private to your team. The control plane and agent are open, so you are never locked in.
How does billing work?
Your plan covers project and environment quotas. CPU, RAM, and build minutes are billed per second on top of that. Pause an environment and usage charges stop immediately. Credits never expire.
Do I need a credit card to start?
No. The Free plan includes $5 in starter credits. Connect a GitHub repo and ship your first preview without entering any payment details.
Still have a question? Email us or read the docs.
Give every branch its own URL
Connect a GitHub repo, push a commit, share the link. That is the whole workflow.
No credit card required · $5 in free credits to start
Get the Nexos newsletter
Product updates, preview-environment tips, and the occasional deep dive. One email a month. No spam, unsubscribe anytime.