SupabaseOperations and accessreference
Supabase disaster recovery tiers: daily backups, PITR, warm standby - RPO, RTO, and cost
A disaster recovery (DR) policy is written in recovery point objective (RPO - how much data you can lose) and recovery time objective (RTO - how long you are down), and Supabase gives you three tiers with very different numbers on both. The incident mechanics and the standby build are the companion docs - the incident reference and the resilience runbook. This page is the money-and-recovery-point axis those two deliberately skip.
The measured numbers on this page come from the
edge-resilience lab experiment: logical replication from a managed
primary (ap-southeast-2) to a managed standby (ap-southeast-1): W05
(replication lag) and W06 (dump and restore) on 2026-08-15, W21 (spend cap)
on 2026-08-17, with the Storage numbers from W10 (2026-08-15) and W26
(2026-08-17) and the resize windows from compute-disk D09 (re-run 2026-10-23) and
platform-downtime D03 (2026-08-04); the standby build and cutover rehearsal are
in the runbook. The restore figures
come from the restore-paths lab experiment (RP01-RP03, 2026-10-10):
throwaway Pro and Free projects in ap-southeast-1, driven over the
Management API and the shared pooler from one IPv4-only vantage, with n
stated on each figure. RP04 (2026-10-20, Team org) added a daily-backup
restore attempt and RP05 (2026-10-20, Pro org) the migration rollback route
and the transactional-apply check, on default-compute projects in the same
region. The release-gating figures are github-branching GB03 (2026-09-23);
the read-replica floor and restore-point figures are sfp-platforms S07 and
S03 (2026-08-25 to 2026-09-03); the clone timings are from
the major-upgrade guide. The restore-to-new-project API
surface was re-read in observability-surface OB06, and pg_cron across a
restart and a resize is cron-behaviour CB04 and CB05 (both 2026-10-28, Micro
projects on a Pro org in ap-southeast-1). The remaining figures are quoted from the cited
Supabase docs and the SLA page, and the evidence table at the end of the
doc splits measured from documented.
TL;DR: Daily backups are already on (Pro: 7 days, Team: 14,
Enterprise: 30) with up to a day of RPO.1 PITR is the add-on
that pulls worst-case RPO to ~2 minutes for ~$100-$400/month plus a
Small compute floor, and it replaces the daily
backups.1 A PITR restore of a 10 MB database on Small was back
to ACTIVE_HEALTHY in 30 s (n=3, measured 2026-10-10); no daily-backup
restore was timed. A hand-rolled warm standby beats both on RPO
(34ms-1s, measured) and RTO (minutes, rehearsed) at the cost of a second
project and owning the cutover. Your own billing state is availability
class zero: under the Fair Use Policy the whole org can answer
402.2 A bad release is undone in two parts: the schema by a
new forward migration (the Management API’s rollback route refuses a
production project), the rows by a restore, best to a new project.
The tiers on one axis
Section titled “The tiers on one axis”| Tier | Worst-case RPO | Expected RTO | Monthly cost | Plan floor |
|---|---|---|---|---|
| Daily backups | up to ~24h | size-dependent restore downtime, project offline (documented; not measured) | included | Pro (7d) / Team (14d) / Ent (30d) |
| PITR add-on | ~2 minutes | size-dependent restore downtime; measured 30-81 s to ACTIVE_HEALTHY at 10-715 MB on Small, with a narrower outage than “offline” (RP02, 2026-10-10, below); at 3.2 to 10.5 GB the Data API read was down 192 to 544 s (RP07; the test machine slept during these runs - checked, lab #234: range ends stand, Auth/Realtime windows void) | ~$100 (7d) / ~$200 (14d) / ~$400 (28d) + Small compute | Pro + Small compute |
| Warm standby (hand-rolled) | 34ms-1s replication lag (measured) | minutes - a rehearsed cutover, plus a resize window (REST reads, Auth and Realtime joins down 144.528 to 254.886 s per resize across four resizes between Micro, Small and Large, compute-disk D09, 2026-10-23, n=1 per op; REST reads down 54 to 218 s across six resizes in platform-downtime the same day; a seventh, 299 s, is void: the test machine slept inside it, lab #211) if the standby runs smaller than the primary | second project’s compute at the size you will cut over to (~$10 if that is Micro) + your runbook | any paid plan |
| Read replicas | asynchronous; lag not measured | no failover - read-only (Data API GET, or SQL over the replica’s pooler), no documented promotion | same compute size as the primary, outside the $10 credits | paid plans |
RPO and RTO are different axes. PITR’s “~2 minutes” is a recovery POINT - how much data you can lose - while its recovery TIME is the size-dependent restore downtime, which the docs describe as the project being inaccessible.1 The PITR restore measured here on a small database showed a narrower outage than that at 10-715 MB (Tier 2); at 3.2 to 10.5 GB the Data API read was down 192 to 544 s (RP07; the test machine slept during these runs - checked, lab #234: range ends stand, Auth/Realtime windows void). The standby flips that: its RPO is the replication lag and its RTO is your cutover procedure. The two cover different failures - PITR for “we deleted the wrong rows yesterday”, standby for “the region is down now”.
The production checklist positions read replicas as the availability answer to a disk failure event and PITR as the durability answer to the same event.3 Replicas serve reads from another node, but the read replica docs describe no way to promote one and Auth always goes to the primary, so they take read load and do not cover an outage.
Tier 1: Daily backups (already running)
Section titled “Tier 1: Daily backups (already running)”On Pro, Team and Enterprise your project is backed up daily already:
7, 14 and 30 days of retention respectively.1 The lab’s orgs
carry the same figure as an entitlement: backup.retention_days read 14 on
the Team org (RP04 artifact) and 7 on the Pro org (a manual call, no
artifact) in GET /organizations/{slug}/entitlements on 2026-10-20, so that endpoint answers “how many days does this org keep”
without opening the dashboard. Free-tier
projects get nothing - the documented self-serve path is a scheduled
supabase db dump (or pg_dump), kept off-site.1 Size the
schedule off the measured floor: 12.4s to dump and 6.4s to restore 10k
rows through the pooler session host (edge-resilience W06, 2026-08-15);
the command and the host shape are in
the runbook, Part 5.
Restoring from a daily backup has these limits:
- Storage objects are not in database backups. The backup holds the
metadata; restoring an old backup does not bring back objects deleted
after it.1 Objects do not follow their metadata through
replication either, so sync them separately and cost the sync. A standby
answered
400withNoSuchBucketin the body for an object that existed on the primary, and the download-then-upload sync of a small object took under a second (edge-resilience W10, 2026-08-15). Dual-writing at the client lands 200/200 with 107ms skew, but a partial failure (primary 200 / standby 400) leaves the object on one side only until a sync-after closes it in 97ms (W26, 2026-08-17). - Custom role passwords are not stored. Restore from a daily backup
and you reset custom-role passwords afterwards.1 That claim
is documented for daily-backup restore and was not tested. For PITR
restore the lab measured the
postgresrole through the pooler (RP02, 2026-10-10, no custom role): 9 of 9 clean restores kept the current password and refused the replaced one. The stored verifier was a third value each time, matching neither the pre-rotation nor the post-rotation fingerprint (first 8 hex characters ofmd5(rolpassword)), so the credentials were set again after the restore. That is a fingerprint inference, and it matches the 2026-07-30 changelog entry saying current credentials are reapplied after every physical restore.4 The current password was refused for about one 5 s poll between “database answers” and “password works” in 6 of 7 restores observed at that resolution, which bounds the stale window at about 10 s without measuring it. Targets here were minutes old; a target hours or days old was not run. - Restore is offline and size-dependent. The docs say the project is
inaccessible during the restore and the downtime grows with the
database.1 That is documented for daily-backup restore, which
the lab could not run: the Management API route answered “unavailable” on
a fresh Pro project (RP01, 2026-10-10) and on a fresh Team project on Micro
compute, retried for 3 minutes (RP04, 2026-10-20), so on these orgs the
Management API offers no in-place daily-backup restore; the dashboard
restore (documented, not run by the lab) is the remaining path. PITR restore on a small database measured differently: the
HTTP-tier REST probe, Auth and the Realtime handshake showed no failed 1 s
sample, Storage failed for 12 s, and the pooler for 5-13 s (41 s at
574 MB). Storage’s 12 s was 8 of 9 restores. A Data API read, probed in
later restores, did fail:
503 PGRST002for 15 and 14 s on two small restores and 192 to 544 s on seven restores of 3.2 to 10.5 GB (RP06, RP07, 2026-10-22 and 2026-10-23; the test machine slept during these runs - checked, lab #234: range ends stand, Auth/Realtime windows void). The two cases differ, and neither is generalised beyond the sizes tested. Mid-incident, restoring to a NEW project keeps the original up - the dashboard and the clone-project flow both offer it.1 The Management API documents no clone path: the published OpenAPI document (115 paths) has none, the create-project body has no source field, and the Dashboard’s clone route answers a PAT401Unsupported access token(re-checked 2026-10-28 with the v2 document as well, see restoring to a new project). The entitlementsproject_cloningandbackup.restore_to_new_projectread true on the Pro org (RP01, 2026-10-10) and on the Team org (RP04, 2026-10-20). The restore-paths modules did not clone; the dashboard clones run for the major-upgrade guide on 2026-07-29 and 2026-08-04 came up with new API keys and reset Auth settings, copied object rows without the file bytes, and were as old as the backup picked. The database password after a clone was not read.5
Tier 2: PITR (the add-on)
Section titled “Tier 2: PITR (the add-on)”Point-in-Time Recovery archives WAL with WAL-G on top of daily physical snapshots: WAL files ship every two minutes by default (immediately past a size threshold, never when idle), so the worst-case recovery point is two minutes back.1
The lab read the quoted latest recoverable instant every 15 s on a Small Pro
project (restore-paths RP06, 2026-10-22, n=1 per phase; the test machine slept
during these runs - checked, lab #234:
the sleep ended the idle phase 5 samples early, so 752 s is a lower bound,
values unaffected): under a writer of
about 5 rows/s it tracked pg_stat_archiver.last_archived_time and lagged at
most 107 s after the first sample; idle, the bound climbed to at least 752 s. A restore to
that instant kept nothing written after it and lost acknowledged statements
from at most 0.79 s before it (R24, R25). Under heavier writes on Small (RP08,
2026-10-23, 63.5 to 71.6 MiB/s of WAL, derived), the instant ran ahead of the
archived WAL by 7 to 33 segments at the call, and in the 6 restores issued at
once with the writers running (the live arm) the restore still did not stop
at the archive frontier; across all 10 RP08 restores none lost an acknowledged
statement older than 0.4 s before the target. The wait-then-restore procedure
of R15 never had more than 1 segment behind at the call. One earlier 10 GB restore to
the quoted instant that came back short (RP07 R15) did not reproduce and
stays unexplained; a backlog that grows without bound, larger compute and
R15’s exact shape were not run6.
- It costs ~$100, ~$200 or ~$400 per month for 7, 14 or 28 days of recovery retention, billed hourly, and the spend cap explicitly does NOT cover it, because it is an opted-in add-on.17
- The project must run at least Small compute.1
- Enabling PITR stops the daily backups - finer granularity makes both unnecessary. Disabling PITR later leaves physical backups only, which restore but cannot be downloaded.1
- Replication topologies must be unwound first. If the project uses
subscriptions or replication slots, drop them before the restore and
recreate them after; only the Realtime slot is exempted and handled
automatically.1 A project acting as your standby’s
publication source loses its slots in a restore, and the standby’s
subscription dies with it and must be recreated with a re-sync.
Inventory them first with
select * from pg_replication_slots;max_replication_slotsis 10 on Micro and on Small (compute-disk D01). A dropped subscription left its slot on the publisher both after a plain drop (edge-resilience W05) and afterslot_name = nonethen drop (W14), so listpg_replication_slotson the publisher andpg_drop_replication_slotany orphan first. A forgotten slot retains WAL and grows the disk. - A resize, a read replica and a restart kept logical slots. Three logical
slots (
pgoutputandwal2json) survived a resize Small to Medium and back, a read replica create and remove, and a project restart, in 3 of 3 runs, withconfirmed_flush_lsnafter each Postgres restart equal to what the consumer had confirmed where both were recorded (22 of 24 cases) and no duplicate or gap on any consumer (restore-paths RP09, 2026-10-23, Small Pro projects). A streaming consumer was disconnected by each resize and the restart and has to reconnect, or its slot sits inactive and retains WAL. An unclean stop, a PITR restore and a major upgrade were not run; the docs require slots dropped before the last two.6
PITR restore on Small, measured
Section titled “PITR restore on Small, measured”The lab ran POST database/backups/restore-pitr on 2026-10-10 against a Pro
project on Small compute with pitr_7 applied by the test and removed
afterwards, a 2 GB gp3 disk, a seed row, a bucket and an object (RP02, five
runs, ap-southeast-1). Each run restored to an instant before a password
rotation, then rotated again and restored to an instant after it as a
control: 9 clean restores, 4 with the pre-rotation target and 5 controls.
Every target was minutes old.
| Measurement | Value | n |
|---|---|---|
Status back to ACTIVE_HEALTHY (10 s polling), 10 MB database | 30 s | 3 |
| Same, control targets after a rotation | 30, 30, 40, 40, 41 s | 5 |
| Same, 574 MB database, pre-rotation target | 81 s | 1 |
| REST (HTTP tier), Auth and Realtime (handshake) (1 s probes) | no failed sample in any restore (one simultaneous timeout on all three 338 s after one run’s first request, no recovery recorded, not explained). The REST probe was an anon GET /rest/v1/, which the API gateway answers with 401 before PostgREST or the database is reached, so it never tested a read | 9 |
Data API read (service_role, up only on 200; later runs) | 503 PGRST002 for 15 and 14 s on two restores of a database a few minutes old (RP06 R24, R25, 30 s and 41 s to healthy); 192 to 544 s on seven restores at 3.2 to 10.5 GB (RP07, R18, R19, R22, R23; the test machine slept during these runs - checked, lab #234: R18 and R19’s 3 GB rest_read and pooler windows are upper bounds, their 144 s Auth/Realtime and 6 s rest/Realtime windows void; the range ends stand), while the HTTP-tier REST probe (rest) in the same runs failed in none of the 9 restores (a 6 s failure earlier recorded in R18 was a sample cut at a wake, void); Auth and the Realtime handshake failed in none of the 9 restores (their 144 s and 6 s windows were the host sleeps, void) (restore-paths RUNLOG, 2026-10-22 and 2026-10-23) | 9 (RP06 R24, R25 and seven RP07 restores; not the RP02 nine) |
| Storage path | failed for 12 s in 8 restores, 24 s in the other; error text The operation timed out, never an HTTP 5xx | 9 |
| Pooler login (5 s poll) | 5-13 s on 10 MB and on a 715 MB control; 41 s at 574 MB pre-rotation; 23 s on the 574 MB control | 9 |
First restore-pitr attempt | refused 400 Recovery time target must be within range with the range named in 8 of 9; accepted on a retry 60 s or 121 s later | 9 |
| Target against the quoted upper bound | 19-96 s past it where recorded | 4 records |
Window right after enabling pitr_7 | the first read already had pitr_enabled=true and a window of 359 or 360 s | 5 |
Reading the table:
- The 574 MB control restored in 40 s and the 715 MB control in 41 s, so the 81 s at 574 MB is a single point, too few for a size curve. Retries ran every 60 s, so the acceptance lag is bounded by that step and not resolved. The reason the window at enable time ends before the create call is not known.
- The pooler error texts during the restores were
the database system is not accepting connections,is starting up,is shutting down,econnrefusedandterminating connection due to administrator command. - After
pitr_7was applied,GET database/backupslisted zero entries and carried the window inphysical_backup_data.
Other behaviour seen across the restores and a Free-plan unpause (RP02 and RP03, 2026-10-10):
- Storage did not return a
500after any restore or unpause: list, download (bytes equal) and upload answered200. One PITR restore to before an object’s upload made its download404not_foundand the listing omit it, and the same path was writable again without upsert (n=1). What happened to the file in object storage was not read. GET /healthreadrealtime=COMING_UPin the read taken right after the restore or unpause in 4 of 8 runs.- A password change while a Free project was paused was refused:
400Cannot reset password for non-active projects(3 of 3 runs, RP03). The stale-credential condition the changelog describes4 cannot be set up through that route; another route was not tried. - The pooler’s circuit breaker is a hazard for restore probes. Polling a
wrong password every 4 s opened it within about a minute, and
(ECIRCUITBREAKER) too many authentication failures, new connections are temporarily blockedthen answered every login, including the correct password, before the password was checked. Poll a known-wrong password at most once a minute, and readblockedas unanswered. - Small’s disk is 2 GB gp3 and WAL counts against it. Growing a PITR project
to 574 MB left 505 MB free of 1981 MB with 736 MB of WAL. Asking for 1500
MB filled the disk at 715 MB; the next password rotation failed and the
restore request was refused
400Database appears to be unreachableuntil 301 s. What filled the disk was not separated (WAL not yet archived, or something else), and the WAL figure is from the 574 MB run only. The compute and disk reference has the otherpg_walmeasurements on a 2 GB disk.
What a Pro project can reach through the Management API (RP01, n=1, one fresh
project, entitlement project_pausing false):
| Call | Answer |
|---|---|
POST /pause | 400 Project is not free-tier |
POST database/backups/restore with the listed physical backup | 400 This endpoint is unavailable at the moment |
GET database/backups/restore-point | 400 This endpoint is unavailable at the moment |
POST database/backups/restore-pitr without the add-on | 400 PITR is not enabled for this project. |
The two unavailable answers also came from a manual call (no artifact) a few
minutes after pitr_7 was applied. Whether they differ on an older project or
an org with another flag was not tested, so read them as “not run”. The pause refusal matches the legacy-project result in
the platform operation cost reference.
Tier 3: the hand-rolled warm standby
Section titled “Tier 3: the hand-rolled warm standby”This is the tier the lab measured: logical replication managed-to-managed, 34ms-1057ms lag cross-region, cutover rehearsed in minutes, sessions portable via third-party-auth registration. The build and every caveat are in the runbook; this page covers the cost:
- A second project at the compute you will cut over to. Micro is
~$10/month; the $10 monthly compute credits cover ONE project, so the
second one is real money.8 Pricing the standby at Micro and
resizing at cutover moves the resize window into your RTO: REST reads,
REST reads were down 231.465 s on Micro -> Small and 223.28 s on Small ->
Large, with Auth and Realtime joins within 4 s of each, with the status reading
ACTIVE_HEALTHYat 218 and 216 s and REST back 18 to 35 s after it (compute-disk D09, 2026-10-23, n=1 per op), or 131 s on Auth and 207 s on the pooler for Micro -> Small on another rig (platform-downtime D03, 2026-08-04). The full sizing table plus resize windows and quota behaviour are in the compute and disk reference. - A read replica does not substitute for the standby. A replica runs at the primary’s compute size, its compute is not covered by the credits,9 and the read replica docs describe no way to promote a replica or fail over to one (doc-read 2026-10-08; see read replicas). It is a read-scaling feature that happens to survive a disk failure.
- Rehearsal is a monthly cost. The standby only beats PITR on RTO if the cutover is rehearsed - sequence resync, config re-apply, routing flip - and rehearsal is your time every month.
Outside the managed platform, an open-source Multigres cluster promotes a standby on its own. Multigres OSS failover measures what a client sees while it does: an ack-free stall of 1.1 s to 56.2 s per fault, and 0 acknowledged writes lost across 17 failovers.
A bad release
Section titled “A bad release”A release goes wrong in two layers: the schema change it shipped, and the rows the new code wrote before anyone noticed. They are undone with different tools: each of the three tiers above rolls back the schema and the rows together, and none rolls back one without the other.
Catch it before production. A preview branch runs the release’s
migrations on its own project first. A migration that altered a missing
table read MIGRATIONS_FAILED on its branch in the 81 s sample (15 s
sampling over 480 s) while a valid one on a
sibling branch went on to FUNCTIONS_DEPLOYED (github-branching GB03,
2026-09-23, one sample). An apply through the Management API migrations
endpoint is one transaction: a migration whose second statement failed
answered 400 with the Postgres error, and its first statement’s table did
not exist afterwards, nor did its row in the migration history (restore-paths
RP05e, 2026-10-20, n=2). The Supabase for Platforms guide documents the
same behaviour for that endpoint: “If the schema migration fails, the
changes will be rolled back.”10
Undo the schema by rolling forward. The docs’ instruction for a
migration already deployed to production is to write a new migration that
reverses it, so “production migrations are always rolling forward”, and to
review it because down migrations are usually destructive.11
The Management API has a rollback route,
DELETE database/migrations?gte=<version>, and the apply body takes an optional
rollback SQL string that is stored with the migration (RP05a). On a
production project the route refuses: 400 You cannot rollback a production branch., with the schema and the history unchanged (RP05b-d, 2026-10-20,
n=2). On a git-less preview branch it ran (RP05g, 2026-10-20, n=1):
| Migration on the branch | rollback stored | After one DELETE ?gte=<B2's version> |
|---|---|---|
| B1: create table, insert a row | drop table | below the cut: table and row kept |
| B2: add a column | drop column | column dropped, history row removed |
| B3: create a second table | none | history row removed, table still there |
So the route removes history rows from the cut onward but runs only the rollback SQL that was stored. A migration applied without one leaves its change behind under a history that no longer lists it. That makes the branch route a way to iterate on a release, and the production fix is still a new forward migration.
Undo the data with a restore, and pick which kind. An in-place PITR
restore to an instant before the deploy brings back the pre-release schema
and rows, and discards every write after that instant, the good ones with
the bad (Tier 2). Restoring to a NEW project at
that instant keeps production up and lets you copy back only the rows the
release damaged; the dashboard clones measured for
the major-upgrade guide
reached ACTIVE_HEALTHY in 100 s, 150 s (the PITR clone, 2026-08-04) and
180 s (three clones), and come
up with a new ref, new API keys and reset Auth settings. Without PITR the
newest point either restore can reach is the last daily backup, so every
write since that backup is lost, from before the release as well as after.
The OpenAPI document also lists restore-point and undo routes (POST backups/restore-point, POST backups/undo). Both answered 400 This endpoint is unavailable at the moment on Pro projects (sfp-platforms,
2026-09-03). On the Team org POST backups/restore-point answered 400
(sfp-platforms S03, 2026-09-03) and GET backups/restore-point answered
400 This endpoint is unavailable at the moment (RP04, 2026-10-20); undo
was not tried there. The Supabase for Platforms guide limits restore points
to select customers.10 Neither route is a release-undo path on the
orgs where it was tried.
Releases from 2026-10-30 may break on grants. Supabase announced that
from that date a new table in public on an existing project gets no Data
API grants, so a release whose migration creates a table without explicit
grant statements would answer 42501 for that table through the Data
API.12 The announcement is not treated as settled here: on
a project created 2026-11-10 a table created in public with no table grant
still answered the anon key 200 (logs-volume LV04g, one project), and the
re-run on a project created before 2026-10-30 has not been done. Both
readings are in
locking down Supabase. A
migration that grants each table explicitly behaves the same either way.
Restoring to a new project
Section titled “Restoring to a new project”Restore to a new project builds a separate project, in the source’s region, from one of the source’s backups or, with PITR, from an instant you pick. It needs a paid plan with physical backups enabled, and a project created this way cannot itself be the source of another one.5 The docs page marks the feature “Beta Version” (read 2026-10-28), so it is outside the uptime SLA’s GA-only scope (below). The source stays up throughout,1 which makes it the restore to reach for mid-incident and after a bad release. The docs call the result a database-only copy. The table sets their list (read 2026-10-28) beside what the dashboard clones for the major-upgrade guide found on 2026-07-29 and 2026-08-04; the supabase-lab modules have not run a clone.
| Part of the project | The clone docs say | Dashboard clones, 2026-07-29 and 2026-08-04 |
|---|---|---|
| Schema, data, indexes, database roles and permissions | copied | copied, as of the backup or PITR instant picked, not the click |
Auth users (the auth schema: accounts, hashed passwords) | copied | auth.users copied intact |
| Encryption root key | copied, so Vault secrets and encrypted columns stay readable | Vault secrets decrypted |
| Compute size, disk attributes, SSL enforcement, network restrictions | copied, same region | compute, disk and region matched the source; SSL enforcement and network restrictions not checked |
| Storage objects and bucket settings | not copied | the bucket and object rows came across (they live in the database), the file bytes did not |
| Edge Functions | not copied | not copied, their secrets neither |
| Auth settings and API keys | not copied | new API keys and JWT signing secret, so existing sessions are invalid; SMTP, templates and redirect URLs reset to defaults |
| Realtime settings | not copied | not copied |
| Data API exposed schemas | not listed | reset to public,graphql_public |
| Database extensions and settings | listed under manual reconfiguration, though the same page says the binary restore copies enabled extensions | a deprecated extension (pgjwt) came across |
pg_cron, pg_net and wrapper jobs | come across and start running as soon as the restore completes, with no way to exclude or pause them | two pg_cron jobs arrived active = true and both ran at their first matching tick, six minutes after the clone came up |
| Read replicas | not copied | not copied |
| PITR | not listed | not inherited: the clone came up with daily backups |
| Database password | not listed | not read |
The copy runs its jobs before you can reach them. The docs call this a
binary restore: it copies the whole database, including enabled extensions
that act outside it, and the jobs those extensions hold start as soon as the
restore completes.5 A job that only touches its own database is
harmless on a copy. A cron job that calls a webhook, a pg_net trigger, or a
wrapper that writes to a remote system acts from the copy against the targets
the source uses, so both projects fire. The docs’ route for inspecting or
removing those first is a logical restore with the Supabase CLI.13
It is manual and does not carry the encryption root key, so Vault secrets and
encrypted columns in it are unreadable unless you move the key
separately.5 Whether a clone’s pg_cron runs the instants missed
between the backup and the clone coming up was not recorded; CB04 and CB05
(below) found no catch-up after a
restart or a resize, and reading that across to a restore is inference.
No API creates the copy. observability-surface OB06g re-read the
Management API on 2026-10-28 (2 runs, Pro org): the v1 OpenAPI document has
115 paths and the v2 document 36, none mentions clone, and the create-project
body has no source, backup or restore field. The restore routes it lists act
in place (/v1/projects/{ref}/restore, database/backups/restore,
restore-pitr, restore-point, undo), plus
POST /v2/projects/{ref}/backups/download, whose body takes a backup id and
the type project_backup_file_url. GET /v1/projects/{ref}/clone answered 404,
and the Dashboard’s clone route answered a personal access token with 401
Unsupported access token (the 401 as restore-paths RP01d found on 2026-10-10). Branch
creation takes with_data; whether that or the backup download gives a usable
copy was not run. A scripted drill therefore stops at one Dashboard step.
The RTO has three parts, and only the first has figures. Because the
source keeps serving, cutting over to the copy costs the time until the new
project serves, plus switching clients to its URL and new API keys, plus
re-applying everything the table lists as not copied (reasoned from the docs,
not measured end to end). The only figures for the first part are the three
dashboard clones in the major-upgrade guide: 100 to 180 s to ACTIVE_HEALTHY (150 s for the PITR
one), timed to the status, not to a working Data API read. Restore to a new
project has not been timed in the restore-paths or observability-surface
modules (not run), and the other two parts belong to your runbook. When the
copy is only a source of rows to copy back after a bad release, no client
switches and production’s RTO does not move.
The upgrades a tier depends on
Section titled “The upgrades a tier depends on”An upgrade to a production project is one of three changes, and each costs
something different. Two of the tiers above also have an upgrade as a
prerequisite: PITR refuses projects below Small compute,1 and a
read replica refuses them too (400 "Read replicas require a minimum size of small", sfp-platforms S07, 2026-08-25; see
read replicas).
| Upgrade | What it changes | Downtime (measured unless marked) | Read next |
|---|---|---|---|
| Compute size (Micro to Small and up) | CPU, memory, connection and pg limits, the PITR and replica floor | Micro -> Small took a row read through REST down for 231.465 s and /auth/v1/health for 231.433 s, with ACTIVE_HEALTHY at 218 s (compute-disk D09, 2026-10-23, 250 ms sampling, n=1); another experiment measured outages of 131 s on /auth/v1/health and 207 s on the pooler for the same step (platform-downtime D03, 2026-08-04, n=1; its REST probe was HTTP-tier only), and on 2026-10-23 a row read through REST on that rig failed for 171 and 218 s on the same step. A second resize within minutes answers 429 We are still processing addon changes (D09) | compute and disk |
| Postgres major version | the database engine, in place or on a new project | in place: about 10 s per GB of disk plus fixed overhead, derived and not measured; a new-project cutover with logical replication: seconds of write stop | major upgrade, end to end |
| Plan (Team to Enterprise) | the uptime SLA, the support response times, 30 days of daily backups | none expected for a billing change; not measured | the SLA section |
When PITR is the goal, resize to Small first, because PITR refuses Micro,
then enable PITR a few minutes later: the add-on endpoint answered 429 to a
second compute change (D09) and to a PITR change right after a compute
change (sfp-platforms S07, 2026-08-25).
Turning PITR on stops the daily backups (Tier 2);
whether any gap opens between the two was not measured.
Scheduled jobs across a restart or resize
Section titled “Scheduled jobs across a restart or resize”A restart or a resize restarts Postgres, and pg_cron does not catch up the
runs it missed. cron-behaviour ran a project restart (CB04) and a resize from
Micro to Small (CB05) on 2026-10-28, one of each in each of two runs (n=2
each), with pg_cron 1.6.4 running jobs over libpq connections to localhost
(cron.use_background_workers=off):
| Event | New postmaster answering the probe, after the request | Every-minute job: last run before / first after | Instants missed | '10 seconds' job gap |
|---|---|---|---|---|
| restart, run a | 49.5 s | 08:34:00.024 / 08:36:00.131 | 1 (08:35) | 62.4 s |
| restart, run b | 67.7 s | 08:35:00.116 / 08:37:00.086 | 1 (08:36) | 83.7 s |
| resize, run a | 67.7 s | 08:40:00.076 / 08:42:00.021 | 1 (08:41) | 81.7 s |
| resize, run b | 49.7 s | 08:41:00.063 / 08:43:00.017 | 1 (08:42) | 61.8 s |
- The every-minute instant inside the outage was skipped, not run late, in 4
of 4 events, and
cron.job_run_detailsheld no row for it. After recovery every every-minute run started 0 to 0.2 s past its boundary, with no late run and no same-minute duplicate. The'10 seconds'job’s first run came 10.2 to 10.3 s after the new postmaster started, then every 10 to 10.1 s, with no burst. - A run in flight at the event (a
pg_sleep(120)job) was recordedfailedin 4 of 4 events and never re-run. The message wasSSL connection has been closed unexpectedlyin run a andserver restarted, with no end time, in run b; which one appears depends on whether the old scheduler recorded the lost connection before it stopped (the lab’s inference; the order was not observed). - A Management API
selectevery 2 s failed for 49.3 s and 67.6 s across the restarts and 67.5 s and 47.4 s across the resizes.
So a job that must run once per period cannot rely on the schedule across a restart or a resize (or, by inference, a restore); it has to find the work it has not done itself. More than one missed minute, a job longer than its interval, background workers on, and a restart on Small or larger compute were not run.
Class zero: your own billing state
Section titled “Class zero: your own billing state”Some org-wide outages are not the platform at all. Under the Fair Use Policy, service restrictions apply when an organization continually exceeds the Free quota, exceeds the Pro quota with the spend cap on, or has overdue invoices:2
- projects paused, databases switched to read-only, new launches blocked
- every API request answered 402 with a restriction description in the body
- applied to ALL projects in the org; dashboard data access is retained
There is a notification and grace period first (except suspected abuse). Removal: fix the cause (pay, update the card, disable the cap, or reduce usage); usage-limit restrictions also lift when the quota refills at the next billing cycle, and immediately on upgrading or disabling the spend cap.2 In a probe table, map 402 to billing rather than to a platform fault. The spend cap setting is the trade-off: cap on means eventual restriction, cap off means an uncapped bill.7
The spend cap does not act as a request-path circuit breaker. Tripping the Pro transform quota by 5 past 100 returned 200 on every render - no synchronous disallow at the boundary (measured, edge-resilience W21, 2026-08-17). The documented “further usage disallowed” rides the billing path - notification, grace period, then the restrictions above - so the first signal you can detect is still the notification, not an API error at quota+1.
What the SLA does and does not cover
Section titled “What the SLA does and does not cover”The uptime SLA is Enterprise-only. 99.9% per product per calendar month, measured per-project, per-region or globally depending on the product, and only for generally-available features - Beta and Alpha are outside it.1415 The remedy is service credits: 10%, 15%, 20% or 30% of the affected service’s monthly fees by availability band, capped at 20% of the trailing twelve months’ fees, and the credits are the sole remedy. Below Enterprise there is no uptime SLA at all - which is most of why the hand-rolled tier exists.
Support SLAs exist for Team and Enterprise. Urgent response is 24 hours 24/7x365 on Team and 1 hour 24/7x365 on Enterprise Standard and Priority Plus; business-hours limits start at High (Team: 1 business day for High and Normal, 2 business days for Low).14 Pro gets support access with no SLA. And on Team or Enterprise, the documented pre-launch channel is a support ticket with at least 2 weeks’ notice before a launch or heavy load event.
When you build availability on top of a non-GA feature, you are outside the contract by construction, which is another reason to build the hand-rolled tier from GA primitives (logical replication, the Management API) rather than platform HA features.
Which do I pick
Section titled “Which do I pick”| Your requirement | Tier | Why |
|---|---|---|
| “Oops, we dropped the wrong table this morning” | PITR | restore target chosen to the second, just before the mistake; the ~2-minute worst-case RPO bounds only WAL not yet shipped, and WAL from this morning has shipped |
| Compliance says “we have backups” | Daily backups | already on; just prove the restore |
| Free tier, any durability at all | scheduled db dump off-site | the only option that exists |
| Region down, RTO in minutes | Warm standby | the only tier that is up somewhere else |
| A release broke the schema | a new forward migration; a preview branch first | the rollback route refuses production; see a bad release |
| A release corrupted rows | restore to a new project at an instant before it (PITR; otherwise the last daily backup), copy the rows back | production stays up; an in-place restore also discards the good writes |
| Read load, plus disk-failure cover | Read replicas | availability for reads; never a failover |
| Zero budget, best possible | cron pg_dump + object sync | measured floor: 12.4s dump / 6.4s restore at 10k rows |
Text version of the diagram, in the same order as the table above: (1) data
loss with a target known to the second -> PITR (~2-minute worst-case RPO,
restore 30-81 s on Small); (2) proof of backups only -> the daily backups
that are already on (up to ~24h RPO); (3) the region is down and the RTO is
minutes -> the hand-rolled warm standby (34ms-1s RPO, minutes RTO, plus the
resize window); (4) read load -> read replicas (no promotion, so not a
failover); (5) Free tier or zero budget -> a scheduled db dump off-site
plus an object sync (12.4s dump / 6.4s restore at 10k rows).
What to do about it
Section titled “What to do about it”The sizing rules that follow from this page’s own numbers. Each row names the module it rests on; a row that is a design choice says so. Module ids resolve in the edge-resilience RUNLOG the compute-disk RUNLOG and the restore-paths RUNLOG (RP04 and RP05 in the 2026-10-20 RUNLOG), with OB06 in the observability-surface RUNLOG and CB04 and CB05 in the cron-behaviour RUNLOG.
| Practice | Evidence | Module |
|---|---|---|
| Run the standby at the compute size you will cut over to, and price that. | A resize at cutover took REST reads, Auth and Realtime joins down 144.528 to 254.886 s per resize across four resizes between Micro, Small and Large (D09, 2026-10-23, n=1 per op), or 131 s Auth / 207 s pooler for Micro -> Small in platform-downtime D03 (2026-08-04); in platform-downtime a row read through REST failed for 54 to 218 s across six resizes between Micro, Small, Medium and Large on 2026-10-23 (one Large to Medium figure, 101 s, a lower bound; a seventh is void, lab #211) (RUNLOG). | compute-disk D09; platform-downtime D03 |
| If you do run the standby small, add the resize window to the standby RTO. | Two resize PATCHes need at least 2 minutes between them (429 We are still processing addon changes). | compute-disk D09 |
| Add a Storage sync step to every tier and cost it. | Objects do not follow metadata (the standby answers 400/NoSuchBucket; a small object’s first sync took under a second), and dual-write is not atomic (200/400 split; sync-after 97ms). | W10, W26 |
| Before enabling PITR on a publication source, inventory subscriptions and slots and drop orphans. | Read them from pg_replication_slots. 10 slots on Micro and Small, and a dropped subscription left its publisher slot pinning WAL in both drills (W05 plain drop; W14 after slot_name = none). | compute-disk D01; W05, W14 |
| Time a restore on a copy before you need the number. | PITR restore on Small, 2026-10-10: 30 s to ACTIVE_HEALTHY at 10 MB (n=3), 30-41 s for targets after a rotation (n=5), 81 s at 574 MB (n=1), so the size effect is one point. Daily-backup restore was not timed. | RP02 |
| Probe a Data API read, Storage and the pooler separately during a restore. | PITR restore on Small: Storage 12 s (8 of 9); pooler 5-13 s on 10 MB, 41 s at 574 MB; the HTTP-tier REST probe, Auth and the Realtime handshake no failed 1 s sample. A Data API read answered 503 PGRST002 for 15 and 14 s on small restores and 192 to 544 s at 3.2 to 10.5 GB (the test machine slept during these runs - checked, lab #234: range ends stand, Auth/Realtime windows void), so a probe of /rest/v1/ alone reports a restore as no outage. | RP02; RP06, RP07 (RUNLOG) |
| After a restore, retry the current password for at least 10 s before alarming. | The current password was refused for about one 5 s poll in 6 of 7 restores; the verifier was set again each time (fingerprint inference). 5 s resolution, so the refusal is a bound and not a duration; the 10 s is a design choice. | RP02 |
Retry restore-pitr every 60 s when it names a range. | The first attempt was refused with the range in 8 of 9 restores and accepted 60 s or 121 s later; targets were 19-96 s past the quoted bound. | RP02 |
| Poll a known-wrong password at most once a minute. | A 4 s poll opened the pooler circuit breaker within about a minute and every login, including the correct password, answered ECIRCUITBREAKER. | RP02 (aborted first run) |
| Check free disk, WAL included, before PITR on Small. | 574 MB database: 505 MB free with 736 MB of WAL on a 2 GB disk; 1500 MB requested filled it at 715 MB and the restore request was refused until 301 s. Cause not separated. | RP02 |
Plan Pro restore around restore-pitr, not pause or backups/restore. | On a fresh Pro project POST /pause answered 400 Project is not free-tier and backups/restore and restore-point answered 400 This endpoint is unavailable at the moment, also after pitr_7. One project, so “not run” on older ones. | RP01 |
| Run every release’s migrations on a preview branch before production. | A migration that altered a missing table read MIGRATIONS_FAILED on its branch at 81 s while a sibling branch deployed. One sample. | github-branching GB03 |
Undo a deployed migration with a new forward migration, and store a rollback on every migration you apply through the API. | DELETE database/migrations?gte= answers 400 You cannot rollback a production branch. on the project; on a preview branch it ran B2’s stored rollback and B3, with none stored, kept its table (n=1). | RP05 |
| Put each migration’s statements in one apply call so a failure leaves nothing half-done. | A failing second statement answered 400 and left no table and no history row (n=2). | RP05 |
| On Pro and Team, plan a daily-backup restore through the dashboard (the API route refuses), and rehearse it there. | backups/restore answered 400 This endpoint is unavailable at the moment on Pro (RP01) and on Team on 4 attempts over 180 s (RP04); the dashboard restore was not run, so no lab figure exists for its downtime. | RP04 |
| Read the org’s backup retention from the entitlements endpoint before quoting it. | backup.retention_days read 14 on the Team org (artifact) and 7 on the Pro org (manual call), 2026-10-20. | RP04 |
| Resize to Small before enabling PITR, as two separate changes. | PITR and replicas refuse Micro; a second compute change, or a PITR change right after a compute change, answered 429. | compute-disk D09; sfp-platforms S07 (2026-08-25); docs1 |
| Verify the 2-minute PITR recovery point before quoting it into a contract. | Use a canary insert against the WAL archive lag. Under a light writer the quoted latest instant lagged at most 107 s after the first sample, and idle it climbed to 752 s (RP06, n=1 per phase); a restore to that instant kept every acknowledged statement older than 0.4 s before it in 10 of 10 restores, 6 of them with 7 to 33 WAL segments unarchived at the call (RP08 live arm, Small only). | the docs;1 restore-paths RP06, RP08 (RUNLOG, 2026-10-22/23) |
| Alert on the spend-cap notification and the usage page rather than on a request error. | 105 renders against a quota of 100 all returned 200, so the notification is the first detectable signal. | W21, 2026-08-17 |
| Before restoring to a new project, list the jobs that act outside the database. | cron.job, pg_net triggers and wrapper servers come across in the binary restore and start when it completes, with no way to pause them (docs); on a 2026-08-04 dashboard clone two pg_cron jobs arrived active and ran at their first tick, six minutes after it came up. | docs;5 dashboard clone in the major-upgrade guide, no module |
| Make those jobs safe to fire from a copy, or use a logical restore and move the root key. | The logical restore with the CLI lets you inspect and remove jobs first but does not carry the encryption root key, so Vault secrets and encrypted columns are unreadable without it. Documented, not run. | docs513 |
| Write the drill with one manual Dashboard step to create the copy. | No clone path in the v1 (115 paths) or v2 (36 paths) OpenAPI document, no source field on create-project, GET /v1/projects/{ref}/clone 404, Dashboard clone route 401 Unsupported access token to a PAT (OB06g, 2026-10-28, 2 runs; RP01d, 2026-10-10). | observability-surface OB06; RP01 |
| Keep a reconfigure list for the copy: keys, Auth, schemas, Functions, Storage bytes. | The clones came up with new API keys and JWT signing secret, Auth settings and exposed schemas reset, no Edge Functions, and object rows without file bytes (dashboard clones, 2026-07-29 and 2026-08-04); the docs list Realtime settings, extensions and settings, and read replicas too. | docs;5 dashboard clones in the major-upgrade guide, no module |
| Budget a cutover to the copy as new project serving + client switch + settings. | The source stays up. Only the first part has figures: 100 to 180 s to ACTIVE_HEALTHY across three dashboard clones, timed to the status only; the lab modules have not timed a restore to a new project (not run). The three-part split is a design choice. | design choice; docs1 |
| Make once-per-period jobs find their own missed work after a restart or resize. | The every-minute instant inside the outage was skipped, not run late, in 4 of 4 events (1 instant each), and after recovery runs started 0 to 0.2 s past their boundary with no burst (n=2 restarts, n=2 Micro to Small resizes). | cron-behaviour CB04, CB05 |
| Re-run by hand the job that was in flight when Postgres restarted. | A pg_sleep(120) run in flight was recorded failed (SSL connection has been closed unexpectedly or server restarted) and never re-run, in 4 of 4 events. | cron-behaviour CB04, CB05 |
On the free tier, schedule the db dump and ship it off the project. | Size the job off 12.4s dump / 6.4s restore per 10k rows through the pooler session host. | W06, 2026-08-15 |
Not measured, so stated as such above: daily-backup restore downtime at any
size, and backups/restore on any project where it answers (it did not on
Pro or Team); the 2-minute
worst-case recovery point under a write rate the archiver cannot keep up with (RP08’s loads on Small never built a growing backlog; the window read 359 or 360 s at enable time, a figure
the lab could not tie to the WAL shipping cadence); PITR restore to a target hours or days old; a
database over 1 GB; the database password after a restore to a new project (clone), and the
Dashboard’s physical-backup restore; direct 5432, which is IPv6-only with no IPv6 route
from the vantage; tooManyConnections on a restore
(recorded in the lab’s summary file with no module, date or artifact, so
anecdotal); read replica behaviour through a disk failure; the full 402
restriction path (W21 proved only the absence of a request-path breaker);
the cutover RTO end to end (per-step timings exist: W05, W16, W17); the
monthly rehearsal cadence; a stored migration rollback that fails on a
branch, and the order several rollbacks run in; the Data API grant
behaviour after 2026-10-30 on a project created before that date; restore to a new project timed in the lab modules
(not run; the only times are the dashboard clones), whether the copy keeps the source’s database password,
SSL enforcement and network restrictions on the copy, whether its pg_cron
runs instants missed between the backup and the copy coming up, and whether
branch with_data or the v2 backup download gives a usable copy; pg_cron
across more than one missed minute, with background workers on, or after a
restart on Small or larger compute.
Evidence
Section titled “Evidence”| Number in this doc | Status | How it was checked |
|---|---|---|
| 34ms-1s replication lag (34ms-1057ms cross-region) | measured elsewhere | edge-resilience lab W05, 2026-08-15: managed-to-managed logical replication, primary ap-southeast-2 -> standby ap-southeast-1, three runs. Build and caveats: the runbook |
| Cutover RTO (minutes, rehearsed) | measured elsewhere | the runbook rehearses the cutover; lab W05 (2026-08-15) measured the lag and session portability the cutover depends on |
| Spend cap: no synchronous disallow at the quota boundary | measured elsewhere | lab W21, 2026-08-17: 105 renders against the Pro quota of 100, every render returned 200 |
| 12.4s dump / 6.4s restore at 10k rows | measured elsewhere | lab W06, 2026-08-15: pg_dump and restore through the pooler session host, exact row count verified |
PITR restore: 30 s (10 MB, n=3), 30-41 s after a rotation (n=5), 81 s (574 MB, n=1) to ACTIVE_HEALTHY | measured elsewhere | restore-paths lab RP02, 2026-10-10: Pro project, Small compute, pitr_7, ap-southeast-1, 10 s status polling, five runs, 9 clean restores |
| Per-path outage during a PITR restore: REST, Auth, Realtime none; Storage 12 s (8 of 9); pooler 5-13 s (41 s at 574 MB) | measured elsewhere | RP02, same runs: 1 s probes on the HTTP paths, 5 s login poll on the pooler, one IPv4-only vantage |
| Current password kept, replaced one refused, verifier a third value (9 of 9); current password refused for about one 5 s poll (6 of 7) | measured elsewhere | RP02 and RP03 (rp03-free-pause-unpause.ts), 2026-10-10: postgres role through the pooler; verifier by 8-hex fingerprint, so the third-value reading is an inference. Custom roles and daily-backup restore not run |
Pro: pause 400; backups/restore and restore-point 400 unavailable; no clone path in the OpenAPI document | measured elsewhere | restore-paths lab RP01, 2026-10-10: one fresh Pro project, plus one manual probe after pitr_7 (no artifact). Clone not run |
Storage 200 after every restore and unpause; 404 for an object newer than the restore target; realtime=COMING_UP in 4 of 8 health reads | measured elsewhere | RP02 and RP03, 2026-10-10: the 404 case is one run |
| Small: 2 GB gp3, 505 MB free with 736 MB of WAL at 574 MB; disk full at 715 MB | measured elsewhere | RP02, 2026-10-10: the WAL figure is from one run, the full-disk cause not separated |
Team: backups/restore 400 unavailable on 4 attempts over 180 s, one GET restore-point the same; backup.retention_days 14 (Team), 7 (Pro) | measured elsewhere | restore-paths lab RP04, 2026-10-20: two fresh Team projects on Micro; the Pro figure is a manual call with no artifact |
Migration rollback route: 400 on production; on a branch the one stored rollback ran and a migration with none kept its table; a failing apply left no table and no history row (n=2) | measured elsewhere | restore-paths lab RP05, 2026-10-20: one Pro project per run (n=2), one git-less preview branch (n=1) |
MIGRATIONS_FAILED on a preview branch at 81 s | measured elsewhere | github-branching lab GB03, 2026-09-23, one sample |
Clone: 100-180 s to ACTIVE_HEALTHY, new keys, Auth settings reset, object bytes not copied, as old as the backup picked | measured elsewhere | dashboard clones, 2026-07-29 and 2026-08-04, in the major-upgrade guide |
Restore to a new project: no clone path in the v1 (115) or v2 (36) OpenAPI document; clone route 404; Dashboard clone route 401 to a PAT | measured elsewhere | observability-surface lab OB06g, 2026-10-28: two Micro projects on a Pro org, document reads and one call per route per run; no clone created |
Restore to a new project: what it copies, the binary restore starting pg_cron/pg_net/wrapper jobs, the logical restore dropping the encryption root key | documented | the clone docs,5 read 2026-10-28; the dashboard clones in the major-upgrade guide measured the copied and reset items on 2026-07-29 and 2026-08-04 |
pg_cron skipped the missed every-minute instant (4 of 4), no burst after; in-flight run failed, not re-run (4 of 4) | measured elsewhere | cron-behaviour lab CB04 and CB05, 2026-10-28: one restart and one Micro to Small resize per run, two runs, pg_cron 1.6.4, job_run_details and clock_timestamp() in the database |
| Daily-backup restore inaccessibility, custom-role passwords not stored, clone behaviour | documented | the backups docs1; not reproduced because backups/restore answered unavailable and clone has no Management API path |
| Current credentials reapplied after every physical restore | documented | the 2026-07-30 changelog entry4; the RP02 fingerprints are consistent with it |
| Retention 7/14/30 days, PITR ~2 minutes, add-on pricing, Fair Use 402 behaviour, 99.9% uptime and support SLAs | documented | Supabase docs and the SLA page, cited per claim with the footnotes below |
Three docs-versus-runtime differences on this page: the daily-backup “project is inaccessible” claim against the narrower PITR outage measured on a small database, a documented restore route that answered “unavailable” on one fresh Pro project, and the clone docs’ “Storage objects & settings” not copied against bucket and object rows that came across without their file bytes. Filed upstream: no.
Modules
Section titled “Modules”References
Section titled “References”-
Supabase, “Backups,” Supabase Docs. https://supabase.com/docs/guides/platform/backups ↩ ↩2 ↩3 ↩4 ↩5 ↩6 ↩7 ↩8 ↩9 ↩10 ↩11 ↩12 ↩13 ↩14 ↩15 ↩16 ↩17 ↩18 ↩19 ↩20
-
Supabase, “Billing FAQ - Fair Use Policy,” Supabase Docs. https://supabase.com/docs/guides/platform/billing-faq#fair-use-policy ↩ ↩2 ↩3
-
Supabase, “Production checklist,” Supabase Docs. https://supabase.com/docs/guides/deployment/going-into-prod ↩
-
Supabase, “Fixed stale database credentials left behind after a restore,” Supabase Changelog, 2026-07-30. https://supabase.com/changelog/restore-credential-resync ↩ ↩2 ↩3
-
Supabase, “Restore to a new project,” Supabase Docs. https://supabase.com/docs/guides/platform/clone-project ↩ ↩2 ↩3 ↩4 ↩5 ↩6 ↩7 ↩8
-
supabase-lab, “Restore-paths experiment,” supabase-lab runlog, sections “2026-10-22/23 - RP06 (PITR recovery point) and RP07 (restore time against size)”, “2026-10-23 - RP08” and “2026-10-23 - RP09”. https://github.com/erfianugrah/supabase-lab/blob/d726c9a/experiments/restore-paths/RUNLOG.md ↩ ↩2
-
Supabase, “Cost control - Spend Cap,” Supabase Docs. https://supabase.com/docs/guides/platform/cost-control ↩ ↩2
-
Supabase, “Manage Compute usage,” Supabase Docs. https://supabase.com/docs/guides/platform/manage-your-usage/compute ↩
-
Supabase, “Manage Read Replica usage,” Supabase Docs. https://supabase.com/docs/guides/platform/manage-your-usage/read-replicas ↩
-
Supabase, “Supabase for Platforms,” Supabase Docs. https://supabase.com/docs/guides/integrations/supabase-for-platforms ↩ ↩2
-
Supabase, “Declarative database schemas - Rolling back a schema change,” Supabase Docs. https://supabase.com/docs/guides/local-development/declarative-database-schemas ↩
-
Supabase, “Breaking Change: Tables not exposed to Data and GraphQL API automatically,” supabase GitHub Discussions #45329, 2026-04-28. https://github.com/orgs/supabase/discussions/45329 ↩
-
Supabase, “Backup and Restore using the CLI,” Supabase Docs. https://supabase.com/docs/guides/platform/migrating-within-supabase/backup-restore ↩ ↩2
-
Supabase, “Service Level Agreement.” https://supabase.com/sla ↩ ↩2
-
Supabase, “Feature maturity,” Supabase Docs. https://supabase.com/docs/guides/getting-started/features ↩
Linked from
- Locking down Supabase: the database is the security boundary
- Monitor Supabase with Grafana: dashboards and alerting
- Multigres OSS failover: what a client sees
- OrioleDB on Supabase: what hosted projects do differently
- Supabase compute and disk sizing
- Supabase incidents: what a client can do - a resilience reference
- Supabase observability surface: trace headers, health advisors, log sources
- Supabase Pipelines (public alpha): what a PAT reaches and how the engine replicates
- Supabase read replicas: how requests reach them and what they cost
- Supabase resilience runbook: probes, TTL levers, edge cache, warm standby
- Upgrade a Supabase project to a new Postgres major version, end to end
- What a Supabase platform operation costs a client