Personal project · 2025–2026
Running my own small platform
Most of the projects in my portfolio have to run somewhere, so I run that somewhere myself: four small servers, deployed and monitored like a tiny company's platform rather than a pile of side projects. I wanted to learn the unglamorous half of shipping software: where things live, who can reach them, how you'd know something broke, and how someone new would find their way around.
If a server went down tomorrow, could I redeploy the app somewhere else?
That's the test every app on the platform is held to. The answer I want is "point it at another server and redeploy," not "rebuild it by hand."
For each app, I check five things:
- 1Its code, and the instructions to build it, live in a GitHub repository.
- 2The deploy tool deploys it from that repository, to a server I can change.
- 3Its settings and secrets live in the deploy tool, not baked into the app.
- 4Every piece of data it keeps is listed, with a written way to back it up and restore it on a new server.
- 5Its public address can be moved to another server.
- Green
- Recoverable today. Point it at another server and redeploy.
- Yellow
- Redeploys from the deploy tool, but something still ties it to one server, usually data with no written restore path or an address pinned to one machine.
- Red
- Run by hand. Losing that server means rebuilding it.
Where it stands: some apps are green, and most are yellow. The two stacks on the hand-run server are red, and one of them already has a successor waiting on another server. Every yellow and red app has a roadmap item that names what's keeping it from green.

What I built
None of this is a product. It's the platform my projects run on, and running it is how I learned what the people who keep production up actually worry about.
- Four servers, each with one job: a rented cloud server that runs production and the deploy tool, a home box that serves the public edge, a mini PC for back-office tools and monitoring, and a Raspberry Pi for the home network.
- GitHub is the source of truth. Coolify, on the cloud server, deploys every app from its repository to whichever server it belongs on.
- Settings and secrets live in the deploy tool, never in the code or the docs. The docs say where a secret lives, not what it is.
- Beszel's hub runs on the mini PC and an agent on each server reports in over the private network. It's the one place to look for host health.
- Operator tools, including the deploy dashboard, monitoring, and my internal portals, are reachable only over Tailscale. Anything that lists server addresses or open problems never goes public.
- AI tools reach the platform through read-only gateways. One of them serves the project inventory, and its tests prove it can't change anything: calling every tool leaves the data file byte-for-byte identical.
Documentation as the control
The docs are their own repository with one rule: the live servers are the source of truth. When something is documented, it's checked against what's actually running, and anything nobody has checked yet is marked as unknown instead of guessed.
- About 85 pages, one topic per page: servers, network, security, backups, runbooks, and open issues.
- A decision register with 31 numbered decisions, so the reason behind a choice outlives the conversation where it was made.
- A machine-readable inventory of every project, checked by a schema and a validator. Bad data can't reach the main branch.
- The first automated checks (CI) of any of my repositories. In CI logs, the validator hides the values of anything it rejects, because those values are internal addresses.
Worth knowing
Auditing the live servers against the docs turned up real gaps. I keep them in a tracked list with a severity and an owner for each, and I don't describe the open ones in public.
The screenshots come from a throwaway Beszel install on a test machine with generic server names, so they show no real addresses, hostnames, or services. All four demo agents ran on the same machine, which is why their numbers match.
