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 · Free tier available · 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 every plan is a flat monthly fee with included vCPU, vRAM, and build-minute quotas — no usage charges on top — 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] fetching delta → feature/new-checkout
[nexos] web changed · rebuilding
[nexos] api, worker, migrations untouched · skipped
ready in 14s
preview → https://feature-new-checkout-acme.nexos.rsA loop fast enough for humans — and AI agents
Every node keeps a persistent mirror of your repo, so a push fetches only the new commits — never a full clone — and Nexos diffs the push to rebuild only what changed. Services whose files are untouched keep their running containers, and migrations re-run only when their files change.
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 fast feedback — not against mocks.
- Incremental git fetches — persistent per-node mirrors, no full clones
- Unchanged services skip the rebuild — their containers keep serving
- Migrations re-run only when their files change
- Real Postgres, Redis, and storage, persisted across deploys
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.
Predictable flat pricing
Each plan is a flat monthly fee with hard vCPU, vRAM, and build-minute quotas included. Hit a cap and deploys pause until you upgrade — your bill never changes mid-month.
Live build logs
Stream BuildKit output and container logs into your dashboard over WebSocket. See exactly what is happening as it happens.
Flat monthly plans, no usage metering
Pick a plan based on how many projects you ship and how many environments you keep open. Every tier is a flat monthly fee — vCPU, vRAM, and build minutes are included, with no usage charges on top. Team includes 5 members; add more seats or compute as add-ons.
Free
For personal projects and weekend hacks.
- 1 project, 5 environments, 2 active at once
- 2 vCPU, 4 GB vRAM total
- Full-stack previews (app + Postgres + Redis)
- Encrypted env vars
- Community support
No credit card required.
Pro
For solo developers shipping multiple side projects.
- 3 projects, 15 environments, 5 active at once
- 6 vCPU, 12 GB vRAM included
- Add +1 vCPU / +2 GB vRAM for $5/mo each
- Auto-pause idle environments
- Remote TCP endpoints (DB connect)
- Encrypted env vars
Flat monthly fee — no usage charges.
Team
For small teams shipping previews on every branch.
- 10 projects, 50 environments, 15 active at once
- 12 vCPU, 24 GB vRAM included
- Add +1 vCPU / +2 GB vRAM for $5/mo each
- 5 members included, add more for $5/seat/mo
- Custom domains
- Auto-pause idle environments
Flat monthly fee — no usage charges.
Enterprise
For engineering orgs that need higher ceilings and dedicated support.
- Higher project, environment, and node limits
- Private nodes + dedicated compute
- Priority support
- Invoice billing
- Custom contracts
From $199/mo. Volume limits negotiated per contract.
How limits work. Your plan sets hard caps on projects, total environments, and how many can be active at once, plus vCPU, vRAM, and build-minute quotas. Need more compute on the same tier? Resource add-ons raise your vCPU/vRAM ceilings by +1 vCPU / +2 GB vRAM per unit for $5/mo each — structured like extra seats. Hit a cap and new deploys pause until you upgrade or free capacity — your bill never changes mid-month. See resource limits for the full breakdown.
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. Migration jobs re-run only when their files actually change — unrelated pushes skip them.
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?
Each plan is a flat monthly subscription. Your fee covers project, environment, vCPU, vRAM, and build-minute quotas — no usage charges on top. Need more compute without jumping tiers? Add resource add-ons: +1 vCPU and +2 GB vRAM for $5/mo each, just like extra seats. Hit a cap and new deploys pause until you upgrade or free capacity. Upgrade or cancel anytime.
Do I need a credit card to start?
No. The Free plan is enough to 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 · Free tier to start
Get the Nexos newsletter
Product updates, preview-environment tips, and the occasional deep dive. One email a month. No spam, unsubscribe anytime.