Skip to content

Supabase and PostgresDatabase and Postgresreference

Supabase compute and disk sizing

A Supabase project stops being affordable or available for one of four reasons: compute throttle, disk throttle, quota, or read-only. This reference covers every compute size and both disk types, and marks per claim whether the behaviour comes from the docs or from a live test here; several of them disagree.

The measured numbers come from a battery written against throwaway projects on the Management API (Free, Pro, and Team orgs; 2026-08-19, paid-plan fill and grow steps added 2026-10-01 in ap-southeast-1), each project deleted in the same run. The compute-disk RUNLOG does not record the AWS region (the platform-downtime run cross-referenced below was in ap-southeast-1; the compute-disk RUNLOG does not record its own region). The live IOPS and throughput change (D13) ran on 2026-11-04 on Large projects in ap-northeast-1. Claims that were not run are still cited to the docs and labelled as such.

  • Compute never upgrades itself; disk never shrinks. A compute resize took REST reads, Auth and Realtime joins down for 144.528 to 254.886 s on each of four resizes (D09, n=1 per op), longer than the documented “less than 2 minutes”; disk decrease is rejected outright.
  • Disk autoscale fires at ~90% usage (measured on Pro). A new Pro project starts on 2 GB and the first grow went to 8 GB, the next +50% to 12 GB. Its settings read back as nulls and cannot be written through the Management API (measured) - the dashboard is the only surface.
  • The spend cap is a billing control, not a disk limit: with the cap on, a manual grow 2 -> 12 GB was accepted and applied (measured). A capped org above the included 8 GB is over quota on Disk Size, which the docs route to notification, grace and Fair Use restriction; that path was not run.
  • Paid-plan read-only at 95% disk holds (measured) and lifted by itself once autoscale grew the disk. A fast import after autoscale had already grown the disk once skipped read-only in one run of two and filled the disk: 53100 No space left on device and a seven-minute outage while the project status read healthy.
  • The Free-plan read-only wall is not the documented 500 MB: measured reads accepted to ~726 MB database size, then ERROR: 25006: cannot execute INSERT in a read-only transaction. Recover with DELETE (TRUNCATE is also blocked), not vacuum alone.
  • The disk modification quota answered 429 with text “once per four hours” (measured). The docs said four modifications per rolling 24 hours until 2026-09-29; since then both docs pages give a cooldown of about four hours after any disk change and keep the 24-hour window for autoscaling (read 2026-11-04). Enforcement was nondeterministic across runs in August; on 2026-11-04 a second change about 25 minutes after the first was refused in 2 of 2 runs, and a size-only grow started the same refusal.
  • Raising gp3 IOPS and throughput on a running Large project dropped no held Postgres connection over 25 minutes, failed no sample on any of six direct and Supavisor paths in the first 3 minutes after the POST, and did not restart Postgres (measured, 2 runs; Data API not tested): one POST /config/disk took the volume from 3000 to 4000 IOPS and 125 to 250 MiB/s, read back in 2.3 s, and a WAL-heavy write load went from 42224-43985 ms to 12672-14919 ms in loads starting 180 s after the POST.
  • The “Large compute or above” gate on disk IOPS/throughput is UI-only: the API accepted AND applied elevated IOPS on a Micro project (measured, confirmed by follow-up read).
what hurts?CPU at sustained capDisk IO % consumed > 0db outgrows diskbill over quotaupgrade computeraise IOPS / io2grow disk (manual first)spend cap option
  1. CPU at a sustained cap: upgrade compute (Compute sizes).
  2. Disk IO % consumed above 0: raise IOPS or move to io2 (Disk).
  3. The database outgrows the disk: grow the disk, manually first (Manual expansion + modification quota).
  4. The bill is over quota: the spend cap option (Spend cap).

Prices and recommended database size from the docs.1

SizeHourlyMonthlyCPUMemoryMax database (recommended)
Nano$0$0sharedup to 0.5 GB500 MB
Micro$0.01344~$102-core shared1 GB10 GB
Small$0.0206~$152-core shared2 GB50 GB
Medium$0.0822~$602-core shared4 GB100 GB
Large$0.1517~$1102-core dedicated8 GB200 GB
XL$0.2877~$2104-core dedicated16 GB500 GB
2XL$0.562~$4108-core dedicated32 GB1 TB
4XL$1.32~$96016-core dedicated64 GB2 TB
8XL$2.562~$1,87032-core dedicated128 GB4 TB
12XL$3.836~$2,80048-core dedicated192 GB6 TB
16XL$5.12~$3,73064-core dedicated256 GB10 TB
>16XL--customcustomcustom

Micro through 2XL is shared and burstable; Large and above are dedicated.1 Burstable means spikes are fine until burst credits drain; then baseline governs.

Nano cannot start on a normal paid (Pro) org: the try was rejected with 400 Minimum instance size on paid plans is Micro (measured, create + PATCH + catalogue; instance-sizing I01, 2026-08-17). On a Free org, Nano pauses and restores fine; wake measured ~162-204 s (I04; in the lab’s AGENTS.md, no RUNLOG entry).

  • Do not wake a legacy free-era paused project on a paid org unless you accept that it joins the always-on Micro floor for good. The restore was accepted, ACTIVE_HEALTHY arrived about 30 minutes later, and POST /v1/projects/{ref}/pause then answered 400 {"message":"Project is not free-tier. Please downgrade it to free-tier first and try again."}; pause eligibility follows the org’s current plan rather than the project’s lineage (I03, 2026-08-18).

