Supabase on VPS: Installation, Configuration, and Maintenance

What is Supabase and Why Consider Installing it on a VPS?

Installing and configuring Supabase on a VPS provides developers with complete flexibility and control over their backend services, allowing them to deploy a powerful open-source alternative to Firebase on their own server for scalable, secure, and fully managed applications.

Supabase is a comprehensive open-source platform positioned as an "open-source Firebase alternative." It provides a set of tools and services necessary for quickly building the backend of modern web and mobile applications. At its core, Supabase leverages the powerful PostgreSQL relational database, complemented by several critical features:

• Postgres Database: A high-performance and reliable database, compatible with all existing PostgreSQL tools.
• Authentication: A complete user authentication system supporting email, password, social providers (Google, GitHub, etc.), and SMS.
• Realtime: The ability to receive real-time database updates via WebSockets, ideal for chats, notifications, and interactive applications.
• Storage: File storage for user data, images, and other media files, with access management capabilities.
• Edge Functions: Serverless functions built on Deno, allowing backend logic to be executed without managing servers.
• PostgREST: An automatically generated RESTful API for your database, enabling interaction without writing server-side code.
• Dashboard: A user-friendly web interface for managing your database, users, files, and project settings.

While Supabase offers a cloud version, many developers and companies opt for Supabase self-hosted on their own VPS. This decision is driven by several significant advantages:

• Full Data Control: You have complete control over your data, its location, and security, which is critical for compliance with regulatory requirements (GDPR, HIPAA) and corporate policies.
• Cost-Effectiveness at Scale: At a certain stage of project development, your own VPS with Supabase can be significantly cheaper than cloud plans, especially under high loads or with large data volumes. You pay only for server resources, not for the usage of each service individually.
• Flexibility and Customization: You can configure each Supabase component to your needs, install additional PostgreSQL extensions, and optimize performance at the operating system and database levels.
• No Vendor Lock-in: Your backend is not tied to a specific Supabase cloud provider, giving you the freedom to migrate and choose your hosting.
• Security: The ability to build an isolated and secure infrastructure that meets your security standards.

Using VPS for deploying Supabase is the golden mean between a fully managed cloud solution and a dedicated server. A VPS provides isolated resources, the ability to install any operating systems and software, and high performance at a relatively low cost. It's an ideal option for projects that require a reliable and scalable backend but without the excessive costs of fully managed cloud services.

System Requirements for Supabase on a VPS: Which Server to Choose?

Choosing the right VPS for Supabase installation is a crucial step that directly impacts your application's performance and stability. Supabase consists of several components, each consuming specific resources. Minimal requirements can be misleading for a production environment, so it's important to understand what each service consumes.

Essential Components and Their Consumption

• PostgreSQL: The core of Supabase. Consumes significant amounts of RAM for data caching and CPU for query processing. The more data, active connections, and complex queries, the more resources will be needed.
• PostgREST: A proxy server for PostgreSQL, relatively lightweight, but requires CPU for HTTP request processing and a small amount of RAM.
• GoTrue (Authentication): Authentication service. Requires CPU for cryptographic operations and a small amount of RAM for session storage.
• Realtime: Service for handling WebSockets. Can consume significant RAM and CPU resources with a large number of active connections and frequent updates.
• Storage: File storage based on S3-compatible MinIO. Consumes disk space and some RAM/CPU for handling uploads/downloads.
• Kong (API Gateway): Acts as an API gateway, routing requests to the appropriate Supabase services. Consumes RAM and CPU for traffic processing.
• Docker and Docker Compose: The containerization platform itself requires certain resources to run and manage containers.

VPS Configuration Recommendations

For Supabase on a server, three parameters are critically important: processor (CPU), random access memory (RAM), and the disk subsystem. The network is also important, but most modern VPS providers offer sufficiently wide channels.

Minimum Configuration (for development and small projects)

• CPU: 2 vCPU. One for PostgreSQL, the other for remaining services.
• RAM: 4 GB. PostgreSQL can use up to 2 GB, other services 1-1.5 GB, plus the remainder for OS and Docker.
• Disk: 50 GB NVMe SSD. NVMe is critically important for database performance. HDDs or regular SSDs will be significantly slower.
• OS: Ubuntu 22.04 LTS or Debian 12.
• Cost: From $10-15 per month (e.g., Valebyte plans with NVMe).

Medium Configuration (for production applications with moderate load)

• CPU: 4 vCPU. Distributed load between PostgreSQL and other Supabase services.
• RAM: 8-16 GB. The more RAM, the more efficiently PostgreSQL caches data, reducing disk access.
• Disk: 100-200 GB NVMe SSD. Sufficient for a growing database and files.
• OS: Ubuntu 22.04 LTS or Debian 12.
• Cost: From $25-50 per month.

