Focalboard on VPS: Installation, Configuration, and Maintenance

To install Focalboard on a VPS and use it effectively, you need a virtual server with at least 2 vCPU, 4 GB RAM, and an NVMe disk, and deployment is most conveniently done using Docker Compose for quick setup and isolation.

What is Focalboard and what is it for?

Focalboard is an open-source, self-hosted project and task management application developed by the Mattermost team. It offers flexible Kanban-style boards, task lists, and calendars, allowing teams and individual users to organize their work, track progress, and visualize tasks. Unlike many SaaS solutions, Focalboard provides full control over data, making it an ideal choice for those looking for a focalboard self-hosted solution with an emphasis on privacy and customization.

Key features and use cases for Focalboard

Focalboard combines best practices in project management, offering an intuitive interface and powerful functionality. It allows you to create various types of boards: Kanban for flexible workflow management, Table for detailed data viewing, Calendar for time-based planning, and Gallery for visual projects. Each item (card) can contain numerous properties such as assignees, statuses, priorities, due dates, checklists, and attachments. This makes Focalboard a versatile tool for a wide range of tasks:

• Software Development Management: Tracking bugs, tasks, sprints, and releases.
• Marketing Campaigns: Content planning, social media management, results tracking.
• Personal Planning: Organizing daily tasks, hobbies, long-term goals.
• Educational Projects: Coordinating group assignments, tracking academic progress.
• HR and Recruiting: Candidate management, hiring stages, onboarding.
• Operational Activities: Meeting planning, resource management, reporting.

Thanks to its architecture and the ability to install Focalboard on your own server, it becomes an excellent alternative to commercial products like Trello, Asana, or Jira, especially for teams that value complete independence and control over their infrastructure. This is particularly relevant for companies dealing with confidential data or having strict compliance requirements.

Focalboard System Requirements on VPS

Choosing the right VPS configuration for Focalboard depends on the anticipated load: the number of active users, the volume of stored data (number of cards, attachments), and the intensity of use. Focalboard can operate in two main modes: with a file-based database (SQLite) for small installations or with a full-fledged DBMS (PostgreSQL, MySQL) for scalable and high-performance solutions.

Optimal VPS Configuration for Different Use Cases

When deploying Focalboard on a server, it's important to consider not only current but also future needs. Excess capacity isn't always a problem, but insufficient capacity can lead to slowdowns and failures. Valebyte.com offers various plans that can be adapted to your needs.

Use Case	vCPU	RAM	NVMe Disk	Approximate VPS Cost (Valebyte.com)	Features / Recommendations
Personal Use / Small Team (1-5 users)	2	2-4 GB	50 GB	From $5 - $10/month	Focalboard with SQLite (default), Docker Compose. Ideal for experiments and small projects.
Medium Team (5-25 users)	2-4	4-8 GB	100-200 GB	From $10 - $25/month	PostgreSQL recommended. Active use of attachments, multiple boards. Reverse Proxy is mandatory.
Large Team / Department (25-50 users)	4-6	8-16 GB	200-400 GB	From $25 - $50/month	PostgreSQL in a separate Docker container or dedicated database. Intensive interaction, large data volume.
Enterprise / Multiple Departments (50+ users)	6+	16+ GB	400+ GB	From $50+/month	Dedicated server or powerful VPS. Clustering, PostgreSQL optimization, CDN for static assets.

It's important to remember that NVMe disks provide significantly higher read/write speeds compared to traditional SSDs, which is critical for database performance and overall application responsiveness. All Valebyte.com plans use high-performance NVMe disks, ensuring stable and fast operation of your Focalboard VPS.

When choosing an operating system for your VPS, preference should be given to Linux-based distributions such as Ubuntu Server (20.04 LTS or 22.04 LTS recommended) or Debian. These OSes are well-supported by Docker and have extensive communities.

Step-by-step Focalboard Installation on VPS via Docker/Compose

Installing Focalboard using Docker and Docker Compose is the most recommended and straightforward method. It provides application isolation, easy dependency management, and simplifies scaling and updates. Below is a detailed guide for installing Focalboard on a VPS.

Preparing the VPS for Docker and Docker Compose Installation

Before proceeding with Focalboard deployment, you need to prepare your VPS:

1. System Update: Connect to your VPS via SSH and update packages:

   sudo apt update && sudo apt upgrade -y

2. Docker Installation: Install Docker Engine by following the official documentation. For Ubuntu, this will look like:

   sudo apt install apt-transport-https ca-certificates curl software-properties-common -y
   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 docker-ce docker-ce-cli containerd.io -y

   Add your user to the docker group to avoid using sudo with Docker commands:

   sudo usermod -aG docker $USER
   newgrp docker

