Baserow on VPS: installation, configuration, and maintenance

To install, configure, and maintain Baserow on a VPS, you need to prepare a server with Docker and Docker Compose, deploy the application using a pre-configured docker-compose.yml file, set up a reverse proxy server (Nginx or Caddy) for domain access with HTTPS, and regularly perform data backups and system updates to ensure stable and secure operation. The optimal VPS choice for Baserow depends on the expected load and number of users, but for a start, 2 vCPU, 4 GB RAM, and a 50 GB NVMe disk are sufficient.

What is Baserow and why choose a VPS for hosting it?

Baserow is a powerful open-source data management platform that combines the flexibility of spreadsheets with the power of relational databases. It allows you to create, organize, and manage data in an intuitive interface without requiring deep programming knowledge. Baserow is positioned as an alternative to services like Airtable, Google Sheets, or Microsoft Access, but with an important advantage: full control over your data and the ability to deploy it on your own server.

Choosing a VPS for Baserow opens up wide possibilities for those who value privacy, security, and flexibility. Unlike cloud SaaS solutions where your data is stored on third-party servers, Baserow self-hosted on your own VPS guarantees that all information remains under your control. This is especially important for companies and projects dealing with confidential data or subject to strict regulatory requirements. Deploying Baserow on a server via Docker ensures application isolation, simplifies its management and scaling, and allows for easy migration of the installation between different environments.

Advantages of Baserow for data management

Baserow offers an extensive set of features that make it an ideal tool for various tasks:

Flexible field types: Support for over 20 field types, including text, numbers, dates, files, links, single select, formulas, and more.
Relational links: Ability to link tables together, creating complex data structures, just like in a full-fledged database.
No-code/Low-code: An intuitive interface allows users without programming skills to create and configure databases, forms, and workflows.
API interface: Every database and table automatically gets a REST API, making it easy to integrate Baserow with other applications and services.
Collaboration: Features for real-time collaborative data work with user access control.
Extensibility: Open source and a plugin architecture allow extending Baserow's functionality for specific needs.

Why Baserow self-hosted on a VPS is the optimal solution?

Hosting Baserow on a Virtual Private Server (VPS) from Valebyte.com offers several key advantages:

Full control over data: You own the server and data, eliminating risks associated with storing information with third-party providers.
Customization and integration: Ability to configure Baserow to your unique requirements, integrate it with your internal infrastructure and other self-hosted applications, such as file management systems like Seafile on VPS.
Security: You independently manage server security, implementing necessary protection measures such as firewalls, VPNs, and regular audits.
Performance: Dedicated VPS resources guarantee stable performance, independent of "neighbors" on the hosting. You can choose a configuration that perfectly matches your workload.
Cost: In the long run, especially with growing data volumes and user numbers, Baserow self-hosted on a VPS can be significantly more cost-effective than paid SaaS solutions.

Baserow System Requirements: Which VPS to choose for Baserow?

Choosing the right VPS configuration for Baserow VPS is critically important for ensuring stable and fast application performance. Baserow, being a relational database and a web application in one, requires sufficient resources, especially for RAM and disk subsystem. Official Baserow recommendations usually indicate minimum requirements, but for real workloads and comfortable operation, it's worth aiming for more powerful configurations.

Minimum and recommended requirements for Baserow

Baserow runs on PostgreSQL and Django, packaged in Docker containers. This means that in addition to the application itself, resources will be consumed by the host operating system, the Docker daemon, and the database.

Processor (CPU): Baserow is not an extremely CPU-intensive application for most everyday tasks, but for complex queries, exporting large volumes of data, or simultaneous work by many users, additional cores will be beneficial.
Random Access Memory (RAM): This is one of the most important resources. Baserow, PostgreSQL, and Docker consume a significant portion of RAM. The more tables, records, relationships, and active users, the more memory will be required.
Disk Space (Storage): In addition to space for the operating system and Docker images, you will need space to store Baserow data (database, uploaded files). NVMe disks are highly recommended due to their high read/write speeds, which is critical for database performance.
Network: A stable and fast network connection with a bandwidth of at least 100 Mbps will ensure quick access to the application.

Below is a table with approximate VPS configurations from Valebyte.com, suitable for various Baserow use cases. Prices are indicative and may vary.

Looking for a reliable server for your projects?

VPS from $10/month and dedicated servers from $9/month with NVMe, DDoS protection, and 24/7 support.

