Vikunja on VPS: installation, configuration, and maintenance

Installing Vikunja on a VPS is an efficient way to deploy a powerful self-hosted task and project manager, requiring a minimum VPS with 2 GB RAM, 1 vCPU, and a 20 GB NVMe disk for basic needs, and up to 4-8 GB RAM for teams with active use and integrations.

What is Vikunja and why is self-hosted Vikunja on a VPS beneficial?

Vikunja is a modern, open-source, and feature-rich task manager that helps effectively organize personal affairs and team projects. Built with an emphasis on performance and ease of use, Vikunja offers a powerful set of tools for planning, tracking progress, and collaboration. Unlike many proprietary solutions, Vikunja is an open-source project, giving users full control over their data and the ability to adapt the system to their unique needs. Deploying Vikunja on a VPS allows for maximum flexibility, security, and independence from third-party providers.

Key features of Vikunja

Vikunja stands out among other task managers due to its rich functionality and well-designed interface:

• Task lists and subtasks: Create hierarchical lists for project detailing.
• Projects and tags: Organize tasks by projects, add tags for quick filtering and categorization.
• Priorities and deadlines: Set priorities and deadlines for tasks to ensure nothing important is missed.
• Reminders: Receive notifications about upcoming tasks.
• Collaboration: Share lists and projects with other users, assign tasks, track team progress.
• Integrations: API support allows Vikunja to integrate with other services and tools.
• Flexible views: View tasks as a list, Kanban board, or calendar.
• Open source: Full transparency and customization options.
• Mobile apps: Available on Android and iOS for managing tasks on the go.

Advantages of self-hosted Vikunja on your own server

Choosing self-hosted Vikunja on your own VPS from Valebyte.com provides a number of significant advantages, especially for those who value privacy, control, and flexibility:

1. Full control over data: All your tasks, projects, and personal information are stored on your server, not on third-party cloud platforms. This is critical for maintaining privacy and security.
2. Customizability: You can adapt the Vikunja environment to your specific needs, integrate it with other internal services, or modify parameters not available in SaaS solutions.
3. Performance: A dedicated VPS ensures stable and predictable performance, independent of "neighbors" on shared hosting. You choose the server configuration that best suits the expected load.
4. Long-term savings: While the initial investment in a VPS may seem higher than a SaaS subscription, for medium and large teams, self-hosting often proves to be significantly more cost-effective, especially when calculated over several years.
5. Independence: You are not tied to the pricing policies or feature changes of a third-party provider. Your system operates as you configured it.

Deploying Vikunja on a server via Docker Compose simplifies this process, making it accessible even to users with basic Linux administration knowledge.

System requirements for installing Vikunja on a server

Before proceeding with the Vikunja installation, it is important to ensure that your VPS meets the minimum system requirements. Vikunja consists of two main components: the backend (written in Go) and the frontend (written in Vue.js). PostgreSQL or MySQL/MariaDB can be used as the database.

For stable Vikunja operation, you need:

• Operating System: Any Linux distribution (Ubuntu 20.04+, Debian 11+, CentOS 8+). It is recommended to use fresh versions of LTS distributions, such as Ubuntu 22.04 LTS or Debian 12.
• Docker and Docker Compose: The primary deployment method for Vikunja, which we will use.
• Database: PostgreSQL 10+ or MySQL/MariaDB 5.7+. PostgreSQL is the preferred option and is well-supported.
• Reverse Proxy: Nginx or Caddy for handling HTTPS and routing traffic to Vikunja containers.
• Domain name: For accessing Vikunja via a clean URL and configuring HTTPS.

Minimum and recommended VPS configurations for Vikunja

The choice of VPS configuration depends on the anticipated load — the number of users, data volume, and frequency of use. Valebyte.com offers various plans that will suit any needs.

Minimum requirements for a single user or small team (up to 5 people) with basic usage:

• CPU: 1 vCPU
• RAM: 2 GB
• Disk: 20-40 GB NVMe SSD (NVMe significantly speeds up database and application operations)
• Bandwidth: 100 Mbps

This configuration will allow comfortable work with Vikunja, but active use and a large number of tasks may lead to delays. The cost of such a VPS usually starts from $5-10 per month.

Recommended requirements for a medium-sized team (up to 20-30 people) or more intensive use:

• CPU: 2 vCPU
• RAM: 4 GB
• Disk: 80-100 GB NVMe SSD
• Bandwidth: 1 Gbps

