AWS Glue Cost Optimization: DPUs, Job Bookmarks, and Savings

AWS Glue has one of the simplest price lists on AWS, one number, $0.44 per DPU-hour, and one of the most reliably surprising bills, because almost nothing about a Glue job is sized by a human. A new Spark job is handed 10 DPUs by default when the minimum is 2. A crawler scheduled nightly pays a ten-minute minimum every night whether or not a single partition changed. An interactive session opened for an afternoon of debugging runs at five DPUs until someone remembers to close it. And a pipeline that was never told where it left off re-reads its entire source every run, so the bill grows with the history rather than with the new data.

This guide explains how AWS Glue pricing actually works, where the charges hide outside the headline rate, and the six levers that typically cut a Glue bill by 40 to 60 percent, with worked US figures. It also covers the reason Glue cost is so often unmanaged: it sits in a data stack with Athena, S3, Redshift, and increasingly Snowflake, and nobody owns the stack's bill as a whole. Rates are from the official AWS Glue pricing page as of October 2026 and vary by region.

Key Takeaways

• Glue bills DPUs multiplied by hours; the bill is driven by how many DPUs a job requests and how long it runs, not by data volume directly.
• Spark jobs default to 10 DPUs against a minimum of 2, so right-sizing with auto-scaling is usually the largest single saving.
• Job bookmarks are free and cut execution time directly by processing only new data; incremental pipelines without them pay for their history every run.
• Flex execution is 34 percent cheaper for anything that can tolerate a delayed start, which is most batch ETL.
• Crawler minimums, idle sessions, Data Catalog overages, and adjacent S3 and transfer charges sit outside the $0.44 rate and inflate real bills.

How AWS Glue Pricing Works

Everything in Glue that runs compute is billed through the Data Processing Unit. One DPU is 4 vCPUs and 16 GB of memory, and the bill for any job, crawler, or session is DPUs allocated, multiplied by hours run, multiplied by the rate. Billing is per second with a one-minute minimum per job run, and crawlers carry a ten-minute minimum. The rate depends on the execution class and worker type.

Worker types map directly to DPUs: G.1X is one DPU ($0.44 an hour), G.2X two ($0.88), G.4X four ($1.76), and G.8X eight ($3.52). A job's cost is its worker count times its worker size times its runtime, which means the two decisions that set the bill, how many workers and how big, are made in a job configuration that most teams copy from a template and never revisit.

Where Glue Bills Actually Grow

• The 10-DPU default. A new Spark job is provisioned with 10 DPUs. Most jobs processing tens of gigabytes finish comfortably on 2 to 4, and a job at 10 DPUs that could run on 4 costs two and a half times what it should on every run, forever. This is the single most common Glue overspend.
• Pipelines without bookmarks. A job that does not track its position re-reads the full source every run. Execution time grows with the history, so a nightly job that took five minutes in month one takes forty in month twelve, at the same DPU count, for the same new data.
• Crawlers on a schedule. A crawler bills at least ten minutes at two DPUs every time it runs, about $0.15, regardless of whether anything changed. Nightly crawlers on a hundred static prefixes cost about $450 a month to discover nothing.
• Idle sessions and endpoints. Interactive sessions open at five DPUs and bill until closed; development endpoints, now discouraged by AWS, were routinely left running for weeks at $0.44 per DPU-hour. A single forgotten five-DPU session costs about $53 a day.
• Scanning more than you read. CSV and JSON sources force full scans; unpartitioned tables force full reads. Both inflate runtime, which inflates the DPU-hour bill, without any configuration being wrong.
• Adjacent charges. S3 GET and PUT requests from Spark, cross-region transfer when a job reads from another region, Data Catalog overages past a million objects, and Redshift or RDS load time all land on other lines of the bill and are rarely attributed to the pipeline that caused them.

The last point is the structural one. Glue is one service in a data stack, and the stack's cost is spread across Glue, S3, Athena, Redshift, and often Snowflake, with no single line that says what a pipeline costs end to end. Our Athena pricing guide covers the query side of the same problem, and S3 cost optimization the storage side; Glue sits between them.

Six Levers That Cut AWS Glue Costs

1. Right-size DPUs and enable auto-scaling

Start every job at the minimum worker count and the smallest worker type that fits its memory profile, then enable Glue auto-scaling so the job adds workers only while a stage needs them and releases them after. On Glue 4.0 and 5.0, auto-scaling removes the choice between a job that is too small for its peak and one that is oversized for its average. Review job run metrics for executor utilization and shuffle spill; a job with low utilization is over-provisioned, and one spilling to disk is under-provisioned on memory, which is what R-type workers are for.

2. Turn on job bookmarks

Job bookmarks are free, built in, and the reason incremental pipelines should never re-read history. Enable them on any job that processes new data from a growing source, confirm the source is partitioned so Glue can skip what it has seen, and verify in the run logs that the number of files read matches the number of new files. For pipelines that have been running unbounded, the first bookmarked run can cut execution time by 80 percent or more.