View offers →

Use Case	vCPU	RAM (GB)	NVMe Disk (GB)	Bandwidth	Approx. Monthly Price ($)
Test/Personal (1-3 users, up to 10 tables, small data volume)	2	4	50	100 Mbps	10-15
Small Team/Project (5-15 users, up to 50 tables, moderate data volume)	2-4	8	100-200	200-500 Mbps	20-40
Medium Business/Department (15-50 users, up to 100 tables, significant data volume)	4-6	16-32	200-400	500-1000 Mbps	50-100
Large Project/Enterprise (50+ users, hundreds of tables, very large data volume)	6-8+	32-64+	500+	1 Gbps+	100+

Recommendations for choosing a VPS for Baserow

Start small: For most new projects or testing Baserow, a configuration with 2 vCPU, 4 GB RAM, and 50 GB NVMe will be sufficient. You can always easily scale VPS resources as your needs grow.
Prioritize RAM: If the budget is limited, it's better to allocate more memory than CPU cores. PostgreSQL loves RAM for data caching.
NVMe - a must: Disk subsystem performance greatly affects Baserow's speed, especially with frequent database queries. NVMe disks significantly outperform SSDs and HDDs.
Resource monitoring: After deploying Baserow, regularly monitor CPU, RAM, and disk usage. This will help you understand if current resources are sufficient or if an upgrade is needed.

Preparing the VPS for Baserow installation

Before proceeding with Baserow installation, you need to properly prepare your VPS. This stage includes updating the operating system, installing Docker and Docker Compose, and basic firewall configuration. We will use Ubuntu Server, as it is one of the most popular and well-documented OS for servers.

Initial setup and Docker/Docker Compose installation

Connect to your VPS via SSH. If you are using a new server, it is recommended to first update all packages:

sudo apt update && sudo apt upgrade -y

Installing Docker Engine

Docker is the foundation for deploying Baserow. Follow the official instructions for installing Docker Engine on Ubuntu:

Install necessary packages:

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

Add Docker's official 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

Set up the Docker repository:

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

Update the package index and install Docker Engine, containerd, and Docker Compose (cli):

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

Add your user to the docker group to execute Docker commands without sudo (requires re-logging into the session):
```
sudo usermod -aG docker $USER
newgrp docker
```
Verify that Docker is installed correctly:
```
docker run hello-world
```
You should see the message "Hello from Docker!".

Installing Docker Compose (V2)

Since Docker version 20.10, Docker Compose is integrated into the Docker CLI as the docker compose plugin. If you installed Docker Engine using the command sudo apt install docker-compose-plugin, then docker compose is already available. Check the version:

docker compose version

If for some reason it is not installed or you need an older version (v1), it can be installed separately. However, for Baserow, it is recommended to use the integrated plugin.

Configuring the firewall (UFW)

Firewall configuration is vital for the security of your VPS. We will use UFW (Uncomplicated Firewall).

Install UFW if it's not already installed:
```
sudo apt install ufw -y
```
Allow SSH connections (port 22) to avoid losing access to the server:
```
sudo ufw allow ssh
```
Allow incoming connections for HTTP (port 80) and HTTPS (port 443), which will be used to access Baserow via the web:
```
sudo ufw allow http
sudo ufw allow https
```
Enable the firewall:
```
sudo ufw enable
```
Confirm the action by pressing y.
Check the firewall status:
```
sudo ufw status verbose
```
You should see that the firewall is active and allows SSH, HTTP, and HTTPS.

rocket_launch Quick pick

Need a dedicated server?

Compare prices from top providers. Configure and order in minutes.

Browse dedicated servers arrow_forward

Installing Baserow on VPS with Docker Compose

After preparing the VPS, we move on to the main part — Baserow installation. We will use the Baserow Docker image and Docker Compose for container orchestration. This method is the most recommended and easiest for deploying Baserow.

Creating a working directory and .env file

Create a directory to store Baserow configuration files and navigate into it:

mkdir -p baserow
cd baserow

Now, create an environment variables file .env. This file will contain important settings such as the secret key and domain name. Replace your.domain.com with your actual domain and YOUR_SECRET_KEY with a random string (e.g., generated by the command openssl rand -hex 32):

nano .env

Add the following content:

