Per-build billing punishes shipping
Build minutes, seats, bandwidth, a line on the invoice for every environment. The better your week goes, the bigger the bill — and the team quietly starts batching deploys to keep it down.
Early access · launch pricing
Your servers. Your bill stays flat.
Jervis DevOps deploys and runs your apps on servers you already own — deploys, domains, SSL, databases, backups, monitoring and a real terminal, from one dashboard. Every build runs on your own machine, so shipping twenty times a day costs exactly what shipping once costs.
No card today. We open servers in small batches and email you when your slot is ready.
shop-api · main healthy
jervis deploy shop-api --branch maingit fetch origin mainnpm cinpm run buildbuild finished · 62 MBrelease 20260917-1142symlink current → 20260917-1142systemctl restart shop-apihealth check /healthz → 200 in 340msdeployed in 1m 04s · rollback availableBuilt for teams who own their serversOutbound 443 onlyUnlimited deploysOne-click rollbackDocker optionalYour data stays on your server
The problem
Three reasons teams move off their platform
None of them are about features. They are about the invoice, the network, and the day something breaks.
Your network blocks anything inbound
NAT, CGNAT, a corporate firewall, no static IP. Anything that needs an inbound SSH port turns into a ticket with the network team, and the ticket takes a week.
The server is a terminal and nothing else
SSH gives you everything and shows you nothing: no deploy history, no rollback, no record of who restarted the service at 2am — and one person who still remembers how it was set up.
How it works
Three steps to your first deploy
- 01
Install the agent
One command on the server. The agent registers itself, dials out over 443, and starts reporting CPU, memory and disk. Nothing listens on a public port.
- 02
Connect a repository
Point Jervis at GitHub, pick the branch and the runtime. It proposes the build and start commands, you confirm them, and the environment variables are stored encrypted.
- 03
Push, and watch it deploy
Every push builds on your server, writes a new release, swaps the symlink and restarts the service. The log streams live, the health check gates the switch, and the previous release stays one click away.
What you get
One dashboard for the whole server
Not deploys alone. The things you would otherwise stitch together from five tools and a folder of shell scripts.
Deploys & rollback
Atomic releases with a symlink swap, live build logs, and one click back to any release you kept.
Domains & SSL
Add a domain, point the DNS, and the certificate is issued and renewed for you.
Databases
Provision Postgres or MySQL next to the app, with the credentials injected into its environment — no password pasted into a config file.
Backups
Database and file backups to any S3-compatible storage, on demand or on a schedule, and a restore you can actually run from the dashboard.
Monitoring & alerts
CPU, memory and disk per server, a health check per app, and email or Telegram the moment something goes down.
Browser terminal
A real shell on the server in a browser tab, with the permissions your role already has — and every session written to the audit log.
Scheduled jobs
Cron managed from the dashboard instead of a crontab nobody remembers, with the output captured and failures alerted.
Teams & audit
Owner, admin, member and viewer roles, invitations, API tokens, and an audit trail that answers who did what and when.
Windows servers
In progressThe Windows agent installs as a service and serves apps through Caddy, but it has not run in enough real environments for us to call it production-ready. Linux has.
Runtimes it deploys today
Node.jsPHP / LaravelPythonStatic sitesDockerDocker ComposeAny start commandEverything included
The full list
Every capability Jervis DevOps has today, with nothing listed that it does not actually do.
Deploy from Git
- Any Git hostGitHub through an app install, GitLab, Gitea and Bitbucket with an access token, or any plain Git URL.
- Deploy on push, on tag, or by handPick a branch and every push to it deploys; or deploy only tags that match a pattern; or keep it manual.
- No CI pipeline to maintainThe build runs on your server when the push arrives. No GitHub Actions workflow, no runner, no build minutes.
- Pull request previewsFor GitHub repositories: open a pull request and it gets its own temporary app and address; close it and the preview is removed.
- Ready-made templatesStart from Next.js, Express, Django, FastAPI, a Dockerfile, or hosted apps like n8n and Uptime Kuma.
Runtimes and app types
- Node.jsThe version you pin is installed for you, with npm, pnpm or Yarn picked from your lockfile.
- PythonA virtual environment per release, served by the start command you give it, such as gunicorn or uvicorn.
- PHP and LaravelServed through its own php-fpm pool, with the directories you name kept across releases.
- Static sitesBuild once, served straight from nginx. VitePress, Vite, Astro, plain HTML.
- Docker and ComposeBuild your Dockerfile, run a public image, or bring up a whole docker compose stack.
- Anything with a start commandGo, Rust, a binary: if it builds on the server and starts with one command, it runs as a service.
Releases you can trust
- Atomic switchEach deploy is a new release directory; going live is a single symlink swap, so there is no half-deployed moment.
- One-click rollbackThe last five releases stay on disk, so going back is a switch, not a rebuild.
- A deploy only succeeds if the app stays upAfter starting it, the deploy watches your process for 30 seconds and fails if it crashes or keeps restarting. You can set the window per app.
- Health checks and hooksProbe a path of your choice after each deploy, and run your own commands before the build and after the app is live.
- Live build logsWatch every line of the build as it happens, cancel a deploy mid-way, and keep the log of every one afterwards.
Domains and certificates
- An address the moment you create an appEvery app gets its own subdomain right away, so it is reachable before your DNS is ready.
- Your own domainsAdd a domain, see the exact DNS record to create, and it goes live once the record points at your server.
- Certificates handled for youLet's Encrypt certificates are issued and renewed automatically, and the dashboard shows how many days each has left.
Configuration and secrets
- Environment variablesEncrypted at rest, with secrets that are never shown again once saved.
- Import from your projectIf your code ships a .env.example, the dashboard lists the variables you have not set yet and fills them in for you.
Databases, backups and files
- Postgres and MySQLCreate a database next to the app with its own user, and the connection string lands in the app's environment.
- Backups off the serverDatabases and files archived to any S3-compatible storage, on demand or on a schedule, and restored from the dashboard.
- File managerBrowse and edit the files your app keeps between releases, without SSH.
Run and watch
- Live logsStream your app's output, and the agent's own, straight into the browser.
- Browser terminalA real shell on your server in a tab, for the roles you allow, with every session in the audit log.
- Scheduled jobsCron jobs managed from the dashboard, running in your app's directory with its environment.
- Server usageCPU, memory and disk for every server, live, and the state of every app on it.
- AlertsEmail or Telegram when an app fails or a server goes offline.
Publish packages
- Release a library the same way you deploy an appTag a version and it is tested, built and published to npm, PyPI, Packagist, crates.io, NuGet, RubyGems, JSR, Go or a Docker registry.
Teams and security
- Roles and invitationsOwner, admin, member and viewer, with invitations by link or email.
- Two-factor sign-inAn authenticator app code on top of the password, with recovery codes.
- API tokensScoped tokens for scripts and CI, shown once and never stored in the clear.
- Audit logWho deployed, changed a setting, opened a terminal or removed a domain, and when.
- Builds never run as rootYour code is built and run by an unprivileged deploy account, not by the agent's own root account.
Your servers
- One command to connect a serverPaste the install command on any Linux server you own; the agent connects out, so no inbound port is opened.
- Lives next to what is already thereIt can keep its apps out of /var/www and never touches sites it did not create.
- Updates itselfUpdate the agent on any server from the dashboard; the new binary is checked before it replaces the old one.
Where Jervis sits
Two honest alternatives, and what changes when you run your own servers with a dashboard on top.
| What matters | Managed platform | SSH by hand | Jervis |
|---|---|---|---|
| Where builds run | Their fleet, metered by the minute | Your server, by hand | Your server, automated |
| Cost of shipping more often | Rises with every build | Your evening | Flat |
| Behind a firewall or NAT | Fine, the code leaves your network | Needs an inbound port or a VPN | Outbound 443, nothing to open |
| Rollback | One click | Whatever you scripted | One click, to any kept release |
| Where your data lives | Their infrastructure | Your server | Your server |
| Who did what | Their dashboard | Shell history, if you are lucky | An audit log per team |
| Docker | Usually required | Your call | Optional |
Scroll the table sideways to compare
Install
One command on the server
The dashboard fills in your host and a one-time token the moment you add a server. Windows gets the same thing in PowerShell.
curl -fsSL https://your-jervis-host/install.sh | sudo sh -s -- --token=SERVER_TOKEN- Add the server in Jervis and copy the command with its one-time token.
- Run it once on the server as root. It installs the agent as a systemd service and starts it.
- Watch the server turn online in the dashboard — it usually takes under a minute.
- Connect a repository, confirm the build command, and deploy.
Pricing
Launch pricing, per team
Priced by what you run, never by how often you deploy. Early-access teams keep this price for their first year.
MonthlySave up to 16%
Starter
One server, one product, one person on call.
$12/month
1 server · Unlimited apps · 1 member
Every feature included; plans differ only in limits
Get early accessTeam
A few servers, and people who deploy each other's work.
$29/month
10 servers · Unlimited apps · 5 members
Every feature included; plans differ only in limits
Get early accessBusiness
A fleet, more than one team, and someone who asks for the audit trail.
$79/month
Unlimited servers · Unlimited apps · Unlimited members
Every feature included; plans differ only in limits
Priority support with a named contact
Get early accessIncluded in every plan
- Unlimited deploys and one-click rollbacks
- Custom domains with automatic SSL
- Scheduled jobs
- Postgres and MySQL databases, credentials injected for you
- Backups to your own S3-compatible storage
- Email and Telegram alerts
- Browser terminal and live logs
- Pull-request previews for GitHub repositories
- Roles, invitations and the audit log
- API tokens and deploy webhooks
Launch pricing while we are in early access. Prices are in US dollars and exclude VAT. There is no free plan — the servers are yours, the support is ours, and both cost something.
Questions we actually get
No. Jervis deploys Node, PHP, Python, Go and static sites straight onto the server with systemd. If you already have a Dockerfile it will use it, but nothing pushes you into containers.
No. It opens an outbound TLS connection on 443 and keeps it alive, so it works behind NAT, CGNAT and corporate firewalls. There is nothing inbound to expose and no SSH key to hand around.
Yes. Builds use your own server’s CPU, so there are no build minutes for us to meter. Your plan sets how many servers, apps and members you get — never how often you ship.
The running release keeps serving. A failed build never touches the live symlink, and a failed health check stops the switch. You get the log, the error code, and a rollback that is one click away.
Not for production yet, and we would rather say so than sell it. The Windows agent installs as a service and serves apps through Caddy, but it has not run in enough real environments for us to stand behind it. Linux has.
On your servers. Source, builds, databases, uploads and backups stay on machines you own. Jervis keeps the account, the app configuration and the deploy history, so the dashboard has something to show you.
Early access
Tell us what you run
We open servers in small batches so we can help each team set up properly. Tell us what you are running and we will email you when your slot is ready.
- Outbound 443 only
- Unlimited deploys
- One-click rollback
- Docker optional
- Your data stays on your server