This configuration will ensure stable and fast Vikunja operation even with simultaneous access by multiple users and the use of various features. The cost of such a VPS can be $15-25 per month.

Optimal requirements for large teams (50+ people) or mission-critical projects:

• CPU: 4+ vCPU
• RAM: 8+ GB
• Disk: 200+ GB NVMe SSD
• Bandwidth: 1 Gbps

For large teams or systems with high loads, it is recommended to consider dedicated servers or more powerful VPS plans to guarantee maximum performance and fault tolerance. The cost of such solutions starts from $30-50 per month and higher.

It is important to remember that NVMe SSDs provide significantly higher read/write speeds compared to regular SSDs or HDDs, which is critical for database performance and overall application responsiveness.

Preparing the VPS for Vikunja installation via Docker

Before proceeding with the Vikunja Docker deployment, you need to prepare your VPS. This includes updating the system, installing Docker and Docker Compose, and basic security configuration.

Installing Docker and Docker Compose

Connect to your VPS via SSH. All commands are executed as a user with sudo privileges.

1. System update:

sudo apt update && sudo apt upgrade -y

2. Installing necessary packages for Docker:

sudo apt install ca-certificates curl gnupg lsb-release -y

3. Adding the official Docker GPG key:

sudo mkdir -p /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
sudo chmod a+r /etc/apt/keyrings/docker.gpg

4. Adding the Docker repository:

echo \
  "deb [arch="$(dpkg --print-architecture)" signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
  "$(. /etc/os-release && echo "$VERSION_CODENAME")" stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

5. Installing Docker Engine:

sudo apt update
sudo apt install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin -y

6. Adding your user to the docker group (to avoid using sudo with every docker command):

sudo usermod -aG docker $USER
newgrp docker

After executing `newgrp docker`, you may need to reconnect to your SSH session for the changes to take effect.

7. Verifying Docker installation:

docker run hello-world

If you see the message "Hello from Docker!", then Docker is installed correctly.

Configuring firewall and domain name

1. Configuring firewall (UFW):

It is very important to configure a firewall to protect your server. Open only the necessary ports.

sudo ufw allow ssh
sudo ufw allow http
sudo ufw allow https
sudo ufw enable
sudo ufw status

These commands will allow SSH (port 22), HTTP (port 80), and HTTPS (port 443). Make sure the SSH port matches your settings if you are using a non-standard port.

2. Configuring domain name:

You will need a domain name (e.g., `vikunja.yourdomain.com`) pointing to your VPS's IP address. Add an A-record in your domain's DNS settings. This is necessary for accessing Vikunja via a clean URL and for obtaining an SSL certificate.

Step-by-step Vikunja Docker Compose installation

Now that the VPS is prepared, we can proceed with the Vikunja Docker installation using Docker Compose. This method allows easy management of all Vikunja components (backend, frontend, database) as a single unit.

Creating the docker-compose.yml file for Vikunja

Create a directory for Vikunja and navigate into it:

mkdir vikunja
cd vikunja

Create the `docker-compose.yml` file:

nano docker-compose.yml

Paste the following content. This is a basic configuration using PostgreSQL as the database. Replace `YOUR_VIKUNJA_DOMAIN` with your domain name (e.g., `vikunja.yourdomain.com`), and generate strong passwords for the database and `JWT_SECRET`.

version: "3.8"

services:
  db:
    image: postgres:15-alpine
    restart: always
    environment:
      POSTGRES_USER: vikunja
      POSTGRES_PASSWORD: <YOUR_DB_PASSWORD>
      POSTGRES_DB: vikunja
    volumes:
      - ./vikunja_db:/var/lib/postgresql/data
    networks:
      - vikunja-network

  vikunja:
    image: vikunja/vikunja:latest
    restart: always
    environment:
      VIKUNJA_DATABASE_HOST: db
      VIKUNJA_DATABASE_USER: vikunja
      VIKUNJA_DATABASE_PASSWORD: <YOUR_DB_PASSWORD>
      VIKUNJA_DATABASE_DATABASE: vikunja
      VIKUNJA_DATABASE_TYPE: postgres
      VIKUNJA_JWT_SECRET: <YOUR_JWT_SECRET>
      VIKUNJA_SERVICE_PUBLICURL: https://YOUR_VIKUNJA_DOMAIN
      VIKUNJA_SERVICE_FRONTENDURL: https://YOUR_VIKUNJA_DOMAIN
      VIKUNJA_MAILER_ENABLED: "false" # Set to "true" and configure if you need email notifications
      # VIKUNJA_MAILER_HOST: smtp.example.com
      # VIKUNJA_MAILER_PORT: "587"
      # VIKUNJA_MAILER_USERNAME: [email protected]
      # VIKUNJA_MAILER_PASSWORD: your_email_password
      # VIKUNJA_MAILER_FROMADDRESS: [email protected]
    depends_on:
      - db
    networks:
      - vikunja-network

  frontend:
    image: vikunja/frontend:latest
    restart: always
    environment:
      VIKUNJA_API_URL: https://YOUR_VIKUNJA_DOMAIN/api/v1
    depends_on:
      - vikunja
    networks:
      - vikunja-network