High-Load Configuration (for large projects and high traffic)

• CPU: 6-8+ vCPU. For maximum performance and parallel query processing.
• RAM: 32 GB+. Allows PostgreSQL to keep most active data in memory.
• Disk: 500 GB+ NVMe SSD. With high IOPS. It might be worth considering RAID10 or dedicated block storage.
• OS: Ubuntu 22.04 LTS or Debian 12.
• Cost: From $80-150+ per month.

Important note: always choose a VPS with KVM virtualization, as it provides full resource isolation and guaranteed performance, unlike OpenVZ.

Step-by-Step Supabase Installation on a VPS Using Docker and Docker Compose

Installing Supabase on a VPS via Docker and Docker Compose is the most recommended and flexible approach. It allows easy management of all components, updating them, and ensuring portability. Follow these steps to deploy Supabase Docker on your server.

Preparing the VPS for Installation

1. System Update:

   Connect to your VPS via SSH and update the system packages:

   sudo apt update && sudo apt upgrade -y

2. Install Docker and Docker Compose:

   If Docker is not yet installed, run the following commands. Docker Compose v2 is now part of the Docker CLI.

   # Install necessary packages
   sudo apt install ca-certificates curl gnupg lsb-release -y
   
   # Add Docker's 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
   
   # Add 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 package index and install Docker Engine
   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 avoid using sudo with docker commands)
   sudo usermod -aG docker $USER
   # Log out of SSH and log back in for changes to take effect, or run:
   # newgrp docker
   
   # Verify installation
   docker run hello-world
   docker compose version

3. Install Git:

   sudo apt install git -y

Deploying Supabase

1. Clone the Supabase repository:

   Navigate to your home directory or any other location where you want to store Supabase files, and clone the official repository:

   cd ~
   git clone --depth 1 https://github.com/supabase/supabase
   cd supabase

2. Configure environment variables:

   Copy the example environment variable file and edit it. This is a critically important step for security and functionality.

   cp .env.example .env
   nano .env

   In the .env file, you will need to configure several key parameters. Here are the most important ones:

   • POSTGRES_PASSWORD: Set a very strong password for the PostgreSQL user.
   • JWT_SECRET: Generate a long, random secret key (e.g., using openssl rand -base64 32).
   • ANON_KEY and SERVICE_KEY: These keys should also be generated. You can use openssl rand -base64 32 for each.
   • SMTP_HOST, SMTP_PORT, SMTP_USER, SMTP_PASS: Configure your SMTP server parameters for sending authentication emails (email confirmation, password reset). If not configured, email authentication functions will not work.
   • AUTH_EXTERNAL_URL: Set the external URL of your Supabase instance, for example, https://supabase.yourdomain.com. This is important for the correct functioning of links in authentication emails.
   • STORAGE_URL, REALTIME_URL and other URLs: These should correspond to your domain.

   Example of JWT_SECRET generation:

   openssl rand -base64 32

   Save changes to the .env file.

3. Start Supabase:

   Now that everything is configured, start all Supabase services using Docker Compose:

   docker compose up -d

   The -d flag runs containers in the background. The process may take several minutes as Docker will download all necessary images.

4. Check status:

   Ensure all containers are running and working:

   docker compose ps

   You should see a list of all Supabase services with a running status.

At this stage, Supabase is running on your server but is only accessible via the internal IP addresses of the containers. To access it externally and use HTTPS, you need to configure a reverse proxy.

Configuring Reverse Proxy (Nginx/Caddy) and HTTPS for Supabase on a Server

After installing Supabase via Docker Compose, all its components run on various ports within the Docker network. To make them accessible externally via a domain name and secure the connection with HTTPS, you need to configure a reverse proxy. We will cover two popular options: Nginx and Caddy.

General Preliminary Steps

1. Domain Binding: Ensure your domain or subdomain (e.g., supabase.yourdomain.com) points to your VPS's IP address in your DNS records (A-record type).
2. Open Firewall Ports: Make sure ports 80 (HTTP) and 443 (HTTPS) are open on your VPS. If you are using UFW (Uncomplicated Firewall), execute:

   sudo ufw allow 80/tcp
   sudo ufw allow 443/tcp
   sudo ufw enable # if firewall was not enabled

Option 1: Nginx with Certbot (recommended for experienced users)

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

1. Install Nginx:

   sudo apt install nginx -y