Scale-to-zero pricing applies only to Nano instances, and only for the select customers given access to it through Supabase for Platforms; that guide says not to pass desired_instance_size at create.2 It was not measured here.

Per-size IO ceiling (docs, unmeasured here)

Section titled “Per-size IO ceiling (docs, unmeasured here)”

Baseline = sustained. Max = burst until credits drain.1 The docs call these values minimums (read 2026-11-04): a project of a given size gets at least these limits and can get more, depending on the configuration it runs on.

SizeBaseline MB/sMax MB/sBaseline IOPSMax IOPS
Nano526125011,800
Micro1126150011,800
Small222611,00011,800
Medium432612,00011,800
Large795943,60020,000
XL1495946,00020,000
2XL29759412,00020,000
4XL59459420,00020,000
8XL1,1881,18840,00040,000
12XL1,7811,78150,00050,000
16XL2,3752,37580,00080,000

The docs go further up to 24XL/48XL at 3,750 / 5,000 MB/s baseline.1

Per-size pg limits (docs; Micro and Small measured here)

Section titled “Per-size pg limits (docs; Micro and Small measured here)”
Sizerep slotswal sendersmax connectionspooler clients
Nano5560200
Micro5560200
Small5590400
Medium55120600
Large88160800
XL24242401,000
2XL80803801,500
4XL80804803,000
8XL80804906,000
12XL80805009,000
16XL808050012,000

Measured (D01): Micro max_connections 60, max_wal_senders 10, max_replication_slots 10, shared_buffers 256 MB; Small 90 / 10 / 10 / 512 MB - the wal senders and rep slots above are the docs’ plan-wide ceilings; pg’s own floor per size sits lower.1 Downgrading below your replication-slot usage is rejected because the server will not start.1

The order Micro -> Small -> Large -> Small -> Micro was run on 2026-10-23 on one throwaway Pro project in ap-southeast-1 (compute-disk D09, n=1 per op), with three data-path probes: a row read through REST with the anon key (rest_read) and GET /auth/v1/health with the anon key, sampled every 250 ms, and a Postgres Changes join (realtime_join) every 1 s. Every PATCH answered 200 on the first attempt, and the next one was sent only after every path had been up for 15 s. Seconds after the accepted PATCH3:

opACTIVE_HEALTHY afterREST read max outageAuth max outageRealtime join max outageREST read recovered
upgrade Micro->Small218 s231.465 s231.433 s228.188 s249.832 s
upgrade Small->Large216 s223.28 s223.516 s223.421 s233.974 s
downgrade Large->Small136 s152.466 s152.375 s144.528 s171.37 s
downgrade Small->Micro245 s254.886 s254.869 s244.941 s273.785 s
  • Every resize, in either direction, took the three data paths down together for 144.528 to 254.886 s. The downgrades were not cheaper: Small -> Micro was the longest of the four.
  • The status read ACTIVE_HEALTHY before the data paths were back: REST reads recovered about 18 to 35 s after the 3 s status poll first read healthy.
  • REST and Auth each had a second, shorter outage of 1.3 to 2.0 s per op; the table carries the long one. Failure modes were HTTP 521 and timeouts on REST and Auth, and pg_changes: {:error, "Too many database timeouts"} on Realtime.

The 2026-08-19 figures that stood here (settle 105, 61, 61 and 73 s; REST outage 1.0, 17.0, 0 and 0 s; Auth 0 s) are withdrawn. The old module dropped an outage still open when a phase ended, stopped sampling at ACTIVE_HEALTHY, and timed PATCHes the addon rate limit had refused as resizes: each 61 s row was its 60 s wait for a status change after a 429, so no Small -> Large resize ran in that run or in the 2026-10-13 re-run. Its /auth/v1/health probe sent no apikey, and the endpoint answered 401 without one on 2026-10-23 (not re-checked for the earlier dates); if it did then, no Auth sample counted as up and its 0 s meant an outage never closed.

Adjacent resize PATCHes are rate-limited independent of rebuild: the second within a window answered 429 We are still processing addon changes, please try again in N minute(s). A separate experiment (platform-downtime D03, 2026-08-04, n=1, 500 ms sampling from a Singapore IPv4 vantage) measured a Micro -> Small resize at 131 s on GET /auth/v1/health (anon key, HTTP 521) and 207 s on the pooler, with its REST probe at zero failed samples; that 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. Re-run on 2026-10-23 with a row read, the same experiment saw REST reads fail for 171 and 218 s on Micro -> Small and 54 s on Small -> Micro, close to Auth’s 171, 218 and 54 s in the same passes.4 D09’s 231.465 s on Micro -> Small is the same order as those 171 and 218 s; the two are different metrics (D09’s longest outage, platform-downtime’s first failure to sustained recovery) on different projects, n=1 each, so not a like-for-like comparison. The docs say compute changes are “usually applied with less than 2 minutes of downtime, but can take longer depending on the underlying Cloud Provider”;1 all four D09 resizes ran past 2 minutes on every data path. The measured restart and resize dwell times per connection path are in the platform operation-cost reference.

Compute is billed hourly (paused projects don’t accrue) and is not spend-cap eligible; the cap only bounds eligible usage items.5

