Compare: adv-contradiction-semantic-control-scope

Write them to BigQuery.

**Why BigQuery is the default choice:**
- Rollup outputs are analytical artifacts — they exist to be sliced, joined with other warehouse data, and queried by BI tools. That's exactly what BigQuery is for.
- It keeps batch aggregation load off your production PostgreSQL instance, so the nightly job can't contend with live application traffic for CPU, locks, or I/O.
- The source data for aggregation is presumably already in BigQuery (or replicated there), so reading and writing in the same system avoids an extra cross-system hop.
- Columnar storage and partitioning make wide aggregate scans cheap; the same queries in Postgres would need careful index/materialized-view management.

**Write to PostgreSQL instead (or in addition) only if:**
- The aggregates power a user-facing feature in the application that needs low-latency point lookups (e.g., a "your stats" panel rendered on each request). BigQuery's per-query latency and cost model are a poor fit for that.
- Another production service needs to join these results transactionally with live tables.

If both are true, the common pattern is: compute in BigQuery, then push a small, curated slice back into Postgres (reverse ETL) for serving.

BigQuery, your analytics warehouse.

Reasoning:

- **Purpose fit** – Aggregated rollups are analytical artifacts consumed by dashboards, reports, and ad‑hoc queries. That's exactly what a warehouse is for. Postgres is optimized for transactional, low‑latency application reads/writes.
- **Load isolation** – Writing large batch aggregations into your production OLTP database competes with live traffic for I/O, cache, locks, and vacuum. Keeping it in BigQuery protects production performance.
- **Query pattern** – Rollups are usually scanned/sliced over wide ranges. BigQuery's columnar storage and MPP engine handle that far better than row‑oriented Postgres.
- **Source of truth** – The rollup's inputs presumably already land in BigQuery, so keeping the output there avoids a round‑trip and keeps lineage in one place.

Write back to Postgres only if the aggregates directly serve an application feature that needs single‑digit‑millisecond lookups by key (e.g. a "your stats" widget). In that case, compute in BigQuery and sync just the small serving slice into Postgres (or a cache like Redis).