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

Dataset slug: managed-postgres Status: LIVE — hand-compiled snapshot @ 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 (weekly re-verification + 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, Google Cloud SQL, Azure Database for PostgreSQL Flexible Server, Neon, Databricks Lakebase, Aurora Serverless v2, Supabase, PlanetScale, DigitalOcean, Crunchy Bridge, TigerData (11 providers).
• Retrieved: 2026-07-20 (re-fetched each weekly refresh; 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 — never one generic archetype 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 hyperscaler config is pinned to that vendor's OWN published price within tolerance and re-checked on every build; a reprice or a wrong rule fails the build and no seed is emitted. Current anchors: Cloud SQL 2 vCPU ≈ $100/mo · 4 vCPU ≈ $197 · HA ≈ $394; Aurora single ≈ $255 · Multi-AZ + replica + 200 GB ≈ $475 (all within ±10–12%).
• Regression cases (named, permanent). neon_ha_adds_no_storage, lakebase_ha_adds_no_storage — serverless HA duplicates no storage and the standby scales to zero, so HA = $0. Once caught, never reintroduced.
• 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, 730 hr/mo, 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 HA + PITR ≥ 7d + HIPAA, which disqualifies DigitalOcean (no HIPAA) even though it is the cheapest — the capability-parity floor working as designed.

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 (2026-07-20). 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).
• 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.

Coverage

• Rows: 44 (pg_comparison) = 11 providers × 4 scenarios · History baseline: 44 rows @ 2026-07-20.
• 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 weekly freshness — the honest, itemized comparison a static blog table can't keep current.