Skip to content

Self-host Supabase

Your own Supabase on one VM, with Studio behind your exe.dev login.

Deploy on exe.dev

Shelley handles the setup. About 15 minutes. Needs a 40 GB disk: Shelley sends you a link to grow it.

Prefer a terminal?
curl -fsSL https://exe.dev/deploy/supabase/prompt.txt | ssh exe.dev new --disk=40GB --prompt=/dev/stdin

Supabase is Postgres with a backend around it: sign-in, file storage, live updates, an instant REST API, and Studio to manage it all. Here it runs on your own exe.dev VM, from Supabase's official Docker setup, on a persistent disk you can back up and keep.

Studio stays behind your exe.dev login, on a private port. The API is private too until you make it public. Studio's AI Assistant uses exe.dev's LLM gateway, with no OpenAI key, and Shelley can write your migrations, functions, and app right next to the database.

What you get#

  • Supabase v0.8.4 running in Docker Compose, with its own generated secrets and keys in ~/supabase/.env (mode 600), and coming back after a reboot.
  • Studio at https://<vm>.exe.xyz:8001/, behind exe.dev login and the dashboard password, showing a notes table with one row.
  • The API on port 8000 answering GET /rest/v1/notes with the publishable key, and refusing Studio and /pg/ paths.
  • Studio's AI Assistant answering through exe.dev's LLM gateway.
  • The Supabase CLI and rclone installed, and supabase-backup.timer saving the database and files to ~/backups nightly, with a first backup made.
What's running, and where
Private https://my-supabase.exe.xyz:8001/ Studio, after exe.dev login and the dashboard password
Private https://my-supabase.exe.xyz/ The API (/rest/v1, /auth/v1, /storage/v1, ...); make it public when apps elsewhere need it
my-supabase.exe.xyz exe.dev VM
Supabase self-hosted v0.8.4 Postgres 17, Auth, PostgREST, Realtime, Storage, Edge Functions, and Studio, in Supabase's own Docker Compose setup ~/supabase/volumes
API gateway (Envoy) Studio, behind a dashboard password, and every API :8001
Front door (Caddy) Passes Supabase's API paths to the gateway, and nothing else :8000
exe.dev LLM gateway Powers Studio's AI Assistant, with no OpenAI key

Deploy with Shelley#

Click Deploy and Shelley will set up Supabase on a new VM, then check that it works. No config-file wrangling required.

Supabase needs a 40 GB disk, more than a new VM has. Shelley checks first and, if it's too small, gives you a link to grow it; the terminal command below makes the VM that size from the start.

Prefer a terminal?
curl -fsSL \
  https://exe.dev/deploy/supabase/prompt.txt \
  | ssh exe.dev new --disk=40GB --prompt=/dev/stdin

When it's done, run this on your computer (only you can):

ssh exe.dev share set-public my-supabase
What Shelley is told
Set up Supabase on this VM by following the exe.dev recipe at https://exe.dev/deploy/supabase.md from top to bottom.

The recipe's example VM name is my-supabase. This VM's name is the output of `hostname`: use it wherever the recipe writes my-supabase. Skip the step that creates the VM; you are on it.

This recipe needs a 40GB disk, and a new VM's may be smaller. Before you install anything, run `df -h /`. If its size is under 36G, stop and ask me to grow the disk, either with this link: https://exe.dev/suggest?command=resize%20my-supabase%20--disk%3D40GB or, on my computer, with `ssh exe.dev resize my-supabase --disk=40GB`. When I say it's done, run `sudo resize2fs "$(findmnt -no SOURCE /)"`, check `df -h /` again, and carry on.

You are done when all of these are true. Check each one yourself:
- Supabase v0.8.4 running in Docker Compose, with its own generated secrets and keys in `~/supabase/.env` (mode 600), and coming back after a reboot.
- Studio at `https://<vm>.exe.xyz:8001/`, behind exe.dev login and the dashboard password, showing a `notes` table with one row.
- The API on port 8000 answering `GET /rest/v1/notes` with the publishable key, and refusing Studio and `/pg/` paths.
- Studio's AI Assistant answering through exe.dev's LLM gateway.
- The Supabase CLI and rclone installed, and `supabase-backup.timer` saving the database and files to `~/backups` nightly, with a first backup made.

