Skip to content

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.

TierWorst-case RPOExpected RTOMonthly costPlan floor
Daily backupsup to ~24hsize-dependent restore downtime, project offline (documented; not measured)includedPro (7d) / Team (14d) / Ent (30d)
PITR add-on~2 minutessize-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 computePro + 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 primarysecond project’s compute at the size you will cut over to (~$10 if that is Micro) + your runbookany paid plan
Read replicasasynchronous; lag not measuredno failover - read-only (Data API GET, or SQL over the replica’s pooler), no documented promotionsame compute size as the primary, outside the $10 creditspaid 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.

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 400 with NoSuchBucket in 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 postgres role 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 of md5(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 PGRST002 for 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 PAT 401 Unsupported access token (re-checked 2026-10-28 with the v2 document as well, see restoring to a new project). The entitlements project_cloning and backup.restore_to_new_project read 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

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_slots is 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 after slot_name = none then drop (W14), so list pg_replication_slots on the publisher and pg_drop_replication_slot any 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 (pgoutput and wal2json) survived a resize Small to Medium and back, a read replica create and remove, and a project restart, in 3 of 3 runs, with confirmed_flush_lsn after 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

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.

MeasurementValuen
Status back to ACTIVE_HEALTHY (10 s polling), 10 MB database30 s3
Same, control targets after a rotation30, 30, 40, 40, 41 s5
Same, 574 MB database, pre-rotation target81 s1
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 read9
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 pathfailed for 12 s in 8 restores, 24 s in the other; error text The operation timed out, never an HTTP 5xx9
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 control9
First restore-pitr attemptrefused 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 later9
Target against the quoted upper bound19-96 s past it where recorded4 records
Window right after enabling pitr_7the first read already had pitr_enabled=true and a window of 359 or 360 s5

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, econnrefused and terminating connection due to administrator command.
  • After pitr_7 was applied, GET database/backups listed zero entries and carried the window in physical_backup_data.

Other behaviour seen across the restores and a Free-plan unpause (RP02 and RP03, 2026-10-10):

  • Storage did not return a 500 after any restore or unpause: list, download (bytes equal) and upload answered 200. One PITR restore to before an object’s upload made its download 404 not_found and 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 /health read realtime=COMING_UP in 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: 400 Cannot 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 blocked then answered every login, including the correct password, before the password was checked. Poll a known-wrong password at most once a minute, and read blocked as 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 400 Database appears to be unreachable until 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 other pg_wal measurements 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):

CallAnswer
POST /pause400 Project is not free-tier
POST database/backups/restore with the listed physical backup400 This endpoint is unavailable at the moment
GET database/backups/restore-point400 This endpoint is unavailable at the moment
POST database/backups/restore-pitr without the add-on400 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.

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_HEALTHY at 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 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 branchrollback storedAfter one DELETE ?gte=<B2's version>
B1: create table, insert a rowdrop tablebelow the cut: table and row kept
B2: add a columndrop columncolumn dropped, history row removed
B3: create a second tablenonehistory 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.

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 projectThe clone docs sayDashboard clones, 2026-07-29 and 2026-08-04
Schema, data, indexes, database roles and permissionscopiedcopied, as of the backup or PITR instant picked, not the click
Auth users (the auth schema: accounts, hashed passwords)copiedauth.users copied intact
Encryption root keycopied, so Vault secrets and encrypted columns stay readableVault secrets decrypted
Compute size, disk attributes, SSL enforcement, network restrictionscopied, same regioncompute, disk and region matched the source; SSL enforcement and network restrictions not checked
Storage objects and bucket settingsnot copiedthe bucket and object rows came across (they live in the database), the file bytes did not
Edge Functionsnot copiednot copied, their secrets neither
Auth settings and API keysnot copiednew API keys and JWT signing secret, so existing sessions are invalid; SMTP, templates and redirect URLs reset to defaults
Realtime settingsnot copiednot copied
Data API exposed schemasnot listedreset to public,graphql_public
Database extensions and settingslisted under manual reconfiguration, though the same page says the binary restore copies enabled extensionsa deprecated extension (pgjwt) came across
pg_cron, pg_net and wrapper jobscome across and start running as soon as the restore completes, with no way to exclude or pause themtwo pg_cron jobs arrived active = true and both ran at their first matching tick, six minutes after the clone came up
Read replicasnot copiednot copied
PITRnot listednot inherited: the clone came up with daily backups
Database passwordnot listednot 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.

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