gp3io2
Price/GB-month$0.125$0.195
IOPS price$0.024/IOPS-month$0.119/IOPS-month
Throughput125 MB/s incl, then $0.095/MB/s (max 2,000 MB/s)scales with IOPS
Max IOPS80,000 (at 160 GB size)80,000 (from 80 GB size)
Max size64 TB60 TB
Effective ceilingmin(compute size, provisioned disk)

Provision more than baseline per GB: gp3 +500 IOPS/GB and +0.25 MB/s/IOPS; io2 +1,000 IOPS/GB.1 The “Large compute” gate on these is UI-only (measured, below).

The gp3 column was re-read against the docs on 2026-11-04.1 Until then this page’s column read Max IOPS 16,000 (from 32 GB size), throughput $0.95/MB/s up to 1,000 MB/s, and Max size 16 TB, which matched the docs when written: the docs moved to 80,000 IOPS at 160 GB, 2,000 MB/s and 64 TB on 2026-09-046 and corrected the throughput price to $0.095/MB/s on 2026-11-03.7 The D11 refusal message of 2026-10-01 (500 IOPS per GB or 80,000) already matched the docs of that date.

Database size = pg_database_size() (tables + indexes + materialised views). Disk = that + WAL + system files + an empty baseline of ~40-60 MB.8 The Free plan quota is on the first; paid-plan read-only trips on the second at 95%.8 Micro runs min_wal_size 1GB and max_wal_size 4GB, and under bulk inserts pg_wal held 816-992 MB of a 2 GB disk, so read-only tripped with an 803 MB database (D10, measured).

Small has the same 2 GB gp3 disk, and three Small projects measured on 2026-10-10 in ap-southeast-1 (Pro org) show WAL taking a large share of it:910

  • A PITR-enabled Small project grown to 574 MB (pg_database_size) held 736 MB of pg_wal and had 505 MB free of 1,981 MB (RP02, run R5).
  • On the same disk, a request to seed 1,500 MB filled the disk at 715 MB (No space left on device; RP02, run R4). The next password-rotation call failed, and the restore request was refused with “Database appears to be unreachable” (57P03) until it was accepted at 301 s. What filled the disk, whether WAL not yet archived or something else, was not separated, and the WAL figure above is from R5 only.
  • The heap control in the OrioleDB comparison was created with a 2 GB default disk (the OrioleDB project in that comparison got 8 GB). Its 1,000,000-row plain upsert filled that disk in every run (OR02, runs A, B and E): could not extend file ...: No space left on device, or the connection dropped and the server went into recovery. Each statement wrote 303-312 MB of WAL; in run E the two completed reps left pg_wal at 0.69 and then 1.29 GB (687,866,220 and 1,290,535,276 bytes), with pg_stat_archiver archived_count 35 then 65 and walg_enabled true on that project. The same cases passed (3 reps, 0 fail) with the disk set to 8 GB first via POST /config/disk (run F). The OrioleDB project, where walg_enabled was false, completed the same statement with archived_count at 0. Why the heap control retained that much WAL (archiving, max_wal_size or checkpoint timing) was not isolated, and an 8 GB disk was not run through a longer sequence.

These are three single-run data points on Small, with the cause open: R5 is one run, R4’s cause was not separated, and the heap control differs from the OrioleDB project in architecture and wal_compression as well as disk size. R4 filled the default disk at 715 MB of data under bulk writes, and the first restore request after it was refused. For restore timings on the same Small projects see the DR tiers reference, and for the per-operation dwell times the platform operation-cost reference.

  • Delete data: database size does not drop until vacuum runs (dead tuples); TRUNCATE drops instantly. Both measured.
  • Disk util endpoint (GET /config/disk/util) answered 200 on Free and Pro (measured) - usable in org-wide cost probes. It is a five-minute sample: the same timestamp and value came back for up to five minutes, and once it returned the pre-fill baseline while the disk was full (D10).

Autoscale: defaults and the missing surface

Section titled “Autoscale: defaults and the missing surface”

Docs describe: the disk grows when the database reaches 90% of the allocated size, by 50% (their example: 8 GB -> 12 GB), at most four modifications in a rolling 24-hour window. The Free Plan section adds “Disable the Spend Cap if you want your Pro instance to auto-scale beyond the 8 GB disk size limit”.8 The cap did not act at resize time: on a Pro org with the cap on, a single manual POST /config/disk from 2 to 12 GB answered 201 and was applied (D12, 2026-10-05). D10’s 8 -> 12 GB autoscale ran in the same org with its cap state unrecorded, so it says nothing about the cap.

The settings are readable as nulls and not settable through the Management API (measured). On both Pro and Team orgs the autoscale GET answered 200 with every field null and PUT/POST/PATCH all answered 404. The dashboard’s editable growth/min/max fields are the only mutation surface. The Data API toggle is different: the http-tier-lockdown experiment found it maps to the Management API’s db_schema field, measured in the AWS PrivateLink reference. Tracking the autoscale values is a manual IaC exercise.

POST /config/disk accepts autoscale keys and discards them. Sent with a full valid attributes object plus growth_percent and max_size_gb - inside attributes, at the top level, and as a nested autoscale object - every shape answered 201, and the autoscale GET still read all-null after a 60 second settle, so a caller gets a success code and no cap. Reaching that point needs the complete attribute set; a partial body is rejected on the missing field (attributes.type, then attributes.iops) rather than on the autoscale keys, so a probe that stops at the first 400 concludes “rejected” when the real answer is “accepted and discarded”.