2. Create Nginx configuration file:

   Create a new configuration file for your domain:

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

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

   server {
       listen 80;
       server_name supabase.yourdomain.com;
   
       location / {
           proxy_pass http://localhost:8000; # Kong API Gateway Port
           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;
   
           # For WebSockets (Realtime)
           proxy_http_version 1.1;
           proxy_set_header Upgrade $http_upgrade;
           proxy_set_header Connection "upgrade";
       }
   
       # For Supabase Dashboard
       location /dashboard {
           proxy_pass http://localhost:3000; # Supabase Studio Port
           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;
       }
   
       # Other Supabase services (example)
       # location /auth {
       #     proxy_pass http://localhost:9999; # GoTrue (Authentication)
       #     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;
       # }
   
       # location /storage {
       #     proxy_pass http://localhost:5000; # Storage (MinIO)
       #     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;
       # }
   
       # location /realtime {
       #     proxy_pass http://localhost:54321; # Realtime
       #     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_http_version 1.1;
       #     proxy_set_header Upgrade $http_upgrade;
       #     proxy_set_header Connection "upgrade";
       # }
   }

   Important note: Ports 8000 (Kong), 3000 (Studio), 9999 (GoTrue), 5000 (Storage), 54321 (Realtime) are ports that Supabase provides *inside* the Docker network. Nginx will access them as localhost:port because Nginx is also running on the VPS host machine. Ensure these ports are not occupied by other applications on the host.

3. Activate configuration and restart Nginx:

   sudo ln -s /etc/nginx/sites-available/supabase.conf /etc/nginx/sites-enabled/
   sudo nginx -t # Syntax check
   sudo systemctl restart nginx

4. Install Certbot for HTTPS:

   sudo apt install certbot python3-certbot-nginx -y
   sudo certbot --nginx -d supabase.yourdomain.com

   Follow Certbot's instructions. It will automatically configure Nginx for HTTPS and add a redirect from HTTP to HTTPS.

Option 2: Caddy (easier for beginners)

Caddy is a modern web server that automatically manages HTTPS certificates using Let's Encrypt. This makes it very easy to configure.

1. 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