3. Docker Compose Installation: Download the latest stable version of Docker Compose:

   sudo curl -L "https://github.com/docker/compose/releases/download/v2.24.5/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
   sudo chmod +x /usr/local/bin/docker-compose

   Verify the installation:

   docker --version
   docker-compose --version

4. Create a directory for Focalboard:

   mkdir -p ~/focalboard
   cd ~/focalboard

Deploying Focalboard with PostgreSQL via Docker Compose

For stable operation and scalability, it is recommended to use PostgreSQL as the database. Create a docker-compose.yml file in the ~/focalboard directory:

nano docker-compose.yml

Insert the following configuration, replacing YOUR_POSTGRES_PASSWORD with a strong password:

version: '3.8'

services:
  focalboard:
    image: mattermost/focalboard:latest
    container_name: focalboard
    restart: unless-stopped
    ports:
      - "8000:8000"
    environment:
      # PostgreSQL database connection settings
      - FB_DB_TYPE=postgres
      - FB_DB_CONNECTION_STRING=postgres://focalboard:YOUR_POSTGRES_PASSWORD@db:5432/focalboard?sslmode=disable
      # Domain name settings (for correct link operation)
      - FB_SERVER_PUBLIC_URL=https://your_domain.com
      # Settings for using Nginx/Caddy as a proxy
      - FB_SERVER_LISTEN_ADDRESS=:8000
    volumes:
      - ./data:/opt/focalboard/data # For storing attachment files
      - ./plugins:/opt/focalboard/plugins # For plugins
    depends_on:
      - db

  db:
    image: postgres:13-alpine
    container_name: focalboard_db
    restart: unless-stopped
    environment:
      POSTGRES_USER: focalboard
      POSTGRES_PASSWORD: YOUR_POSTGRES_PASSWORD
      POSTGRES_DB: focalboard
    volumes:
      - ./db_data:/var/lib/postgresql/data # For storing PostgreSQL data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U focalboard -d focalboard"]
      interval: 10s
      timeout: 5s
      retries: 5

networks:
  default:
    name: focalboard_network

Don't forget to replace YOUR_POSTGRES_PASSWORD and https://your_domain.com with actual values. If you plan to use a different port, change 8000:8000. At this stage, we will use port 8000 inside Docker and proxy it externally via Nginx/Caddy.

Start the containers:

docker-compose up -d

Check the status of the containers:

docker-compose ps