On the Free tier: measured baseline disk was 2 GB (docs claim 1 GB) and the disk did not grow at 90%+ through a fill, so autoscale did not prevent read-only.8

On Pro it fires (D10, 2026-10-01). A fresh project also starts on 2 GB. With the fill paced at ~25 MB per util sample, the sample crossed 90% (91.1%) and the volume grew 2 GB -> 8 GB within about two minutes, with no write refused. A later grow on the same project went 8 GB -> 12 GB. The first step lands on the 8 GB plan baseline rather than adding 50%, although the notification email says “Each expansion increases the disk by 50%” directly above “Disk Size: 2GB -> 8GB”. The second grow came ten minutes after the first, while a manual POST /config/disk on the same project was answering the four-hour 429, so that cooldown binds manual changes and not autoscale.

Increase is OK (HTTP 201, +200 GB cap per change); decrease is refused (HTTP 400, measured).8

From the 2 GB starting volume the smallest grow is 6 GB (D11, measured). 4 and 5 GB are refused on the gp3 IOPS floor: 400 Invalid IOPS value for gp3 volume 3000. Minimum is 3000. Max is 500 IOPS per GB or 80,000, whichever is lower. 6 GB answered 201 with an empty body and read back within 10 seconds. The 80,000 in that message matches the docs’ gp3 maximum, stated there since 2026-09-04; the table above read 16,000 until 2026-11-04.

Modification quota measured: 429 Database disk can only be modified once per four hours. Last modified at <UTC>, where the docs then said “four modifications within a rolling 24-hour window” (changed 2026-09-29, below).8 One run also accepted 5 consecutive increases in one burst, so enforcement was nondeterministic across runs; plan for a cooldown that can fire on the second change, and raise the disk before a bulk import that would take the volume past 90%. Since 2026-09-2911 the Database Size page applies the rolling 24-hour window to autoscaling and also says expansions can occur only once every four hours,8 and the Compute and Disk page gives a cooldown of “approximately four hours” after any disk attribute change (both read 2026-11-04).1

On 2026-11-04 (D13, Large, ap-northeast-1) the refusal held in both runs that sent a second change after an accepted one (runs 3 and 4): a second change 1501.2 s (run 3) and 1501 s (run 4) after an accepted IOPS change answered 429 Database disk can only be modified once per four hours. Last modified at 04-11-2026 10:11:05 UTC (run 3; the body is JSON, {"message":"..."}), with no Retry-After header. The date is day-month-year (4 November, not 11 April), and the time is the accepted change’s own POST. A size-only grow starts the same refusal: in run 2 an IOPS change 949.5 s after a grow from 8 to 24 GB was refused, and ten more attempts at 5-minute intervals were refused naming the same time (the run’s local log, recorded in the RUNLOG; the published artifact keeps the first attempt only).12 HTTP 429 is also the Management API’s general rate-limit signal - a separate mechanism from this quota; its budget and back-off are worked through in the Management API guide.

Free plan (measured): accepts to ~726 MB database size, then a write fails with ERROR: 25006: cannot execute INSERT in a read-only transaction; a SELECT on the management endpoint answered 201 the whole time. The documented 500 MB was not the boundary in this run,8 and recovery required DELETE (TRUNCATE was rejected) or the override GUC set default_transaction_read_only = 'off' once below the threshold.8

Paid plans (Pro, D10, measured): read-only at ~95% disk util as documented,8 with the same 25006 error, GET /readonly reading {"enabled":true}, and about three minutes of 57P03 the database system is not accepting connections before it. Autoscale grew the disk about four minutes after the trip, and read-write came back by itself once the grow landed, without a Postgres restart.

The documented “>1.5x the current size” import rule8 did not fire as written: 385 MB loaded onto a 203 MB database (1.90x) in 26 seconds was accepted with read-only off. The trigger is disk utilisation; the ratio matters only when it pushes utilisation over the line.

Read-only is not guaranteed to come first. With autoscale’s grow already spent (a manual POST answering the four-hour 429), a burst of 100 MB every 6 seconds crossed the 90-95% band between two five-minute util samples. In one run it failed on ERROR: 53100: could not extend file ...: No space left on device; every query then answered 57P03 for seven minutes and Postgres restarted, while GET /projects/{ref} read ACTIVE_HEALTHY throughout. The reproduction run at the same rate got read-only at 95.1% instead and was writable again 492 seconds later, also after a restart. In both, autoscale grew the disk 8 GB -> 12 GB and the project came back read-write with nothing done by the caller.

Disk IOPS/throughput gate (dashboard-only)

Section titled “Disk IOPS/throughput gate (dashboard-only)”

The dashboard says “Adjusting your disk configuration requires LARGE Compute size or above.” Through the API the raise was accepted and stuck on Micro (measured, verified by follow-up GET), so a PAT bypasses the gate without a warning, and IOPS billing starts regardless.

Raising IOPS and throughput on a running project (measured)

Section titled “Raising IOPS and throughput on a running project (measured)”