Read the whole recipe, including the closed details. For initial setup,
follow "Install by hand" first, skipping VM creation and SSH, through the
first backup. The walkthrough at the top is for the owner afterwards. Do
not run the email hook, SMTP, S3, Cloud move, Restore, or Update sections
unless the user asks.
Never print ~/supabase/.env or setup.sh's secret output into the chat; tell
the owner where the dashboard password is (`grep DASHBOARD ~/supabase/.env`).
Don't make the VM public or share it: the owner decides. Leave the `notes`
table in place so the owner can see it in Studio.

Finish with the URLs I should open and these commands, which only I can run, from my own computer (with this VM's name in them):
  ssh exe.dev share set-public my-supabase

Also at /deploy/supabase/prompt.txt. The recipe it follows is /deploy/supabase.md.

Open Studio#

Open https://my-supabase.exe.xyz:8001/ (with your VM's name) and sign in to exe.dev. Studio then asks for the user supabase and the dashboard password. On the VM:

grep DASHBOARD ~/supabase/.env

Setup left a notes table with one row in Table Editor; delete it whenever you like.

Supabase Studio's Table Editor on an exe.dev VM, showing the notes table with one row: Hello from exe.dev
Studio, on the VM's private port 8001.

The AI Assistant (top right) explains tables and writes SQL, and runs it once you approve. Its requests count against your exe.dev LLM allocation.

Connect your app#

Your app needs the URL, https://my-supabase.exe.xyz, and a key from ~/supabase/.env:

  • SUPABASE_PUBLISHABLE_KEY (sb_publishable_…) for browsers and mobile apps. Row Level Security decides what it can see.
  • SUPABASE_SECRET_KEY (sb_secret_…) bypasses Row Level Security. Keep it on servers.

ANON_KEY and SERVICE_ROLE_KEY are their older JWT forms, for older apps.

import { createClient } from '@supabase/supabase-js'

const supabase = createClient('https://my-supabase.exe.xyz', 'sb_publishable_…')
const { data } = await supabase.from('notes').select('body')

Until you make it public, only code on the VM reaches the API, at http://localhost:8000. For browsers, mobile apps, or servers elsewhere, on your computer:

ssh exe.dev share set-public my-supabase

Port 8000 answers only Supabase's API paths (/rest/v1, /auth/v1, /storage/v1, /realtime/v1, /functions/v1, /graphql/v1). Studio stays on port 8001, which exe.dev never makes public.

Warning

Once the API is public, Row Level Security is what protects your data. Turn it on for every table in public; Studio's Advisors page flags the ones without it.

To give a teammate Studio, run ssh exe.dev share add my-supabase teammate@example.com and send them the dashboard password. For psql from your computer, tunnel to the pooler with ssh -L 5432:localhost:5432 my-supabase.exe.xyz, then connect to localhost as postgres.your-tenant-id with POSTGRES_PASSWORD from .env.

Auth emails#

Out of the box, Auth has nowhere to send confirmation, reset, and magic-link emails, so sign-up fails with Error sending confirmation email. Pick one:

  • While you build: set ENABLE_EMAIL_AUTOCONFIRM=true in ~/supabase/.env and run sh run.sh start in ~/supabase.
  • For a team app: send through exe.dev, with no email account. exe.dev delivers only to you, your team, and people you've shared the VM with.
  • For the public: fill in the SMTP_* lines of .env for a provider such as Amazon SES or Resend, and run sh run.sh start.

Set SITE_URL in .env to your app's address as well; email links send people there.

Files#

Uploads live on the VM's disk, in ~/supabase/volumes/storage, and the nightly backup copies them. To use an S3 bucket instead, see Store files in S3.

Move from Supabase Cloud#

Dump the database with the Supabase CLI, load it on the VM, and copy the files with rclone: Move a Cloud project has the commands, or ask Shelley. Users, passwords, buckets, and policies come along. Then point your app at the new URL and keys (users sign in once more), add the VM to your OAuth providers' redirect URLs, and recreate edge functions and secrets. Coming from Lovable? Use Migrate from Lovable.

Backups#

Every night, between 03:30 and 04:00 UTC, a timer saves the database as SQL, the stored files, and .env into ~/backups, keeping seven nights. Keep a copy off the VM too. On your computer:

scp -r my-supabase.exe.xyz:backups ./my-supabase-backups

.env holds every key, so keep these private. Restore puts a backup back.

What you give up#

This is Supabase's open-source core, without the Cloud platform:

  • One project per install. Use another VM for another project, or for staging.
  • No branching, point-in-time recovery, or read replicas; backups are nightly.
  • No usage, billing, or log search in Studio; logs come from sh run.sh logs.
  • Updates, email, and OAuth setup are yours to run.

Want plain Postgres instead? See PostgreSQL.

The nuts and bolts#

Happy clicking Deploy? You can stop here. These are Shelley's setup steps, plus the commands for later.

Install by hand

Create a VM#

On your computer (pick another name if my-supabase is taken):

ssh exe.dev new --name=my-supabase --disk=40GB
ssh my-supabase.exe.xyz

All remaining installation commands run on the VM, as exedev. Commands use hostname, so your VM can have any name.

Room on the disk#

Check the disk:

df -h /

If Size is under 38G, the VM was made with a smaller disk. Grow it with this link (with your VM's name), or on your computer with ssh exe.dev resize my-supabase --disk=40GB. Then, back on the VM, grow the filesystem to match:

sudo resize2fs "$(findmnt -no SOURCE /)"
df -h /

Get Docker and the tools ready#

Enable Docker at boot, so Supabase comes back after a reboot. Then install the Supabase CLI, checked against its release checksums, for database dumps, and rclone for stored files:

sudo systemctl enable --now docker.service
cd /tmp
curl -fsSLO https://github.com/supabase/cli/releases/download/v3.2.0/supabase_3.2.0_linux_amd64.deb
curl -fsSL https://github.com/supabase/cli/releases/download/v3.2.0/checksums.txt |
  grep ' supabase_3.2.0_linux_amd64.deb$' | sha256sum -c
sudo apt-get install -y ./supabase_3.2.0_linux_amd64.deb
curl -fsSL https://rclone.org/install.sh | sudo bash
cd ~
systemctl is-enabled docker.service; supabase --version; rclone version | head -1

Expect supabase_3.2.0_linux_amd64.deb: OK, then enabled, 3.2.0, and rclone v1. something.

Download Supabase#

Supabase's setup.sh downloads one release into ~/supabase, generates every secret and key into .env, and pulls about 12 GB of images. It prints the secrets, so keep only its progress lines:

curl -fsSL https://raw.githubusercontent.com/supabase/supabase/self-hosted/v0.8.4/docker/setup.sh -o /tmp/supabase-setup.sh
sh /tmp/supabase-setup.sh --skip-deps --ref self-hosted/v0.8.4 --project-dir supabase -y | grep '^===>'
ls ~/supabase/.env ~/supabase/.supabase-version

The last line should list both files. Update moves to later releases.

Point it at your VM's address#

Set the three addresses Supabase builds links from to the VM's HTTPS address, and move the gateway to port 8001, leaving 8000 for the front door. Then remove setup.sh's leftover copies and make .env private:

cd ~/supabase
url=https://$(hostname).exe.xyz
sed -i \
  -e "s|^SUPABASE_PUBLIC_URL=.*|SUPABASE_PUBLIC_URL=$url|" \
  -e "s|^API_EXTERNAL_URL=.*|API_EXTERNAL_URL=$url/auth/v1|" \
  -e "s|^SITE_URL=.*|SITE_URL=$url|" \
  -e "s|^API_GW_HTTP_PORT=.*|API_GW_HTTP_PORT=8001|" \
  .env
rm -f .env.old docker-compose.yml.old
chmod 600 .env
grep -E '^(SUPABASE_PUBLIC_URL|API_EXTERNAL_URL|SITE_URL|API_GW_HTTP_PORT)=' .env

The four lines should show your VM's address and 8001.

Add the front door#

Supabase's gateway serves Studio and the APIs on one port. A small Caddy container on port 8000, the one exe.dev can make public, passes on the API paths only. The same file points Studio's AI Assistant at exe.dev's LLM gateway. It's docker-compose.override.yml, which updates never touch:

cat > ~/supabase/docker-compose.override.yml <<'EOF'
# exe.dev additions to Supabase's Docker Compose setup. update.sh never
# changes this file. After editing it: sh run.sh start
services:
  # The front door on port 8000, the port exe.dev can make public. It passes
  # Supabase's APIs to the gateway and nothing else. Studio and the rest of
  # the gateway stay on port 8001, which only you can reach.
  front:
    container_name: supabase-front
    image: caddy:2.11-alpine
    restart: unless-stopped
    ports:
      - 8000:8000
    depends_on:
      api-gw:
        condition: service_healthy
    configs:
      - source: front
        target: /etc/caddy/Caddyfile

  # Studio's AI Assistant, through exe.dev's LLM gateway: no OpenAI key.
  studio:
    environment:
      OPENAI_BASE_URL: https://llm.int.exe.xyz/v1
      OPENAI_API_KEY: exe-dev-llm-gateway

configs:
  front:
    content: |
      {
        admin off
        auto_https off
      }
      :8000 {
        @api path /auth/v1/* /rest/v1/* /graphql/v1 /graphql/v1/* /realtime/v1/* /storage/v1/* /functions/v1/* /sso/* /.well-known/oauth-authorization-server/auth/v1
        handle @api {
          reverse_proxy api-gw:8000
        }
        handle {
          respond "Not a Supabase API path. Studio is on port 8001." 404
        }
      }
EOF
cd ~/supabase && sh run.sh config add override

The last command adds it to COMPOSE_FILE in .env, so run.sh and docker compose use it.

Start Supabase#

cd ~/supabase
sh run.sh start
docker ps --format '{{.Names}}: {{.Status}}' | sort

The first start takes about a minute. Expect twelve containers, all healthy except supabase-front, which has no health check.

Check the API#

Make a table with one row that anyone may read, then read it through the front door with the publishable key:

cd ~/supabase
docker exec -i supabase-db psql -U postgres -d postgres -v ON_ERROR_STOP=1 <<'EOF'
create table public.notes (
  id bigint generated always as identity primary key,
  body text not null,
  created_at timestamptz not null default now()
);
alter table public.notes enable row level security;
create policy "anyone can read notes" on public.notes
  for select to anon, authenticated using (true);
insert into public.notes (body) values ('Hello from exe.dev');
EOF
sleep 2
key=$(grep '^SUPABASE_PUBLISHABLE_KEY=' .env | cut -d= -f2-)
curl -s 'http://localhost:8000/rest/v1/notes?select=body' -H "apikey: $key"; echo
curl -s -o /dev/null -w '%{http_code}\n' http://localhost:8000/pg/tables

Expect [{"body":"Hello from exe.dev"}], then 404: the database admin API stays off port 8000. If it says Could not find the table, run the curl again in a few seconds.

Check Studio#

cd ~/supabase
curl -s -o /dev/null -w '%{http_code}\n' http://localhost:8001/
curl -s -o /dev/null -w '%{http_code}\n' -u "supabase:$(grep '^DASHBOARD_PASSWORD=' .env | cut -d= -f2-)" http://localhost:8001/

Expect 401 without the password and 307 (into Studio) with it.

Set up nightly backups#

~/bin/supabase-backup dumps the database with the CLI, copies stored files with rclone, and saves .env. Storage checks S3 signatures against the VM's public address, so rclone uses that name, reaching it through the front door with HTTP_PROXY:

cd ~/supabase
env() { grep "^$1=" .env | cut -d= -f2-; }
rclone config create supabase s3 provider=Other \
  endpoint=http://$(hostname).exe.xyz/storage/v1/s3 region=$(env REGION) \
  access_key_id=$(env S3_PROTOCOL_ACCESS_KEY_ID) \
  secret_access_key=$(env S3_PROTOCOL_ACCESS_KEY_SECRET) >/dev/null
mkdir -p ~/bin
cat > ~/bin/supabase-backup <<'EOF'
#!/usr/bin/env bash
# Back up Supabase: the database as three SQL files (the same format as a
# Supabase Cloud dump), the stored files, and the settings. Keeps 7 nights.
set -euo pipefail
cd ~/supabase
env() { grep "^$1=" .env | cut -d= -f2-; }
db="postgresql://postgres.$(env POOLER_TENANT_ID):$(env POSTGRES_PASSWORD)@localhost:5432/postgres"
dir=~/backups/$(date +%F)
mkdir -p "$dir"
supabase db dump --remote "$db" -f "$dir/roles.sql" --role-only
supabase db dump --remote "$db" -f "$dir/schema.sql"
supabase db dump --remote "$db" -f "$dir/data.sql" --use-copy --data-only
HTTP_PROXY=http://localhost:8000 rclone sync supabase: ~/backups/storage
cp .env docker-compose.override.yml "$dir/"
chmod -R go-rwx ~/backups
find ~/backups -mindepth 1 -maxdepth 1 -name '20*' -mtime +7 -exec rm -rf {} +
echo "Backed up to $dir"
EOF
chmod +x ~/bin/supabase-backup

A systemd timer runs it nightly:

sudo tee /etc/systemd/system/supabase-backup.service >/dev/null <<'EOF'
[Unit]
Description=Back up Supabase
After=docker.service

[Service]
Type=oneshot
User=exedev
ExecStart=/home/exedev/bin/supabase-backup
EOF
sudo tee /etc/systemd/system/supabase-backup.timer >/dev/null <<'EOF'
[Unit]
Description=Back up Supabase nightly

[Timer]
OnCalendar=*-*-* 03:30
RandomizedDelaySec=30m
Persistent=true

[Install]
WantedBy=timers.target
EOF
sudo systemctl daemon-reload
sudo systemctl enable --now supabase-backup.timer
sudo systemctl start supabase-backup.service
journalctl -u supabase-backup.service -n 1 --no-pager -o cat
ls ~/backups/$(date +%F)

The first run fetches the CLI's Postgres image and takes a minute. Expect Backed up to /home/exedev/backups/…, then data.sql, roles.sql, and schema.sql.

Send auth emails through exe.dev

Auth can hand each email to a database function, its send email hook. This one posts it to exe.dev's email gateway, as plain text with a link and a code. The gateway delivers only to you, your team, and people you've shared the VM with.

On the VM, create the function:

cd ~/supabase
url=$(grep '^API_EXTERNAL_URL=' .env | cut -d= -f2-)
sed "s|@AUTH_URL@|$url|" <<'SQL' | docker exec -i supabase-db psql -U postgres -d postgres -v ON_ERROR_STOP=1
create schema exe;
create or replace function exe.send_email(event jsonb) returns jsonb
language plpgsql security definer set search_path = ''
as $$
declare
  d jsonb := event->'email_data';
  link text := '@AUTH_URL@' || '/verify?token=' || (d->>'token_hash')
    || '&type=' || (d->>'email_action_type')
    || '&redirect_to=' || coalesce(d->>'redirect_to', '');
begin
  perform net.http_post(
    url := 'http://169.254.169.254/gateway/email/send',
    body := jsonb_build_object(
      'to', event->'user'->>'email',
      'subject', case d->>'email_action_type'
        when 'signup' then 'Confirm your sign-up'
        when 'magiclink' then 'Your sign-in link'
        when 'recovery' then 'Reset your password'
        when 'invite' then 'You have been invited'
        else 'Your verification code' end,
      'body', 'Open this link to continue:' || chr(10) || link
        || chr(10) || chr(10) || 'Or enter this code: ' || (d->>'token')));
  return '{}'::jsonb;
end
$$;
revoke all on function exe.send_email from public, anon, authenticated;
grant usage on schema exe to supabase_auth_admin;
grant execute on function exe.send_email to supabase_auth_admin;
SQL

Then turn the hook on. Add these lines to the services: section of ~/supabase/docker-compose.override.yml, after the studio: block:

  # Auth emails through exe.dev's email gateway.
  auth:
    environment:
      GOTRUE_HOOK_SEND_EMAIL_ENABLED: "true"
      GOTRUE_HOOK_SEND_EMAIL_URI: pg-functions://postgres/exe/send_email

and run cd ~/supabase && sh run.sh start. Sign up with your exe.dev email address to try it. Auth reports success even when the gateway refuses an address; see what the gateway said with:

docker exec supabase-db psql -U postgres -c "select created, status_code, content from net._http_response order by id desc limit 5"

To switch to SMTP later, remove the auth: lines and run sh run.sh start.

Store files in S3

Create the bucket and an access key with your provider. On the VM, back up the files you already have; they don't move by themselves:

~/bin/supabase-backup

Put the bucket's details in ~/supabase/.env. REGION also becomes the region of Supabase's own S3 endpoint:

cd ~/supabase
sed -i -e 's|^GLOBAL_S3_BUCKET=.*|GLOBAL_S3_BUCKET=your-bucket|' \
  -e 's|^REGION=.*|REGION=your-region|' .env
cat >> .env <<'EOF'
STORAGE_S3_ENDPOINT=https://your-endpoint
STORAGE_S3_KEY_ID=your-access-key-id
STORAGE_S3_SECRET=your-secret-access-key
EOF

Add these lines to the services: section of docker-compose.override.yml, after the studio: block:

  # Uploaded files in an S3 bucket.
  storage:
    environment:
      STORAGE_BACKEND: s3
      GLOBAL_S3_ENDPOINT: ${STORAGE_S3_ENDPOINT}
      GLOBAL_S3_FORCE_PATH_STYLE: "true"
      AWS_ACCESS_KEY_ID: ${STORAGE_S3_KEY_ID}
      AWS_SECRET_ACCESS_KEY: ${STORAGE_S3_SECRET}

Then restart, tell rclone the new region, and upload the files:

cd ~/supabase
sh run.sh start
rclone config update supabase region=$(grep '^REGION=' .env | cut -d= -f2-) >/dev/null
HTTP_PROXY=http://localhost:8000 rclone copy --ignore-times ~/backups/storage supabase:

For Amazon S3, leave out the two endpoint lines and GLOBAL_S3_FORCE_PATH_STYLE; see Supabase's S3 guide.

Move a Cloud project

Install Supabase on the VM first. Then, in the Cloud dashboard:

  • Connect: copy the Session pooler connection string. The direct connection is IPv6-only, which exe.dev VMs can't reach.
  • Storage → S3 Configuration → Access keys: create a key pair, and note the endpoint and region.

On the VM, dump the Cloud database as Supabase's restore guide does:

read -rs CLOUD_DB && export CLOUD_DB    # paste the session pooler string, with your password
mkdir -p ~/cloud && cd ~/cloud
supabase db dump --remote "$CLOUD_DB" -f roles.sql --role-only
supabase db dump --remote "$CLOUD_DB" -f schema.sql
supabase db dump --remote "$CLOUD_DB" -f data.sql --use-copy --data-only

Load it in one transaction, as supabase_admin, since postgres can't write to some Storage tables here:

cd ~/cloud
{ cat roles.sql schema.sql; echo 'SET session_replication_role = replica;'; cat data.sql; } |
  docker exec -i supabase-db psql --single-transaction -v ON_ERROR_STOP=1 -U supabase_admin -d postgres -q >/dev/null
echo "exit $?"

Expect exit 0. If it stops on a table or column the VM doesn't have yet, comment out that COPY line and its \. line in data.sql and run it again.

Then copy every bucket's files (the VM's supabase remote comes with the backups):

rclone config create cloud s3 provider=Other \
  endpoint=https://your-project-ref.supabase.co/storage/v1/s3 \
  region=your-region access_key_id=your-key-id secret_access_key=your-secret >/dev/null
rclone lsd cloud:
for bucket in $(rclone lsf cloud: | tr -d '/'); do
  HTTP_PROXY=http://localhost:8000 rclone copy --ignore-times "cloud:$bucket" "supabase:$bucket"
done

--ignore-times matters: the restored database already lists the files, so rclone would skip them.

Check the tables, users, and files in Studio, then point your app at https://<vm>.exe.xyz with the VM's keys. Add https://<vm>.exe.xyz/auth/v1/callback to each OAuth provider's redirect URLs, and put its keys in the override, as Migrate from Lovable does for Google. Edge functions go in ~/supabase/volumes/functions/<name>/index.ts. When it all works, rm -rf ~/cloud and delete the Cloud S3 key.

Restore a backup

A restore starts the database and files over, then loads a backup. Keys don't change, so apps carry on. On the VM, set the current data aside:

b=~/backups/2026-11-16    # the night to restore
cd ~/supabase
sh run.sh stop
sudo mv volumes/db/data ~/db-before-restore
sudo mv volumes/storage ~/storage-before-restore
mkdir volumes/storage
sh run.sh start

Load the backup into the fresh database, then put back the files (the latest copy):

cd "$b"
{ cat roles.sql schema.sql; echo 'SET session_replication_role = replica;'; cat data.sql; } |
  docker exec -i supabase-db psql --single-transaction -v ON_ERROR_STOP=1 -U supabase_admin -d postgres -q >/dev/null
echo "exit $?"
HTTP_PROXY=http://localhost:8000 rclone copy --ignore-times ~/backups/storage supabase:

Expect exit 0. Once Studio looks right, sudo rm -rf ~/db-before-restore ~/storage-before-restore.

On a new VM, copy the backup over and install through Download Supabase. Copy the backup's .env and docker-compose.override.yml into ~/supabase, run Point it at your VM's address, then Start Supabase and Set up nightly backups. Then load the backup with the two commands above. The old keys keep working.

Update Supabase

Supabase's update.sh moves to the latest release, merging its changes into docker-compose.yml and .env and leaving your values, the override, and your data alone. It doesn't back up data, so back up first, and read ~/supabase/CHANGELOG.md after the dry run:

cd ~/supabase
~/bin/supabase-backup
sh update.sh --dry-run
sh update.sh
sh run.sh pull && sh run.sh recreate
docker ps --format '{{.Names}}: {{.Status}}' | sort

Every container should come back healthy. Update the CLI the way you installed it, from its releases.

Troubleshooting
  • A container isn't healthy: in ~/supabase, sh run.sh status, then sh run.sh logs auth (or rest, storage, ...).
  • Error sending confirmation email: see Auth emails.
  • Could not find the table, still: docker exec supabase-db psql -U postgres -c "notify pgrst, 'reload schema'".
  • A browser app gets a login page or a CORS error: the VM is still private; ssh exe.dev share set-public my-supabase.
  • rclone says SignatureDoesNotMatch: use the endpoint http://<vm>.exe.xyz/storage/v1/s3 with HTTP_PROXY=http://localhost:8000.
  • Disk full: du -sh ~/backups ~/supabase/volumes; docker image prune -f clears old images; or ssh exe.dev resize.

Frequently asked questions#

Is self-hosted Supabase the same as Supabase Cloud?

Same open-source services and client libraries, so supabase-js code works unchanged. You give up the platform around them: one project per install, and no branching, point-in-time recovery, or read replicas. See What you give up.

How big a VM do I need?

The stack idles at about 1.5 GB of memory, so the default VM is plenty for a small app. Images take about 12 GB of disk; Supabase asks for 40 GB to leave room for data and backups.

Can I keep the API private?

Yes, that's the default; code on the VM uses http://localhost:8000. Make it public only when browsers or servers elsewhere need it. Studio stays private either way.

How do I move my project from Supabase Cloud?

Dump the database with the Supabase CLI, load it on the VM, and copy files with rclone; see Move a Cloud project. From Lovable, use Migrate from Lovable.

How much does it cost?

Supabase is free and open source (Apache 2.0). You pay for your exe.dev plan, with no per-project fees or row limits.

Updated Nov 16, 2026 · tested end to end Nov 16, 2026 · Markdown · manifest.json · Something wrong? Tell us