Compare: adv-contradiction-semantic-control-scope

For a nightly rollup that produces aggregated analytics data, BigQuery is the right target in almost all cases.

Reasoning:

- **Purpose match**: Rollups exist to serve reporting, dashboards, and ad‑hoc analytical queries. That's exactly what BigQuery is optimized for (columnar storage, cheap large scans, easy joins across historical data).
- **Protect production**: Writing large aggregate tables (and the heavy read queries that follow) into PostgreSQL competes for I/O, cache, and connections with your live transactional workload. Keeping analytics off the OLTP box avoids that contention and the operational risk.
- **Data locality**: The source data for the rollup is presumably already in BigQuery (or replicated there). Aggregating within the warehouse avoids pulling data out and pushing results back across systems.
- **Scale and retention**: Historical rollups grow unbounded. That's fine in BigQuery, but bloats a production Postgres instance and its backups.

When you might also write a copy back to PostgreSQL:

- The aggregates power a **user-facing product feature** that needs single-digit-millisecond lookups by primary key (e.g., "account summary" shown in the app). In that case, compute in BigQuery, then push a small, bounded result set into a dedicated Postgres table (or a cache like Redis) for serving. BigQuery remains the system of record for analytics; Postgres just holds a serving copy.

Default recommendation: **write the rollup output to BigQuery**, and only mirror a slim subset into PostgreSQL if a low-latency application feature specifically requires it.

Write the aggregated results to **BigQuery**.

Reasoning:

- **Purpose fit.** Rollups are analytical artifacts (aggregations, historical trends, reporting tables). That's exactly what the warehouse exists for. Consumers of rollups—dashboards, analysts, BI tools—are already pointed at BigQuery.
- **Protect production.** A nightly batch job scanning large tables and writing big result sets adds load, lock contention, and storage bloat to the database serving live application traffic. Keeping that workload off PostgreSQL preserves predictable production performance.
- **Cost and scale.** BigQuery is built for large scans and columnar aggregate storage; running the same over time in PostgreSQL means growing tables you have to index, vacuum, and eventually partition or prune.
- **Separation of concerns.** Analytics data living in the warehouse keeps a clean boundary: OLTP in Postgres, OLAP in BigQuery.

Exceptions—write back to PostgreSQL only if:

- The application itself needs to read the aggregates at request time with low latency (e.g. showing a user their monthly totals on page load), and querying BigQuery per request is too slow or costly. In that case, compute in BigQuery and sync a small summary table back to Postgres.
- The rollup feeds an operational feature (billing, quotas, feature gating) rather than reporting.

Common pattern: raw/event data lands in BigQuery, the nightly job aggregates there, and only a compact serving slice is pushed to PostgreSQL if the product needs it.