Snowflake warehouse one size smaller: when it saves
Each Snowflake warehouse size bills twice the credits an hour of the size below it.
A warehouse whose queries are short, rarely queue and never spill can often run one size smaller for less.
Run read-only queries in your own console and paste the results. The report is worked out in your browser, with no access to your account.
What the check looks at
Each warehouse's size from SHOW WAREHOUSES, and from 30 days of query history: how many queries ran, how long they queued because the warehouse was full, and how much they spilled to remote storage.
Why it costs money
- Credits an hour double with each size: X-Small bills 1 credit an hour on Gen1, Small 2, Medium 4, Large 8, and so on.
- A size that is larger than the work needs still bills its full rate for every second it runs.
- Short queries finish quickly on any size, so the extra capacity mostly goes unused while the warehouse waits for its next query or its auto-suspend timer.
How the tool measures it
Priced. The report puts a monthly saving range on this check, from your own query results at your price.
Only warehouses that ran queries, queued for less than a minute in the month and spilled nothing to remote storage are candidates. A smaller size halves credits an hour, priced after the auto-suspend change so the two savings add. The low end assumes queries take twice as long, so only the idle time left after a 300-second setting gets cheaper. The high end assumes queries take no longer, so everything left after a 60-second setting halves.
When the report raises it. Queries 2 and 3 are both provided and at least one warehouse passes the queue and spill tests.
In the sample report
One size smaller
- LOADER_WH
- BI_WH
- ADHOC_WH
$1,855 to $1,882 a month, modeled.
From the tool's own sample: made-up results for one account over 30 days, priced at Enterprise list prices in US East (N. Virginia).
What to do
- 1Pick the candidate with the shortest queries first.
- 2Resize it during a quiet hour: ALTER WAREHOUSE name SET WAREHOUSE_SIZE = 'SMALL' (one step down from its size now).
- 3Make the auto-suspend change first if the report suggests one, so you can see each effect on its own.
How to tell it worked. Over the next two weeks, compare the warehouse's credits, the queued time (QUEUED_OVERLOAD_TIME) and any remote spilling in QUERY_HISTORY with the two weeks before.
Trade-offs. Queries take longer on a smaller warehouse, and some may start to queue or spill. If they do, the saving can disappear, and size back up.
The read-only queries behind it
The same SQL the tool gives you. Each reads usage views and changes nothing.
Query 2: warehouse activity, idle time and resumes
-- Finitizer Snowflake Cost Check, query 2 of 5: warehouse activity
-- sf-cost-check-v1 (2026-11-10). Read-only: it reads Account Usage and changes nothing.
-- Per warehouse: metered credits, the time queries kept it busy, and the idle time and
-- resumes it would have at each auto-suspend setting. Names and totals, no query text.
-- It reads 30 days of query history, so run it on a small warehouse. Allow a minute or two.
WITH w AS (
SELECT DATEADD(day, -30, DATE_TRUNC('day', CONVERT_TIMEZONE('UTC', CURRENT_TIMESTAMP()))) AS ws,
DATE_TRUNC('day', CONVERT_TIMEZONE('UTC', CURRENT_TIMESTAMP())) AS we
),
q AS (
SELECT h.warehouse_name, h.warehouse_size, h.start_time, h.end_time, h.execution_time,
h.execution_status, h.queued_overload_time,
h.bytes_spilled_to_local_storage, h.bytes_spilled_to_remote_storage
FROM snowflake.account_usage.query_history h, w
WHERE h.start_time >= w.ws AND h.start_time < w.we
AND h.warehouse_name IS NOT NULL
AND h.warehouse_size IS NOT NULL
AND h.end_time IS NOT NULL
),
o AS (
SELECT q.*,
MAX(end_time) OVER (PARTITION BY warehouse_name ORDER BY start_time, end_time
ROWS BETWEEN UNBOUNDED PRECEDING AND 1 PRECEDING) AS prev_end
FROM q
),
g AS (
SELECT o.*,
GREATEST(0, DATEDIFF(millisecond, IFF(prev_end > start_time, prev_end, start_time), end_time)) / 1000 AS busy_s,
IFF(prev_end < start_time, DATEDIFF(millisecond, prev_end, start_time) / 1000, NULL) AS gap_s
FROM o
),
a AS (
SELECT warehouse_name,
MODE(warehouse_size) AS size_seen,
COUNT(*) AS queries,
COUNT_IF(UPPER(execution_status) <> 'SUCCESS') AS failed_queries,
SUM(busy_s) AS busy_seconds,
COUNT(gap_s) AS gaps,
SUM(gap_s) AS gap_seconds,
SUM(LEAST(gap_s, 75)) AS idle_60,
COUNT_IF(gap_s > 75) AS resumes_60,
SUM(LEAST(gap_s, 135)) AS idle_120,
COUNT_IF(gap_s > 135) AS resumes_120,
SUM(LEAST(gap_s, 315)) AS idle_300,
COUNT_IF(gap_s > 315) AS resumes_300,
SUM(LEAST(gap_s, 615)) AS idle_600,
COUNT_IF(gap_s > 615) AS resumes_600,
SUM(LEAST(gap_s, 915)) AS idle_900,
COUNT_IF(gap_s > 915) AS resumes_900,
SUM(LEAST(gap_s, 1815)) AS idle_1800,
COUNT_IF(gap_s > 1815) AS resumes_1800,
SUM(LEAST(gap_s, 3615)) AS idle_3600,
COUNT_IF(gap_s > 3615) AS resumes_3600,
SUM(LEAST(gap_s, 10815)) AS idle_10800,
COUNT_IF(gap_s > 10815) AS resumes_10800,
APPROX_PERCENTILE(execution_time, 0.95) / 1000 AS p95_execution_seconds,
SUM(bytes_spilled_to_local_storage) AS spill_local_bytes,
SUM(bytes_spilled_to_remote_storage) AS spill_remote_bytes,
SUM(queued_overload_time) / 1000 AS queued_overload_seconds,
COUNT_IF(queued_overload_time > 0) AS queued_queries
FROM g
GROUP BY warehouse_name
),
m AS (
SELECT warehouse_name,
SUM(credits_used_compute) AS credits_compute,
SUM(credits_used_cloud_services) AS credits_cloud_services,
SUM(credits_attributed_compute_queries) AS credits_attributed
FROM snowflake.account_usage.warehouse_metering_history, w
WHERE start_time >= w.ws AND start_time < w.we
GROUP BY warehouse_name
)
SELECT COALESCE(m.warehouse_name, a.warehouse_name) AS warehouse_name,
m.credits_compute, m.credits_cloud_services, m.credits_attributed,
a.size_seen, a.queries, a.failed_queries, a.busy_seconds, a.gaps, a.gap_seconds,
a.idle_60, a.resumes_60,
a.idle_120, a.resumes_120,
a.idle_300, a.resumes_300,
a.idle_600, a.resumes_600,
a.idle_900, a.resumes_900,
a.idle_1800, a.resumes_1800,
a.idle_3600, a.resumes_3600,
a.idle_10800, a.resumes_10800,
a.p95_execution_seconds, a.spill_local_bytes, a.spill_remote_bytes,
a.queued_overload_seconds, a.queued_queries,
TO_VARCHAR(w.ws, 'YYYY-MM-DD') AS window_start,
TO_VARCHAR(w.we, 'YYYY-MM-DD') AS window_end
FROM m
FULL OUTER JOIN a ON a.warehouse_name = m.warehouse_name
CROSS JOIN w
ORDER BY m.credits_compute DESC NULLS LAST;Query 3: warehouse settings (SHOW WAREHOUSES)
-- Finitizer Snowflake Cost Check, query 3 of 5: warehouse settings
-- sf-cost-check-v1 (2026-11-10). Read-only: it reads Account Usage and changes nothing.
-- Size, type, generation, auto-suspend and cluster counts for every warehouse your role can see.
-- Run it as the same role as query 2 (ACCOUNTADMIN sees every warehouse).
SHOW WAREHOUSES;Other checks in the report
- Snowflake auto-suspend: what idle warehouse time costsPriced
- Snowflake transient tables: cutting Fail-safe storagePriced
- Snowflake idle warehouse time: credits no query usedTo investigate
- Snowflake cloud services credits: when they billTo investigate
- Snowflake background services: credits outside warehousesTo investigate
- Snowflake warehouse pressure: queuing and spillingTo investigate
- Snowflake failed queries: warehouse time with no resultTo investigate
- Snowflake poor pruning: queries that read most of a tableTo investigate
- Snowflake repeated queries: the same work every hourTo investigate
- Snowflake clone-retained storage: bytes kept for clonesTo investigate
- Snowflake stage storage: files left in internal stagesTo investigate
What a credit and a terabyte cost in each region and edition: Snowflake pricing in 2026. Finitizer does this for BigQuery today. Snowflake and Redshift support is on the way.