OpenProject on VPS: Installation, Configuration, and Maintenance

For installing, configuring, and maintaining OpenProject on a VPS, it is recommended to use containerization via Docker and Docker Compose. This significantly simplifies deployment, dependency management, updates, and backups, ensuring stable operation of the project management system on your own server.

What is OpenProject and why do you need it on a VPS?

OpenProject is powerful open-source project management software that provides a wide range of features for planning, tracking, and collaborating on projects. It is designed as an all-in-one solution, combining task management, bug tracking, project planning (Gantt charts), cost management, wiki pages, forums, and much more within a single platform. This makes it an ideal choice for teams of any size, from startups to large enterprises, aiming for efficient organization of their work.

Hosting OpenProject on a VPS (Virtual Private Server) provides full control over data, performance, and security, unlike cloud-based SaaS solutions. This allows you to adapt the environment to your team's specific requirements, integrate with other internal systems, and ensure compliance with corporate security and privacy standards. Self-hosting OpenProject also eliminates per-user subscription fees, making it a cost-effective solution for growing teams in the long run.

OpenProject: Features and Benefits

OpenProject provides a comprehensive set of tools covering the entire project lifecycle. Its functionality includes:

• Task and Project Management: Create, assign, track tasks, manage milestones, configure workflows. Various methodologies are supported, including Scrum, Kanban, and Waterfall.
• Gantt Charts: Visual project planning, tracking dependencies and progress.
• Bug and Request Tracking: Efficient management of defects, feature requests, and user support.
• Cost and Time Management: Budgeting, time tracking, project cost reporting.
• Collaboration: Wiki pages for documentation, forums for discussions, task comments.
• Agile Boards: Integrated Scrum and Kanban boards for teams working with agile methodologies. If you are interested in other Kanban systems, we recommend checking out our article on Kanboard on VPS.
• Customizable Reports: Flexible tools for creating reports on project status, progress, and resources.
• Document Management: Ability to attach files to tasks and projects, create document libraries.
• API: RESTful API for integration with external systems.

Advantages of OpenProject:

• Open Source: Transparency, the ability to modify and adapt to unique needs.
• Deployment Flexibility: Supports self-hosting on various platforms, including VPS, providing full control.
• Active Community: Continuous development and support from the developer community.
• Extensive Functionality: One of the most complete sets of features among free PM systems.

Why Choose OpenProject Self-Hosted?

Choosing OpenProject self-hosted, i.e., hosting on your own server, especially on a VPS, is driven by several key factors:

1. Full Data Control: All your project data is stored on your server, which is critical for companies with strict security and confidentiality requirements. You fully manage backups, access, and storage policies.
2. Customization and Integration: The self-hosted version allows for deep system customization, integration with other internal services (e.g., LDAP/Active Directory, CI/CD systems, CRM), and adaptation to your organization's specific business processes.
3. Provider Independence: You are not tied to the terms and pricing policies of a third-party cloud provider. Your data is always accessible, and the system's operability depends solely on your VPS and your infrastructure.
4. Long-term Economic Benefit: While the initial costs of setting up a VPS and OpenProject might be higher than a subscription for a few users, as your team grows or with long-term use, the self-hosted solution often proves significantly cheaper, as you only pay for VPS resources, not per user.
5. Performance: You can allocate exactly as many VPS resources as your team needs, ensuring optimal performance without "neighboring" other clients on shared hosting.

OpenProject System Requirements: What You Need to Know?

For successful installation and stable operation of OpenProject, especially in a Docker container environment, it is important to consider system requirements. These depend on the number of users and the anticipated load. OpenProject can be quite resource-intensive, especially with active use and a large volume of data.

Minimum and Recommended Requirements

When planning OpenProject installation on a VPS, consider the following metrics:

Resource	Minimum Requirements (up to 10 users)	Recommended Requirements (10-50 users)	For Large Teams (50+ users)
Processor (vCPU)	2 cores (2 GHz+)	4 cores (2.5 GHz+)	8+ cores (3.0 GHz+)
Random Access Memory (RAM)	4 GB	8 GB	16+ GB
Disk Space (NVMe SSD)	50 GB	100 GB	200+ GB
Network Bandwidth	100 Mbps	1 Gbps	1 Gbps+
Operating System	Ubuntu 20.04/22.04 LTS, Debian 11/12, CentOS 7/8, RHEL 8/9
Docker Engine	20.10+
Docker Compose	1.29+ (or Docker Compose V2)

Important Notes:

• NVMe SSD: It is highly recommended to use NVMe SSDs. OpenProject actively works with the database (PostgreSQL), and the speed of the disk subsystem is critically important for overall performance. Standard HDDs or even SATA SSDs can become a bottleneck.
• RAM: OpenProject, especially with PostgreSQL, can consume a significant amount of RAM. If you plan to use other services on the same VPS, ensure you have enough free memory.
• CPU: The number of processor cores affects the speed of request processing and background task execution. Active teams with frequent updates and reports require more cores.
• Swap file: It is recommended to configure a swap file 1-2 times the size of RAM if you have less than 16 GB of RAM, to prevent crashes during peak loads.

Supported Operating Systems

For installing OpenProject on a server via Docker, you can use most modern Linux distributions. The most popular and well-supported are:

• Ubuntu LTS (Long Term Support): Versions 20.04 and 22.04. These are the most commonly used distributions for deploying Docker containers.
• Debian: Versions 11 (Bullseye) and 12 (Bookworm).
• CentOS/RHEL: Versions 7, 8, and 9.

Ensure that the chosen OS has up-to-date security updates and works stably with the latest versions of Docker Engine and Docker Compose.

Preparing Your VPS for OpenProject Docker Installation

Before proceeding with OpenProject Docker installation, you need to prepare your VPS. This process includes updating the operating system, installing Docker Engine, and Docker Compose. We will use Ubuntu 22.04 LTS as an example, but the steps will be similar for other Debian-like systems.

System Update and Docker Engine Installation

The first step is always to update your operating system packages. This ensures that you have the latest versions of all dependencies and security patches installed.

sudo apt update
sudo apt upgrade -y

Next, we will install the necessary packages for Docker and add the official Docker repository:

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

Now you can install Docker Engine, containerd, and Docker Compose (older version, we will update to V2 later):

sudo apt install docker-ce docker-ce-cli containerd.io -y

After installation, ensure that Docker is running and active:

sudo systemctl start docker
sudo systemctl enable docker
sudo systemctl status docker

Add the current user to the docker group to avoid using sudo with every Docker command:

sudo usermod -aG docker $USER
newgrp docker

Verify that Docker is installed correctly by running a test container:

docker run hello-world

Installing Docker Compose

Docker Compose V2 is the preferred version and is installed as a plugin to the Docker CLI (docker compose instead of docker-compose). If you installed Docker Engine as shown above, Docker Compose V2 should already be available. You can check this by running:

docker compose version

If the command doesn't work or shows an older version (1.x.x), you can install it manually:

sudo apt update
sudo apt install docker-compose-plugin -y

After installation, check the version again:

docker compose version

You should see a version starting with v2.x.x. Your VPS is now ready for OpenProject deployment.

Step-by-Step OpenProject Installation on VPS via Docker Compose

Installing OpenProject via Docker Compose is the most recommended and straightforward deployment method. This approach allows you to manage all components (OpenProject, PostgreSQL, Nginx/Caddy) as a single service. We will use the official OpenProject image.

Creating the docker-compose.yml file

Create a directory for your OpenProject project and navigate into it:

mkdir -p /opt/openproject
cd /opt/openproject

Now, create a docker-compose.yml file in this directory:

nano docker-compose.yml

Insert the following content. This file defines three services: db (PostgreSQL), openproject (the main application), and web (Nginx as a reverse proxy). Note that Nginx here will act only as a proxy for OpenProject, not for external access. An external reverse proxy (Nginx/Caddy) will be configured later.

