Hi David, Cron jobs are recreated as inactive, and recognised Database Webhooks are recreated disabled, including during the restore. My earlier “nothing calls out” was too broad. Other SQL can still make outbound requests, and ReviveDB has no general outbound block. Your independent switch would need to cover those paths. You would need to arrange access isolation on the destination before restoring. ReviveDB preserves destination settings, but does not block Auth, APIs or Edge Functions or manage reopening them. A separate project alone does not guarantee that isolation.
On the cron and webhook part: a restore into a new project can bring those back paused. ReviveDB restores a recovery point into a separate, empty Supabase project with the `pg_cron` jobs set to inactive and Database Webhook triggers disabled, so nothing calls out until you switch them on yourself. Your live project is not affected. A trigger of your own that calls `pg_net` directly comes back as it was, so keep your fail-closed switch for those. For the deletion registry, each recovery point records `capturedAt` in its `manifest.json`. That moment is always before the database snapshot was taken, so replaying every deletion and revocation logged from `capturedAt` onwards covers everything. A few deletions then run twice, which does nothing when they are idempotent. https://revivedb.dev (I build ReviveDB)
Without a computer, whatever runs `pg_dump` and `psql` has to run somewhere else. For the restore that means decrypting a file with password hashes on a CI runner. ReviveDB works from the browser. You connect the project with Supabase OAuth, and every backup includes the `auth` schema, so user IDs, identities and password hashes are kept unchanged. The backup uses a read-only login, so the 3 live accounts are not modified. To check recovery, restore a recovery point into a second, empty project and test the IDs, identity links and a password sign-in there, as nicholas-greenwood suggested. The Free plan runs a weekly backup, allows one manual backup a day and keeps 3 recovery points. https://revivedb.dev (I build ReviveDB)
If the dump runs as a separate read-only role, check what that role can see. Without BYPASSRLS, pg_dump stops on each table that has RLS with `query would be affected by row-level security policy`. Adding `--enable-row-security` gets rid of the error, but then the dump only has the rows the role is allowed to read, which for a backup role is usually none of them, and pg_dump still exits 0. ```sql select rolname, rolsuper, rolbypassrls from pg_roles where rolname = current_user; ``` If both are false, grant the role bypassrls and pg_read_all_data, then restore one dump somewhere and compare row counts on the RLS tables with the live project. I wrote up the scheduled pg_dump setup here: https://revivedb.dev/blog/supabase-backup-github-actions (I build ReviveDB)
`migration down --linked` resets the remote database and replays your migrations up to the version you picked, so the data in those tables is gone. The CLI issue GaryAustin1 linked (supabase/cli#3635) describes the same thing. Free projects officially get no backups. A few people got older daily backups back after upgrading to Pro, so it's worth asking support before you pay for it. Next time, run `supabase db dump --linked --data-only -f data.sql` before anything that touches the linked project. I wrote up the recovery options per plan here: https://revivedb.dev/blog/restore-deleted-table-supabase (I build ReviveDB)
`prisma migrate dev` resets the whole database when it detects drift. If `auth` is in your Prisma `schemas` list, it gets wiped along with everything else. On Pro you can restore one of the daily backups. On free there are officially no backups, though a few people here said older daily backups showed up after they upgraded to Pro. Worth asking support before you pay. If you get a backup, restore it into a new project and copy `auth.users` and `auth.identities` back from there. The rest of your current data stays as it is. To stop it happening again, take `auth` out of Prisma's `schemas` and only run `migrate dev` against a local database. I wrote down the steps for copying a single table back here: https://revivedb.dev/blog/restore-deleted-table-supabase (my own site, I build ReviveDB)
If rclone gives signature errors on Storage, the AWS CLI works against the S3 endpoint: ```bash aws s3 sync s3://<bucket> ./storage/<bucket> \ --endpoint-url https://<project-ref>.storage.supabase.co/storage/v1/s3 \ --region <project-region> ``` The access keys are under Project Settings > Storage. One thing to check after a restore: `storage.objects` only holds the rows that describe your files, not the files. A restored dump can list every object while every download fails. Compare object count, size and checksum against your copy, not the row count. More on what a Storage backup should record: https://revivedb.dev/blog/do-supabase-backups-include-storage (Disclosure: I build ReviveDB, a hosted backup service for Supabase. None of the above needs it.)
@albertocubeddu that error means the connection dropped in the middle of the `COPY`. The dump itself isn't the problem. Two things I'd check: - The Postgres logs for your project around the time it fails. If Postgres restarted or ran out of memory while copying a big table, it shows up there. `assessments_voice` sounds like it could have large rows. - Run `pg_dump` yourself against the session pooler (port 5432) or the direct connection instead of the CLI wrapper, and dump only the failing table with `--table public.assessments_voice --verbose`. Then you know quickly whether it's that one table or the connection in general. I wrote up the whole pg_dump route, including which client version to use: https://revivedb.dev/blog/download-supabase-database-backup (I run ReviveDB, a backup service for Supabase.)