3. Move time-insensitive jobs to Flex

Flex runs on spare capacity at $0.29 per DPU-hour, 34 percent below Standard, with a start time that can drift. Nightly batch, backfills, non-production jobs, and any ELT whose consumers read the output hours later are candidates. Keep SLA-bound and streaming jobs on Standard. On a typical estate, half or more of Glue DPU-hours are Flex-eligible.

4. Scan less: Parquet, partitions, and pushdown

Convert CSV and JSON sources to Parquet so Spark reads only the columns a job needs, partition tables by the keys jobs filter on, and use pushdown predicates so filters are applied at the source rather than after a full read. These changes reduce runtime, and runtime is the multiplier on every DPU-hour. They also cut S3 request charges and speed up Athena on the same data.

5. Crawl on change, not on schedule

Replace nightly crawlers on static data with event-driven crawls triggered by S3 notifications, or with schema updates written by the job itself using the Glue API, which costs nothing. Reserve scheduled crawls for sources that genuinely change shape, and set them to the lowest frequency the data requires.

6. Close what is idle

Set interactive session idle timeouts to minutes rather than hours, decommission development endpoints in favor of Glue Studio notebooks, and audit for sessions and streaming jobs nobody owns. Streaming jobs in particular bill continuously; one left running after its consumer was retired costs its full DPU-hours a month for nothing.

A Worked Example

A data team runs 40 nightly Spark jobs at the default 10 DPUs, averaging 25 minutes each, plus 60 crawlers scheduled nightly and a handful of interactive sessions. Monthly DPU-hours for the jobs are 40 jobs times 10 DPUs times 0.42 hours times 30 nights, about 5,000, costing about $2,200 at Standard. Crawlers add 60 runs times 30 nights at $0.15, about $270. Idle sessions, audited, come to about $400. The Glue bill is roughly $2,900 a month.

Apply the levers. Right-sizing with auto-scaling brings the jobs to an average of 4 DPUs: about $880. Bookmarks on the 25 incremental jobs cut their runtime by about 60 percent, taking the job line to about $560. Moving the 30 jobs without a morning SLA to Flex at $0.29 brings it to roughly $410. Event-driven crawling on the 50 static prefixes leaves 10 scheduled crawlers at about $45. Session timeouts remove most of the $400. The bill lands near $500 a month, an 83 percent reduction, with the same data landing in the same tables at the same time. None of it required rewriting a job; all of it required knowing which jobs cost what, which is the step most teams cannot do because Glue is one line on an AWS bill that nobody breaks down by pipeline.

How Opslyft Does This

Glue's cost problem is only partly a Glue problem. The jobs are over-provisioned because nobody sees the cost of each one, the crawlers run nightly because nobody owns the schedule, and the pipeline's real cost is split across Glue, S3, Athena, and Redshift lines that no console adds up. Opslyft treats the data stack as one estate. Explorer shows Glue spend with the rest of the AWS bill and alongside Snowflake, broken down by service, team, project, or product, and tracked over time, so a pipeline's end-to-end cost, the Glue DPU-hours, the S3 requests, the Athena scans, the warehouse credits downstream, is one number rather than four. Canvas puts that view on the data platform team's screen and on finance's, from the same source.

Atlas keeps a live inventory of every resource across every connected cloud with an owner and a cost on each, which for a data stack means the jobs, crawlers, sessions, and buckets that make up a pipeline are listed with the team responsible for them, and the change history traces a cost movement, a job's DPU count doubling or a crawler's schedule tightening, back to the change that caused it. Its optimization recommendations weigh each workload's purpose and criticality rather than utilization alone, so a production ETL job and a one-off backfill at the same DPU count get different advice. Dimension Studio allocates pipeline cost to the teams and products that consume the data, including the shared cost of a central ingestion job that feeds many downstream products, without needing every job to be tagged.

Monitor is where runaway DPU-hours are caught. A job whose bookmark was reset and is re-reading its history, a streaming job left running after its consumer retired, or a crawler schedule changed from weekly to hourly all show up as anomalies with a root-cause explanation, the job and the change, delivered to the data team's Slack channel before the month closes. Tickets turns the fix into an assigned item in Jira, ServiceNow, or Asana tracked to a measured saving, and Iris answers the question the data platform lead gets asked every quarter, which pipelines cost the most and why, in plain English. Our guide to database monitoring metrics and costs covers the downstream side of the same stack.

The Bottom Line

AWS Glue is priced simply and spent carelessly, because its defaults are generous, its minimums are easy to trip, and its cost is scattered across a data stack nobody owns as a whole. Start every job small and let auto-scaling grow it, enable bookmarks on every incremental pipeline, move batch to Flex, scan less by storing data properly, crawl on change, and close what is idle. Those six changes commonly halve a Glue bill without touching the logic of a single job. Then put the pipeline's whole cost, Glue and everything around it, in front of the team that owns it, because a DPU-hour nobody sees is a DPU-hour nobody right-sizes. For the wider AWS picture, see our guides to AWS cost optimization and where cloud waste hides.