Managed Postgres — decision map (cost by workload + equivalence)

Dataset slug: managed-postgres Status: LIVE — hand-compiled snapshot, last re-verified 2026-10-18 (first compiled 2026-07-20). Cadence is null (staleness-exempt): the data is compiled from published vendor pricing pages, which are not reliably auto-fetchable (same basis as saas-pricing). The spec's automated weekly refresh (§8) is the P4 goal and is not yet wired — we don't claim a cadence the pipeline can't honor. Re-verified manually as the market moves.

A first-party compilation of publicly published vendor pricing, normalized into one apples-to-apples cost model. Prices, plan names, positioning and ownership are facts published by each vendor; facts are not copyrightable. The value we add — and license — is the normalization judgment (resolving incompatible billing models into one comparable number for a stated workload), the freshness (manual re-verification as vendors reprice + append-only history), and the opinionated fit caveat. Spec: docs/flagship-managed-postgres-spec.md; schema: docs/postgres-dataset-schema.md.

Source

• Primary compilation basis: each provider's own public pricing / docs pages (one pg_sources row per provider with url + retrieved_at + kind): AWS Aurora, Amazon RDS for PostgreSQL, Google Cloud SQL, Azure Database for PostgreSQL Flexible Server, Neon, Databricks Lakebase, Aurora Serverless v2, Supabase, PlanetScale, DigitalOcean, Crunchy Bridge, TigerData, Render, Heroku, Fly.io Managed Postgres, Ubicloud, Xata (17 providers). Where a vendor's page renders prices client-side (AWS instance tables, Azure, Cloud SQL), rates were cross-checked against independent trackers (bytebase.com/dbcost, sparecores, holori) and marked from-provider-calculator.
• Retrieved: 2026-10-18, every provider re-checked against its live pricing page (re-fetched on each manual re-verification; every pg_comparison row carries retrieved_at + source_url, and each pg_pricing_components value carries its pg_sources id).
• Why a model, not a scrape: vendors bill in incompatible units (per-vCPU-hr vs serverless CU-hr vs ACU-hr vs flat tier). We store each provider's native unit + a sourced conversion to a canonical {vCPU, GB RAM} (pg_compute_units) and compute an itemized bill (compute / storage / HA / I/O / extras) with a per-provider function, not one generic formula. The architectural rules that make the math correct per provider (e.g. ha_duplicates_storage, replica_scales_to_zero, io_model) live in pg_pricing_rules as sourced data, not buried code.