On 2026-11-04 two throwaway Pro projects created Large in ap-northeast-1, with the IPv4 add-on so direct 5432 was reachable from an IPv4-only vantage in Singapore, each took one accepted POST /config/disk from 3000 to 4000 IOPS and 125 to 250 MiB/s on gp3, with no size change (D13 runs 3 and 4). The POST answered 201 with an empty body.12 The volume read 8 GB at the start, which allows 4,000 IOPS at 500 per GB; 6,000 would have needed a grow to 12 GB first, and a grow starts the cooldown above.

Held connections ran select pg_postmaster_start_time() every 1 s and fresh connections connected, ran select 1 and disconnected every 2 s, each through direct 5432, the Supavisor session pooler and the Supavisor transaction pooler. The write load was two sessions each inserting 500,000 rows (2049 MB heap and 1974 MB WAL per load), timed as the slower session.

Run 3Run 4
Failed samples in the first 3 min after the POST, each held path0 of 1800 of 180
Failed samples in the first 3 min after the POST, each fresh path0 of 890 of 90
pg_postmaster_start_time() changednono
New values first read by GET /config/disk2.3 s after the POST2.3 s after the POST
Write load on logged tables (WAL), before the change43538, 42278 ms42224, 43985 ms
Same load at +180, +420, +660, +900 s after the POST12890, 14919, 12824, 12771 ms12791, 12938, 12693, 12672 ms
Unlogged control load (no WAL)2379 ms2480 ms
  • The project read ACTIVE_HEALTHY at every status poll to +25 min.
  • Over those 25 min the one failed sample on any path came in run 4, a fresh direct connection about 21 min after the POST (5003ms timeout expired, the next sample succeeded). The same fresh direct path had failed three times in run 4 before any change was made, so it is not attributed to the change; run 2’s one such failure came 1229.2 s after its accepted grow, so the change is not excluded either.
  • The before-change times varied between runs: run 2’s two loads at 3000 IOPS and 125 MiB/s, on its volume grown to 24 GB, took 43230 and 28945 ms, and that spread was not explained.
  • Most of the logged load’s time is WAL work: the unlogged control took about 2.4 s. IOPS and throughput changed in one POST, so which of the two bound the load was not separated, and nothing was measured between the POST and +180 s.
  • The post-change WAL rate, up to 155.8 MB/s, is above the 79 MB/s Large baseline, a figure the docs give as a minimum (Per-size IO ceiling table above). Whether a sustained load slows again when the burst budget drains was not measured.

Not run: the Data API path (the lab’s org answered 402 that day under an unrelated usage restriction), an IOPS or throughput decrease, io2, other compute sizes and regions, and a change under an application’s own write load.

Spend cap (and where compute/disk escape it)

Section titled “Spend cap (and where compute/disk escape it)”

Spend cap ON = eligible overages blocked past quota after notification + grace period, ending in Fair Use restriction; it is enforced on the billing path and does not break requests (measured).5

Disk Size is on the covered list, where past the quota (8 GB included on Pro) “further usage of that item is disallowed until the next billing cycle”,5 and the Database Size page’s Free Plan section says to disable the cap for a Pro instance to auto-scale beyond 8 GB.8 Neither describes a resize being refused, and with the cap on a manual grow 2 -> 12 GB was accepted and applied (D12). The cap’s effect on disk is on the billing path: a project that stays above 8 GB under the cap is over quota, which the billing FAQ routes to notification, grace and Fair Use restriction (not run here).13 A database that will live above 8 GB belongs in an org with the cap off, billed per GB over the included size.

Exclusions (never capped): compute hours, disk throughput, disk IOPS-hours, custom domains, PITR, read replicas, IPv4, branching, advanced MFA/SSO, log drains.5 Team plan has no spend cap at all - overages are simply billed.5