If everything is running correctly, you will see two active containers: focalboard and focalboard_db. Focalboard is now accessible on port 8000 of your VPS (e.g., http://your_vps_ip:8000), but for full use and security, a reverse proxy and HTTPS setup are required. This is an important step for any Focalboard Docker installation.

If you are looking for other project and task management solutions, consider Planka on VPS or Vikunja on VPS, which are also easily deployed on Valebyte.com.

Setting up Reverse Proxy (Nginx/Caddy) and HTTPS

Direct access to Focalboard via IP address and port 8000 is neither secure nor convenient. To ensure security, use a domain name, and enable HTTPS encryption, you need to set up a reverse proxy server. We will cover two popular options: Nginx and Caddy.

Nginx as a Reverse Proxy with Let's Encrypt

Nginx is a powerful and widely used web server that excels as a reverse proxy. To start, install Nginx:

sudo apt install nginx -y

Create a configuration file for your domain (e.g., focalboard.conf) in the /etc/nginx/sites-available/ directory:

sudo nano /etc/nginx/sites-available/focalboard.conf

Insert the following configuration, replacing your_domain.com with your domain:

server {
    listen 80;
    server_name your_domain.com www.your_domain.com;

    location / {
        proxy_pass http://localhost:8000;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_buffering off;
        proxy_request_buffering off;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
        proxy_read_timeout 900s; # Increase timeout for large attachments
    }
}

Create a symbolic link to this file in sites-enabled and test the Nginx configuration:

sudo ln -s /etc/nginx/sites-available/focalboard.conf /etc/nginx/sites-enabled/
sudo nginx -t
sudo systemctl restart nginx

Focalboard is now accessible via HTTP through your domain. For HTTPS, use Certbot from Let's Encrypt:

sudo apt install certbot python3-certbot-nginx -y
sudo certbot --nginx -d your_domain.com -d www.your_domain.com

Follow Certbot's instructions. It will automatically update the Nginx configuration to use HTTPS and set up automatic certificate renewal. After this, your Focalboard VPS will be accessible via HTTPS.

Caddy as an Automatic Reverse Proxy with HTTPS

Caddy is a modern web server that automatically configures HTTPS using Let's Encrypt. This makes it very easy to use. Install Caddy:

sudo apt install -y debian-keyring debian-archive-keyring apt-transport-https
curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/gpg.key' | sudo gpg --dearmor -o /usr/share/keyrings/caddy-stable-archive-keyring.gpg
curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/debian.deb.txt' | sudo tee /etc/apt/sources.list.d/caddy-stable.list
sudo apt update
sudo apt install caddy -y

Create a Caddyfile in the /etc/caddy/ directory:

sudo nano /etc/caddy/Caddyfile

Insert the following configuration, replacing your_domain.com with your domain:

your_domain.com {
    reverse_proxy localhost:8000 {
        header_up Host {host}
        header_up X-Real-IP {remote_ip}
        header_up X-Forwarded-For {remote_ip}
        header_up X-Forwarded-Proto {scheme}
        # Increase timeout for large attachments
        transport http {
            read_timeout 15m
            write_timeout 15m
        }
    }
}

Test the Caddy configuration and restart the service:

sudo caddy validate --config /etc/caddy/Caddyfile
sudo systemctl restart caddy

Caddy will automatically obtain and configure HTTPS certificates for your domain. This significantly simplifies the process, making Focalboard on the server secure without manual SSL configuration. Proper reverse proxy setup is also important for other self-hosted solutions, such as Filebrowser on VPS, ensuring centralized access management.

Focalboard Backups and Updates

Regular backups and timely updates are critically important aspects of maintaining any self-hosted application, including Focalboard. This ensures data integrity and access to new features and security fixes.

Focalboard Data Backup Strategies

For Focalboard deployed via Docker Compose, data is stored in two main locations:

1. PostgreSQL Database: Contains all Focalboard metadata (cards, boards, users, properties).
2. Attachments directory: ./data, where uploaded files are stored.

An optimal backup strategy should include both these parts. It is recommended to use a script that will run on a schedule (e.g., via Cron).

Example backup script (save as backup_focalboard.sh):

#!/bin/bash

# Settings
BACKUP_DIR="/var/backups/focalboard"
DATE=$(date +%Y%m%d%H%M%S)
DB_CONTAINER="focalboard_db" # Database container name from docker-compose.yml
DB_USER="focalboard" # DB user from docker-compose.yml
DB_NAME="focalboard" # DB name from docker-compose.yml
FOCALBOARD_DATA_DIR="/root/focalboard/data" # Path to Focalboard data directory on the host

# Create backup directory if it doesn't exist
mkdir -p "$BACKUP_DIR"

echo "Starting Focalboard backup on $DATE..."

# 1. PostgreSQL Database Backup
echo "Creating PostgreSQL database dump..."
docker exec "$DB_CONTAINER" pg_dump -U "$DB_USER" -d "$DB_NAME" > "$BACKUP_DIR/focalboard_db_$DATE.sql"

if [ $? -eq 0 ]; then
    echo "Database dump successfully created: $BACKUP_DIR/focalboard_db_$DATE.sql"
else
    echo "Error creating database dump!"
    exit 1
fi

# 2. Archiving attachments directory
echo "Archiving attachments directory..."
tar -czvf "$BACKUP_DIR/focalboard_data_$DATE.tar.gz" -C "$(dirname "$FOCALBOARD_DATA_DIR")" "$(basename "$FOCALBOARD_DATA_DIR")"

if [ $? -eq 0 ]; then
    echo "Data archive successfully created: $BACKUP_DIR/focalboard_data_$DATE.tar.gz"
else
    echo "Error archiving data directory!"
    exit 1
fi

# 3. Deleting old backups (e.g., older than 7 days)
echo "Deleting old backups (older than 7 days)..."
find "$BACKUP_DIR" -type f -name "focalboard_db_*.sql" -mtime +7 -delete
find "$BACKUP_DIR" -type f -name "focalboard_data_*.tar.gz" -mtime +7 -delete
echo "Backup completed."

Make the script executable and add it to Cron:

chmod +x backup_focalboard.sh
sudo mv backup_focalboard.sh /usr/local/bin/
sudo crontab -e

Add a line for daily backup, for example, at 03:00 AM:

0 3 * * * /usr/local/bin/backup_focalboard.sh >> /var/log/focalboard_backup.log 2>&1

Consider automatically uploading backups to remote storage (S3, Google Drive, Backblaze B2) using tools like Restic on VPS for maximum reliability.

Focalboard and Docker Container Update Procedure

Updating Focalboard deployed via Docker Compose is quite straightforward. It's important to perform updates regularly to receive new features, performance improvements, and critical security fixes.

Update Steps:

1. Create a backup: Before any update, always perform a full backup of the database and the file directory. This is your insurance against unforeseen problems.
2. Navigate to the Focalboard directory:

   cd ~/focalboard

3. Stop current containers:

   docker-compose down

4. Pull new images and start containers:

   docker-compose pull
   docker-compose up -d

   The docker-compose pull command will download the latest versions of the images specified in docker-compose.yml (in our case, mattermost/focalboard:latest and postgres:13-alpine). docker-compose up -d will recreate the containers with the new images, while preserving the data volumes.
5. Check logs: After starting, ensure that all containers are running correctly and there are no errors in the logs:

   docker-compose logs focalboard

This approach ensures minimal downtime and reliable updates for your Focalboard Docker installation.

Which VPS Config for Real Focalboard Load

Choosing the optimal VPS configuration for Focalboard VPS is critical for performance and cost. Insufficient resources will lead to slowdowns, while excessive resources will result in overpayment. Here, we will look at how to scale Valebyte.com resources based on your team's growth and data volumes.

Recommendations for Scaling VPS Resources

Focalboard, being a web application, is sensitive to processor performance, RAM capacity, and disk subsystem speed. As the number of users and data volume grow, the requirements for these resources increase.

1. CPU (vCPU):
   • 1-5 users: 2 vCPU is sufficient. Focalboard does not require significant computational power for small teams.
   • 5-25 users: 2-4 vCPU. With active use, multiple simultaneous requests, and attachment processing, additional cores will help maintain responsiveness.
   • 25-50+ users: 4-6+ vCPU. For large teams and intensive work, where dozens of users simultaneously interact with boards, more processor resources are needed to handle requests and database operations.
   It's important that vCPUs are not "shared virtual cores" but dedicated resources, as offered by Valebyte.com, for predictable performance.
2. RAM (Random Access Memory):
   • 1-5 users: 2-4 GB RAM. This is enough for Focalboard and PostgreSQL Docker containers, as well as for data buffering.
   • 5-25 users: 4-8 GB RAM. PostgreSQL actively uses RAM for data caching, which significantly speeds up queries. The more users and data, the more memory is required.
   • 25-50+ users: 8-16+ GB RAM. For large installations, so that the database can keep a significant portion of frequently used data in memory, and Focalboard itself has enough resources to handle sessions.
3. NVMe Disk:
   • Capacity: Start with 50-100 GB. Keep in mind that the database and especially attachments can take up a lot of space. Plan with a reserve for 1-2 years of growth. If your team actively uploads files, you will need more disk space.
   • Disk Type: NVMe disks are mandatory for Focalboard. They provide high input/output operations per second (IOPS), which is critical for database performance and fast access to attachment files. Using regular SSDs or HDDs can lead to significant delays.
4. Network Connection: Valebyte.com offers high-speed ports (1 Gbps and higher), which is important for fast page loading and file exchange, especially when working with a large number of attachments or remote teams.

Example Valebyte.com VPS Configurations for Focalboard

Valebyte.com offers flexible plans that can be adapted to your needs. Here are a few examples, based on the recommendations above:

For Personal Use / Small Team (1-5 users):

• Plan: VPS-Small
• Configuration: 2 vCPU, 4 GB RAM, 80 GB NVMe
• Approximate Cost: From $10/month
• Why it fits: Sufficient resources for stable operation of Focalboard with PostgreSQL, as well as for other basic services on the same VPS. NVMe ensures fast performance.

For Medium Team (5-25 users):

• Plan: VPS-Medium
• Configuration: 4 vCPU, 8 GB RAM, 160 GB NVMe
• Approximate Cost: From $25/month
• Why it fits: Increased RAM and CPU allow PostgreSQL to efficiently cache data, and Focalboard to handle more simultaneous connections and requests, ensuring smooth operation even with active use of attachments.

For Large Team / Department (25-50+ users):

• Plan: VPS-Large or Dedicated Server
• Configuration: 6+ vCPU, 16+ GB RAM, 320+ GB NVMe
• Approximate Cost: From $50+/month
• Why it fits: These configurations provide maximum performance for intensive work. In case of very high loads, a dedicated server can be considered for full control over hardware resources and further optimization.

When choosing a VPS for Focalboard self-hosted, it's always better to start with a configuration that slightly exceeds your minimum needs to have a performance buffer and avoid future problems. Valebyte.com allows you to easily scale VPS resources as your requirements grow, so you can start with a smaller plan and upgrade as needed. For other solutions requiring flexible scaling, such as NocoDB on VPS or Baserow on VPS, the approaches to configuration selection will be similar.

Conclusion

Installing and configuring Focalboard on a VPS using Docker Compose provides a powerful, flexible, and secure project management solution. Choosing the optimal VPS configuration from Valebyte.com with NVMe disks and sufficient RAM ensures high performance, while regular backups and updates maintain the stability and security of your Focalboard installation.