version: '3.8'

services:
  db:
    image: postgres:13
    restart: always
    environment:
      POSTGRES_DB: openproject
      POSTGRES_USER: openproject
      POSTGRES_PASSWORD: your_strong_db_password_here # Be sure to change to a strong password!
    volumes:
      - ./pgdata:/var/lib/postgresql/data
    networks:
      - openproject-net

  openproject:
    image: openproject/openproject:13
    restart: always
    environment:
      DATABASE_URL: postgres://openproject:your_strong_db_password_here@db:5432/openproject
      RAILS_ENV: production
      # EMAIL_DELIVERY_METHOD: smtp # Uncomment and configure for sending emails
      # SMTP_HOST: smtp.example.com
      # SMTP_PORT: 587
      # SMTP_USER_NAME: your_email_user
      # SMTP_PASSWORD: your_email_password
      # SMTP_AUTHENTICATION: plain
      # SMTP_ENABLE_STARTTLS_AUTO: 'true'
      # DEFAULT_URL_HOST: your_domain.com # Replace with your domain
      # OPENPROJECT_HOST__NAME: your_domain.com # Replace with your domain
      # OPENPROJECT_HTTPS: 'true' # Set to true if using HTTPS (recommended)
      # If you are using an external reverse proxy, you do not need to configure these variables here.
      # They will be set in the reverse proxy configuration.
    volumes:
      - ./data:/var/openproject/assets
    depends_on:
      - db
    networks:
      - openproject-net

  web:
    image: openproject/community-nginx:1.0.0 # Using the official Nginx for OpenProject
    restart: always
    ports:
      - "8080:80" # OpenProject will be accessible on port 8080 inside the VPS
    depends_on:
      - openproject
    networks:
      - openproject-net

networks:
  openproject-net:
    driver: bridge

Important points:

• your_strong_db_password_here: Don't forget to change this password to something strong and unique. It must be the same in both the db and openproject sections.
• ./pgdata and ./data: These are volumes for storing PostgreSQL data and OpenProject assets (files, attachments). They will be created in the pgdata and data subdirectories within /opt/openproject. This is critically important for preserving data during container restarts and updates.
• OpenProject Environment Variables: The commented lines for SMTP and DEFAULT_URL_HOST/OPENPROJECT_HOST__NAME/OPENPROJECT_HTTPS. You will need to uncomment and configure them when you are ready to send emails and use an external domain with HTTPS. For now, do not touch DEFAULT_URL_HOST and OPENPROJECT_HOST__NAME, as we will be using an external reverse proxy.
• Port 8080:80: OpenProject will be accessible on port 8080 of your VPS. We will configure an external Nginx or Caddy to proxy requests from port 80/443 to this port 8080.

Save the file (Ctrl+O, Enter, Ctrl+X).

Starting OpenProject

After creating the docker-compose.yml file, you can start OpenProject:

docker compose up -d

The -d flag runs the containers in the background. The process may take several minutes as Docker downloads images and initializes the database.

Check the status of the running containers:

docker compose ps

You should see three running services: db, openproject, web.

Wait for OpenProject to fully initialize. This may take a few minutes. You can check the logs of the openproject container to ensure it has started successfully:

docker compose logs -f openproject

When you see messages about the Puma server starting or similar, the application is ready. OpenProject should now be accessible at http://your_vps_ip:8080. Open it in your browser. You will see the OpenProject welcome page.

Initial OpenProject Configuration

Upon first accessing OpenProject via the web interface, you will be prompted to create an administrator account. Follow the on-screen instructions:

1. Go to http://your_vps_ip:8080.
2. On the first screen, you will be asked to create a new administrator. Enter your desired username, email address, and a strong password.
3. After creating the account, you will be redirected to the login page. Log in using the credentials you just created.
4. You may be prompted to configure language, timezone, and other basic settings.