BASEROW_PUBLIC_URL=https://your.domain.com
SECRET_KEY=YOUR_SECRET_KEY
# Additional PostgreSQL settings (can be left as default)
DATABASE_HOST=db
DATABASE_NAME=baserow
DATABASE_USER=baserow
DATABASE_PASSWORD=your_db_password # Replace with a strong password
# Ports for Baserow
WEB_FRONTEND_PORT=80
WEB_BACKEND_PORT=8000
# If you want to use S3-compatible storage for files (optional)
# MEDIA_ROOT_URL=https://your-s3-endpoint.com/your-bucket/
# AWS_ACCESS_KEY_ID=your_access_key
# AWS_SECRET_ACCESS_KEY=your_secret_key
# AWS_STORAGE_BUCKET_NAME=your_bucket_name
# AWS_S3_ENDPOINT_URL=https://your-s3-endpoint.com
# AWS_S3_REGION_NAME=your-region

Be sure to replace your.domain.com with your domain and generate strong values for SECRET_KEY and DATABASE_PASSWORD. To generate SECRET_KEY, you can use:

openssl rand -hex 32

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

Creating the docker-compose.yml file for Baserow

Now, let's create the docker-compose.yml file, which will define Baserow services (web interface, backend, database) and their configuration:

nano docker-compose.yml

Paste the following content:

version: "3.4"
services:
  baserow:
    image: baserow/baserow:1.24.0 # Specify the actual version
    environment:
      BASEROW_PUBLIC_URL: ${BASEROW_PUBLIC_URL}
      SECRET_KEY: ${SECRET_KEY}
      DATABASE_HOST: ${DATABASE_HOST}
      DATABASE_NAME: ${DATABASE_NAME}
      DATABASE_USER: ${DATABASE_USER}
      DATABASE_PASSWORD: ${DATABASE_PASSWORD}
      # S3 settings, if used
      # MEDIA_ROOT_URL: ${MEDIA_ROOT_URL}
      # AWS_ACCESS_KEY_ID: ${AWS_ACCESS_KEY_ID}
      # AWS_SECRET_ACCESS_KEY: ${AWS_SECRET_ACCESS_KEY}
      # AWS_STORAGE_BUCKET_NAME: ${AWS_STORAGE_BUCKET_NAME}
      # AWS_S3_ENDPOINT_URL: ${AWS_S3_ENDPOINT_URL}
      # AWS_S3_REGION_NAME: ${AWS_S3_REGION_NAME}
    ports:
      - "${WEB_FRONTEND_PORT}:${WEB_FRONTEND_PORT}"
      - "${WEB_BACKEND_PORT}:${WEB_BACKEND_PORT}"
    volumes:
      - baserow_data:/baserow/data
    depends_on:
      - db
    restart: unless-stopped
  db:
    image: postgres:15-alpine # Specify the actual PostgreSQL version
    environment:
      POSTGRES_DB: ${DATABASE_NAME}
      POSTGRES_USER: ${DATABASE_USER}
      POSTGRES_PASSWORD: ${DATABASE_PASSWORD}
    volumes:
      - baserow_db_data:/var/lib/postgresql/data
    restart: unless-stopped
volumes:
  baserow_data:
  baserow_db_data:

Important: Always check the official Baserow documentation for the most up-to-date image version (baserow/baserow:TAG) and recommended PostgreSQL version.

Save the file.

Starting Baserow Docker containers

Now that we have the .env and docker-compose.yml files, we can start Baserow:

docker compose up -d

This command will download the necessary Docker images (Baserow and PostgreSQL), create the containers, and run them in the background (-d). The process may take some time, especially when downloading images for the first time.

You can check the status of running containers with the command:

docker compose ps

You should see that the baserow and db containers are in the "Up" state.

At this point, Baserow is running and accessible via your VPS's IP address on port 80 (HTTP). However, for production use, it is highly recommended to configure a reverse proxy server with HTTPS. We will cover this in the next section.

Configuring Reverse Proxy and HTTPS for Baserow

Direct access to Baserow via IP address and HTTP is not a secure or professional solution. To ensure security, use a domain name, and encrypt traffic (HTTPS), you need to configure a reverse proxy server. We will look at two popular options: Nginx and Caddy.

Preparing the domain name

Before configuring the proxy, ensure that your domain (e.g., baserow.yourdomain.com) points to your VPS's IP address. To do this, add an A-record in your domain's DNS settings.

Option 1: Nginx as Reverse Proxy for Baserow

Nginx is a powerful and widely used web server that is excellent for acting as a reverse proxy.

