Weekend Showcase Challenge: Server Control Room
A self-hosted server monitoring dashboard unifying Netdata and Portainer, deployed to AWS EC2 with an automated GitHub Actions CI/CD pipeline.
Vision: What It Does
Managing a live production server usually means bouncing between multiple tools — one dashboard for system metrics, another for container status, and a third if you want alerts when something's about to break. When I was working hands-on with a Hetzner production server, this constant tool-switching was slowing me down and making it easy to miss early warning signs.
Server Control Room solves that by unifying everything into a single, self-hosted monitoring dashboard. It pulls live CPU, RAM, disk, and network metrics from Netdata, container status and stats from Portainer CE, and combines both into one clean interface — no more jumping between tabs to understand server health at a glance. On top of that, a background Python watcher continuously polls system stats and sends automated email alerts the moment CPU, RAM, or disk usage crosses a configurable threshold, with a cooldown period to avoid alert spam.
It's a lightweight, zero-framework tool — plain HTML/CSS/JS, no build step, served entirely through Nginx in Docker.
How I Built It
The dashboard itself is intentionally simple on the frontend: static HTML/CSS/JS served by an Nginx container, with reverse proxy rules routing
/netdata/ and /portainer-api/ to their respective services running locally on the host. This keeps the frontend dependency-free while still surfacing real-time data from two separate monitoring backends.The trickier part was the watcher service — a Python container with read-only access to the host filesystem and the Docker socket, polling metrics every 15 seconds and triggering SMTP-based alerts when thresholds are breached. Getting this right meant thinking carefully about
docker-compose.yml networking: the server-gui service runs in network_mode: host so it can reach Netdata (port 19999) and Portainer (port 9000) on the same machine exactly the way Netdata itself does, while the watcher stays isolated with only the specific mounts it needs.For this weekend's showcase, I took the project further by adding a proper CI/CD pipeline. Every push to
main now triggers a GitHub Actions workflow that SSHs into the EC2 instance, pulls the latest code, rebuilds the Docker images, and redeploys — all automatically, with zero manual intervention. Setting this up meant generating a dedicated deploy key on the server, wiring it into GitHub Secrets, and writing a workflow that handles the full pull-rebuild-restart cycle cleanly, including pruning old images so the instance doesn't accumulate dead layers over time.AWS Services Used & Architecture
- Amazon EC2 — hosts the entire stack: the dashboard container, the watcher container, Netdata, and Portainer, all running on a single Ubuntu instance
- Security Groups — configured to expose the dashboard (8090), Netdata (19999), Portainer (9000), and SSH (22) for management and CI/CD access
GitHub push → GitHub Actions → SSH into EC2 → git pull → docker compose up -d --build │ ┌─────────────┴─────────────┐ │ │ server-gui (Nginx) watcher (Python) proxies to Netdata polls host stats, & Portainer locally sends SMTP alertsThe deployment is intentionally minimal — one EC2 instance, Docker Compose orchestrating everything locally, and GitHub Actions handling the deploy trigger. No orchestration platform, no managed services beyond EC2 itself — just enough infrastructure to keep it reliable and easy to reason about.
What I Learned This Summer
This summer pushed me from writing individual scripts to thinking in terms of full systems — how a frontend, a background service, a reverse proxy, and a deployment pipeline all need to work together reliably, not just individually. Working through real networking issues (getting
network_mode: host right so containers could reach host-level services), debugging Docker permission and volume mount issues, and now wiring up a genuinely automated CI/CD pipeline gave me a much clearer picture of what "production-ready" actually requires — not just working code, but a repeatable, observable way to ship it.Try It / Repo
Shoutout
Tagging Lewis Sawe, whose "Museum That Grows" project — an always-on agent that autonomously curates a museum for a civilization that never existed — was one of the standout builds I followed this summer. Genuinely creative use of autonomous agents, and inspiring to see what's possible when you let a build run on its own.
#application


Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article