Congratulations! The basic OpenProject installation is complete. The next step is to configure secure access via a domain name and HTTPS.

Configuring Reverse Proxy and HTTPS for OpenProject on the Server

To ensure security and convenient access to OpenProject, you need to configure a Reverse Proxy and HTTPS. A Reverse Proxy will allow you to use a domain name (e.g., openproject.your-domain.com) instead of an IP address and port, while HTTPS (SSL/TLS encryption) will protect transmitted data. We will cover configuration with Nginx and Caddy.

Before you begin, ensure that your domain or subdomain (e.g., openproject.your-domain.com) points to your VPS's IP address in your DNS records.

Configuring Nginx as a Reverse Proxy

Nginx is a high-performance web server that is excellent for acting as a reverse proxy. If Nginx is not installed, install it:

sudo apt install nginx -y
sudo systemctl enable nginx
sudo systemctl start nginx

Create a new configuration file for OpenProject in Nginx:

sudo nano /etc/nginx/sites-available/openproject

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

server {
    listen 80;
    server_name openproject.your-domain.com; # Replace with your domain

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

server {
    listen 443 ssl http2;
    server_name openproject.your-domain.com; # Replace with your domain

    ssl_certificate /etc/letsencrypt/live/openproject.your-domain.com/fullchain.pem; # Path to your certificate
    ssl_certificate_key /etc/letsencrypt/live/openproject.your-domain.com/privkey.pem; # Path to your private key

    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;

    add_header X-Frame-Options "SAMEORIGIN";
    add_header X-Content-Type-Options "nosniff";
    add_header X-XSS-Protection "1; mode=block";

    location / {
        proxy_pass http://localhost:8080; # Proxy to the port where OpenProject Docker is running
        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_redirect off;
        proxy_buffering off;
        proxy_request_buffering off;

        # For WebSocket support
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
    }
}

Save the file. Now, activate the configuration and check the Nginx syntax:

sudo ln -s /etc/nginx/sites-available/openproject /etc/nginx/sites-enabled/
sudo nginx -t
sudo systemctl restart nginx

At this point, Nginx is configured as a reverse proxy, but HTTPS is not yet working because you don't have certificates. To obtain free SSL certificates from Let's Encrypt, use Certbot:

sudo apt install certbot python3-certbot-nginx -y
sudo certbot --nginx -d openproject.your-domain.com

Certbot will automatically obtain the certificates and update the Nginx configuration. After this, your OpenProject will be accessible at https://openproject.your-domain.com.

Using Caddy for Automatic HTTPS

Caddy is a modern web server with automatic HTTPS support via Let's Encrypt, which significantly simplifies configuration. It's an excellent alternative to Nginx, especially if you value simplicity.

Install Caddy (example for Ubuntu):

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 Caddy configuration file (Caddyfile):

sudo nano /etc/caddy/Caddyfile

Remove the existing content and insert the following, replacing openproject.your-domain.com with your domain:

openproject.your-domain.com {
    reverse_proxy localhost:8080
    # Enable compression (optional)
    encode gzip zstd
    # Security headers (optional, but recommended)
    header {
        X-Frame-Options "SAMEORIGIN"
        X-Content-Type-Options "nosniff"
        X-XSS-Protection "1; mode=block"
    }
}

Save the file. Now, validate the Caddy configuration and restart it:

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

Caddy will automatically obtain and install SSL certificates for your domain. Your OpenProject will be accessible at https://openproject.your-domain.com.

After configuring the reverse proxy, don't forget to return to the docker-compose.yml file and set the environment variables for OpenProject so it knows its external URL and uses HTTPS. Edit the openproject section:

  openproject:
    # ...
    environment:
      DATABASE_URL: postgres://openproject:your_strong_db_password_here@db:5432/openproject
      RAILS_ENV: production
      # ... other email settings ...
      DEFAULT_URL_HOST: openproject.your-domain.com # Uncomment and replace with your domain
      OPENPROJECT_HOST__NAME: openproject.your-domain.com # Uncomment and replace with your domain
      OPENPROJECT_HTTPS: 'true' # Uncomment
    # ...

After saving the file, restart the OpenProject containers:

cd /opt/openproject
docker compose down
docker compose up -d

This ensures that OpenProject knows its external address and will generate correct links.

OpenProject Docker Backup and Update

Regular backups and timely updates are critically important aspects of maintaining any production application, including OpenProject. They ensure data security and access to new features and security fixes.

Backup Strategies for OpenProject

When using OpenProject via Docker Compose, your data is stored in two main locations:

1. PostgreSQL Database: Contains all core information about projects, tasks, users, and configuration.
2. OpenProject Assets: Attachments, files uploaded by users (stored in the ./data volume).

To create a full backup, both of these components must be copied.

Step-by-step backup:

1. Stop OpenProject (optional, but recommended for consistency):

   cd /opt/openproject
   docker compose stop openproject

   This ensures that data will not change during the backup process.

2. Create a PostgreSQL database dump:

   docker compose exec db pg_dump -U openproject openproject > /path/to/backup/openproject_db_$(date +%Y%m%d_%H%M%S).sql

   Replace /path/to/backup/ with the path to your backup directory. You will be prompted to enter the password for the openproject user (the one you specified in docker-compose.yml).

3. Copy the assets directory:

   cp -R /opt/openproject/data /path/to/backup/openproject_data_$(date +%Y%m%d_%H%M%S)

4. Start OpenProject again:

   docker compose start openproject

Automating Backups:

You can automate this process using a script and cron jobs. For example, create a script named backup_openproject.sh:

#!/bin/bash

BACKUP_DIR="/var/backups/openproject"
TIMESTAMP=$(date +%Y%m%d_%H%M%S)
PROJECT_DIR="/opt/openproject"
DB_USER="openproject"
DB_NAME="openproject"
DB_PASSWORD="your_strong_db_password_here" # Use the same password as in docker-compose.yml

mkdir -p $BACKUP_DIR

echo "Stopping OpenProject container..."
docker compose -f $PROJECT_DIR/docker-compose.yml stop openproject

echo "Creating PostgreSQL database dump..."
PGPASSWORD=$DB_PASSWORD docker compose -f $PROJECT_DIR/docker-compose.yml exec db pg_dump -U $DB_USER $DB_NAME > $BACKUP_DIR/openproject_db_$TIMESTAMP.sql

echo "Copying OpenProject assets..."
cp -R $PROJECT_DIR/data $BACKUP_DIR/openproject_data_$TIMESTAMP

echo "Starting OpenProject container..."
docker compose -f $PROJECT_DIR/docker-compose.yml start openproject

echo "Cleaning up old backups (e.g., keep last 7 days)..."
find $BACKUP_DIR -type f -name "openproject_db_*.sql" -mtime +7 -delete
find $BACKUP_DIR -type d -name "openproject_data_*" -mtime +7 -exec rm -rf {} +

echo "Backup complete: $BACKUP_DIR"

Make the script executable and add it to cron for daily execution:

chmod +x /path/to/backup_openproject.sh
sudo crontab -e

Add a line to execute the script, for example, daily at 3:00 AM:

0 3 * * * /path/to/backup_openproject.sh > /dev/null 2>&1

Consider using more advanced backup tools, such as Restic on VPS, for encrypting and sending backups to remote storage.

OpenProject Update Process

Updating OpenProject when using Docker Compose is a relatively simple process that involves pulling new images and restarting containers. Always back up before updating!

1. Create a backup: Before you begin, ensure you have an up-to-date backup of your database and assets.
2. Navigate to the OpenProject directory:

   cd /opt/openproject

3. Stop the current containers:

   docker compose down

   This will stop and remove the current containers but preserve the data volumes.

4. Pull the latest images:

   docker compose pull

   This command will download the latest versions of the images specified in docker-compose.yml (e.g., openproject/openproject:13). If you want to update to a specific version, change the image tag in docker-compose.yml (e.g., to openproject/openproject:14) before running docker compose pull.

5. Start OpenProject with the new images:

   docker compose up -d

   Docker Compose will create new containers from the downloaded images. OpenProject will automatically perform necessary database migrations upon the first launch of the new version. This may take some time, especially for large databases.

6. Check the status:

   docker compose ps

   Ensure that all containers are running.

7. Check the logs:

   docker compose logs -f openproject

   Ensure there are no errors and the application has started correctly.

After a successful update, your OpenProject will be running the latest version.

Which VPS Config to Choose for OpenProject Under Real Load?

Choosing the optimal VPS configuration for OpenProject depends on many factors: the number of active users, intensity of use (frequency of task creation, file uploads, report generation), volume of stored data, and the presence of other applications on the same server. Underestimating requirements can lead to slow performance, while overestimating can result in unnecessary expenses. Valebyte.com offers various plans that may be suitable for OpenProject.

Load Assessment and Resource Selection

When choosing a VPS for OpenProject on a server, consider the following parameters:

1. Number of Users: This is the primary factor. The more users, the more simultaneous requests to the database and application.
2. Intensity of Use: A team that actively uses OpenProject throughout the workday (constantly creating tasks, commenting, uploading files) will generate a much higher load than a team that uses it only for weekly planning.
3. Disk Type: NVMe SSD is not a recommendation but a requirement for stable and fast OpenProject operation. The PostgreSQL database is very sensitive to disk subsystem speed.
4. Data Volume: As projects and attachments grow, more disk space will be required.
5. Additional Services: If other applications (e.g., NocoDB for databases, Wiki.js for documentation) will be running on the same VPS, this will increase the overall resource load.

Resource Recommendations:

• Processor (vCPU): OpenProject actively uses the CPU for processing requests, rendering pages, and executing background tasks. The higher the clock speed and number of cores, the better.
• Random Access Memory (RAM): OpenProject, especially with PostgreSQL, can be quite memory-hungry. Insufficient RAM will lead to active swap usage and a sharp drop in performance.
• Disk Space: Start with some extra capacity. While 50 GB NVMe SSD might be sufficient for a small start, an active team with many attachments will require 100-200 GB.

Example VPS Configurations from Valebyte.com

Based on resource needs, we offer the following approximate VPS configurations from Valebyte.com for OpenProject:

Usage Scenario	vCPU	RAM	NVMe SSD	Approx. Cost/month	Recommendations
Small Team (up to 10 users) Small projects, basic functionality	2 cores	4 GB	50 GB	~ $10-15	Suitable for startups and small teams. Ensure no other resource-intensive applications are on the same VPS.
Medium Team (10-30 users) Active use, multiple projects, attachments	4 cores	8 GB	100 GB	~ $20-35	Optimal choice for most growing teams. Provides good performance under moderate load.
Large Team (30-70 users) Many projects, intensive work, reports	6-8 cores	16 GB	200 GB	~ $45-70	For teams actively using OpenProject as their central management system. Allows handling a significant number of simultaneous requests.
Very Large Team / Enterprise (70+ users) Critical projects, high availability, large data volumes	8+ cores	32+ GB	400+ GB	~ $80+	Requires careful monitoring and possibly clustered database solutions. Contact Valebyte.com specialists for individual consultation.

Important: Always start with a configuration that you believe meets your current needs and be prepared to scale. The advantage of a VPS is that you can easily increase resources (vCPU, RAM, disk) as your team and projects grow. Valebyte.com provides flexible pricing plans that allow you to adapt to changing requirements.

Conclusion

Installing OpenProject on a VPS via Docker Compose is an efficient and scalable way to gain full control over your project management system. Choosing the right VPS configuration and following backup and update recommendations will ensure stable and secure OpenProject operation for your team. It is recommended to start with a VPS with 4 GB RAM and 2 vCPU on NVMe SSD, scaling resources as the load grows.