Snowflake Queue Time: How to Balance Your Query Workloads

Snowflake Queue Time | Keebo Blog

Queue time doesn’t appear as its own line on your Snowflake bill, but it’s often a sign that your warehouses are running less efficiently than they need to. And it’s easy to miss unless you know where to look. 

Queuing in Snowflake is often the first visible sign that a single, poorly optimized warehouse has stopped being a localized annoyance and turned into an avoidable line item. Over time, that waste compounds, dragging down the entire pipeline.

I’ve written before about a hygiene framework for Snowflake pipeline efficiency, but queuing deserves its own conversation. Let’s walk through what it is, what it signals about performance, and how to address its root causes. 

What Is Queuing in Snowflake?

The mechanics of Snowflake queuing are straightforward. When you send more concurrent queries to a warehouse than it can handle, Snowflake queues those queries until resources free up. Snowflake records that wait in the queued_overload_time column of QUERY_HISTORY, so you can measure it per query and per warehouse. Here’s how to put it to use.

Snowflake bills per second while a warehouse is running. Auto-suspend only kicks in when the warehouse goes idle.

Queuing means the warehouse is fully busy, so auto-suspend correctly stays out of the way. The credits go to the queries already running. The cost of queuing is the delay to everything waiting behind them, and that delay is a leading indicator that the workload has outgrown how the warehouse is configured.

What Does Queuing Tell You About Query Costs?

An overloaded warehouse does more than make queries wait in a queue. It also forces the queries that are running to fight for the same CPU and memory. Under pressure, queries that usually fit in memory start spilling to local disk and then to remote storage, and every spill makes execution drastically slower. Slower execution, in turn, creates more contention for the next query. 

Think about one bloated, inefficient query. Maybe it scans ten times more partitions than it needs. Or, maybe an AI assistant wrote it with a re-evaluated CTE instead of a materialized one. Its cost doesn’t stay contained. It slows every other query sharing the warehouse, so one team’s unoptimized workload becomes every team’s latency problem.

What Does Queuing Signal for the Rest of Your Stack?

The inefficiency behind queuing spills over the Snowflake boundary, acting as a force multiplier for waste across your stack. This happens in several ways.

First, you can see it in your dependency chains. When an overloaded warehouse holds a model in queue for two minutes, every downstream model starts late, and those delays add up across the DAG. Meanwhile, the warehouses across your account may resume on schedule and sit waiting for late inputs, billing their 60-second minimums while they idle toward auto-suspend. One overloaded warehouse can add cost to the other warehouses that depend on it.

Second, the delay reaches services outside Snowflake, namely from your cloud provider. Your orchestrator and serverless compute both bill by duration. AWS’s own cost guidance says a blocking call bills for the time it waits. The Airflow project built deferrable operators specifically to free worker slots during external polls. If your code makes a synchronous call to a busy warehouse, that wait is billed on the AWS side, and a retry bills it again. A fully asynchronous pattern (submit, disconnect, poll) avoids it.

And when this compounded inefficiency causes you to miss your SLA targets, it gets treated like a data incident. Monte Carlo’s data quality survey found organizations average 61 data incidents a month. How many first showed up as a simple queue, an early sign of an overloaded warehouse pushing a load window past its deadline? Engineers spend hours debugging a pipeline that was fine. The real problem was how its warehouse was sized for the load.

What Are the Indirect Costs Behind Snowflake Queuing?

Two other places this cost lands don’t appear on a monthly statement, but they’re arguably more expensive: 

Should I Size Up My Warehouse to Fix Queuing?

Eventually, the drag on performance becomes impossible to ignore. The easy fix: more compute. You size up or convert to a multi-cluster warehouse that spins up extra clusters when queries queue. I’ve made this trade myself. It always feels smart in the moment.

But this quick fix doesn’t solve the core issue of an inefficient workload. The fix was just provisioning more compute to muscle through it, which can burn through as many as double the credits. Essentially, you pay more to run unoptimized queries faster. 

How Do I Reduce Queuing in Snowflake?

So if sizing up isn’t the first move, what is? Here are three steps I’d recommend to reduce queuing by attacking the root cause of poorly written queries. 

1. Put a Number on Your Queue Time

Sum queued_overload_time by warehouse over the last 30 days and divide it by total execution time:

SELECT warehouse_name,   ROUND(SUM(queued_overload_time) / 1000, 0) AS queued_seconds,   ROUND(SUM(execution_time) / 1000, 0) AS execution_seconds,   ROUND(100 * SUM(queued_overload_time) / NULLIF(SUM(execution_time), 0), 1) AS queue_tax_pct FROM snowflake.account_usage.query_history WHERE start_time > dateadd('days', -30, current_date) GROUP BY warehouse_name ORDER BY queue_tax_pct DESC;

If you see more than a few percent on anything serving humans or SLA-bound pipelines, it’s a sign you’re leaving money on the table. Little’s Law guarantees the relationship you will find: the wait you measure is a direct function of arrival rate and the concurrency you provisioned.

2. Isolate Before You Upsize

Find out what is at the front of the line. Moving one rogue, heavy-duty job to its own right-sized warehouse beats a size bump. It usually costs less. Performance isolation between warehouses is not a workaround, either. It is a designed property of the architecture, described in Snowflake’s own SIGMOD paper.

3. Make the Response Autonomous

Queue pressure fluctuates hour to hour, and workloads drift month to month. The warehouse size that was right in January may not be right by March. Sizes, cluster counts, and suspend settings are hard to keep current by hand, which is why manual fixes tend to drift.

This is the gap my team at Keebo is focused on: autonomous optimization that watches the queue signal around the clock, rightsizes in real time, and keeps learning as your workload changes, so the fix you make today is still the right fix six months from now.

The signal is already in your account, timestamped to the millisecond in SNOWFLAKE.ACCOUNT_USAGE.QUERY_HISTORY.

Close the gap between the warehouse you provisioned and the workload you actually run. See how my team at Keebo keeps queue time in check as your workloads change.