networks:
  vikunja-network:
    driver: bridge

Explanations for `docker-compose.yml` file:

• `db` service: Uses the official PostgreSQL 15 image.
  • `environment`: Sets the username, password, and database name for PostgreSQL.
  • `volumes`: Mounts the local directory `./vikunja_db` into the container for persistent database storage. This is critically important for preserving your data across container restarts.
• `vikunja` service (backend): Uses the official `vikunja/vikunja:latest` image.
  • `environment`: Configures the database connection (`VIKUNJA_DATABASE_HOST` points to the `db` service name), sets the secret key for JWT tokens (`VIKUNJA_JWT_SECRET`), and the public URL of your Vikunja instance.
  • `depends_on`: Ensures that the `db` container is started before the backend.
• `frontend` service: Uses the official `vikunja/frontend:latest` image.
  • `environment`: Tells the frontend which Vikunja API to connect to.
  • `depends_on`: Ensures that the backend is started before the frontend.
• `networks`: Defines an internal Docker network for communication between containers. This isolates Vikunja services from the outside world; access to them will be through a reverse proxy.

For other useful self-hosted tools, such as NocoDB on VPS or Baserow on VPS, a similar Docker Compose approach is often used, demonstrating the versatility of this method.

Starting Vikunja and initial setup

After saving `docker-compose.yml`, start the containers:

docker compose up -d

The `-d` option runs containers in detached mode (in the background). Check the status of the containers:

docker compose ps

All services should be in the `running` state. If errors occur, check the logs:

docker compose logs -f

At this stage, Vikunja is running but is only accessible within the Docker network. For external access and HTTPS, we will need a reverse proxy.

Configuring Reverse Proxy (Nginx or Caddy) and HTTPS for Vikunja VPS

To make Vikunja accessible via your domain name with a secure HTTPS connection, you need to configure a reverse proxy. We will consider two popular options: Nginx and Caddy.

Configuring Nginx as a reverse proxy

Nginx is a powerful and widely used web server that is excellent for the role of a reverse proxy. It requires manual SSL configuration using Certbot.

1. Installing Nginx:

sudo apt install nginx -y

2. Creating the Nginx configuration file for Vikunja:

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

Paste the following configuration, replacing `YOUR_VIKUNJA_DOMAIN` with your domain name:

server {
    listen 80;
    listen [::]:80;
    server_name YOUR_VIKUNJA_DOMAIN;

    location / {
        return 301 https://$host$request_uri;
    }
}

server {
    listen 443 ssl http2;
    listen [::]:443 ssl http2;
    server_name YOUR_VIKUNJA_DOMAIN;

    ssl_certificate /etc/letsencrypt/live/YOUR_VIKUNJA_DOMAIN/fullchain.pem; # Will be created by Certbot
    ssl_certificate_key /etc/letsencrypt/live/YOUR_VIKUNJA_DOMAIN/privkey.pem; # Will be created by Certbot
    ssl_session_timeout 1d;
    ssl_session_cache shared:SSL:10m;
    ssl_session_tickets off;
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers "ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384";
    ssl_prefer_server_ciphers off;
    ssl_stapling on;
    ssl_stapling_verify on;
    add_header Strict-Transport-Security "max-age=15768000; includeSubDomains" always;
    add_header X-Frame-Options "SAMEORIGIN" always;
    add_header X-Content-Type-Options "nosniff" always;
    add_header X-XSS-Protection "1; mode=block" always;
    add_header Referrer-Policy "no-referrer-when-downgrade" always;

    location / {
        proxy_pass http://localhost:3456; # Vikunja backend by default listens on port 3456
        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_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
    }

    location /api/v1/ws {
        proxy_pass http://localhost:3456;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
        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;
    }
}