Each practice names the module it rests on; module ids resolve in the compute-disk RUNLOG and the instance-sizing RUNLOG. A line marked “docs” or “design choice” is not a measurement.

  • Expand the disk before a bulk import: size the import against free disk (data + WAL + system), not against database size. If it would take the volume past 90%, expand manually first (single POST). A fast import outruns the five-minute util sample and autoscale, and after autoscale has grown the disk once it ended in a full disk and an outage in one run of two. Then re-check the quota before a second attempt (D03 quota; D10 fill).
  • Schedule the next disk change from the 429 body: once the quota fires, its message carries Last modified at <UTC>, so parse the timestamp and schedule from it rather than re-trying blind (D03). Parse it as day-month-year (04-11-2026 is 4 November) and read it as the accepted change’s time: refused attempts do not move it. Whether the refusal ends at exactly four hours was not measured (D13).
  • Raise IOPS and throughput live, in one change, at the final target: on Large, 3000 -> 4000 IOPS on gp3, the raise dropped no held Postgres connection, failed no sample in the first 3 minutes and did not restart Postgres (Data API not tested), and a second change about 25 minutes later was refused (D13, n=2). Check the target against the volume first (500 IOPS per GB, so 8 GB allows 4,000): a grow to make room is a disk change of its own and started the refusal for the IOPS change after it (D13 run 2). One POST carrying both size and IOPS was not tried.
  • Space resize PATCHes: wait >= 2 minutes between adjacent resize PATCHes, or the second returns 429 with still processing (D09). On 2026-10-23 no follow-on PATCH was refused when each was sent after every data path had been up for 15 s; whether that wait avoided the 429 was not separated (D09).
  • Poll for ACTIVE_HEALTHY after a resize, then probe a read with GET /v1/projects/{ref} instead of sleeping a fixed time: the status flipped 136-245 s after the PATCH across four operations (D09, 2026-10-23) and 107 s on D01, and REST reads came back about 18 to 35 s after it (D09).
  • Size client retries for the resize gap in minutes: a row read (platform-downtime, 2026-10-23) failed for 171 and 218 s on Micro -> Small and 54 s on Small -> Micro, and D09 the same day saw 144.528 to 254.886 s on every data path per resize. The default supabase-js client took 4 attempts and ~7.0s to ride out three 503s (edge-resilience W02); a gap of minutes is beyond a retry loop of that shape (reasoned from W02’s timings, not measured).
  • Do not treat a downgrade as a cheap dry run: on 2026-10-23 Large -> Small took the data paths down for 144.528 to 152.466 s and Small -> Micro for 244.941 to 254.886 s (D09, n=1 per op).
  • Read the addon GET for null when returning to Micro, not for ci_micro: Micro is the absence of a compute addon (platform-downtime D04).
  • Do not wake a legacy free-era paused project on a paid org unless you accept it can never be re-paused: 400 Project is not free-tier after a ~30 minute wake (instance-sizing I03).
  • Alert on database size, not disk utilisation, on Free projects below ~700 MB: read-only hit at ~726 MB of database size on a 2 GB disk and autoscale did not fire during the fill (D05, D06); /config/disk/util answers on Free (D05) if you also want the disk figure.
  • Verify a fresh project’s disk with GET /config/disk before relying on the documented baseline: Free started at 2 GB, not 1 GB (D05), and Pro started at 2 GB, not 8 GB (D10). The first manual grow from there is 6 GB (D11).
  • Watch database health, not project status, during a disk event: the project read ACTIVE_HEALTHY through a seven-minute full-disk outage (D10). Probe with a query.
  • Count WAL when alerting on a small volume: pg_wal held about half of a 2 GB disk under bulk load (D10).
  • Raise IOPS on a Micro via the API only if you accept the bill: the POST was accepted and applied on Micro, and IOPS billing starts regardless of the dashboard’s Large-only text (D08). Whether IO throughput improved was not measured; D08 verified the config stuck.
  • Size on CPU and IO burn: CPU utilisation + Disk IO % consumed (the burst-budget drain metric: >0 means past baseline). Over it -> upgrade.1 (docs)
  • Pin autoscale settings outside the API: the API reads them as nulls and cannot set them, and the disk write returns 201 while ignoring the keys - so do not treat a 2xx there as a cap being applied. Pin their intended state in IaC and audit the dashboard manually (D04, D07). If you bill on provisioned capacity, poll /config/disk/util and raise capacity deliberately with POST /config/disk once approved; that schedules the charge but does not stop autoscale firing between polls.

Not measured: recovery from paid-plan read-only by freeing space under the override GUC (every refusal in D10 was cleared by autoscale first); autoscale on Team; resize windows above Large or from a non-local vantage; whether the D09 REST gaps are per-client or per-vantage; the disk quota’s determinism (D03 varied run to run; D13 refused 2 of 2); the Data API during a disk performance change (D13).

Doc claimRuntime measuredSeverity
read-only at 500 MB database (Free)read-only at ~726 MB, reads survivedocs stale
4 modifications / 24 h (both docs pages until 2026-09-29)429 once/4h; nondeterministic in August, refused 2 of 2 on 2026-11-04docs text differed, quota exists; resolved 2026-09-29: both docs pages state four hours, and the 24 h window is for autoscaling
Free disk starts 1 GBstarted 2 GBdocs understate
autoscale “increases the disk by 50%” (docs and email)first grow 2 -> 8 GB, then 8 -> 12 GBfirst step differs
read-only at 95% protects the disktrue when the fill is slow; a fast burst after a spent grow hit 53100 disk full and a 7 min outage in one run of twogap in the guarantee
import >1.5x current size trips read-only1.90x accepted, read-only offrule does not hold as written
gp3 max IOPS 16,000 (as read before 2026-11-04)API message: 500 per GB or 80,000resolved: the docs changed to 80,000 at 160 GB on 2026-09-04
Large-only for IOPS/throughputaccepted + applied on MicroUI-only gate
autoscale config via APIverbs 404; GET empty or all-null; POST /config/disk takes the keys, returns 201, applies nothingsurface gap, and it fails silently
compute change “usually applied with less than 2 minutes of downtime”REST read, Auth and Realtime join down 144.528 to 254.886 s on each of four resizes (D09, 2026-10-23, n=1 per op)docs understate

Each measured row above comes from the supabase-lab pvlab harness, module ids D01-D08 (2026-08-19), D09 (re-run 2026-10-23), D10-D11 (2026-10-01) and D13 (2026-11-04) under experiments/compute-disk; the full run log is RUNLOG.md; the consolidated reference is COMPUTE-DISK.md at the repo root.

  • ACTIVE_HEALTHY seconds are measured from the accepted PATCH to the first status poll (every 3 s) that read healthy. They are not the outage: in D09 the data paths stayed down 18 to 35 s past them.
  • Outage values in the resize table are the longest outage per path, first failing sample to the first success after it, on one sample timeline per path; a shorter second outage of 1.3 to 2.0 s per op is not in the table. n=1 per op, one project, one vantage.
  • Disk quota behaviour varied run to run (bursts accepted, then reject); treat the limit as volatile rather than a fixed number to schedule against.

