We ran 30 days of identical production workloads on both platforms — pipelines, ad-hoc analyst queries, three BI tools — and tracked every dollar. The cheapest query is one that scans nothing; the second cheapest scans less. Here's what we learned, what the billing models don't tell you upfront, and the levers to pull on either platform.
Test Setup
| Parameter | Value |
|---|---|
| Data volume | ~8 TB scanned per day (full table scans + selective queries) |
| Query mix | 40% scheduled pipeline queries, 60% ad-hoc analyst queries |
| BI tools | Looker, Tableau, and Metabase — all three connected simultaneously |
| Team size | 15 analysts + 8 data engineers |
| Snowflake config | 2× Medium warehouses (pipelines + ad-hoc, isolated) |
| BigQuery config | On-demand pricing with BI Engine reservations for Looker |
Why two warehouses on Snowflake? Compute isolation is a core cost pattern. Running pipelines and analyst queries on the same warehouse causes resource contention — analysts slow pipelines, pipelines blow analyst budgets. Dedicated warehouses let each workload scale and suspend independently.
Cost Results
| Platform | Monthly cost | Breakdown |
|---|---|---|
| ❄ Snowflake | $4,820 | $3,200 compute · $420 storage · $1,200 cloud services |
| ◈ BigQuery | $3,940 | $2,800 on-demand · $240 active storage · $60 long-term · $840 BI Engine |
BigQuery came in 18% cheaper — saving ~$880/month, or ~$10,560 annualized.
Decoding the bill: credits, slots, and DBUs are how each platform meters compute, and confusing them is how teams overspend silently. Snowflake credits map to warehouse size × time running. BigQuery slots are units of query concurrency (on-demand = burst; reservations = guaranteed).
Where Snowflake Won
Consistent query performance. Snowflake's query performance was more consistent across the test period. Ad-hoc queries on large tables returned in predictable time because compute is always available when the warehouse is running. BigQuery's on-demand model introduced occasional queue delays during peak hours.
Snowflake's warehouse model bills by credit per second with a 60-second minimum per query. A 2XL warehouse burns 16 credits/hour. Short, frequent queries on large warehouses are expensive — right-sizing the warehouse is the key lever.
SELECT
query_text,
warehouse_name,
total_elapsed_time / 1000 AS elapsed_sec,
credits_used_cloud_services,
partitions_scanned,
partitions_total
FROM snowflake.account_usage.query_history
WHERE start_time >= dateadd('day', -7, current_timestamp)
ORDER BY credits_used_cloud_services DESC
LIMIT 25;Aggressive result caching. Repeated queries with the same parameters from different BI tools hit the result cache and cost zero credits. For Looker dashboards refreshing on a schedule with identical SQL, this mattered significantly.
Auto-suspend saves real money. The pipeline warehouse was configured with a 2-minute auto-suspend. Between batch windows, it sits at zero. If your warehouse is idle 70% of the time, auto-suspend eliminates that waste entirely.
ALTER WAREHOUSE pipeline_wh
SET AUTO_SUSPEND = 120 -- seconds; 60 is the minimum
AUTO_RESUME = TRUE
MIN_CLUSTER_COUNT = 1
MAX_CLUSTER_COUNT = 3; -- multi-cluster handles analyst spikesWhere BigQuery Won
Simpler cost model to reason about. BigQuery's on-demand pricing — pay for bytes scanned, not time — is easier to budget and explain to leadership. Snowflake's credit consumption is opaque until you learn the patterns.
In BigQuery, SELECT * on a 1 TB table costs ~$6.25. Selecting 3 of 80 columns on the same table might scan 40 GB — costing $0.25. Columnar storage means you pay per column touched, not per row.
Richer cost monitoring out of the box. BigQuery's INFORMATION_SCHEMA lets you attribute costs to users, labels, and time windows with zero configuration. Snowflake has ACCOUNT_USAGE views, but they're delayed by up to 3 hours.
SELECT
user_email,
COUNT(*) AS job_count,
SUM(total_bytes_processed) / pow(10,12) AS tb_processed,
ROUND(SUM(total_bytes_processed) / pow(10,12) * 6.25, 2) AS est_cost_usd
FROM `region-us`.INFORMATION_SCHEMA.JOBS_BY_PROJECT
WHERE creation_time >= TIMESTAMP_SUB(CURRENT_TIMESTAMP(), INTERVAL 7 DAY)
AND job_type = 'QUERY'
AND state = 'DONE'
GROUP BY user_email
ORDER BY est_cost_usd DESC;Partition pruning & slot efficiency. A query filtered to a single partition on a date-partitioned table might scan 0.5 GB instead of 800 GB — a 1,600× cost reduction with no query rewrite, just good table design.
Native GIS performance. BigQuery handled our geospatial queries significantly faster. A genuine advantage for logistics or location-aware workloads.
Full Comparison
| Dimension | ❄ Snowflake | ◈ BigQuery |
|---|---|---|
| Monthly cost (our workload) | $4,820 | $3,940 ✓ |
| Billing unit | Credits (compute-time) | Bytes scanned or slots |
| Concurrency / queue delays | No queuing (multi-cluster) ✓ | On-demand can queue at peak |
| Result caching (cross-session) | Aggressive, free hits ✓ | Per-user, not shared |
| Idle compute cost | Auto-suspend eliminates it | Zero idle cost inherently ✓ |
| Cost monitoring tooling | ACCOUNT_USAGE (3hr lag) | INFORMATION_SCHEMA real-time ✓ |
| Partition pruning | Clustering keys (manual setup) | Automatic on partition columns ✓ |
| dbt incremental support | Excellent, merge strategy ✓ | Good, insert-overwrite preferred |
| Geospatial queries | Functional, slower | Native GIS, faster ✓ |
| Pricing complexity | Opaque until you learn it | Simpler to explain & budget ✓ |
Levers We'd Pull Next
- Snowflake: clustering + dbt incrementals. Our highest-cost Snowflake queries were full-table scans on an un-clustered events table (~900 GB). Adding a clustering key on
(event_date, user_id)and rewriting downstream dbt models as incremental would cut per-run cost ~60–80%. - BigQuery: BI Engine right-sizing. The $840/mo BI Engine reservation was over-provisioned for our actual Looker usage. Sizing it to actual query patterns would have saved an estimated $300/month.
- Both: column-level discipline. The single biggest free optimization: ban
SELECT *in production queries and require explicit column lists in dbt models. Cuts scan volume 60–90% on wide tables.
Master your data warehouse
The platform choice matters less than the discipline. Auto-suspend, partition pruning, columnar awareness, clustering keys, and cost-attribution dashboards make either Snowflake or BigQuery dramatically cheaper than the default config — usually 40-60% cheaper.
Our Data Warehousing module covers the warehouse-agnostic patterns: cost-model decoding, dbt incrementals, partition + cluster design, and the per-team chargeback dashboard that drives behavior.