{"id":399,"date":"2026-11-05T09:01:44","date_gmt":"2026-11-05T07:01:44","guid":{"rendered":"https:\/\/john-nessime.com\/blog\/?p=399"},"modified":"2026-11-05T09:01:44","modified_gmt":"2026-11-05T07:01:44","slug":"athena-partitioning-performance","status":"publish","type":"post","link":"https:\/\/john-nessime.com\/blog\/technical-guides\/athena-partitioning-performance\/","title":{"rendered":"Athena Partitioning: Why Your Queries Are Still Slow"},"content":{"rendered":"\n<p class=\"wp-block-paragraph\">The ticket said the daily rollup was timing out. Same query, same workgroup, same table, nobody had touched the SQL in months. The only thing that had changed was that the table kept collecting data.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">That is the part that confuses people, because the table <em>was<\/em> partitioned. Someone had done the work. The S3 prefixes had tidy <code>key=value<\/code> folders, the Glue catalog knew about them, and the query had a <code>WHERE<\/code> clause on the date. By every checklist on the internet, this table was fine.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Athena partitioning fails quietly in a way that other performance problems do not. A query that reads every byte of a five terabyte table does not throw an error. It returns the correct answer. It just takes four minutes instead of eight seconds and bills you for the privilege, and the only place the truth shows up is in the bytes-scanned number that nobody looks at until the finance channel does.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">This post is about the gap between having partitions and getting the benefit of them. I will go through the three failure families that actually cause slow Athena queries on partitioned external data, how to tell which one you are in, and what to do about each. There is some setup DDL along the way, but the point is the mechanism, not the syntax.<\/p>\n\n\n\n<h2 class=\"wp-block-heading\">How Athena decides what to read<\/h2>\n\n\n\n<p class=\"wp-block-paragraph\">Before any of the failures make sense, it helps to be precise about what happens between pressing run and bytes moving off S3.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Athena does not scan a table. It builds a list of S3 objects and reads those. Getting to that list involves three separate reductions, and each one can fail independently of the others:<\/p>\n\n\n\n<ol class=\"wp-block-list\">\n<li><strong>Partition resolution.<\/strong> Athena asks the AWS Glue Data Catalog for the partitions belonging to the table. For a Hive-style table this is a <code>GetPartitions<\/code> call, and it happens before any filtering of your data.<\/li>\n\n<li><strong>Partition pruning.<\/strong> Athena compares your <code>WHERE<\/code> clause against those partition values and throws away the prefixes that cannot match. Objects under discarded prefixes are never fetched at all.<\/li>\n\n<li><strong>In-file skipping.<\/strong> Within the surviving files, columnar formats let Athena read only the columns you asked for, and use row group statistics to skip chunks whose min and max values rule them out.<\/li>\n<\/ol>\n\n\n\n<p class=\"wp-block-paragraph\">Step two is the one people mean when they say partitioning. Step one is the one that quietly becomes the bottleneck on tables with a lot of partitions. Step three is the one that gets wiped out by bad file layout even when the first two worked perfectly.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Each reduction only helps if the one above it fired. That is the whole shape of the problem.<\/p>\n\n\n\n<h2 class=\"wp-block-heading\">Failure family one: the filter that never pruned<\/h2>\n\n\n\n<p class=\"wp-block-paragraph\">This is the most common one and the least visible. The table is partitioned correctly. The query filters on the partition column. Athena still reads everything.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Pruning happens during planning, before Athena has seen a single row. So the planner has to be able to evaluate your predicate against literal partition values using nothing but the query text. Anything that defers the value until runtime defeats it.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">The usual culprits:<\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li><strong>A function wrapped around the partition column.<\/strong> Partition values live in the prefix as text. If you write something that parses or casts them before comparing, the planner is comparing the output of a function it has not run yet, so it keeps every partition.<\/li>\n\n<li><strong>A filter that arrives through a join.<\/strong> If the partition value comes from the other side of a join rather than from a literal, planning has no value to prune with. This is the expensive one, because the query looks careful. Joining a small control table that says which day to load is a very natural thing to write and a very reliable way to scan the whole fact table.<\/li>\n\n<li><strong>A subquery that produces the value.<\/strong> Same problem, same reason.<\/li>\n\n<li><strong>Filtering the wrong column.<\/strong> Tables often carry both an event timestamp inside the data and a partition column derived from it. Filtering the timestamp is correct and returns the right rows. It also prunes nothing.<\/li>\n<\/ul>\n\n\n\n<p class=\"wp-block-paragraph\">You do not have to guess. Run the query through <code>EXPLAIN<\/code> and look at what the table scan node says it is doing.<\/p>\n\n\n\n<pre class=\"wp-block-code\"><code>EXPLAIN\nSELECT status, count(*)\nFROM logs.access_events\nWHERE dt = '2024-05-01';<\/code><\/pre>\n\n\n\n<p class=\"wp-block-paragraph\">The plan shows the constraint applied to the source. If your partition column appears there with a bound value, pruning will happen. If the predicate has been pushed into a filter node above the scan instead, it will not, and you are about to read the table.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">The cheaper check is behavioral: run the query with a narrow filter and note the bytes scanned, then widen the filter by ten times and run it again. If the number barely moves, nothing is pruning. Two runs and you have your answer without reading a plan.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">The fix for the join and subquery cases is unglamorous: resolve the value first, then substitute it into the query as a literal. In an orchestrated pipeline that means one step that computes the partition to load and a second step that templates it into the SQL. Step Functions, Airflow, or a shell script all do this fine. It feels like a step backwards from a single elegant query. It is the difference between reading one prefix and reading all of them.<\/p>\n\n\n\n<h2 class=\"wp-block-heading\">Failure family two: the partition list is the bottleneck<\/h2>\n\n\n\n<p class=\"wp-block-paragraph\">Now the opposite situation. Pruning works, the query reads a tiny slice, and the thing is still slow. Watch where the time goes and you will find most of it elapses before any data is read.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">That is partition resolution. Athena has to retrieve the partition metadata from Glue before it can prune it, and on a table with hundreds of thousands of partitions that retrieval is a real remote operation with real latency. AWS documents that Athena can query Glue tables with up to ten million partitions but cannot read more than one million partitions in a single scan, which is a ceiling worth knowing about before you design a scheme that approaches it.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">You get a strong hint from a query that scans almost nothing and still takes twenty seconds. Planning time is not proportional to data volume. It is proportional to partition count.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\">Option one: Glue partition indexes<\/h3>\n\n\n\n<p class=\"wp-block-paragraph\">Glue lets you create an index on a combination of partition keys, which lets the catalog filter server-side rather than handing Athena the full list. Creating the index alone does nothing for Athena. You also have to flip a table property, and this is the step people miss:<\/p>\n\n\n\n<pre class=\"wp-block-code\"><code>ALTER TABLE logs.access_events\nSET TBLPROPERTIES ('partition_filtering.enabled' = 'true');<\/code><\/pre>\n\n\n\n<p class=\"wp-block-paragraph\">The index makes filtering possible on the Glue side; the property tells Athena to actually use it. Set the same property to <code>false<\/code> to back the change out without dropping the index, which makes this an easy thing to try and easy to reverse.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">This is the option I reach for first when the table already exists, already has registered partitions, and is also read by other engines. It changes nothing about how the table works.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\">Option two: partition projection<\/h3>\n\n\n\n<p class=\"wp-block-paragraph\">Partition projection takes a different approach. Instead of asking Glue what partitions exist, you describe the pattern in table properties and Athena computes the partition values and their S3 locations in memory. The <code>GetPartitions<\/code> call disappears entirely.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">It also solves a maintenance problem. There is nothing to register when new data lands, so no crawler schedule and no repair command. For time-series data with a predictable layout, this is usually the right answer.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">A date-partitioned table looks like this:<\/p>\n\n\n\n<pre class=\"wp-block-code\"><code>CREATE EXTERNAL TABLE logs.access_events (\n  request_id string,\n  status int,\n  path string,\n  event_time timestamp\n)\nPARTITIONED BY (dt string)\nSTORED AS PARQUET\nLOCATION 's3:\/\/my-lake\/access-events\/'\nTBLPROPERTIES (\n  'projection.enabled' = 'true',\n  'projection.dt.type' = 'date',\n  'projection.dt.format' = 'yyyy-MM-dd',\n  'projection.dt.range' = '2021-01-01,NOW',\n  'projection.dt.interval' = '1',\n  'projection.dt.interval.unit' = 'DAYS'\n);<\/code><\/pre>\n\n\n\n<p class=\"wp-block-paragraph\">The <code>range<\/code> property accepts relative expressions such as <code>NOW<\/code>, <code>NOW-3YEARS<\/code> and <code>NOW+1MONTH<\/code>, which is what makes the table self-maintaining. The <code>format<\/code> string follows Java&#8217;s date formatter, and the same format must be used for the range bounds.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">If your prefixes do not follow the standard <code>column=value<\/code> layout, which is common for Firehose delivery streams and service logs, add a template that maps partition values onto your actual paths:<\/p>\n\n\n\n<pre class=\"wp-block-code\"><code>'storage.location.template' = 's3:\/\/my-lake\/access-events\/${dt}\/'<\/code><\/pre>\n\n\n\n<p class=\"wp-block-paragraph\">Every partition column must appear in the template, and the path must end in a slash.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\">Where partition projection hurts<\/h3>\n\n\n\n<p class=\"wp-block-paragraph\">Projection is the most oversold feature in this whole area, so here are the edges honestly.<\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li><strong>Out-of-range queries return zero rows, not an error.<\/strong> Query a date before your configured range starts and Athena completes successfully with an empty result. This is the single nastiest behavior in the feature, because a dashboard that silently goes blank looks like a data problem rather than a configuration problem.<\/li>\n\n<li><strong>Empty partitions cost you.<\/strong> Athena projects partitions whether or not they exist in S3. AWS&#8217;s own guidance is that if more than half your projected partitions are empty, you are better off with traditional registered partitions.<\/li>\n\n<li><strong>Enabling it makes Athena ignore registered partition metadata for that table.<\/strong> Any hand-registered partition pointing somewhere unusual stops being honored.<\/li>\n\n<li><strong>It is Athena-only.<\/strong> Redshift Spectrum, EMR and Athena for Spark reading the same table fall back to standard partition metadata. If your lake is shared, projection fixes one consumer and leaves the rest as they were.<\/li>\n\n<li><strong><code>SHOW PARTITIONS<\/code> stops being useful.<\/strong> Projected partitions are not in the catalog, so the command does not list them. Tooling that introspects partitions will need another approach.<\/li>\n\n<li><strong>Views do not inherit it.<\/strong> Projection is configured on tables. Set it on the underlying tables, not on views over them.<\/li>\n\n<li><strong>Projected dates are generated in UTC.<\/strong> If your prefixes are written in local time, the boundaries will not line up and you will lose or duplicate a day at the edges.<\/li>\n<\/ul>\n\n\n\n<p class=\"wp-block-paragraph\">The <code>enum<\/code> type deserves its own warning. It is tempting for things like customer IDs or account codes, but AWS recommends keeping enum projections to a few dozen values, because the whole projection configuration lives inside the Glue table metadata and that metadata has a size ceiling. If you need high-cardinality identifiers as a partition key, the <code>injected<\/code> type is the right tool, with the caveat that queries fail unless every injected column has a filter, and the <code>IN<\/code> list is capped at a thousand values.<\/p>\n\n\n\n<h2 class=\"wp-block-heading\">Failure family three: too many partitions and too many files<\/h2>\n\n\n\n<p class=\"wp-block-paragraph\">This is the one people create for themselves while trying to fix the first two. Partitioning felt good, so they partitioned harder. Year, month, day, hour, region, tenant. The prefixes look magnificent. The queries get worse.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Two mechanisms are working against you at once.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\"><strong>Per-file overhead.<\/strong> Every object Athena reads costs a listing entry, an S3 GET, and header parsing before a single useful byte is decoded. On a Parquet file that overhead is relatively fixed, so as file size shrinks it becomes the dominant cost. AWS guidance targets splits of roughly 128 MB, and Parquet&#8217;s default row group size is 128 MB with ORC stripes at 64 MB. Below that, the columnar format is paying its own tax without earning it back. Splitting one hour of data across six partition levels turns a healthy 200 MB file into hundreds of files measured in kilobytes.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\"><strong>S3 request rate.<\/strong> This is the failure mode that arrives as an actual error rather than slowness. S3 enforces a request rate ceiling per prefix, and a query fanning out across an enormous number of small objects can trip it. AWS explicitly calls out unpartitioned or badly structured data causing S3 exceptions on the GET rate. When your query fails with a throttling error rather than a timeout, look at object count, not data volume.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Streaming ingestion is the usual source. A delivery stream buffering every sixty seconds produces well over a thousand objects per day per partition, and none of them are big. The layout is not wrong; the buffering is just not aligned with how the data is read.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\">Compacting without breaking the table<\/h3>\n\n\n\n<p class=\"wp-block-paragraph\">The standard fix is a CTAS query that rewrites a slice of the table into fewer, larger objects. There is a constraint you will hit immediately if you try to do a whole table at once: Athena writes a maximum of 100 unique partition and bucket combinations per query, and exceeding it raises <code>HIVE_TOO_MANY_OPEN_PARTITIONS<\/code>.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">So the pattern AWS documents is CTAS to create the table with the first batch, then a series of <code>INSERT INTO<\/code> statements each staying under the same limit:<\/p>\n\n\n\n<pre class=\"wp-block-code\"><code>CREATE TABLE logs.access_events_compacted\nWITH (\n  format = 'PARQUET',\n  parquet_compression = 'SNAPPY',\n  partitioned_by = ARRAY['dt'],\n  external_location = 's3:\/\/my-lake\/access-events-compacted\/'\n) AS\nSELECT request_id, status, path, event_time, dt\nFROM logs.access_events\nWHERE dt &gt;= '2024-01-01' AND dt &lt; '2024-04-01';<\/code><\/pre>\n\n\n\n<pre class=\"wp-block-code\"><code>INSERT INTO logs.access_events_compacted\nSELECT request_id, status, path, event_time, dt\nFROM logs.access_events\nWHERE dt &gt;= '2024-04-01' AND dt &lt; '2024-07-01';<\/code><\/pre>\n\n\n\n<p class=\"wp-block-paragraph\">Two things about this that are easy to get wrong. The partition columns must come last in the select list, in the order given to <code>partitioned_by<\/code>. And <code>INSERT INTO<\/code> is not allowed against bucketed tables, so if you are also planning to bucket, you cannot use this incremental pattern for the same table.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">If compaction becomes a routine job rather than a one-off rescue, that is a strong signal to move the table to Apache Iceberg, where compaction is a maintenance operation on a live table instead of a rebuild-and-swap dance.<\/p>\n\n\n\n<h2 class=\"wp-block-heading\">Choosing partition keys without guessing<\/h2>\n\n\n\n<p class=\"wp-block-paragraph\">Most partitioning arguments are really arguments about granularity, and granularity has an arithmetic answer rather than an opinion. Work it backwards from file size.<\/p>\n\n\n\n<ol class=\"wp-block-list\">\n<li><strong>Measure compressed daily volume for the table.<\/strong> Not raw, compressed, because that is what lands in S3.<\/li>\n\n<li><strong>Divide by your target file size.<\/strong> Somewhere in the low hundreds of megabytes is a reasonable target. If a day of data does not comfortably exceed that, do not partition below daily. If a day is many gigabytes, hourly is defensible.<\/li>\n\n<li><strong>Only add a second dimension if it appears in nearly every query.<\/strong> A partition key that half your queries ignore multiplies your partition count while pruning nothing for those queries. Region and tenant are the classic examples, useful when every consumer is tenant-scoped and pure overhead when they are not.<\/li>\n\n<li><strong>Use bucketing for high-cardinality filters instead.<\/strong> Bucketing on something like a user ID gives Athena a way to skip files within a partition without creating a prefix per value.<\/li>\n\n<li><strong>Sort within files on your second-most-common filter.<\/strong> Row group statistics only help skip data when values are clustered. Sorted data makes the min and max in the metadata meaningful; randomly ordered data makes every row group look like it might match.<\/li>\n<\/ol>\n\n\n\n<p class=\"wp-block-paragraph\">On the recurring question of a single <code>dt=2024-05-01<\/code> column versus separate <code>year<\/code>, <code>month<\/code> and <code>day<\/code> columns: a single ISO-formatted date column is easier to filter correctly, is a clean fit for date-type projection, and makes range queries trivial. Split columns are worth it when you genuinely query at month or year granularity often enough to benefit from pruning at that level. Most tables do not, and the split scheme mostly buys you three chances to forget a predicate instead of one.<\/p>\n\n\n\n<h2 class=\"wp-block-heading\">Troubleshooting Athena partitioning problems<\/h2>\n\n\n\n<p class=\"wp-block-paragraph\">A short decision path for when something is wrong and you do not yet know which family you are in.<\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li><strong>Query returns zero rows, no error.<\/strong> If projection is enabled, check the configured range first. Out-of-range values return empty rather than failing. Also check the format string against the actual prefix text; one is dashed and the other is not more often than you would think.<\/li>\n\n<li><strong>Bytes scanned barely changes when you narrow the filter.<\/strong> Pruning is not happening. Look for functions, joins and subqueries on the partition column, then confirm with <code>EXPLAIN<\/code>.<\/li>\n\n<li><strong>Query is slow but scans almost nothing.<\/strong> Planning cost. Consider a Glue partition index with <code>partition_filtering.enabled<\/code>, or partition projection.<\/li>\n\n<li><strong>New data is invisible to queries.<\/strong> Hive-style layouts need <code>MSCK REPAIR TABLE<\/code>, non-Hive layouts need <code>ALTER TABLE ADD PARTITION<\/code>, and neither is needed with projection. Confirm which regime the table is actually in before running anything.<\/li>\n\n<li><strong><code>MSCK REPAIR TABLE<\/code> runs clean but adds nothing.<\/strong> It only understands <code>key=value<\/code> prefixes. It also skips paths containing uppercase characters, which is a genuinely infuriating hour to lose.<\/li>\n\n<li><strong>Partitions from a different table appear.<\/strong> <code>MSCK REPAIR TABLE<\/code> walks subfolders, so a table whose location sits above another table&#8217;s data will adopt its partitions. Give every table its own prefix hierarchy.<\/li>\n\n<li><strong>Throttling errors from S3.<\/strong> Object count, not data size. Time to compact.<\/li>\n\n<li><strong><code>HIVE_TOO_MANY_OPEN_PARTITIONS<\/code>.<\/strong> You crossed the write limit in a single CTAS or <code>INSERT INTO<\/code>. Split it into batches.<\/li>\n<\/ul>\n\n\n\n<p class=\"wp-block-paragraph\">Worth knowing: Athena has no setting that requires queries to filter on a partition column. There is no equivalent of the partition-filter-required flag some engines expose. What you can do is put a bytes-scanned cutoff on the workgroup, so a query that ignores the partition scheme fails fast instead of running to completion.<\/p>\n\n\n\n<pre class=\"wp-block-code\"><code>aws athena create-work-group \n  --name analytics-guarded \n  --configuration '{\n    \"ResultConfiguration\": {\"OutputLocation\": \"s3:\/\/my-athena-results\/analytics\/\"},\n    \"BytesScannedCutoffPerQuery\": 10737418240,\n    \"EnforceWorkGroupConfiguration\": true,\n    \"PublishCloudWatchMetricsEnabled\": true\n  }'<\/code><\/pre>\n\n\n\n<p class=\"wp-block-paragraph\">With CloudWatch metrics published per workgroup, bytes scanned becomes a graphable series. Whether you look at it in CloudWatch directly, in Amazon Managed Grafana, or in Grafana Cloud alongside the rest of your telemetry, the point is that a partitioning regression stops being invisible. Cost platforms such as Vantage or CloudZero will attribute the spend back to a workgroup for you if you want the finance-facing version of the same signal.<\/p>\n\n\n\n<h2 class=\"wp-block-heading\">Common mistakes<\/h2>\n\n\n\n<ul class=\"wp-block-list\">\n<li>Partitioning by a column that queries rarely filter on, then wondering why nothing improved.<\/li>\n\n<li>Adding hourly partitions to a table that receives a few megabytes an hour.<\/li>\n\n<li>Filtering the timestamp column that lives inside the data instead of the partition column derived from it.<\/li>\n\n<li>Enabling projection and leaving the range open-ended into the distant past, so most projected partitions point at nothing.<\/li>\n\n<li>Creating Glue partition indexes and never setting <code>partition_filtering.enabled<\/code>, so the index sits there doing nothing.<\/li>\n\n<li>Mixed-case S3 prefixes, which quietly break <code>MSCK REPAIR TABLE<\/code>.<\/li>\n\n<li>Treating projection as a drop-in upgrade on a lake that other engines also read.<\/li>\n\n<li>Compacting into the same prefix the table already points at, which is how you get duplicated rows in the middle of a rewrite.<\/li>\n<\/ul>\n\n\n\n<h2 class=\"wp-block-heading\">Best practices for Athena partitioning<\/h2>\n\n\n\n<ul class=\"wp-block-list\">\n<li>Pick granularity from compressed daily volume divided by a target file size, not from instinct.<\/li>\n\n<li>Use a single ISO date partition column unless you have a concrete reason to split it.<\/li>\n\n<li>Prefer partition projection for predictable time-series layouts, and Glue partition indexes for shared or irregular tables.<\/li>\n\n<li>Resolve dynamic partition values in the orchestration layer and pass literals into the SQL.<\/li>\n\n<li>Store data in Parquet or ORC with a splittable compression codec, and sort within files on a common secondary filter.<\/li>\n\n<li>Compact streaming output on a schedule, or align the delivery buffer so it produces usable file sizes in the first place.<\/li>\n\n<li>Put a bytes-scanned cutoff on every workgroup, including the one analysts use interactively.<\/li>\n\n<li>Track bytes scanned per workgroup as a time series and treat a step change as an incident, not a curiosity.<\/li>\n\n<li>Test partition changes against a copy first. Rewriting a table&#8217;s layout under live consumers is not something to improvise.<\/li>\n<\/ul>\n\n\n\n<hr class=\"wp-block-separator has-alpha-channel-opacity\"\/>\n\n\n\n<h2 class=\"wp-block-heading\">Frequently asked questions<\/h2>\n\n\n\n<h3 class=\"wp-block-heading\">How many partitions is too many for one Athena table?<\/h3>\n\n\n\n<p class=\"wp-block-paragraph\">There is a hard ceiling, since Athena cannot read more than a million partitions in a single scan, but you will feel the pain long before that. The practical limit is where planning time becomes a noticeable fraction of query time. If a highly selective query spends most of its life before reading data, you are over-partitioned regardless of the absolute count.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\">Does partition projection make queries faster on a table with few partitions?<\/h3>\n\n\n\n<p class=\"wp-block-paragraph\">Not meaningfully. Projection removes catalog lookup latency, and on a small table that lookup was never the problem. Its value on small tables is operational rather than performance related, since you stop having to register new partitions at all.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\">Can I use partition projection and registered partitions on the same table?<\/h3>\n\n\n\n<p class=\"wp-block-paragraph\">No. Enabling projection makes Athena ignore the partition metadata registered for that table. It is one regime or the other, which matters if you have hand-registered partitions pointing at locations outside the normal pattern.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\">Why did my Athena query scan the whole table even though I filtered on the partition column?<\/h3>\n\n\n\n<p class=\"wp-block-paragraph\">Almost always because the predicate could not be evaluated at planning time. A function wrapped around the partition column, a value arriving through a join, or a subquery producing the value all defeat pruning. Run <code>EXPLAIN<\/code> and check whether the constraint reaches the table scan node or sits in a filter above it.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\">Should I partition by year, month and day or by a single date column?<\/h3>\n\n\n\n<p class=\"wp-block-paragraph\">A single ISO-formatted date column is the better default. It maps cleanly onto date-type projection, makes range filters straightforward, and gives you one predicate to remember instead of three. Split columns earn their place only if you routinely query at month or year granularity.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\">Does partitioning help if my data is CSV or JSON?<\/h3>\n\n\n\n<p class=\"wp-block-paragraph\">Yes, because pruning happens at the prefix level and does not care about file format. But you are leaving the larger win on the table. Row-oriented text formats force Athena to read every column of every surviving row, so converting to Parquet or ORC typically cuts far more than partitioning alone. Do both, and do the format conversion first if you have to pick.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\">How do I stop analysts from running unpartitioned queries?<\/h3>\n\n\n\n<p class=\"wp-block-paragraph\">Athena cannot require a partition filter. The workable control is a per-query bytes-scanned cutoff on the workgroup, which cancels a runaway query before it finishes. Pair it with published CloudWatch metrics so you can see who is hitting it and why.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\">Is it worth moving to Iceberg instead of tuning Hive-style partitions?<\/h3>\n\n\n\n<p class=\"wp-block-paragraph\">If you are rewriting files regularly, handling late-arriving data, or fighting the write-side partition limits, Iceberg removes a lot of that work through hidden partitioning and table maintenance operations. If your table is append-only, time-partitioned and stable, Hive-style partitioning with projection is simpler and there is no prize for migrating.<\/p>\n\n\n\n<h2 class=\"wp-block-heading\">The one thing worth remembering<\/h2>\n\n\n\n<p class=\"wp-block-paragraph\">Athena partitioning is not a property of your S3 layout. It is a property of the interaction between your layout, your catalog, and the exact text of your queries, and all three have to cooperate before a single byte is saved. A perfect prefix structure with a predicate the planner cannot evaluate reads the whole table. A perfect predicate against half a million tiny objects reads them all one GET at a time.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">So measure the thing that tells the truth. Bytes scanned should fall roughly in proportion to how much you narrow the filter. When it does not, one of the three reductions has stopped firing, and now you know which questions to ask to find out which one.<\/p>\n\n\n\n<hr class=\"wp-block-separator has-alpha-channel-opacity\"\/>\n\n\n\n<h2 class=\"wp-block-heading\">Need a second pair of eyes on your Athena tables?<\/h2>\n\n\n\n<p class=\"wp-block-paragraph\">Most of the work here is diagnosis rather than construction. Things I help with:<\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li>Auditing a slow or expensive Athena workload and identifying whether the cost is pruning, planning, or file layout.<\/li>\n\n<li>Designing a partition scheme from your actual query patterns and daily volumes, including whether to bucket or sort instead.<\/li>\n\n<li>Migrating tables to partition projection or Glue partition indexes without breaking the other engines reading the same lake.<\/li>\n\n<li>Building compaction jobs for streaming ingestion that respect the write-side partition limits and do not duplicate data mid-run.<\/li>\n\n<li>Rewriting orchestrated queries so dynamic partition values resolve to literals and actually prune.<\/li>\n\n<li>Setting up workgroup guardrails and bytes-scanned monitoring so the next regression shows up on a dashboard rather than an invoice.<\/li>\n<\/ul>\n\n\n\n<p class=\"wp-block-paragraph\">If you send me your table DDL and the <code>EXPLAIN<\/code> output for one slow query, I can usually tell you which of the three failure families you are in before we talk about anything else.<\/p>\n\n\n\n<div class=\"wp-block-buttons is-layout-flex wp-block-buttons-is-layout-flex\">\n<div class=\"wp-block-button\"><a class=\"wp-block-button__link wp-element-button\" href=\"https:\/\/www.upwork.com\/freelancers\/~01f15a912ad84a6620\" target=\"_blank\" rel=\"noreferrer noopener\">Work with me on Upwork<\/a><\/div>\n<\/div>\n","protected":false},"excerpt":{"rendered":"<p>Partitioning an Athena table is not the same as getting the benefit of it. A walkthrough of the three failure families behind slow queries on partitioned external data: predicates that never prune, catalog lookups that dominate planning, and file layouts that undo everything. Includes partition projection trade-offs, Glue partition indexes, compaction patterns, and how to tell which problem you have.<\/p>\n","protected":false},"author":1,"featured_media":1216,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[25,498,52],"tags":[163,161,164,162,518,187,580,160,489,433,206,522,581,579],"class_list":["post-399","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-cloud-computing","category-data-engineering","category-technical-guides","tag-amazon-athena","tag-amazon-s3","tag-apache-iceberg","tag-aws-glue","tag-columnar-storage","tag-cost-optimization","tag-ctas","tag-data-lake","tag-data-partitioning","tag-parquet","tag-partition-projection","tag-predicate-pushdown","tag-query-performance","tag-small-files","entry","has-media"],"yoast_head":"<!-- This site is optimized with the Yoast SEO plugin v28.8 - https:\/\/yoast.com\/product\/yoast-seo-wordpress\/ -->\n<title>Athena Partitioning: Fix Slow, Costly Queries<\/title>\n<meta name=\"description\" content=\"Athena partitioning that actually works: why partition pruning silently fails, when projection helps, and how to fix small files in your S3 data lake.\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/john-nessime.com\/blog\/technical-guides\/athena-partitioning-performance\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Athena Partitioning: Fix Slow, Costly Queries\" \/>\n<meta property=\"og:description\" content=\"Athena partitioning that actually works: why partition pruning silently fails, when projection helps, and how to fix small files in your S3 data lake.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/john-nessime.com\/blog\/technical-guides\/athena-partitioning-performance\/\" \/>\n<meta property=\"og:site_name\" content=\"John Nessime\" \/>\n<meta property=\"article:publisher\" content=\"https:\/\/www.facebook.com\/J.Nessime\" \/>\n<meta property=\"article:author\" content=\"https:\/\/www.facebook.com\/J.Nessime\" \/>\n<meta property=\"article:published_time\" content=\"2026-11-05T07:01:44+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/john-nessime.com\/blog\/wp-content\/uploads\/2026\/09\/athena-partitioning-slow-queries.png\" \/>\n\t<meta property=\"og:image:width\" content=\"1536\" \/>\n\t<meta property=\"og:image:height\" content=\"1024\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/png\" \/>\n<meta name=\"author\" content=\"John Nessime\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"John Nessime\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"17 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\\\/\\\/john-nessime.com\\\/blog\\\/technical-guides\\\/athena-partitioning-performance\\\/#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/john-nessime.com\\\/blog\\\/technical-guides\\\/athena-partitioning-performance\\\/\"},\"author\":{\"name\":\"John Nessime\",\"@id\":\"https:\\\/\\\/john-nessime.com\\\/blog\\\/#\\\/schema\\\/person\\\/ede0b56d0c808f123f57d5d796902105\"},\"headline\":\"Athena Partitioning: Why Your Queries Are Still Slow\",\"datePublished\":\"2026-11-05T07:01:44+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/john-nessime.com\\\/blog\\\/technical-guides\\\/athena-partitioning-performance\\\/\"},\"wordCount\":3784,\"publisher\":{\"@id\":\"https:\\\/\\\/john-nessime.com\\\/blog\\\/#\\\/schema\\\/person\\\/ede0b56d0c808f123f57d5d796902105\"},\"image\":{\"@id\":\"https:\\\/\\\/john-nessime.com\\\/blog\\\/technical-guides\\\/athena-partitioning-performance\\\/#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/john-nessime.com\\\/blog\\\/wp-content\\\/uploads\\\/2026\\\/09\\\/athena-partitioning-slow-queries.png\",\"keywords\":[\"Amazon Athena\",\"Amazon S3\",\"Apache Iceberg\",\"AWS Glue\",\"Columnar Storage\",\"Cost Optimization\",\"CTAS\",\"Data Lake\",\"Data Partitioning\",\"Parquet\",\"Partition Projection\",\"Predicate Pushdown\",\"Query Performance\",\"Small Files\"],\"articleSection\":[\"Cloud Computing\",\"Data Engineering\",\"Technical Guides\"],\"inLanguage\":\"en-US\"},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/john-nessime.com\\\/blog\\\/technical-guides\\\/athena-partitioning-performance\\\/\",\"url\":\"https:\\\/\\\/john-nessime.com\\\/blog\\\/technical-guides\\\/athena-partitioning-performance\\\/\",\"name\":\"Athena Partitioning: Fix Slow, Costly Queries\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/john-nessime.com\\\/blog\\\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\\\/\\\/john-nessime.com\\\/blog\\\/technical-guides\\\/athena-partitioning-performance\\\/#primaryimage\"},\"image\":{\"@id\":\"https:\\\/\\\/john-nessime.com\\\/blog\\\/technical-guides\\\/athena-partitioning-performance\\\/#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/john-nessime.com\\\/blog\\\/wp-content\\\/uploads\\\/2026\\\/09\\\/athena-partitioning-slow-queries.png\",\"datePublished\":\"2026-11-05T07:01:44+00:00\",\"description\":\"Athena partitioning that actually works: why partition pruning silently fails, when projection helps, and how to fix small files in your S3 data lake.\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/john-nessime.com\\\/blog\\\/technical-guides\\\/athena-partitioning-performance\\\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/john-nessime.com\\\/blog\\\/technical-guides\\\/athena-partitioning-performance\\\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/john-nessime.com\\\/blog\\\/technical-guides\\\/athena-partitioning-performance\\\/#primaryimage\",\"url\":\"https:\\\/\\\/john-nessime.com\\\/blog\\\/wp-content\\\/uploads\\\/2026\\\/09\\\/athena-partitioning-slow-queries.png\",\"contentUrl\":\"https:\\\/\\\/john-nessime.com\\\/blog\\\/wp-content\\\/uploads\\\/2026\\\/09\\\/athena-partitioning-slow-queries.png\",\"width\":1536,\"height\":1024,\"caption\":\"Amazon Athena partitioning illustration showing S3 partitions, AWS Glue metadata, successful partition pruning, and inefficient full-table scanning.\"},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/john-nessime.com\\\/blog\\\/technical-guides\\\/athena-partitioning-performance\\\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\\\/\\\/john-nessime.com\\\/blog\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Athena Partitioning: Why Your Queries Are Still Slow\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/john-nessime.com\\\/blog\\\/#website\",\"url\":\"https:\\\/\\\/john-nessime.com\\\/blog\\\/\",\"name\":\"John Nessime\",\"description\":\"Cloud, DevOps, Data &amp; AI \u2014 Built, Tested, Explained\",\"publisher\":{\"@id\":\"https:\\\/\\\/john-nessime.com\\\/blog\\\/#\\\/schema\\\/person\\\/ede0b56d0c808f123f57d5d796902105\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/john-nessime.com\\\/blog\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"en-US\"},{\"@type\":[\"Person\",\"Organization\"],\"@id\":\"https:\\\/\\\/john-nessime.com\\\/blog\\\/#\\\/schema\\\/person\\\/ede0b56d0c808f123f57d5d796902105\",\"name\":\"John Nessime\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/john-nessime.com\\\/blog\\\/wp-content\\\/uploads\\\/2026\\\/07\\\/cropped-jn.png\",\"url\":\"https:\\\/\\\/john-nessime.com\\\/blog\\\/wp-content\\\/uploads\\\/2026\\\/07\\\/cropped-jn.png\",\"contentUrl\":\"https:\\\/\\\/john-nessime.com\\\/blog\\\/wp-content\\\/uploads\\\/2026\\\/07\\\/cropped-jn.png\",\"width\":512,\"height\":512,\"caption\":\"John Nessime\"},\"logo\":{\"@id\":\"https:\\\/\\\/john-nessime.com\\\/blog\\\/wp-content\\\/uploads\\\/2026\\\/07\\\/cropped-jn.png\"},\"description\":\"AWS Certified Solutions Architect helping businesses build reliable cloud, data, reporting, and automation solutions. I help startups, agencies, and growing businesses replace manual processes and disconnected data with practical AWS architectures, clean data pipelines, useful dashboards, and maintainable automation.\",\"sameAs\":[\"https:\\\/\\\/john-nessime.com\\\/blog\",\"https:\\\/\\\/www.facebook.com\\\/J.Nessime\",\"https:\\\/\\\/www.linkedin.com\\\/in\\\/john-m-nessime\"],\"url\":\"https:\\\/\\\/john-nessime.com\\\/blog\\\/author\\\/johnnessime\\\/\"}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Athena Partitioning: Fix Slow, Costly Queries","description":"Athena partitioning that actually works: why partition pruning silently fails, when projection helps, and how to fix small files in your S3 data lake.","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/john-nessime.com\/blog\/technical-guides\/athena-partitioning-performance\/","og_locale":"en_US","og_type":"article","og_title":"Athena Partitioning: Fix Slow, Costly Queries","og_description":"Athena partitioning that actually works: why partition pruning silently fails, when projection helps, and how to fix small files in your S3 data lake.","og_url":"https:\/\/john-nessime.com\/blog\/technical-guides\/athena-partitioning-performance\/","og_site_name":"John Nessime","article_publisher":"https:\/\/www.facebook.com\/J.Nessime","article_author":"https:\/\/www.facebook.com\/J.Nessime","article_published_time":"2026-11-05T07:01:44+00:00","og_image":[{"width":1536,"height":1024,"url":"https:\/\/john-nessime.com\/blog\/wp-content\/uploads\/2026\/09\/athena-partitioning-slow-queries.png","type":"image\/png"}],"author":"John Nessime","twitter_card":"summary_large_image","twitter_misc":{"Written by":"John Nessime","Est. reading time":"17 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/john-nessime.com\/blog\/technical-guides\/athena-partitioning-performance\/#article","isPartOf":{"@id":"https:\/\/john-nessime.com\/blog\/technical-guides\/athena-partitioning-performance\/"},"author":{"name":"John Nessime","@id":"https:\/\/john-nessime.com\/blog\/#\/schema\/person\/ede0b56d0c808f123f57d5d796902105"},"headline":"Athena Partitioning: Why Your Queries Are Still Slow","datePublished":"2026-11-05T07:01:44+00:00","mainEntityOfPage":{"@id":"https:\/\/john-nessime.com\/blog\/technical-guides\/athena-partitioning-performance\/"},"wordCount":3784,"publisher":{"@id":"https:\/\/john-nessime.com\/blog\/#\/schema\/person\/ede0b56d0c808f123f57d5d796902105"},"image":{"@id":"https:\/\/john-nessime.com\/blog\/technical-guides\/athena-partitioning-performance\/#primaryimage"},"thumbnailUrl":"https:\/\/john-nessime.com\/blog\/wp-content\/uploads\/2026\/09\/athena-partitioning-slow-queries.png","keywords":["Amazon Athena","Amazon S3","Apache Iceberg","AWS Glue","Columnar Storage","Cost Optimization","CTAS","Data Lake","Data Partitioning","Parquet","Partition Projection","Predicate Pushdown","Query Performance","Small Files"],"articleSection":["Cloud Computing","Data Engineering","Technical Guides"],"inLanguage":"en-US"},{"@type":"WebPage","@id":"https:\/\/john-nessime.com\/blog\/technical-guides\/athena-partitioning-performance\/","url":"https:\/\/john-nessime.com\/blog\/technical-guides\/athena-partitioning-performance\/","name":"Athena Partitioning: Fix Slow, Costly Queries","isPartOf":{"@id":"https:\/\/john-nessime.com\/blog\/#website"},"primaryImageOfPage":{"@id":"https:\/\/john-nessime.com\/blog\/technical-guides\/athena-partitioning-performance\/#primaryimage"},"image":{"@id":"https:\/\/john-nessime.com\/blog\/technical-guides\/athena-partitioning-performance\/#primaryimage"},"thumbnailUrl":"https:\/\/john-nessime.com\/blog\/wp-content\/uploads\/2026\/09\/athena-partitioning-slow-queries.png","datePublished":"2026-11-05T07:01:44+00:00","description":"Athena partitioning that actually works: why partition pruning silently fails, when projection helps, and how to fix small files in your S3 data lake.","breadcrumb":{"@id":"https:\/\/john-nessime.com\/blog\/technical-guides\/athena-partitioning-performance\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/john-nessime.com\/blog\/technical-guides\/athena-partitioning-performance\/"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/john-nessime.com\/blog\/technical-guides\/athena-partitioning-performance\/#primaryimage","url":"https:\/\/john-nessime.com\/blog\/wp-content\/uploads\/2026\/09\/athena-partitioning-slow-queries.png","contentUrl":"https:\/\/john-nessime.com\/blog\/wp-content\/uploads\/2026\/09\/athena-partitioning-slow-queries.png","width":1536,"height":1024,"caption":"Amazon Athena partitioning illustration showing S3 partitions, AWS Glue metadata, successful partition pruning, and inefficient full-table scanning."},{"@type":"BreadcrumbList","@id":"https:\/\/john-nessime.com\/blog\/technical-guides\/athena-partitioning-performance\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/john-nessime.com\/blog\/"},{"@type":"ListItem","position":2,"name":"Athena Partitioning: Why Your Queries Are Still Slow"}]},{"@type":"WebSite","@id":"https:\/\/john-nessime.com\/blog\/#website","url":"https:\/\/john-nessime.com\/blog\/","name":"John Nessime","description":"Cloud, DevOps, Data &amp; AI \u2014 Built, Tested, Explained","publisher":{"@id":"https:\/\/john-nessime.com\/blog\/#\/schema\/person\/ede0b56d0c808f123f57d5d796902105"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/john-nessime.com\/blog\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":["Person","Organization"],"@id":"https:\/\/john-nessime.com\/blog\/#\/schema\/person\/ede0b56d0c808f123f57d5d796902105","name":"John Nessime","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/john-nessime.com\/blog\/wp-content\/uploads\/2026\/07\/cropped-jn.png","url":"https:\/\/john-nessime.com\/blog\/wp-content\/uploads\/2026\/07\/cropped-jn.png","contentUrl":"https:\/\/john-nessime.com\/blog\/wp-content\/uploads\/2026\/07\/cropped-jn.png","width":512,"height":512,"caption":"John Nessime"},"logo":{"@id":"https:\/\/john-nessime.com\/blog\/wp-content\/uploads\/2026\/07\/cropped-jn.png"},"description":"AWS Certified Solutions Architect helping businesses build reliable cloud, data, reporting, and automation solutions. I help startups, agencies, and growing businesses replace manual processes and disconnected data with practical AWS architectures, clean data pipelines, useful dashboards, and maintainable automation.","sameAs":["https:\/\/john-nessime.com\/blog","https:\/\/www.facebook.com\/J.Nessime","https:\/\/www.linkedin.com\/in\/john-m-nessime"],"url":"https:\/\/john-nessime.com\/blog\/author\/johnnessime\/"}]}},"_links":{"self":[{"href":"https:\/\/john-nessime.com\/blog\/wp-json\/wp\/v2\/posts\/399","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/john-nessime.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/john-nessime.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/john-nessime.com\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/john-nessime.com\/blog\/wp-json\/wp\/v2\/comments?post=399"}],"version-history":[{"count":1,"href":"https:\/\/john-nessime.com\/blog\/wp-json\/wp\/v2\/posts\/399\/revisions"}],"predecessor-version":[{"id":421,"href":"https:\/\/john-nessime.com\/blog\/wp-json\/wp\/v2\/posts\/399\/revisions\/421"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/john-nessime.com\/blog\/wp-json\/wp\/v2\/media\/1216"}],"wp:attachment":[{"href":"https:\/\/john-nessime.com\/blog\/wp-json\/wp\/v2\/media?parent=399"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/john-nessime.com\/blog\/wp-json\/wp\/v2\/categories?post=399"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/john-nessime.com\/blog\/wp-json\/wp\/v2\/tags?post=399"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}