Run your servers like you run code.
An essay on what it means to put live infrastructure under version control, and why that hasn't happened until now.
Every developer has had the moment. You're staring at a production server. Something is wrong. You know the box was fine yesterday. You don't know what changed. You don't know who changed it. You don't know whether it was the deploy, or the package upgrade, or the cron job that ran at 3 AM, or the config someone edited from a laptop. git log has spoiled you for the rest of your life, and now you're SSH'ing into a black box and squinting at last output like a forensic archaeologist.
The strange thing is: we accept this. We accept that source code, the abstract specification of behavior, gets cryptographic history, branchable working copies, three-way merges, time-travel, and blame attribution down to the line. And the actual running thing — the live process, the packages installed, the configs in /etc, the kernel parameters, the services enabled — gets, at best, a snapshot you took two weeks ago and a memory of what you fixed since.
ComputeForge exists to close that gap.
The wrong abstractions
For twenty years, the industry's answer to "how do I manage a live server" has been one of three things, all of them wrong.
Configuration management — Puppet, Chef, Ansible, Salt — said: the spec is the truth, the running server is a re-creatable artifact. So we wrote our spec, ran the spec, and then learned that the running server drifts from the spec the moment a human touches it. Drift detection became its own industry. The spec was a wish, not a reality.
Infrastructure-as-Code — Terraform, Pulumi, CloudFormation — said: forget servers, describe topology. So we wrote our topology, applied our topology, and then learned that what runs inside the VMs is invisible to the topology language. We had perfect history of how many VMs existed and zero history of what they were doing.
Observability — Datadog, Honeycomb, Grafana — said: stop trying to know what changed, instead measure outcomes. So we wired up dashboards and alerts and learned that we could see thatsomething was wrong, sometimes very precisely, but the closer we tried to look at what changed on the box, the further we got from anything resembling source control.
None of these are wrong, exactly. They're all useful. But none of them give you what git gives a working programmer: the ability to look at the live thing, ask "what's different from yesterday," get a precise answer, branch a sandbox to try a fix, throw the sandbox away, and roll forward when you've found the right change.
What version control on a live server actually means
We mean it literally, and most of it works today, in the panel, the API and the cf CLI (what is not live yet is marked "Coming soon" across this site). Changes to the tracked paths on a connected VM are recorded with timestamp, agent of change, and content hash. cf log prod-web shows the history. cf diff prod-web @{12.hours.ago} shows what's different. cf blame /etc/nginx/api.conf tells you who changed which line and when. cf branch prod makes a running copy of the server — in a minute or two on our cloud (at DigitalOcean, Hetzner or AWS with your own API token: Coming soon). cf tag names a state. cf checkout restores it, and cf revert undoes one specific change (files need apply mode on the server; on our cloud a whole server can be restored). cf push migrates the whole VM to another provider. Coming soon
The verbs are the same as git's. The substrate is different — block-level snapshots, agent-recorded file events, the content of configuration files and hashes of the rest, and any path you tell us to track. The point is that the operations feel the same as the operations you already do on source code, and the mechanism behind them is engineered to make that feeling honest.
Cross-provider, on purpose
ComputeForge works on the Linux servers you connect (systemd or OpenRC, amd64 or arm64) — at AWS, GCP, DigitalOcean, Hetzner, Linode, your homelab, or our own metal. We are not a hosting company that grudgingly added a panel; we are an operations layer that ships its own hosting tier as one option among many, designed to integrate cleanly with everywhere else you already run.
This matters because lock-in is the wrong way to keep customers. The right way is to be useful enough that leaving costs more than staying, and to make sure that if leaving ever does become cheaper, the door isn't bolted shut. Our exports use open formats: a server's checkpoint as a standard Borg or Restic archive, encrypted with your key and restorable on any Linux box; DNS as standard BIND zone files; the mesh as standard WireGuard configs. Your data, your format, your keys.
What we don't do
We don't fabricate numbers. If we haven't measured it, it doesn't appear in our marketing copy. No fake uptime stats, no fake migration speeds, no fake sign-up-to-SSH timings. If the number is interesting and we don't have it yet, we leave it out.
We don't trap your data. Your activity log exports today as CSV or JSON-Lines through the API. The checkpoint, DNS and mesh exports use the open formats above, so you can restore them without us.
We don't hide how we act on accounts. Our abuse policy lists what can stop a server, its mail or an account, what you are told, and how to reach a person.
Where this goes
Today: cloud servers in one region, billed monthly or by the second, with the panel, the API, the cf CLI, snapshots, backups and DNS hosting. On any server you connect: cf log (and fleet-level cf log --all), cf diff, cf blame, cf tag, cf checkout, cf revert, integrity scans, a private mesh, and health checks that can switch DNS to a standby. On our cloud: branches in a minute or two, cf merge to bring a branch's file changes back, whole-server checkout on the same IP addresses, checkpoints exported in open formats, and whole servers archived and downloadable as a standard disk image.
Being built now, and marked "Coming soon" across this site until each one ships: cf push between providers, branching at other providers, and an AI sysadmin that reads diffs, explains them and suggests cherry-picks. OS upgrades are a workflow, not a verb: branch, upgrade the branch, cf diff, then cf merge --whole. The same primitives, applied wider.
Eventually: every running server in the world is under version control, and running production works the way working on a code base does. You can always see what changed. You can always go back. You can always branch and try.
Until then, we'll keep building.