Important note: This configuration assumes that the Vikunja backend is available at `http://localhost:3456`. However, if you are using Docker Compose as shown above, the Vikunja backend is within the Docker network and does not listen on host ports directly. Instead, Nginx must proxy requests to Vikunja's internal port (3000) through the Docker network. To do this, you will need to modify Vikunja's `docker-compose.yml` to "publish" port 3000 on the host, or use a more complex configuration with Docker network Nginx. The simplest way for Nginx, not connected to Docker, is to publish Vikunja ports:

Add to the `vikunja` section of your `docker-compose.yml`:

    ports:
      - "3456:3000" # Proxy container port 3000 to host port 3456

And restart Vikunja:

docker compose down
docker compose up -d

Now Nginx will be able to access Vikunja at `http://localhost:3456`.

3. Activating the configuration and checking syntax:

sudo ln -s /etc/nginx/sites-available/vikunja.conf /etc/nginx/sites-enabled/
sudo nginx -t

4. Installing Certbot for Let's Encrypt SSL:

sudo apt install certbot python3-certbot-nginx -y
sudo certbot --nginx -d YOUR_VIKUNJA_DOMAIN

Follow Certbot's instructions. It will automatically obtain an SSL certificate and configure Nginx for HTTPS.

5. Reloading Nginx:

sudo systemctl reload nginx

Now Vikunja should be accessible at `https://YOUR_VIKUNJA_DOMAIN`.

Configuring Caddy with automatic HTTPS

Caddy is a modern web server that automatically manages Let's Encrypt SSL certificates, which significantly simplifies HTTPS setup. It's an excellent choice for those looking for simplicity and automation.

1. Adding Caddy to `docker-compose.yml`:

You don't need to install Caddy on the host system. Instead, we will add it as another service to our `docker-compose.yml`. Remove the `ports` section from the `vikunja` service if you added it.

Update your `docker-compose.yml` as follows. Replace `YOUR_VIKUNJA_DOMAIN` with your domain:

version: "3.8"

services:
  db:
    image: postgres:15-alpine
    restart: always
    environment:
      POSTGRES_USER: vikunja
      POSTGRES_PASSWORD: <YOUR_DB_PASSWORD>
      POSTGRES_DB: vikunja
    volumes:
      - ./vikunja_db:/var/lib/postgresql/data
    networks:
      - vikunja-network

  vikunja:
    image: vikunja/vikunja:latest
    restart: always
    environment:
      VIKUNJA_DATABASE_HOST: db
      VIKUNJA_DATABASE_USER: vikunja
      VIKUNJA_DATABASE_PASSWORD: <YOUR_DB_PASSWORD>
      VIKUNJA_DATABASE_DATABASE: vikunja
      VIKUNJA_DATABASE_TYPE: postgres
      VIKUNJA_JWT_SECRET: <YOUR_JWT_SECRET>
      VIKUNJA_SERVICE_PUBLICURL: https://YOUR_VIKUNJA_DOMAIN
      VIKUNJA_SERVICE_FRONTENDURL: https://YOUR_VIKUNJA_DOMAIN
      VIKUNJA_MAILER_ENABLED: "false"
    depends_on:
      - db
    networks:
      - vikunja-network

  frontend:
    image: vikunja/frontend:latest
    restart: always
    environment:
      VIKUNJA_API_URL: https://YOUR_VIKUNJA_DOMAIN/api/v1
    depends_on:
      - vikunja
    networks:
      - vikunja-network

  caddy:
    image: caddy:2-alpine
    restart: always
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./Caddyfile:/etc/caddy/Caddyfile
      - ./caddy_data:/data
    environment:
      VIKUNJA_DOMAIN: YOUR_VIKUNJA_DOMAIN
    networks:
      - vikunja-network
    depends_on:
      - vikunja
      - frontend

networks:
  vikunja-network:
    driver: bridge

2. Creating the `Caddyfile`:

Create a `Caddyfile` in the same directory as `docker-compose.yml`:

nano Caddyfile

Paste the following configuration, replacing `YOUR_VIKUNJA_DOMAIN` with your domain:

{
  # Replace with your email for Let's Encrypt notifications
  email [email protected] 
}