Measured claims map to module ids D01-D13 in the experiment, plus the borrowed modules listed under Modules - platform-downtime D03/D04, instance-sizing I01/I03/I04 and edge-resilience W02; the documented and not-run rows rest on the cited pages only.

ClaimStatusHow it was checked
Per-size pg floors: Micro max_connections 60, wal senders 10, rep slots 10; Small 90 / 10 / 10measuredD01 - pg_settings read on a Pro org, resize to Small, re-read
Disk decrease refused (HTTP 400); increase accepted (HTTP 201)measuredD02 - attribute mutations on a fresh Pro project
Modification quota: 429 “once per four hours”; a 5-mod burst accepted in one runmeasuredD03 - serial +1 GB increases until one rejected
Autoscale on a Pro org: GET all-null, PUT/POST/PATCH 404measuredD04 - verb probes against the autoscale endpoint
Free-org baseline disk 2 GB (docs: 1 GB); no growth at 90%+ through a fillmeasuredD05 - continuous fill on a Free project
Free read-only at ~726 MB database size (docs: 500 MB); reads kept answering; TRUNCATE rejected, DELETE required for recoverymeasuredD06 - write rejection, endpoint SELECT, and recovery in the same fill run
Autoscale gap identical on a Team orgmeasuredD07 - the same verb probes as D04
IOPS/throughput raise accepted and applied on Micro; the Large gate is UI-onlymeasuredD08 - config/disk POST, verified by follow-up GET
Resize Micro -> Small -> Large -> Small -> Micro: ACTIVE_HEALTHY after 218/216/136/245 s; REST read max outage 231.465/223.28/152.466/254.886 s, Auth and Realtime join within 10 s of it in each op; REST back 18-35 s after ACTIVE_HEALTHYmeasured, 2026-10-23, n=1 per opD09 - rest_read and auth_health (anon key) every 250 ms, realtime_join every 1 s, on one timeline per path; artifact
Resize settle 105/61/61/73 s; max contiguous outages 1.0/17.0/0/0 s; Auth 0 swithdrawn 2026-10-23D09 as of 2026-08-19: open outages dropped at a phase end, refused PATCHes timed as resizes, Auth probe sent no apikey (RUNLOG, 2026-10-23)
Nano rejected on a paid org; Free-org wake ~162-204 smeasuredinstance-sizing I01 (create + PATCH + catalogue); I04 (figure in the lab’s AGENTS.md, no RUNLOG entry)
Legacy free-era paused project on a Pro org: wake ~30 min, then 400 Project is not free-tier on pausemeasuredinstance-sizing I03, 2026-08-18
Scale-to-zero pricing is Nano-only and limited to select Supabase for Platforms customersdocumentednot run; cited to the Supabase for Platforms guide,2 read 2026-11-13
Per-size price, IO ceiling, and pg ceiling tables, incl. 24XL/48XL at 3,750 / 5,000 MB/s baselinedocumentednot run; cited to the Compute and Disk page
Pro autoscale bounded at 8 GB unless the spend cap is offdocumented; no resize block at runtime (D12)cited to the Database Size page (Free Plan section)
Pro starts on 2 GB; autoscale fires at ~90% util: 2 -> 8 GB, then 8 -> 12 GB; not bound by the manual 4 h cooldownmeasuredD10 - paced fill with a fresh util sample per batch, then a burst
Paid-plan read-only at ~95% (25006), lifted automatically after the growmeasuredD10 run 1 - unpaced fill on a 2 GB Pro project, recorded in the RUNLOG
1.90x import onto a 203 MB db: no read-onlymeasuredD10a - seed then back-to-back burst
Burst after a spent grow: 53100 disk full and a 7 min 57P03 outage with status healthy (1 of 2 runs); read-only at 95.1%, writable after 492 s (the other)measuredD10c/D10d - burst with the manual POST answering 429, then hands-off recovery poll
Grow from 2 GB: 4/5 GB 400 on the gp3 IOPS floor, 6 GB 201measuredD11 - curl replay, recorded in the RUNLOG
Spend cap on: a manual grow 2 -> 12 GB answered 201 and was appliedmeasuredD12 - one POST /config/disk on a fresh Pro project, 2026-10-05, recorded in the RUNLOG
Live gp3 raise on Large, 3000 -> 4000 IOPS and 125 -> 250 MiB/s: 0 failed samples on six Postgres paths in the first 3 min, no restart, new values read back 2.3 s after the POST; logged write load 42224-43985 ms before, 12672-14919 ms from +180 smeasured, 2026-11-04, n=2D13 - held (1 s) and fresh (2 s) connections through direct 5432, Supavisor session and Supavisor transaction, a timed 500,000-row insert per session before and after; run 3, run 4
Second disk change 1501 s after the first: 429 ... once per four hours. Last modified at a day-month-year time; a size-only grow starts the same refusalmeasured, 2026-11-04, n=2 (grow n=1)D13 runs 2 to 4, recorded in the RUNLOG; run 2
Small, PITR on: 574 MB database, 736 MB pg_wal, 505 MB free of 1,981 MB; a 1,500 MB seed filled the disk at 715 MB and the restore request was refused until 301 smeasured, 2026-10-10; one run each, cause of the fill not separatedRP02 runs R4 and R5, recorded in the RUNLOG
Small heap control, 2 GB disk: 1,000,000-row plain upsert (303-312 MB WAL per statement) filled it; passed with 8 GBmeasured, 2026-10-10OR02 runs E and F, recorded in the RUNLOG
ModuleExperimentTestArtifact
D01compute-diskd01-compute-pg-limits.tsnone published
D02compute-diskd02-disk-mutations.tsnone published
D03compute-diskd02-disk-mutations.tsnone published
D03platform-downtimed03-resize-up.tsnone published
D04compute-diskd04-autoscale-surface.tsnone published
D04platform-downtimed04-resize-down.tsnone published
D05compute-diskd05-free-org-autoscale-readonly.tsnone published
D06compute-diskd05-free-org-autoscale-readonly.tsnone published
D07compute-diskd04-autoscale-surface.tsnone published
D08compute-diskd08-storage-type-gate.tsnone published
D09compute-diskd09-compute-resize-timing.ts (2026-08-19); 2026-10-23 versionrun-2026-10-23T07-56-13-302Z
D10compute-diskd10-paid-fill-readonly.tsnone published
D11compute-diskcurl replay (RUNLOG, 2026-10-01)none published
D12compute-diskd12-spend-cap-manual-grow.tsnone published
D13compute-diskd13-live-iops-change.tsrun-2026-11-04T09-23-59-871Z, run-2026-11-04T09-53-29-290Z, run-2026-11-04T10-21-54-142Z
RP02restore-pathsrp02-pitr-restore.tsrun-2026-10-10T01-42-15-009Z, run-2026-10-10T01-57-31-964Z
OR02orioledbor02-upsert.tsout/2026-10-10
I01instance-sizingi01-nano-availability.tsnone published
I03instance-sizingi03-legacy-pause-lifecycle.tsnone published
I04instance-sizingi04-free-org.tsrun-2026-08-18T04-43-40-236Z, run-2026-08-18T04-49-43-066Z, run-2026-08-18T05-07-03-585Z
W02edge-resiliencew02-retry-probe.tsout/2026-08-16, out/2026-08-17
  1. Supabase, “Compute and Disk,” Supabase Docs. https://supabase.com/docs/guides/platform/compute-and-disk ↩ ↩2 ↩3 ↩4 ↩5 ↩6 ↩7 ↩8 ↩9 ↩10 ↩11

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

  3. supabase-lab, “Compute-disk experiment,” supabase-lab runlog, section “2026-10-23 - D09 outage accounting fixed; a resize is minutes down, not seconds” (2026-10-23; supersedes the section “2026-10-13 - D09 re-run after the explicit Data API grant” at https://github.com/erfianugrah/supabase-lab/blob/3c53268/experiments/compute-disk/RUNLOG.md). https://github.com/erfianugrah/supabase-lab/blob/d726c9a/experiments/compute-disk/RUNLOG.md ↩

  4. supabase-lab, “Platform-downtime experiment,” supabase-lab runlog, including the 2026-10-23 data-path re-measure. https://github.com/erfianugrah/supabase-lab/blob/3c53268/experiments/platform-downtime/RUNLOG.md ↩

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

  6. Supabase, “studio: increase gp3 max size to new aws limit (#45611),” supabase/supabase commit 2ee0108, 2026-09-04. https://github.com/supabase/supabase/commit/2ee010892880aa8b8240be705469835d4590faf9 ↩

  7. Supabase, “docs: correct gp3 disk throughput price in Compute and Disk guide (#52715),” supabase/supabase commit 1e26878, 2026-11-03. https://github.com/supabase/supabase/commit/1e26878d7f7010b73099d4997a7e4ce127c32706 ↩

  8. Supabase, “Database Size,” Supabase Docs. https://supabase.com/docs/guides/platform/database-size ↩ ↩2 ↩3 ↩4 ↩5 ↩6 ↩7 ↩8 ↩9 ↩10 ↩11 ↩12

  9. supabase-lab, “Restore-paths experiment,” supabase-lab runlog, runs R4 and R5 (2026-10-10). https://github.com/erfianugrah/supabase-lab/blob/899fef3/experiments/restore-paths/RUNLOG.md ↩

  10. supabase-lab, “OrioleDB experiment,” supabase-lab runlog, OR02 heap-control disk, runs A, B, E and F (2026-10-10). https://github.com/erfianugrah/supabase-lab/blob/899fef3/experiments/orioledb/RUNLOG.md ↩

  11. Supabase, “Update copy RE disk configuration changes and cooldown (#50844),” supabase/supabase commit fea8b8b, 2026-09-29. https://github.com/supabase/supabase/commit/fea8b8b41d7f8bb5732b225e49d90d9239081cdc ↩

  12. supabase-lab, “Compute-disk experiment,” supabase-lab runlog, section “2026-11-04 - raising disk IOPS and throughput on a running gp3 project” (2026-11-04). https://github.com/erfianugrah/supabase-lab/blob/9cccc39/experiments/compute-disk/RUNLOG.md ↩ ↩2

  13. Supabase, “Billing FAQ,” Supabase Docs. https://supabase.com/docs/guides/platform/billing-faq ↩