UpgradeWhat it changesDowntime (measured unless marked)Read next
Compute size (Micro to Small and up)CPU, memory, connection and pg limits, the PITR and replica floorMicro -> 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 versionthe database engine, in place or on a new projectin 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 stopmajor upgrade, end to end
Plan (Team to Enterprise)the uptime SLA, the support response times, 30 days of daily backupsnone expected for a billing change; not measuredthe 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.

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):

EventNew postmaster answering the probe, after the requestEvery-minute job: last run before / first afterInstants missed'10 seconds' job gap
restart, run a49.5 s08:34:00.024 / 08:36:00.1311 (08:35)62.4 s
restart, run b67.7 s08:35:00.116 / 08:37:00.0861 (08:36)83.7 s
resize, run a67.7 s08:40:00.076 / 08:42:00.0211 (08:41)81.7 s
resize, run b49.7 s08:41:00.063 / 08:43:00.0171 (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_details held 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 recorded failed in 4 of 4 events and never re-run. The message was SSL connection has been closed unexpectedly in run a and server 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 select every 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.

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.

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.

Your requirementTierWhy
“Oops, we dropped the wrong table this morning”PITRrestore 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 backupsalready on; just prove the restore
Free tier, any durability at allscheduled db dump off-sitethe only option that exists
Region down, RTO in minutesWarm standbythe only tier that is up somewhere else
A release broke the schemaa new forward migration; a preview branch firstthe rollback route refuses production; see a bad release
A release corrupted rowsrestore to a new project at an instant before it (PITR; otherwise the last daily backup), copy the rows backproduction stays up; an in-place restore also discards the good writes
Read load, plus disk-failure coverRead replicasavailability for reads; never a failover
Zero budget, best possiblecron pg_dump + object syncmeasured floor: 12.4s dump / 6.4s restore at 10k rows
What are you recovering from?Data loss, target knownto the secondProof of backups onlyThe region is down,RTO in minutesRead loadFree tier, orzero budgetPITR~2 min RPOrestore 30-81 sDaily backupsalready onup to ~24h RPOWarm standby34ms-1s RPOminutes RTORead replicasno promotionScheduled db dumpoff-site, plusobject sync

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

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.

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

Number in this docStatusHow it was checked
34ms-1s replication lag (34ms-1057ms cross-region)measured elsewhereedge-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 elsewherethe 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 boundarymeasured elsewherelab W21, 2026-08-17: 105 renders against the Pro quota of 100, every render returned 200
12.4s dump / 6.4s restore at 10k rowsmeasured elsewherelab 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_HEALTHYmeasured elsewhererestore-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 elsewhereRP02, 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 elsewhereRP02 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 documentmeasured elsewhererestore-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 readsmeasured elsewhereRP02 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 MBmeasured elsewhereRP02, 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 elsewhererestore-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 elsewhererestore-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 smeasured elsewheregithub-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 pickedmeasured elsewheredashboard 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 PATmeasured elsewhereobservability-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 keydocumentedthe 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 elsewherecron-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 behaviourdocumentedthe backups docs1; not reproduced because backups/restore answered unavailable and clone has no Management API path
Current credentials reapplied after every physical restoredocumentedthe 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 SLAsdocumentedSupabase 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.

ModuleExperimentTestArtifact
D01compute-diskd01-compute-pg-limits.tsnone published
D03platform-downtimed03-resize-up.tsnone published
D09compute-diskd09-compute-resize-timing.ts (2026-08-19); 2026-10-23 versionrun-2026-10-23T07-56-13-302Z
W05edge-resiliencew05-standby-replication.tsout/2026-08-16, out/2026-08-17
W06edge-resiliencew06-cold-dr-timing.tsout/2026-08-16, out/2026-08-17
W10edge-resiliencew10-storage-fallback.tsout/2026-08-16, out/2026-08-17
W14edge-resilienceRUNLOG-
W16edge-resiliencew16-sequence-resync.tsout/2026-08-16, out/2026-08-17
W17edge-resiliencew17-config-parity.tsout/2026-08-16, out/2026-08-17
W21edge-resiliencew21-spend-cap.tsout/2026-08-17
W26edge-resiliencew26-storage-dual-write.tsout/2026-08-17
RP01restore-pathsrp01-pro-surface.tsrun-2026-10-10T01-27-07-341Z
RP02restore-pathsrp02-pitr-restore.tsrun-2026-10-10T01-30-06-076Z, run-2026-10-10T01-42-15-008Z, run-2026-10-10T01-42-15-009Z, run-2026-10-10T01-57-31-964Z, run-2026-10-10T02-11-13-334Z
RP06, RP07restore-pathswritten up in the RUNLOGout/2026-10-22, out/2026-10-23
RP08restore-pathsrp08-pitr-archiver-lag.tsrun-2026-10-23T08-50-41-278Z, run-2026-10-23T09-21-24-819Z
RP09restore-pathsrp09-slots-platform-ops.tsrun-2026-10-23T07-58-01-360Z, run-2026-10-23T08-17-52-950Z, run-2026-10-23T08-37-26-434Z
RP04restore-pathsrp04-daily-backup-restore.tsrun-2026-10-20T09-49-42-217Z, run-2026-10-20T09-53-54-870Z
RP05restore-pathsrp05-migration-rollback.tsrun-2026-10-20T09-52-11-293Z, run-2026-10-20T09-53-31-105Z
GB03github-branchinggb03-per-project-signal.tsout/2026-09-23
RP03restore-pathsrp03-free-pause-unpause.tsrun-2026-10-10T01-30-06-076Z-rp03, run-2026-10-10T01-43-58-645Z, run-2026-10-10T02-19-59-081Z
OB06observability-surfaceob06-planning-locks-clone.tsout/2026-10-28
CB04cron-behaviourcb04-restart.tsout/2026-10-28
CB05cron-behaviourcb05-resize.tsout/2026-10-28
  1. 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

  2. Supabase, “Billing FAQ - Fair Use Policy,” Supabase Docs. https://supabase.com/docs/guides/platform/billing-faq#fair-use-policy ↩ ↩2 ↩3

  3. Supabase, “Production checklist,” Supabase Docs. https://supabase.com/docs/guides/deployment/going-into-prod ↩

  4. Supabase, “Fixed stale database credentials left behind after a restore,” Supabase Changelog, 2026-07-30. https://supabase.com/changelog/restore-credential-resync ↩ ↩2 ↩3

  5. Supabase, “Restore to a new project,” Supabase Docs. https://supabase.com/docs/guides/platform/clone-project ↩ ↩2 ↩3 ↩4 ↩5 ↩6 ↩7 ↩8

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

  7. Supabase, “Cost control - Spend Cap,” Supabase Docs. https://supabase.com/docs/guides/platform/cost-control ↩ ↩2

  8. Supabase, “Manage Compute usage,” Supabase Docs. https://supabase.com/docs/guides/platform/manage-your-usage/compute ↩

  9. Supabase, “Manage Read Replica usage,” Supabase Docs. https://supabase.com/docs/guides/platform/manage-your-usage/read-replicas ↩

  10. Supabase, “Supabase for Platforms,” Supabase Docs. https://supabase.com/docs/guides/integrations/supabase-for-platforms ↩ ↩2

  11. Supabase, “Declarative database schemas - Rolling back a schema change,” Supabase Docs. https://supabase.com/docs/guides/local-development/declarative-database-schemas ↩

  12. 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 ↩

  13. Supabase, “Backup and Restore using the CLI,” Supabase Docs. https://supabase.com/docs/guides/platform/migrating-within-supabase/backup-restore ↩ ↩2

  14. Supabase, “Service Level Agreement.” https://supabase.com/sla ↩ ↩2

  15. Supabase, “Feature maturity,” Supabase Docs. https://supabase.com/docs/guides/getting-started/features ↩