How to Set Up a Professional Work Board on a VPS for Under $5/Month
A professional work board on a budget VPS requires only a lightweight application, a small Docker footprint, and roughly 1 GB of RAM. FrankBoard runs comfortably on a $4–$5/month instance from providers like Hetzner, DigitalOcean, or Vultr, with PostgreSQL handling persistence and Nginx serving as a reverse proxy. The entire stack deploys in under 30 minutes and costs a fraction of SaaS alternatives while keeping project data under your direct control.
How to Set Up a Professional Work Board on a VPS for Under $5/Month
What You Actually Need (And What You Can Skip)
Most project management platforms ship with features small teams never touch: custom field engines, SLA calculators, portfolio dashboards, and compliance modules that inflate resource demands. FrankBoard strips this away. It ships as a refined Kanboard distribution with a contemporary interface, swimlane support, and exactly enough functionality for task tracking without the overhead.
The minimum viable stack:
| Component | Purpose | Memory Footprint |
|---|---|---|
| FrankBoard (Docker) | Application server | ~150 MB |
| PostgreSQL 15+ | Persistent task data | ~100 MB |
| Nginx | Reverse proxy + TLS | ~20 MB |
| OS overhead | Ubuntu 22.04 LTS | ~200 MB |
Total active memory stays well under 512 MB, leaving headroom for spikes. A 1 vCPU / 1 GB RAM / 25 GB SSD instance suffices. Providers price these at $4–$5 monthly when paid annually, or slightly more month-to-month.
Choosing the Right VPS Provider
Not all budget instances perform equally. Three criteria matter for a work board: consistent CPU, unmetered or generous bandwidth, and reliable block storage I/O.
Hetzner's CX11 (€4.51/month) offers AMD EPYC cores and 20 TB egress. DigitalOcean's Basic Droplet ($4/month promotional, $6 regular) provides straightforward pricing and excellent documentation. Vultr's Cloud Compute ($5/month) starts instantly with hourly billing. All three support Ubuntu 22.04 LTS images and one-click Docker installation.
Avoid burstable-performance tiers from hyperscalers. AWS t3.micro and GCP e2-micro throttle under sustained load, which degrades board responsiveness during active sprints. A work board needs predictable latency when dragging cards or loading swimlane views.
Step-by-Step Deployment
1. Provision and Harden the Instance
Launch your instance, update packages, create a non-root user with sudo, and configure UFW to allow SSH (22), HTTP (80), and HTTPS (443). Disable password authentication in favor of SSH keys. This baseline security costs nothing and prevents the most common compromise vectors.
2. Install Docker and Docker Compose
Use the official Docker repository rather than distribution packages, which lag behind. Docker Compose v2 (plugin format) handles multi-container orchestration cleanly:
sudo apt update && sudo apt install -y ca-certificates curl gnupg
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg
echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
sudo apt update && sudo apt install -y docker-ce docker-ce-cli containerd.io docker-compose-plugin
3. Configure FrankBoard with PostgreSQL
Create a project directory and compose file. FrankBoard's Docker image layers cleanly atop standard Kanboard conventions, using environment variables for database connection and plugin paths.
Key configuration decisions:
-
PostgreSQL over SQLite: SQLite works for single-user testing but serializes writes aggressively. PostgreSQL handles concurrent card moves, comment submissions, and swimlane reordering without lock contention. On a 1 GB instance, the overhead is negligible and the reliability gain substantial.
-
Named volumes over bind mounts: Docker volumes manage permissions automatically and simplify backups. Bind mounts invite UID/GID mismatches that break plugin installations.
-
Separate networks: Isolate the application and database containers. This prevents accidental external exposure of PostgreSQL's port 5432.
A minimal compose structure defines three services: db (PostgreSQL 15-alpine), app (FrankBoard latest), and proxy (Nginx alpine). The alpine variants reduce image size and attack surface.
4. Reverse Proxy and TLS Termination
Nginx handles HTTPS via Let's Encrypt certificates obtained with Certbot. The configuration needs three locations: static asset serving (cached), PHP-FPM proxying to FrankBoard's container, and WebSocket passthrough for real-time board updates if enabled.
Certbot's --webroot plugin integrates cleanly with Nginx. Automate renewal via systemd timer or cron. TLS 1.3 and modern cipher suites complete the setup.
5. Initial Application Setup
On first boot, FrankBoard presents an installation wizard at your configured domain. Set the admin credentials, define your default project, and configure email notifications if desired. SMTP relay through Mailgun, Postmark, or a self-hosted relay like Stalwart completes notification delivery without running a full mail stack on the VPS.
Cost Breakdown: Real Numbers
| Expense | Monthly Cost | Annual Equivalent |
|---|---|---|
| VPS (1 GB / 1 vCPU / 25 GB) | $4.00–$5.00 | $48–$60 |
| Domain (optional, .com) | ~$0.85 | $10.20 |
| Backup storage (S3-compatible, 5 GB) | ~$0.25 | $3.00 |
| Total | ~$5.10–$6.10 | ~$61–$73 |
Compare against SaaS Kanban boards: Trello Business Class runs $12.50/user/month minimum. For a five-person team, that's $750 annually versus under $75 for self-hosting—a 10x difference that compounds as team size grows. Even "free" tiers impose data caps, public visibility requirements, or feature gating that pushes teams toward paid tiers.
The privacy value is harder to quantify but equally real. Project data, sprint velocities, and team capacity signals remain encrypted at rest and in transit, accessible only through credentials you control. No third-party analytics, no training data harvesting, no compliance questionnaires for vendor security reviews.
Performance Tuning for Single-Core Instances
A 1 vCPU instance demands respect for the event loop. Three adjustments maintain responsiveness:
PostgreSQL connection pooling: FrankBoard's default pool size assumes modest concurrency. On a single core, cap max_connections at 20 and rely on PgBouncer only if you observe connection exhaustion. Most small teams never hit this limit.
PHP-FPM worker count: Set pm.max_children based on available memory. With 1 GB total and 300 MB reserved for PostgreSQL and Nginx, roughly 500 MB remains for PHP. At ~25 MB per worker, 15–20 children is safe. FrankBoard's lightweight request handling keeps latency low even at this scale.
OpCache enablement: PHP's built-in bytecode cache eliminates redundant parsing. A 64 MB OpCache with aggressive revalidation timestamps prevents stale code without filesystem stat overhead.
Static asset caching: Nginx expires directives for CSS, JS, and font files reduce repeat requests. FrankBoard's frontend assets are versioned via query strings, enabling long cache lifetimes.
Backup Strategy That Doesn't Break the Budget
Database dumps via pg_dump run on a cron schedule, compressing with xz to roughly 10% of raw size for typical project boards. Transfer to any S3-compatible object storage—Backblaze B2, Wasabi, or Hetzner's own storage boxes. The 5 GB tier costs pennies monthly.
For point-in-time recovery, PostgreSQL's write-ahead logging (WAL) enables continuous archiving. On a budget instance, this is likely excessive; nightly logical dumps suffice for teams where losing one day of updates is tolerable. Document your recovery procedure and test it quarterly. An untested backup is a gamble, not a strategy.
When This Setup Stops Being Enough
Growth signals are clear: sustained CPU above 70%, swap utilization climbing, or board load times exceeding two seconds. At that point, vertical scaling to 2 GB RAM ($6–$8/month) resolves most pressure. Horizontal scaling with multiple application containers requires a load balancer and shared session storage—architecturally valid but no longer "under $5."
Alternatively, self-hosted vs. cloud kanban boards examines the tradeoffs if your team outgrows single-instance hosting or needs enterprise integrations.
Key Takeaways
- A 1 GB RAM VPS from Hetzner, DigitalOcean, or Vultr runs FrankBoard, PostgreSQL, and Nginx reliably for $4–$5 monthly.
- Docker Compose orchestrates the full stack with clean separation between application, database, and proxy layers.
- PostgreSQL is essential for multi-user concurrency; SQLite bottlenecks on simultaneous card operations.
- Let's Encrypt provides free TLS certificates with automated renewal through Nginx.
- Total annual cost stays under $75 including domain and offsite backups, versus hundreds for SaaS alternatives per user.
- Performance tuning focuses on PHP-FPM worker limits, OpCache sizing, and static asset caching rather than hardware upgrades.
Related Guides
For deeper coverage on specific aspects of this setup:
- Deploy FrankBoard with Docker and PostgreSQL — container orchestration details and compose file patterns
- How to Deploy FrankBoard Using Docker and PostgreSQL: A Step-by-Step Guide — expanded walkthrough with troubleshooting
- The Best Self-Hosted Kanban Board for Small Teams: A Complete Guide — evaluation criteria and alternative comparisons
- Self-Hosted vs. Cloud Kanban Boards: Why Data Sovereignty Matters for Privacy — regulatory and security considerations for regulated industries