YOUR_VIKUNJA_DOMAIN {
    # Automatic HTTPS
    tls {
        external_port 443
    }

    # Proxying Vikunja API (backend)
    reverse_proxy /api/v1/* vikunja:3000 {
        header_up Host {host}
        header_up X-Real-IP {remote_ip}
        header_up X-Forwarded-For {remote_ip}
        header_up X-Forwarded-Proto {scheme}
        # Enable WebSocket for /api/v1/ws
        websocket
    }

    # Proxying Vikunja frontend
    reverse_proxy / frontend:80 {
        header_up Host {host}
        header_up X-Real-IP {remote_ip}
        header_up X-Forwarded-For {remote_ip}
        header_up X-Forwarded-Proto {scheme}
    }
}

Explanations for `Caddyfile`:

• `email`: Specify your email address to receive notifications from Let's Encrypt.
• `YOUR_VIKUNJA_DOMAIN`: Caddy will automatically obtain an SSL certificate for this domain.
• `reverse_proxy /api/v1/* vikunja:3000`: Directs requests to `/api/v1/` to the Vikunja backend, which listens on port 3000 within the Docker network. The `websocket` directive is important for correct WebSocket connection operation.
• `reverse_proxy / frontend:80`: All other requests are directed to the Vikunja frontend, which listens on port 80 within the Docker network.

3. Restarting Docker Compose:

docker compose down
docker compose up -d

Caddy will automatically start, obtain an SSL certificate, and begin proxying requests. Within a few seconds, Vikunja should be accessible at `https://YOUR_VIKUNJA_DOMAIN`.

Using Caddy with Docker Compose is an elegant solution for many self-hosted applications, such as Cal.com on VPS or AFFiNE on VPS, as it significantly simplifies SSL and reverse proxy setup.

Vikunja Maintenance: Backups, Updates, and Monitoring

Regular maintenance is crucial for ensuring the stable operation and security of your Vikunja instance on a VPS. This includes creating backups, timely updates, and monitoring.

Vikunja backup strategies

Backup is the most important aspect of maintaining any self-hosted application. For Vikunja, two main components need to be backed up:

1. PostgreSQL database: Contains all your tasks, projects, users, and settings.
2. Docker volumes: Contain PostgreSQL data (if you are using volume mounting, as in our example, `./vikunja_db`).

Step-by-step backup instructions:

1. PostgreSQL database backup:

Use the `pg_dump` command inside the `db` container. First, stop Vikunja to avoid data corruption during backup:

cd /path/to/your/vikunja/directory
docker compose stop vikunja frontend

Then perform the backup:

docker exec -t db pg_dumpall -c -U vikunja > vikunja_backup_$(date +%F).sql

This command will create a full dump of all PostgreSQL databases into a file `vikunja_backup_YYYY-MM-DD.sql` in the current directory. Make sure you have enough disk space.

After the backup is complete, start Vikunja back up:

docker compose start vikunja frontend

2. Docker volume backup:

If you followed our instructions, PostgreSQL data is stored in the `./vikunja_db` directory on the host. You can simply copy this directory:

sudo cp -r vikunja_db vikunja_db_backup_$(date +%F)

It is also important to save your `docker-compose.yml` and `Caddyfile` (or Nginx configuration), as they contain the settings for running Vikunja.

cp docker-compose.yml vikunja_docker-compose_backup_$(date +%F).yml
cp Caddyfile vikunja_Caddyfile_backup_$(date +%F)

3. Automating backups:

For regular and reliable backups, it is recommended to set up a script and add it to `cron`. Example of a simple backup script:

#!/bin/bash

BACKUP_DIR="/path/to/your/vikunja/backups" # Specify the directory to store backups
VIKUNJA_DIR="/path/to/your/vikunja/directory" # Specify the directory with docker-compose.yml

mkdir -p $BACKUP_DIR
cd $VIKUNJA_DIR

# Stop Vikunja backend and frontend for backup integrity
docker compose stop vikunja frontend

# Database backup
docker exec -t db pg_dumpall -c -U vikunja > $BACKUP_DIR/vikunja_db_backup_$(date +%F_%H-%M).sql

# Docker volumes backup
tar -czvf $BACKUP_DIR/vikunja_volumes_backup_$(date +%F_%H-%M).tar.gz vikunja_db caddy_data

# Configuration files backup
cp docker-compose.yml $BACKUP_DIR/docker-compose_$(date +%F_%H-%M).yml
cp Caddyfile $BACKUP_DIR/Caddyfile_$(date +%F_%H-%M)

# Start Vikunja back up
docker compose start vikunja frontend

# Delete old backups (e.g., older than 7 days)
find $BACKUP_DIR -type f -name "vikunja_db_backup_*.sql" -mtime +7 -delete
find $BACKUP_DIR -type f -name "vikunja_volumes_backup_*.tar.gz" -mtime +7 -delete
find $BACKUP_DIR -type f -name "docker-compose_*.yml" -mtime +7 -delete
find $BACKUP_DIR -type f -name "Caddyfile_*" -mtime +7 -delete

Save this script (e.g., `backup_vikunja.sh`), make it executable (`chmod +x backup_vikunja.sh`), and add it to `crontab -e` for daily execution. For example, to run at 3 AM:

0 3 * * * /path/to/your/backup_vikunja.sh >> /var/log/vikunja_backup.log 2>&1

Consider using external backup tools, such as Restic on VPS, which allows securely and efficiently saving backups to cloud storage or remote servers.

Updating Vikunja and Docker components

Regular updates provide access to new features, security fixes, and performance improvements.

1. Updating Docker images:

Navigate to the Vikunja directory and execute:

cd /path/to/your/vikunja/directory
docker compose pull

This command will download the latest versions of all images specified in `docker-compose.yml` (e.g., `vikunja/vikunja:latest`, `vikunja/frontend:latest`, `postgres:15-alpine`, `caddy:2-alpine`).

2. Restarting containers with new images:

docker compose up -d

Docker Compose will automatically stop old containers, remove them, and start new ones with updated images, while preserving your data (thanks to the use of volumes).

3. Updating the operating system:

Don't forget to regularly update your VPS's OS itself:

sudo apt update && sudo apt upgrade -y

4. Monitoring:

Monitor container logs (`docker compose logs -f`) after updates to ensure there are no errors. It is also useful to set up basic VPS resource monitoring (CPU, RAM, disk) via the Valebyte.com control panel or third-party tools.

For managing other self-hosted projects, such as Wiki.js on VPS or Trilium on VPS, the update and backup processes will be similar, making Docker Compose a versatile tool for administration.

Which VPS to choose for Vikunja: Valebyte.com recommendations

Choosing the optimal VPS configuration for Vikunja on VPS directly impacts performance, stability, and total cost of ownership. Valebyte.com offers a wide range of VPS plans that can be adapted to various Vikunja usage scenarios. We recommend focusing on the number of active users and intensity of use.

Table comparing VPS configurations for Vikunja

The table below presents recommended VPS configurations from Valebyte.com for various Vikunja usage scenarios. Please note that prices are approximate and may vary.

Usage Scenario	vCPU	RAM (GB)	NVMe SSD (GB)	Bandwidth	Approximate Cost/month	Recommended Valebyte.com Plan
Personal Use / Testing (1-2 users)	1	2	20-40	100 Mbps	$5 - $10	VPS Basic / Starter
Small Team (up to 5 users)	1-2	2-4	40-80	200 Mbps - 1 Gbps	$10 - $18	VPS Standard
Medium Team (5-20 users)	2	4-6	80-120	1 Gbps	$18 - $30	VPS Pro
Large Team / Active Use (20-50+ users)	4+	8+	200+	1 Gbps	$30 - $60+	VPS Enterprise / Dedicated Server

Additional recommendations for choosing a VPS:

1. NVMe SSD: Always prioritize VPS with NVMe SSDs. They provide significantly higher read/write speeds compared to regular SSDs or HDDs, which is critical for Vikunja's database performance and overall application responsiveness.
2. Server location: Choose a data center that is geographically closer to most of your users. This will reduce latency and improve the user experience. Valebyte.com offers servers in various locations.
3. Scalability: Ensure that your hosting provider (e.g., Valebyte.com) offers easy scaling of resources (CPU, RAM, disk) in case your team grows or the load on Vikunja increases.
4. Backup: While we covered application-level backups, many VPS providers offer additional services for creating snapshots or automatic full server backups. This can be a useful addition to your backup strategy.
5. Support: The availability of qualified technical support that can help with basic VPS questions is an important factor, especially if you are not an experienced system administrator.

For most users and small teams, the VPS Standard from Valebyte.com will be an excellent choice, offering an optimal balance of performance and cost for Vikunja installation.

Conclusion

Deploying Vikunja on your own VPS is a powerful solution for efficient task and project management, providing full data control and high flexibility. By following the step-by-step instructions for installation via Docker Compose, configuring a reverse proxy, and ensuring regular backups, you can create a reliable and secure working environment.

For optimal performance and stability of your Vikunja instance on a VPS, Valebyte.com recommends choosing plans with NVMe SSD and sufficient RAM, such as VPS Standard, which is ideal for most teams, balancing power and cost.