Cost-model fidelity (how we make sure it's true)

ingest/sources/managed-postgres.ts holds the model and a verification harness:

• Anchor tests. Each provider's model is pinned to that vendor's OWN published price and re-checked on every build; a reprice or a wrong rule fails the build and no seed is emitted. Since 2026-10-18 at least one anchor per provider is at scenario size, so a wrong unit conversion or instance mapping can't hide behind an anchor that shares the model's assumption (that gap let the Aurora errors below through). Current anchors (19): Cloud SQL 4 vCPU / 15 GB ≈ $197 and HA = 2×; Aurora 4 vCPU = db.r7g.xlarge $403.69 and the HA reader is the same class; Aurora Serverless v2 4 GB-hour = 2 ACU = $0.24; RDS 2 vCPU / 8 GB = db.m7g.large $122.64 and Multi-AZ doubles storage; PlanetScale PS-320 HA = $570; Supabase Pro + XL = $225; Crunchy Standard-16 = $280; DigitalOcean 8 GiB = Advanced $130; Render 4c-16g = $200; Fly.io Launch = $282; Ubicloud standard-2 = $78; Xata 2 vCPU always-on ≈ $70; Heroku HA = Premium-3 $750.
• Plan matching. Fixed-size providers are priced at the smallest published plan with at least the workload's vCPUs and within 10% of its memory. Shared or burstable CPUs count only for workloads busy < 12 h/day without HA. Heroku publishes no vCPU counts, so it's matched on memory. Every row records the exact plan priced (plan, migration 0008) and how failover works (failover).
• Regression cases (named, permanent). neon_ha_restart_costs_nothing — Neon keeps no standby (compute restarts in a healthy zone, 1–10 min), so HA adds $0. lakebase_ha_bills_secondary — Lakebase HA secondaries run continuously and are billed. aurora_sv2_4gb_hour=2acu — 1 ACU ≈ 2 GiB. neon_compliance_bills_scale_rate — a HIPAA workload is priced on the plan that offers the BAA. Once caught, never reintroduced.
• Corrections (2026-10-18). Aurora Serverless v2 had been overstated ~2× (4 ACU counted per 4 GB); Aurora provisioned understated for 4-vCPU workloads (a 2-vCPU class had been priced; Production HA $436 → $819). Neon's HA had been described as a scale-to-zero standby, which doesn't exist; Lakebase's standby was unbilled. Unsourced commitment discounts were removed (only Cloud SQL, Azure and RDS publish one). Crunchy's acquisition date corrected to June 2025. The hobby scenario was resized to 0.25 vCPU / 1 GB, so pre-2026-10-18 hobby history is not comparable.
• Uncertainty is tagged honestly. Every row carries cost_method (list-price | from-provider-calculator | modeled) and confidence; a committed/reserved range (low_usd…high_usd) is shown, never false precision. Assumptions are pinned on-page (us-east region, monthly list price for fixed plans and a 30-day month for hourly ones, on-demand, egress excluded unless noted).

Capability-parity floor

Each workload scenario carries required_capabilities; a provider that fails a required capability is flagged (meets_requirements = 0), never ranked #1. In v1 the Production-HA scenario requires automatic failover + PITR ≥ 7d + HIPAA on the plan priced; a BAA gated behind a support upgrade, Enterprise contract or paid add-on counts as partial and does not clear it. Where HIPAA has a published price (Neon Scale, Render Scale workspace + 20%), that price is used; an unpublished retention window doesn't count. As of 2026-10-18 this disqualifies Xata (the cheapest row), Ubicloud, TigerData, Supabase, DigitalOcean, Crunchy Bridge, PlanetScale, Heroku (Shield is Teams/Enterprise-only), Fly.io and Lakebase (HIPAA needs the compliance security profile add-on).

License / redistribution basis

Rights are split (same precedent as llm-api-pricing):

• CURRENT snapshot — CC BY 4.0 (open). The 4-scenario map — the provider map (identity, positioning class, ownership, engine type) and the normalized cost for the four named workload scenarios as published on datafloe.dev/managed-postgres and served by the keyless /sample — is CC BY 4.0: free to use and redistribute with attribution. Free embeds render from this snapshot, so the backlink is required by the licence. This point-in-time snapshot is the SEO / citation surface, exactly like the llm-api-pricing current-prices snapshot.
• Maintained feed + history + keyed API — commercial-api@1 ($49/mo). What's sold is not exclusivity over the published numbers — it's the maintained, re-verified feed (kept current as acquisitions/repricings land), the append-only pg_pricing_history, and the keyed rows API for programmatic / integrated access. The normalization judgment and freshness are the value.
• ai_training: false on both profiles by platform design (07 §6).

Freshness

• Cadence: null today (staleness-exempt). The data is a hand-compiled snapshot (last re-verified 2026-10-18). Pricing pages are not reliably auto-fetchable, so there is no automated refresh cron yet — the catalog does not advertise a cadence the pipeline can't honor, and the staleness monitor skips it. Re-verified manually as acquisitions and repricings land (the events that matter — Neon→Databricks repricing dropped storage $1.75→$0.35/GB; DigitalOcean's 2026-10-15 Standard/Advanced Edition split moved 8 GiB+ and HA clusters to Advanced).
• Where list pages render client-side (AWS instance tables, Azure, Cloud SQL, Lakebase as of 2026-10-18), rates were taken from the vendor's docs or cross-checked against bytebase.com/dbcost and marked confidence: med. TigerData publishes no per-size compute price, so its rate stays modeled (confidence: low).
• Planned refresh path (flagship spec §8, P4 — not yet wired): per-provider fetch/parse → pg_pricing_components → recompute pg_computed_costs + rebuild pg_comparison → append total-cost deltas to pg_pricing_history, reusing the llm-api-pricing hardening (per-provider drop HOLD, cross-source spot check, new-tier scan, tombstones). Regenerate the seed any time with npm run ingest:postgres (re-runs the anchor tests; refuses to emit on drift).
• History semantics: effective_date = the date the cost was observed and verified at compile, not a vendor announcement date. low_usd before 2026-10-18 applied commitment discounts we could not source for several providers; from 2026-10-18 only published discounts (Cloud SQL, Azure, RDS) apply.

Coverage

• Rows: 68 (pg_comparison) = 17 providers × 4 scenarios · History: one row per (provider, scenario, date) at 2026-07-20, 2026-10-15 and 2026-10-18 (68 rows on the latest date). Pre-2026-10-18 rows that the model corrections changed (both Aurora products, Lakebase prod-ha, every hobby row) were deleted so history shows vendor repricing only.
• Costs in USD/mo, us regions, on-demand list unless a committed range is shown.

Vendor ToS note

This is a compilation of public facts with a per-number source; we copy no vendor pricing page wholesale and assert no ownership over the prices. The open CC BY snapshot says so out loud; the paid product is the normalization model and re-verification as vendors reprice.