the home server is one of the projects i use the most. it pulls together raspberry pi hardware, docker, reverse proxy setup, domains, ssl, shared files, and the day-to-day work of keeping a small stack running.
what makes it worth documenting is that it is not one app. it is the place where everything else starts becoming real. projects stop being only local folders once they can be deployed, routed, secured, reached from other devices, and kept alive without too much ceremony.
what is in it
- raspberry pi 5 as the base machine
- docker-based services
- reverse proxy with nginx and let’s encrypt
- domain and subdomain setup
- file access and shared storage
- vpn experiments like wireguard or tailscale
at this point it is also the environment behind this portfolio and other small services i keep running. that includes the reverse proxy, ssl handling, deployed app folders, shared storage, and the rough but useful infrastructure decisions around them.
what the work really looks like
most of it is not glamorous self-hosting content. it is:
- moving things into cleaner docker stacks
- figuring out why certificates do not issue
- separating host concerns from container concerns
- cleaning up messy deploy paths
- checking what is actually exposed and what only feels exposed
- fixing small operational mistakes before they turn into real problems
that is why i keep this project around as a real part of the portfolio. it shows operations work in the practical sense, not as a cloud diagram.
what i am using it for
the server is turning into a small personal platform:
- publishing and updating sites
- running backend services and databases
- handling files across mac and windows
- testing self-hosted workflows i may want to keep or expand
- keeping more of my own stack under my control
it is also where a lot of the current learning happens. networking, ssh hardening, reverse proxying, backup-ish thinking, and small security checks all become much clearer once they affect something you actually depend on.
why it matters
it is one of the clearest examples of work that is actually mine end to end. not just using a service, but running it, fixing it, and understanding where it breaks. it is infrastructure in a small personal form, but the same instincts carry over: understand the stack, reduce fragile manual steps, and make the system easier to trust over time.