2. Create Caddyfile configuration file:

   sudo nano /etc/caddy/Caddyfile

   Replace the existing content with the following, specifying your domain:

   supabase.yourdomain.com {
       reverse_proxy /dashboard/* localhost:3000
       reverse_proxy /auth/* localhost:9999
       reverse_proxy /storage/* localhost:5000
       reverse_proxy /realtime/* localhost:54321 {
           header_up Upgrade {http.request.header.Upgrade}
           header_up Connection {http.request.header.Connection}
       }
       reverse_proxy /graphql/* localhost:8000
       reverse_proxy /rest/* localhost:8000
       reverse_proxy localhost:8000 {
           header_up Upgrade {http.request.header.Upgrade}
           header_up Connection {http.request.header.Connection}
       }
   }

   Caddy will automatically obtain and renew Let's Encrypt certificates.

3. Restart Caddy:

   sudo systemctl reload caddy

Now your Supabase should be accessible at https://supabase.yourdomain.com, and the dashboard at https://supabase.yourdomain.com/dashboard.

Hosting providers, such as Valebyte, offer high-performance VPS that are ideal for such deployments, ensuring stability and fast access to your Supabase instance. For a deeper understanding of different hosting types, you can refer to the article Containers vs. VMs vs. Bare-metal: The Hosting Landscape 2026.

Ensuring Reliability: Supabase Backups and Recovery Strategies

Backups are the cornerstone of any production system. For Supabase self-hosted on a VPS, you need to develop a backup strategy that covers both the PostgreSQL database and configuration files.

PostgreSQL Database Backup

The PostgreSQL database is the heart of your Supabase project. Its regular backup is critically important. Docker Compose creates a separate volume for PostgreSQL data, which simplifies its management.

1. Manual backup using pg_dump:

You can perform a database backup directly from the PostgreSQL container. First, find the PostgreSQL container name (usually supabase_db_1 or similar):

docker ps | grep postgres

Then, execute the pg_dump command. Replace <CONTAINER_NAME> with your PostgreSQL container name and <DATABASE_NAME> with your database name (default is postgres or supabase, check in .env):

docker exec <CONTAINER_NAME> pg_dump -U postgres -Fc <DATABASE_NAME> > /path/to/backup/supabase_db_$(date +%Y%m%d_%H%M%S).bak

-U postgres: Specifies the PostgreSQL user. -Fc: Creates a custom archive format, which is the most flexible for restoration. /path/to/backup/: Specify the path on the host system where the backup will be saved.

2. Automatic backup using Cron:

To automate backups, use cron. Create a backup script, for example, /usr/local/bin/supabase_backup.sh:

#!/bin/bash

# Path where backups will be stored
BACKUP_DIR="/var/backups/supabase_db"
# PostgreSQL container name (check via docker ps)
DB_CONTAINER="supabase_db_1" # Example
# Database name
DB_NAME="postgres" # Example, check in .env
# Database user
DB_USER="postgres"

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

# Generate backup file name with timestamp
BACKUP_FILE="$BACKUP_DIR/supabase_db_$(date +%Y%m%d_%H%M%S).bak"

# Perform backup
docker exec $DB_CONTAINER pg_dump -U $DB_USER -Fc $DB_NAME > "$BACKUP_FILE"

# Check backup success
if [ $? -eq 0 ]; then
    echo "Supabase DB backup created successfully: $BACKUP_FILE"
else
    echo "Error creating Supabase DB backup!"
fi

# Delete old backups (e.g., older than 7 days)
find $BACKUP_DIR -type f -name "supabase_db_*.bak" -mtime +7 -delete
echo "Old backups cleaned up."

Make the script executable:

sudo chmod +x /usr/local/bin/supabase_backup.sh

Add a job to crontab (e.g., for a daily backup at 03:00 AM):

sudo crontab -e

Add the line:

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

Configuration File Backup

Save the .env file and the supabase/docker directory, which contains your settings and scripts. This will help quickly restore the configuration.

cp ~/supabase/.env /path/to/backup/supabase_env_$(date +%Y%m%d_%H%M%S).env

Also consider backing up Docker volumes, especially if you are not using MinIO with persistent storage outside the container.

Recovery Strategies

1. Database Recovery:

To restore a database from a .bak file, first stop Supabase, then create a new database or clear an existing one, and restore the data:

# Stop Supabase
cd ~/supabase
docker compose stop

# (Optional) Remove existing data volumes for a clean installation
# docker compose down -v

# Start only the PostgreSQL container
docker compose up -d db

# Find the PostgreSQL container name
docker ps | grep postgres

# Restore the database (replace <CONTAINER_NAME>, <DATABASE_NAME>, and backup path)
# If the database does not exist, pg_restore can create it, but sometimes it's better to create it manually
docker exec -it <CONTAINER_NAME> psql -U postgres -c "DROP DATABASE IF EXISTS <DATABASE_NAME>;"
docker exec -it <CONTAINER_NAME> psql -U postgres -c "CREATE DATABASE <DATABASE_NAME>;"
docker exec -i <CONTAINER_NAME> pg_restore -U postgres -d <DATABASE_NAME> < /path/to/backup/supabase_db_LATEST.bak

# Start all Supabase services
docker compose up -d

2. Full Server Recovery:

In case of a complete VPS failure, you will need a new VPS. On it:

1. Install Docker, Docker Compose, Git.
2. Clone the Supabase repository.
3. Copy your saved .env file to the ~/supabase/ directory.
4. Run docker compose up -d.
5. Restore the database from the freshest backup, following the steps above.
6. Configure the reverse proxy (Nginx/Caddy) and HTTPS.

Important Backup Recommendations:

• Store backups off-VPS: Never keep the sole copy of your backups on the same server as your production data. Use cloud storage (S3, Backblaze B2) or another VPS for storing backups.
• Test recovery: Regularly test the recovery process on a separate test server to ensure the backups are functional.
• Monitoring: Set up monitoring for the successful execution of backup scripts.

Managing your own server requires attention to detail but provides full control, which is one of the advantages of a self-managed VPS.

Updating Supabase: How to Keep Your Installation Current

Keeping your Supabase self-hosted installation on a VPS up-to-date is critically important for security, stability, and access to new features. As Supabase actively develops, regular updates are necessary.

Core Principles of Supabase Docker Updates

The process of updating Supabase, deployed via Docker Compose, consists of several steps:

1. Stop current services: Before updating the code, you need to stop the running containers.
2. Update Supabase repository code: Fetch the latest changes from the official GitHub repository.
3. Update Docker images: Download new versions of Docker images for each Supabase component.
4. Restart services: Start Supabase with the updated images.
5. Database migrations: In some cases, database schema migrations may be required.

Step-by-Step Update Process

Execute the following commands in the directory where you cloned the Supabase repository (e.g., ~/supabase):

cd ~/supabase

1. Check current status (optional):

Before updating, it's useful to check which containers are running and which versions are in use:

docker compose ps

2. Stop Supabase services:

Stop all running Supabase containers. This will result in a brief downtime for your application.

docker compose down

or

docker compose stop

docker compose down will also remove containers but preserve data volumes, which is a cleaner approach before updating.

3. Update Supabase repository:

Fetch the latest changes from the GitHub repository. Ensure you don't have uncommitted local changes that might conflict with the update.

git pull origin main

If you had local changes in files such as docker-compose.yml (which is not recommended unless you know what you're doing), you might need to resolve conflicts.

4. Update Docker images:

Download the latest versions of all Docker images used by Supabase.

docker compose pull

This command will download new image versions if available.

5. Apply database migrations (if necessary):

After updating the code and images, database migrations may be required. Supabase typically includes migration scripts in its updates.

docker compose up -d --build

The --build flag ensures that any local changes in the Dockerfile or build context are taken into account, although for standard updates, docker compose up -d is usually sufficient.

Supabase will automatically start the containers and apply the necessary database migrations. If errors occur, check the PostgreSQL container logs.

docker compose logs db

6. Check status after update:

Ensure all containers are running again and working correctly:

docker compose ps

Check the availability of your Supabase dashboard and the functionality of your application.

Important Update Recommendations:

• Perform backups: Always create a full backup of your database and configuration files before starting the update process. This is your insurance against unforeseen issues.
• Read the changelog: Before updating, always check the official Supabase changelog or blog. Critical changes that require additional actions or attention may be listed there.
• Test in staging: If your project is critical, first test the update process in a staging environment that closely resembles production.
• Plan for downtime: Updates almost always require brief service downtime. Plan it for times of minimal user activity.

Regular updates help keep your Supabase on the server current and secure, providing access to the latest improvements and fixes. For large and critical systems where minimal downtime is a priority, more complex deployment strategies such as blue/green or canary deployments should be considered; however, for most VPS installations, the approach described above is sufficient.

Optimal VPS Configuration for Supabase Under Various Loads

Choosing a VPS configuration for Supabase on a VPS directly depends on your application's expected load. Insufficient resources will lead to slow performance and failures, while excessive resources will result in unnecessary costs. Valebyte offers a wide range of VPS that are ideally suited for hosting Supabase. Let's consider optimal configurations for different scenarios.

Factors Influencing Configuration Choice

• Number of active users: The more users simultaneously interact with your application, the higher the load on the CPU and Realtime service.
• Volume and complexity of data: Large databases and complex SQL queries require more RAM for caching and a powerful CPU for processing.
• Frequency of read/write operations: Intensive database and file storage operations require a high-performance disk subsystem (NVMe SSD).
• Use of Realtime functionality: Applications with chats, notifications, or real-time dashboards actively use the Realtime service, consuming significant RAM and CPU with a large number of simultaneous connections.
• Number of Edge Functions: If you actively use serverless functions, they will also consume CPU and RAM.

Table: VPS Recommendations for Supabase on Valebyte.com

Here is a table with recommended VPS configurations from Valebyte for various Supabase use cases, including approximate prices.

Additional Recommendations for Optimizing VPS for Supabase

1. Use NVMe SSD: This is not just a recommendation, but a requirement for good PostgreSQL performance. The difference compared to regular SSDs or HDDs will be colossal.
2. Resource Monitoring: Install monitoring tools (Netdata, Prometheus/Grafana) to track CPU, RAM, disk I/O, and network traffic usage. This will help you understand when it's time to scale your VPS.
3. PostgreSQL Optimization: After deployment, take time to optimize your PostgreSQL configuration (postgresql.conf) for your RAM volume and load. Parameters like shared_buffers, work_mem, effective_cache_size are hugely important.
4. File System: For the PostgreSQL data volume, it is recommended to use the ext4 or xfs file system.
5. Network: Ensure your VPS provider offers a stable and sufficiently wide communication channel, especially if your application actively uses Realtime or transfers large files.
6. Security: In addition to a firewall, consider using SSH keys, regular OS and Docker updates, and two-factor authentication for server access.

The correct choice and regular monitoring of your VPS configuration will allow your Supabase installation to operate stably and efficiently, providing fast response times for your users and reliable application performance. For those who want to delve deeper into server infrastructure, the article What is a Server and Dedicated Server: A Complete Guide for Beginners can be very useful.

Conclusion

Installing and configuring Supabase on a VPS is a powerful solution for developers seeking full control, flexibility, and cost-effectiveness for their backend. Choosing an optimal VPS configuration with NVMe disks, careful Docker Compose setup, ensuring security with a reverse proxy and HTTPS, along with regular backups and updates, are key factors for success. Valebyte offers high-performance VPS ideally suited for Supabase deployment, providing a reliable foundation for your project.

Ready to choose a server?

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

Get started now →