Install Nginx:
```
sudo apt install nginx -y
```

Create a configuration file for Baserow:

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

Paste the following configuration, replacing your.domain.com with your domain:

server {
    listen 80;
    listen [::]:80;
    server_name your.domain.com;

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

server {
    listen 443 ssl http2;
    listen [::]:443 ssl http2;
    server_name your.domain.com;

    ssl_certificate /etc/letsencrypt/live/your.domain.com/fullchain.pem; # Will be created by Certbot
    ssl_certificate_key /etc/letsencrypt/live/your.domain.com/privkey.pem; # Will be created by Certbot
    ssl_trusted_certificate /etc/letsencrypt/live/your.domain.com/chain.pem; # Will be created by Certbot

    # Recommended SSL/TLS security settings
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers "TLS_AES_128_GCM_SHA256:TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384";
    ssl_prefer_server_ciphers off;
    ssl_session_cache shared:SSL:10m;
    ssl_session_timeout 1d;
    ssl_session_tickets off;
    ssl_stapling on;
    ssl_stapling_verify on;
    resolver 8.8.8.8 8.8.4.4 valid=300s;
    resolver_timeout 5s;
    add_header X-Frame-Options "SAMEORIGIN";
    add_header X-Content-Type-Options "nosniff";
    add_header X-XSS-Protection "1; mode=block";
    add_header Referrer-Policy "no-referrer-when-downgrade";

    location / {
        proxy_pass http://localhost:80; # Proxy to port 80, where Baserow listens in Docker
        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_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
        proxy_http_version 1.1;
    }

    # Settings for WebSocket (if Baserow uses them)
    location /ws {
        proxy_pass http://localhost:8000; # Proxy to port 8000, where Baserow backend listens
        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_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
        proxy_http_version 1.1;
    }
}

Save the file.

Activate the configuration and check syntax:

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

If the syntax is OK, reload Nginx:

sudo systemctl restart nginx

Install Certbot for HTTPS (Let's Encrypt):
```
sudo apt install certbot python3-certbot-nginx -y
sudo certbot --nginx -d your.domain.com
```
Follow Certbot's instructions. It will automatically obtain a certificate and configure Nginx for HTTPS.

Option 2: Caddy as Reverse Proxy for Baserow (simpler)

Caddy is a modern web server with automatic HTTPS configuration (via Let's Encrypt) by default, making it significantly easier 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 the Caddyfile configuration:
```
sudo nano /etc/caddy/Caddyfile
```
Replace the existing content with the following, specifying your domain:
```
your.domain.com {
    reverse_proxy localhost:80
}
```
Caddy will automatically obtain and renew SSL certificates for your.domain.com.

Check and restart Caddy:

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

Now your Baserow should be accessible at https://your.domain.com. Upon first access, you will be able to create an administrator account.

Baserow Maintenance: Backups and Updates

Regular maintenance is key to the long-term and stable operation of Baserow on the server. This includes creating data backups and timely application updates.

Baserow data backup strategies

Baserow data is stored in two places: in the PostgreSQL database and in the file system (user-uploaded files). For a complete backup, both components must be saved.

PostgreSQL database backup

Use the pg_dump utility to create a database dump. This can be done from within the PostgreSQL Docker container.

# Navigate to the Baserow directory
cd ~/baserow

# Get the PostgreSQL container name
DB_CONTAINER_NAME=$(docker compose ps -q db)

# Create a database dump
docker exec $DB_CONTAINER_NAME pg_dumpall -U baserow > baserow_backup_$(date +%Y%m%d%H%M%S).sql

This command will create an SQL file with a full dump of your Baserow database. Replace baserow with the database username if you changed it in .env.

Baserow uploaded files backup

Files are stored in the baserow_data volume. You can create an archive of this directory:

# Navigate to the Baserow directory
cd ~/baserow

# Create an archive of the data directory
tar -czvf baserow_files_backup_$(date +%Y%m%d%H%M%S).tar.gz baserow_data

For automated backups, it is recommended to use cron jobs and external storage (e.g., S3-compatible services or other VPS). For more advanced and reliable backup strategies, consider tools like Restic on VPS.

Restoring Baserow from backup

To restore:

Stop Baserow: docker compose down
Delete existing data (caution!): docker volume rm baserow_data baserow_db_data
Create new empty volumes (or just run docker compose up -d, they will be created automatically).
Restore files: unpack the .tar.gz archive into the baserow_data directory.

Restore the database:

# Get the PostgreSQL container name
DB_CONTAINER_NAME=$(docker compose ps -q db)

# Copy the SQL file into the container
docker cp baserow_backup_YYYYMMDDHHMMSS.sql $DB_CONTAINER_NAME:/tmp/baserow_backup.sql

# Restore the database
docker exec $DB_CONTAINER_NAME psql -U baserow -d baserow -f /tmp/baserow_backup.sql

Start Baserow: docker compose up -d

Baserow Docker image update process

Baserow updates bring new features, bug fixes, and security improvements. The process of updating Baserow Docker containers is relatively simple:

Navigate to the Baserow directory:
```
cd ~/baserow
```
Stop current containers:
```
docker compose down
```
Change the image version in docker-compose.yml:
Open docker-compose.yml and change the line image: baserow/baserow:1.24.0 to the actual version (e.g., baserow/baserow:1.25.0). Also, check for new recommendations regarding the PostgreSQL version.
```
nano docker-compose.yml
```
Download new images and start containers:
```
docker compose pull
docker compose up -d
```
The docker compose pull command will download new image versions. docker compose up -d will start the containers with the new images and apply any necessary database migrations.
Clean up old Docker images (optional):
To free up space, you can remove old, unused Docker images:
```
docker image prune -a
```

Always back up before updating, especially if it's a major version upgrade!

rocket_launch Quick pick

Need a dedicated server?

Compare prices from top providers. Configure and order in minutes.

Browse dedicated servers arrow_forward

Optimizing and Scaling Baserow on the server

As Baserow usage grows, with an increasing number of users, tables, and data volume, performance optimization or even scaling of your VPS resources may be required. Efficient resource management ensures the smooth operation of your Baserow on the server.

Monitoring VPS resources

Regular monitoring is your best tool for understanding current load and identifying potential bottlenecks.

CPU Usage: High CPU utilization (close to 100%) can indicate intensive computations, complex queries, or a lack of cores. Use htop or top for monitoring.
RAM Usage: If RAM is constantly full and the system actively uses a swap file, this will significantly slow down performance. Baserow and PostgreSQL are sensitive to insufficient RAM. The command free -h will show current usage.
Disk Usage (I/O): Slow disk performance (especially during intensive write/read operations) can cause delays. Use iostat or iotop to analyze disk activity. NVMe drives significantly reduce this risk.
Network Traffic: If users frequently upload or download large files, network bandwidth can become a limitation.

# Install htop and iotop (if not installed)
sudo apt install htop iotop -y

# Monitor CPU and RAM
htop

# Monitor disk activity
sudo iotop

Baserow performance tips

Database Optimization:
- Indexes: Ensure that frequently used fields, especially those used for searching and filtering, are indexed. Baserow automatically creates some indexes, but for specific queries, manual optimization may be required.
- Table Size: Split very large tables into several linked ones if logically possible.
- Cleanup: Regularly delete unnecessary data.
Baserow Settings: Review Baserow documentation for additional environment variables that can help optimize performance (e.g., caching settings, number of workers).
Caching: Ensure your reverse proxy (Nginx/Caddy) is configured for efficient caching of static files.
User Browser: Recommend users to use modern browsers and clear their cache if problems arise.

When to upgrade your VPS plan?

Signs that your current VPS configuration for Baserow VPS is becoming insufficient:

Consistently high CPU load: If CPU regularly exceeds 80-90% under normal load.
Lack of RAM: If the system actively uses swap, and free memory is minimal. This is the main indicator for an upgrade.
Slow response: Noticeable delays when loading pages, executing queries, or saving data.
Errors: Appearance of errors related to insufficient memory or timeouts.

If you encounter one or more of these signs, consider upgrading your VPS plan with Valebyte.com. Increasing RAM almost always provides the greatest performance boost for Baserow.

Conclusion

Installing and configuring Baserow on a VPS via Docker Compose provides a flexible, secure, and fully controlled data management solution. By choosing a suitable VPS plan from Valebyte.com and following our recommendations for reverse proxy setup with HTTPS, backups, and updates, you will get a stable and high-performing platform. Regular resource monitoring and timely optimization will help scale your Baserow installation as your project's needs grow.

Ready to choose a server?

VPS and dedicated servers in 72+ countries with instant activation and full root access.

Get started now →