Push-to-deploy on the server you already have.
You have a Linux box and a few side projects. Maybe a site, an API, and a Postgres database you'd rather not think about. shed turns that box into a small deployment platform: push to GitHub, and your app is built, started next to its database, put behind HTTPS, and backed up.
It's one binary and it runs on hardware you control. Here's the whole install:
curl -fsSL https://shed.land/install.sh | sudo bashOn Linux (amd64 or arm64) with systemd, and ports 80 and 443 free. The script installs Docker, git, and Railpack if they're missing, asks for your domain, and starts shed.
Push, and it's live
Connect a repository and pick a branch. Every push builds a new image: from your Dockerfile if there is one, or with Railpack if there isn't. If you'd like, shed waits for the commit's CI to pass first.
The new container starts beside the old one. shed checks that it's healthy, moves the traffic over, and only then retires the old one. If the build breaks or the health check never passes, nothing changes for your visitors. The old container keeps serving, and the failed attempt stays in the history with its full log.
Rolling back is redeploying an older build. It reuses the image, so there's no rebuild and no wait for CI. One caveat: a redeploy starts with today's variables, so rolling back code doesn't roll back settings. How deployments work
Your database lives next door
Add Postgres, MySQL, MongoDB, or Redis to a project and it runs on a persistent volume, with a generated password and a connection string ready to use. Services in a project share a private network and find each other by name, like postgres:5432. Nothing is published to the internet unless you ask.
You never copy that password into your app. You point at it, and shed fills it in when the deployment starts:
postgresql://postgres:••••••••••••@postgres:5432/appHTTPS without the yak shaving
Caddy is built into shed, so there's no proxy to configure. Point a domain at the server, add it to a service, and the certificate is issued and renewed for you. Set a wildcard base domain and every new app can get its own address, like web-acme.myshed.com, without a trip to your DNS provider.
Backups you can restore without shed
Every service with a volume is backed up on a schedule, and so is shed's own database. Databases are dumped with their own tools, like pg_dumpall and mysqldump; anything else has its volume archived.
Archives are compressed with zstd, can be encrypted with age, and are kept on disk and, if you add one, in any S3-compatible bucket. Restoring is a button in the dashboard. But the formats are standard on purpose, so if the server is ever gone, the tools you already know are enough:
age -d -i key.txt postgres.sql.zst.age | zstd -d | psql -U postgresKnowing when something breaks
Build logs and live runtime logs are in the dashboard, with your secrets masked. Every service gets CPU, memory, network, and disk charts, sampled every ten seconds and kept for a week.
When a deploy, backup, or restore fails, or a service runs out of memory or starts crashing in a loop, shed can let you know.
If you want more, turn on telemetry. shed runs Grafana with VictoriaMetrics, VictoriaLogs, and VictoriaTraces on the same server, and accepts OpenTelemetry from your apps.
There's also a read-only MCP server, so you can ask a coding agent why the last deploy failed. It reads the deployment, the build log, the runtime log, and the metrics, then tells you. It can't deploy, restart, or delete anything, and it never sees a variable's value.
What shed isn't
shed is small on purpose, and it's better that you hear the limits from us than find them later.
- It's one server. Everything runs on one machine. There's no cluster, no failover, and no scaling out. If the server goes down, so do your apps. When it boots again, Docker brings the containers back and shed checks its books.
- There are no environments. A project is a set of services that run together. For staging, make a second project.
- Databases restart to deploy. Two containers can't share one data directory, so a service with a volume stops its old container before the new one starts. Expect a short outage there.
- Updates restart the proxy. Caddy lives inside shed, so while shed updates itself your domains are unreachable, usually for a few seconds. The containers keep running.
- Builds take turns. One build runs at a time across the whole server, so pushes to several apps at once queue up behind each other.
- It isn't Kubernetes. Underneath, it's Docker, systemd, and one SQLite file, and you can look at each of them with the tools you already have.
Yours to keep
All of shed's state is in that one SQLite file, which it backs up like everything else, with secrets encrypted. The GitHub App asks only for read access, so it can never write to your repositories. Every change and sign-in goes into an audit log.
Updates are signature-checked before they run, and the previous binary stays next to the new one in case you want it back. And the whole thing is free and open source.
Try it on a spare server
Run this, open the setup link it prints, and let shed create its GitHub App in a couple of clicks. Then add a repository and push.
curl -fsSL https://shed.land/install.sh | sudo bash