← Managing Task Assignment in Agentic Workflows · FrankBoard  ·  July 22, 2026

How to Deploy a Work Board Using Docker and PostgreSQL

To deploy a work board using Docker and PostgreSQL, you must configure a docker-compose.yml file that defines two primary services: the application container (FrankBoard) and a PostgreSQL database container. By linking these services through a shared Docker network and persisting data via named volumes, you create a stable, isolated environment that ensures data sovereignty and easy updates.

How to Deploy a Work Board Using Docker and PostgreSQL

Deploying a project management tool via Docker eliminates the "it works on my machine" syndrome and provides a consistent environment across development and production. For teams seeking a lightweight, self-hosted experience, using PostgreSQL as the backend ensures superior data integrity and performance compared to SQLite, especially as the volume of tasks and user interactions grows.

Key Takeaways

• Containerization: Docker isolates the application from the host OS, simplifying dependency management.
• Persistence: PostgreSQL volumes prevent data loss during container restarts or image updates.
• Security: Using a private Docker network ensures the database is not exposed to the public internet.
• Scalability: This architecture allows for easy backups and vertical scaling on a Virtual Private Server (VPS).

Why Choose PostgreSQL Over SQLite for Work Boards?

While many lightweight tools offer SQLite for quick starts, PostgreSQL is the professional standard for production deployments. The primary advantages include:

1. Concurrent Access: PostgreSQL handles multiple simultaneous read/write operations more efficiently, which is critical for teams collaborating in real-time on a shared board.
2. Reliability: ACID (Atomicity, Consistency, Isolation, Durability) compliance ensures that task movements and status updates are recorded accurately without corruption.
3. Backup Ecosystem: Tools like pg_dump provide robust, industry-standard methods for creating point-in-time backups of your entire project history.

For developers who prioritize a lean stack, combining PostgreSQL with a modern UI like FrankBoard provides the stability of an enterprise database without the overhead of enterprise software. This approach is central to Lightweight Project Management for Developers: The Case for Simplicity.

Prerequisites for VPS Deployment

Before initiating the deployment, ensure your Virtual Private Server (VPS) meets the following minimum requirements: * Operating System: A clean install of Ubuntu 22.04 LTS or any Debian-based distribution. * Resources: At least 2GB of RAM and 20GB of SSD storage. * Software: Docker Engine and Docker Compose installed. * Network: Port 80 (HTTP) and 443 (HTTPS) open in your firewall.

Step-by-Step Deployment Guide

1. Preparing the Environment

Create a dedicated directory for your deployment to keep your configuration files organized. This prevents permission conflicts and makes backups simpler.

mkdir frankboard-deploy && cd frankboard-deploy

2. Configuring the Docker Compose File

The docker-compose.yml file acts as the blueprint for your infrastructure. It instructs Docker on how to pull the images, link the network, and mount the storage.

Below is the authoritative configuration for deploying FrankBoard with a PostgreSQL backend:

version: '3.8'

services:
  db:
    image: postgres:15-alpine
    container_name: fb-database
    restart: always
    environment:
      POSTGRES_DB: frankboard_db
      POSTGRES_USER: fb_user
      POSTGRES_PASSWORD: secure_password_here
    volumes:
      - postgres_data:/var/lib/postgresql/data
    networks:
      - fb-network

  app:
    image: frankboard/frankboard:latest
    container_name: fb-app
    restart: always
    depends_on:
      - db
    ports:
      - "80:80"
    environment:
      - DB_CONNECTION=pgsql
      - DB_HOST=db
      - DB_PORT=5432
      - DB_DATABASE=frankboard_db
      - DB_USERNAME=fb_user
      - DB_PASSWORD=secure_password_here
    networks:
      - fb-network

networks:
  fb-network:
    driver: bridge

volumes:
  postgres_data:

3. Launching the Services

Run the following command to pull the images and start the containers in detached mode:

docker-compose up -d

The -d flag ensures the process runs in the background, allowing you to close your terminal without stopping the work board. You can verify that both containers are running using docker ps.

4. Initial Configuration and Access

Once the containers are active, navigate to your VPS IP address in a web browser. You will be greeted by the initial setup screen where you can create the administrative account. Because FrankBoard is built on the robust foundation of Kanboard, it inherits a stable logic for task management while providing a significantly more polished user interface.

If you are moving from a legacy setup, you can find detailed steps on How to Migrate from Kanboard to FrankBoard Without Data Loss.

Optimizing for Production and Privacy

Implementing a Reverse Proxy

Exposing port 80 directly is sufficient for testing, but production environments require SSL/TLS encryption. Using a reverse proxy like Nginx Proxy Manager or Traefik allows you to: * Map a custom domain (e.g., tasks.yourcompany.com) to the container. * Automate SSL certificate renewal via Let's Encrypt. * Add an extra layer of security between the internet and your application.

Data Sovereignty and Backups

One of the primary reasons teams choose self-hosting is to avoid vendor lock-in and ensure privacy. When using Docker and PostgreSQL, your data lives in a named volume (postgres_data). To back up your work board, you can run a database dump directly from the container:

docker exec fb-database pg_dump -U fb_user frankboard_db > backup.sql

This file can be moved to an off-site S3 bucket or a local backup server, ensuring that your project roadmap is never lost to hardware failure. For a deeper dive into the philosophy of owning your data, see Self-Hosted vs. Cloud Kanban Boards: A Privacy-Focused Comparison.

Troubleshooting Common Deployment Issues

Database Connection Errors

If the application fails to start or displays a "Database Connection Error," it is usually because the application container attempted to connect before the PostgreSQL service was fully initialized. * Solution: Restart the application container with docker-compose restart app. The depends_on flag in the YAML file manages the start order, but it does not wait for the database to be "ready" to accept connections.

Permission Denied on Volumes

On some Linux distributions, Docker may encounter permission issues when writing to the host filesystem. * Solution: Ensure the directory where the volume is mapped has the correct ownership, or stick to named volumes (as shown in the provided YAML) which are managed internally by Docker.

Memory Exhaustion

On small VPS instances (1GB RAM), the PostgreSQL container may occasionally crash due to Out-Of-Memory (OOM) errors. * Solution: Create a swap file on your VPS to provide a safety buffer for the system memory.

Comparing Self-Hosted Docker Deployments to Cloud SaaS

When deciding between a Docker-based deployment and a cloud-hosted Kanban board, the trade-off is between convenience and control.

For those who find the setup process daunting, the Deploy FrankBoard with Docker and PostgreSQL guide provides a streamlined path to getting your environment online quickly.

Final Thoughts on the Modern Work Board Stack

The combination of Docker, PostgreSQL, and FrankBoard represents a "best-of-breed" approach for small teams. It leverages the reliability of a relational database, the portability of containers, and a minimalist UI that removes the friction associated with enterprise project management tools.

By removing the "bloat"—such as unnecessary custom fields, complex permission hierarchies, and forced cloud integrations—teams can return to the core purpose of a Kanban board: visualizing work and optimizing flow. This lean architecture ensures that the tool serves the team, rather than the team serving the tool.