TL;DR. Redshift cost optimization starts with idle hours, not query tuning. In a modelled 4-node RA3 cluster on demand, busy 12 hours on weekdays, idle hours are 86% of the waste: $2,024.30 of $2,364.06 a month. Pausing is the first cut, but it has two side effects nobody lists. The free concurrency scaling credits shrink from 30 hours to 11 ($82.08 more a month), and the daily load hour into tables nobody reads goes from free to $95.57 a month. A 1-year reservation bought after the pause schedule and the table cleanup would cost $2,219.78 a month against $1,051.25 on demand for the 242 hours the cluster still runs.
Redshift cost optimization goes wrong when it starts from a tips list: right-size, reserve, vacuum, tune. Each tip is sound, but none tells you which one your bill needs. Rank the waste in dollars from the system views first, then cut in the order that keeps every early step reversible. The meters themselves are in Redshift pricing; this post starts where that one stops.
Every rate here comes from the US East (N. Virginia) Redshift offer file in AWS's Price List API, dated September 11, 2026 and read November 18, 2026. The example is a model, not a measurement. The SQL follows AWS's documentation of that date and was not run on a live cluster for this post.
Where a Redshift bill hides waste: four places, ranked
Consider a team on 4 ra3.xlplus nodes on demand at $1.086 per node-hour, $4.344 an hour for the cluster. It runs 730 hours a month, but loads and dashboards keep it busy only from 06:00 to 18:00 on 22 weekdays, 264 hours. Peaks use 50 hours of concurrency scaling a month. It stores 5 TB in managed storage, 2 TB of which nobody has read in 90 days.
| Waste line | Inputs | Per month |
|---|---|---|
| Idle cluster hours | (730 - 264) h × $4.344 | $2,024.30 |
| Concurrency scaling past free credits | (50 - 30) h × 4 nodes × 3,600 s × $0.0003 | $86.40 |
| Spectrum scans of an unpartitioned table | 0.1 TB × 10 refreshes × 22 days × $5 per TB | $110.00 |
| Manual snapshots of a deleted cluster | 4,096 GB × $0.023 | $94.21 |
| Managed storage for unread tables | 2,048 GB × $0.024 | $49.15 |
| Total waste | $2,364.06 |
The whole bill is $3,584.61: $3,171.12 of compute, $122.88 of storage for the 5 TB, plus the scaling, Spectrum and snapshot lines. The snapshot row reuses the deleted RA3 cluster from AWS snapshot cost.
The ranking depends on the deployment. On Serverless, idle hours bill nothing unless something keeps the meter on, and AWS says concurrency scaling and Spectrum "are both included with Amazon Redshift Serverless" on its pricing page. So run the queries below before you trust any order, including this one.
Idle hours on provisioned clusters and Serverless base RPUs
Provisioned (on demand): count the hours in which no user query started. Multiply by your node count and node rate.
-- Provisioned. Hours in the last 7 days with no user query
WITH busy AS (
SELECT DISTINCT date_trunc('hour', start_time) AS hour
FROM sys_query_history
WHERE user_id > 1
AND start_time >= dateadd(day, -7, getdate())
)
SELECT 168 - COUNT(*) AS idle_hours,
(168 - COUNT(*)) * 4 * 1.086 AS idle_cost_7_days -- nodes x node-hour rate
FROM busy;
A query that crosses an hour boundary counts only in its start hour, so this overstates idle time a little. Health checks from a BI tool's connection pool make idle hours look busy: filter out its username.
The cut is a pause schedule. AWS's pause and resume guide says that while a cluster is paused, "on-demand billing is suspended. Only the cluster's storage incurs charges." A recurring schedule creates two scheduled actions, one to pause and one to resume. Read the limits before you rely on it:
- Pausing "typically completes within 15 minutes", and resuming "can take several minutes" before queries run.
- AWS begins terminating running queries when the pause starts.
- A cluster with automated snapshots turned off cannot be paused.
Serverless: the meter runs on RPU-seconds, so idle time costs nothing unless something keeps it on. Find charged RPU-hours in hours with no user query:
-- Serverless. Charged RPU-hours in hours with no user query
WITH charged AS (
SELECT date_trunc('hour', start_time) AS hour,
SUM(charged_seconds) / 3600.0 AS rpu_hours
FROM sys_serverless_usage
GROUP BY 1
),
busy AS (
SELECT DISTINCT date_trunc('hour', start_time) AS hour
FROM sys_query_history
WHERE user_id > 1
)
SELECT SUM(c.rpu_hours) AS idle_rpu_hours,
SUM(c.rpu_hours) * 0.375 AS idle_cost -- your RPU-hour price
FROM charged c
LEFT JOIN busy b ON b.hour = c.hour
WHERE b.hour IS NULL;
SYS_SERVERLESS_USAGE is visible only to superusers, and AWS "retains the information in SYS_SERVERLESS_USAGE for 7 days". Hours this query finds are the meter running with no query started in them. One documented cause is an open transaction: AWS's Serverless billing guide says Serverless keeps using RPUs until it is ended or rolled back, for up to six hours of inactivity. AWS also says charged_seconds is "computed after transactions end", so a charge can land in a later hour than the idle time behind it. Health checks from a connection pool are user queries, so they hide here as busy hours; Redshift pricing covers them with the base capacity choice.
Concurrency scaling and Spectrum: the meters that switch on by themselves
Both bill per use on provisioned clusters, on top of the node hours.
Concurrency scaling is free up to a credit. AWS's pricing page says: "You can accumulate one hour of Concurrency Scaling cluster credits every 24 hours while your main cluster is running", and a cluster holds at most 30 hours of them. Past that you pay "the per-second on-demand rate" with "a one-minute minimum charge each time a Concurrency Scaling cluster is activated". The price list rate for ra3.xlplus is $0.0003 per node-second, $4.32 an hour for a 4-node scaling cluster.
Credits accrue only while the cluster runs, so the pause schedule shrinks them. At 730 running hours the model earns the 30-hour cap; at 264 hours it earns 11. With 50 hours of scaling a month, billed time rises from 20 hours ($86.40) to 39 hours ($168.48): $82.08 more.
-- Provisioned. Concurrency scaling hours used, last 30 days SELECT SUM(usage_in_seconds) / 3600.0 AS scaling_hours FROM svcs_concurrency_scaling_usage WHERE start_time >= dateadd(day, -30, getdate());
Spectrum bills $5 per TB scanned in S3, "rounded up to the next megabyte, with a 10 MB minimum per query". In the model, a dashboard refreshes 10 times a weekday over a 0.1 TB table with no partitions: 22 TB, $110 a month. SYS_EXTERNAL_QUERY_DETAIL shows which tables cause it, and whether their partitions are being pruned:
-- Provisioned (RA3). Spectrum scans per external table, last 7 days
SELECT trim(table_name) AS external_table,
COUNT(DISTINCT query_id) AS queries,
SUM(returned_bytes) / power(1024, 4) AS tb_scanned,
SUM(qualified_partitions) AS partitions_scanned,
SUM(total_partitions) AS partitions_total
FROM sys_external_query_detail
WHERE source_type = 'S3'
AND start_time >= dateadd(day, -7, getdate())
GROUP BY 1
ORDER BY tb_scanned DESC;
The guard for both is a usage limit: daily, weekly or monthly, set in hours for concurrency scaling and in terabytes for Spectrum. The action is log, alert or disable, and AWS's API reference says disable turns the feature off "until the next usage period begins". Start with alert, and choose disable only once you accept slower peaks.
Tables nobody has read in 90 days, priced in managed storage
Managed storage costs $0.024 per GB-month, so 2 TB of unread tables is $49.15 a month. That is the smallest line in the model. The money is in the loads that keep writing them. On an always-on cluster, an hour of loading costs nothing extra. Once the cluster pauses outside busy hours, the daily hour spent loading unread tables keeps the cluster running 22 more hours a month: $95.57.
Find the candidates by joining each table's size to its last read. SVV_TABLE_INFO gives size "in 1-MB data blocks", and SYS_QUERY_DETAIL logs a table_id for each scan step:
-- Both. Tables with no read in the retained history, largest first
WITH reads AS (
SELECT d.table_id, MAX(h.start_time) AS last_read
FROM sys_query_detail d
JOIN sys_query_history h ON h.query_id = d.query_id
WHERE trim(d.step_name) = 'scan'
AND h.query_type IN ('SELECT', 'UNLOAD', 'CTAS', 'INSERT')
AND h.user_id > 1
GROUP BY 1
)
SELECT t."schema", t."table",
t.size AS size_mb,
ROUND(t.size / 1024.0 * 0.024, 2) AS storage_usd_month,
r.last_read
FROM svv_table_info t
LEFT JOIN reads r ON r.table_id = t.table_id::int
WHERE r.last_read IS NULL
OR r.last_read < dateadd(day, -90, getdate())
ORDER BY t.size DESC;
This query is only as good as the history behind it. AWS says STL views "retain seven days of log history", and its SYS_QUERY_DETAIL page warns that view data "is not saved when your data warehouse is lacking space". Copy the reads result into your own table every day for 90 days before you drop anything. Other gaps to check:
- When a query matches the result cache, AWS says Redshift "uses the cached results and doesn't run the query". Check
result_cache_hitin SYS_QUERY_HISTORY for the dashboards that used to read a candidate. - For a table shared through data sharing, check the consumer warehouses' query history too.
SVV_TABLE_INFOlists only tables with at least one row, in the database you are connected to, and only superusers see it by default.
Then price what writes each candidate. COPY loads are in SYS_LOAD_HISTORY with table_name and duration. For dbt or INSERT jobs, sum execution_time from SYS_QUERY_HISTORY for queries with an insert step on the table.
Snapshots that outlive their cluster
AWS's snapshot guide says "manual snapshots are retained indefinitely, even after you delete your cluster". Without a retention period, they stay until someone deletes them. AWS's pricing page says "Snapshots are billed until they expire or are deleted, including when the cluster is paused or deleted." The 4 TB in the model cost $94.21 a month. AWS snapshot cost has the CLI check that matches snapshots to clusters that no longer exist.
Cut in this order: limits, schedules, tables, then reservations
- Usage limits. Alert on concurrency scaling and Spectrum, and on Serverless a maximum of RPU-hours. AWS recommends setting "maximum RPU hours in the console to guard against unexpected cost". Nothing changes until a limit is reached.
- Pause schedule or Serverless base capacity. In the model: -$2,024.30 idle, +$82.08 scaling, a net $1,942.22 a month.
- Query monitoring rules. WLM rules can log, hop or abort a query past a threshold, including
spectrum_scan_size_mb. Start with log. - Stop the loads, then unload or drop the unread tables. In the model: $95.57 of load hours and $49.15 of storage, less $3.96 of scaling credits lost to the shorter schedule, a net $140.76. UNLOAD to S3 first if anyone may ask.
- Delete orphaned snapshots. $94.21.
- Reserve only now. AWS's pricing page says reserved nodes bill "even if you are not currently running a cluster, or if an existing cluster is paused". At $0.7602 per node-hour, the 1-year no-upfront reservation is $2,219.78 a month, against $1,051.25 for the 242 hours the cluster now runs. A reservation beats the pause schedule only above 511 running hours a month, 70% of the time.
Steps 2, 4 and 5 take the modelled bill from $3,584.61 to $1,407.42, a 60.7% cut. The Spectrum line stays at $110 in the model, because what partitioning saves depends on how the dashboard filters.
The strongest objection: a pause schedule makes the first morning queries wait for a resume, and teams with users in many time zones have few idle hours to pause. For them, the cut is a reservation or a move to RG nodes: rg.xlarge lists at $0.7602 an hour against $1.086 for ra3.xlplus, 30% less. The order still holds: measure busy hours first, then choose.
Limits of this model: US East list prices on one date, a hypothetical workload, and a scaling cluster billed at the size of the 4-node main cluster. We did not price Redshift ML, zero-ETL, data transfer or negotiated discounts. For the same cost questions across warehouse, databases and pipelines, see data warehouse cost.
Datapace is building one map of your data estate with usage and cost attached, and agents that propose changes as pull requests your team reviews and merges, such as stopping a nightly load into a table nobody has read in 90 days. If your Redshift bill has lines nobody can explain, book a call.
Sources
- AWS Price List API, Redshift offer file for us-east-1, dated September 11, 2026, read November 18, 2026 (ra3.xlplus node and concurrency scaling rates, managed storage, Spectrum data scan, paid snapshots, reserved node rates).
- AWS, Amazon Redshift pricing (concurrency scaling credits, Spectrum rounding, Serverless inclusions, snapshot billing, reserved nodes while paused).
- AWS, Pausing and resuming a cluster.
- AWS, Setting a usage limit on a cluster, the UsageLimit API reference and Billing for Amazon Redshift Serverless.
- AWS, WLM query monitoring rules.
- AWS system view references: System tables and views, SYS_QUERY_DETAIL, SVV_TABLE_INFO, SYS_SERVERLESS_USAGE, SYS_EXTERNAL_QUERY_DETAIL, SVCS_CONCURRENCY_SCALING_USAGE and SYS_LOAD_HISTORY.
- AWS, Working with snapshots.




