<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    <title>hoolco: reports and guides</title>
    <link>https://hool.co</link>
    <atom:link href="https://hool.co/feed.xml" rel="self" type="application/rss+xml" />
    <description>AWS benchmarks measured in AWS, practical guides with primary sources, and what changed at the vendors engineers build on.</description>
    <language>en-us</language>
    <lastBuildDate>Thu, 12 Nov 2026 12:00:00 GMT</lastBuildDate>
    <item>
      <title>Microsoft 365 Outage, November 12, 2026: What Is Down, What Microsoft Has Said, and What to Do</title>
      <link>https://hool.co/reports/microsoft-365-outage-november-12-2026-exchange-online-teams</link>
      <guid isPermaLink="true">https://hool.co/reports/microsoft-365-outage-november-12-2026-exchange-online-teams</guid>
      <pubDate>Thu, 12 Nov 2026 12:00:00 GMT</pubDate>
      <category>Internet Fundamentals</category>
      <description>Outlook, Exchange Online, Teams, SharePoint, Copilot and Defender XDR went down worldwide on the afternoon of November 12. Microsoft says servers are failing health checks and overloading the rest. What we know, what happens to email sent to you in the meantime, and what to check once it is back.</description>
    </item>
    <item>
      <title>AWS Spend Limits: How the Hard Monthly Cap Works, What Pauses, and Who Can Use It</title>
      <link>https://hool.co/reports/aws-spend-limits-hard-cap-how-it-works-what-pauses</link>
      <guid isPermaLink="true">https://hool.co/reports/aws-spend-limits-hard-cap-how-it-works-what-pauses</guid>
      <pubDate>Mon, 09 Nov 2026 12:00:00 GMT</pubDate>
      <category>Cost Optimization</category>
      <description>AWS now has a hard spending cap. A project in the new AWS experience pauses when it reaches its monthly limit instead of billing past it: every resource stops, S3 included, and data is kept for 90 days. It covers all of the project's charges, egress too, but only for projects created through the new signup experience. Not existing accounts, and not Organizations, yet.</description>
    </item>
    <item>
      <title>AWS Spend Limits vs Budgets, Budget Actions and Cost Anomaly Detection: Which Stops a Runaway Bill</title>
      <link>https://hool.co/guides/aws-spend-limits-vs-budgets-budget-actions-cost-anomaly-detection</link>
      <guid isPermaLink="true">https://hool.co/guides/aws-spend-limits-vs-budgets-budget-actions-cost-anomaly-detection</guid>
      <pubDate>Mon, 09 Nov 2026 12:00:00 GMT</pubDate>
      <category>Cost Optimization</category>
      <description>AWS now has four cost controls that sound alike and behave very differently. Budgets alert, budget actions apply a policy or stop EC2 and RDS instances, Cost Anomaly Detection flags unusual spend, and spend limits pause an entire project at a hard cap. What each one actually stops, how fast, and where each fits.</description>
    </item>
    <item>
      <title>AWS Spend Limits: The Limitations, and What to Do About Each</title>
      <link>https://hool.co/guides/aws-spend-limits-limitations-existing-accounts-organizations-per-resource</link>
      <guid isPermaLink="true">https://hool.co/guides/aws-spend-limits-limitations-existing-accounts-organizations-per-resource</guid>
      <pubDate>Mon, 09 Nov 2026 12:00:00 GMT</pubDate>
      <category>Cost Optimization</category>
      <description>Spend limits only work on projects created through the new AWS signup experience, can't cover an existing account or an organization, can't spare production while stopping the rest, and pause everything at once. Each limitation, what it means in practice, and the workaround until AWS extends the feature.</description>
    </item>
    <item>
      <title>Building Your Own Spend Cap on an Existing AWS Account: Budget Actions, Service Control Policies and Quotas</title>
      <link>https://hool.co/guides/build-your-own-aws-spend-cap-existing-account-budget-actions-scp</link>
      <guid isPermaLink="true">https://hool.co/guides/build-your-own-aws-spend-cap-existing-account-budget-actions-scp</guid>
      <pubDate>Mon, 09 Nov 2026 12:00:00 GMT</pubDate>
      <category>Cost Optimization</category>
      <description>Spend limits don't cover existing AWS accounts yet. You can build most of the same protection today: budget actions that apply a deny policy or stop instances at a threshold, service control policies that keep accounts away from the most expensive services, lower quotas, and anomaly alerts. The setup, in order, and the gaps it leaves.</description>
    </item>
    <item>
      <title>Database Failover Downtime on AWS, Measured: RDS Multi-AZ 13–15 Seconds, Aurora Under 2</title>
      <link>https://hool.co/reports/database-failover-downtime-aws-rds-multi-az-vs-aurora-measured</link>
      <guid isPermaLink="true">https://hool.co/reports/database-failover-downtime-aws-rds-multi-az-vs-aurora-measured</guid>
      <pubDate>Mon, 09 Nov 2026 12:00:00 GMT</pubDate>
      <category>Data Platform</category>
      <description>We wrote to Postgres every 50 ms and forced failovers. RDS Multi-AZ lost writes for 13.0 and 14.8 seconds; in one trial the switch began three minutes after the reboot was requested. Aurora PostgreSQL lost writes for 2.0 and 0.5 seconds, one failed write each time. The full timelines, the errors your application will see, and what to set so it recovers on its own.</description>
    </item>
    <item>
      <title>Aurora Serverless v2, Measured: 14–21 Seconds to Resume From Zero, Two Minutes to Scale to 16 ACUs</title>
      <link>https://hool.co/reports/aurora-serverless-v2-resume-from-zero-and-scaling-measured</link>
      <guid isPermaLink="true">https://hool.co/reports/aurora-serverless-v2-resume-from-zero-and-scaling-measured</guid>
      <pubDate>Mon, 09 Nov 2026 12:00:00 GMT</pubDate>
      <category>Data Platform</category>
      <description>With auto-pause at 0 ACUs, the first query after a pause took 21.4 and 13.6 seconds to answer. Under sustained CPU load, the cluster went from 2 ACUs to its 16-ACU maximum in about two minutes, and tail latency fell from 24 seconds to 5. What that means for scale-to-zero databases behind real users.</description>
    </item>
    <item>
      <title>Lambda Cold Starts With Postgres, RDS Proxy and DynamoDB, Measured: VPC or Not, 200 at Once</title>
      <link>https://hool.co/reports/lambda-cold-starts-postgres-rds-proxy-dynamodb-vpc-measured</link>
      <guid isPermaLink="true">https://hool.co/reports/lambda-cold-starts-postgres-rds-proxy-dynamodb-vpc-measured</guid>
      <pubDate>Mon, 09 Nov 2026 12:00:00 GMT</pubDate>
      <category>Serverless</category>
      <description>Node.js 22 functions on arm64 took 570–650 ms end to end on a cold start, whether they talked to Postgres directly, through RDS Proxy, or to DynamoDB, and a function in a VPC was no slower than one outside it. Bursts of 200 simultaneous cold starts all succeeded. Warm, RDS Proxy added about 3 ms per query.</description>
    </item>
    <item>
      <title>DynamoDB vs Postgres, Measured in AWS: 53 Workloads From the Same Client</title>
      <link>https://hool.co/reports/dynamodb-vs-postgres-measured-in-aws-53-workloads</link>
      <guid isPermaLink="true">https://hool.co/reports/dynamodb-vs-postgres-measured-in-aws-53-workloads</guid>
      <pubDate>Mon, 09 Nov 2026 12:00:00 GMT</pubDate>
      <category>Data Platform</category>
      <description>We ran 53 workloads against RDS Postgres 17 and DynamoDB from one Fargate task in the same Availability Zone, at 100,000, 1 million and 5 million orders. Key lookups took 0.35 ms in Postgres and 2.7 ms in DynamoDB; a two-item transaction 1.75 ms against 20 ms; a question nobody designed for, 0.08–2.7 s against a full table scan. The full results, with the method and every caveat.</description>
    </item>
    <item>
      <title>Ad-Hoc Questions on DynamoDB vs Postgres: 16 Analytics Queries at 100,000, 1 Million and 5 Million Orders</title>
      <link>https://hool.co/reports/ad-hoc-queries-dynamodb-vs-postgres-16-analytics-questions-measured</link>
      <guid isPermaLink="true">https://hool.co/reports/ad-hoc-queries-dynamodb-vs-postgres-16-analytics-questions-measured</guid>
      <pubDate>Mon, 09 Nov 2026 12:00:00 GMT</pubDate>
      <category>Data Platform</category>
      <description>Every question across customers is a full table scan in DynamoDB: 217,000 read units at 5 million orders, whether it returns 10 rows or all of them. Postgres answered the same 16 questions in 0.08 to 2.7 seconds without a single index added for them, and an index built in 2.7 seconds took one from 148 ms to 44 ms. Measured in AWS.</description>
    </item>
    <item>
      <title>Postgres Connection Limits on RDS: What 1,600 Simultaneous Connections Do, With and Without RDS Proxy</title>
      <link>https://hool.co/reports/postgres-connection-limits-rds-1600-connections-with-and-without-rds-proxy</link>
      <guid isPermaLink="true">https://hool.co/reports/postgres-connection-limits-rds-1600-connections-with-and-without-rds-proxy</guid>
      <pubDate>Mon, 09 Nov 2026 12:00:00 GMT</pubDate>
      <category>Data Platform</category>
      <description>db.m7g.large allows 832 connections. When 1,600 clients connected at once, 916 were refused; through RDS Proxy all 1,600 succeeded, with the slowest waiting 12 seconds. The measurements at 100, 400, 800 and 1,600, the errors you'll see, and what a fresh AWS SDK client per request does under the same burst.</description>
    </item>
    <item>
      <title>Concurrent Transactions, Measured: Deadlocks, Lock Order and Conflicts in Postgres and DynamoDB</title>
      <link>https://hool.co/reports/concurrent-transactions-postgres-dynamodb-deadlocks-lock-order-measured</link>
      <guid isPermaLink="true">https://hool.co/reports/concurrent-transactions-postgres-dynamodb-deadlocks-lock-order-measured</guid>
      <pubDate>Mon, 09 Nov 2026 12:00:00 GMT</pubDate>
      <category>Data Platform</category>
      <description>Moving money between 10 accounts with 64 concurrent workers, Postgres committed 5 transfers a second when rows were locked in random order (50 deadlocks, median wait 24 s) and 1,185 a second when locked in a fixed order. DynamoDB committed 228 a second and cancelled 14,344. Also: hot counters, sharding, and serializable isolation.</description>
    </item>
    <item>
      <title>JSONB Performance in Postgres 17, Measured: GIN, jsonb_path_ops, Expression Indexes and Document Size</title>
      <link>https://hool.co/reports/postgres-jsonb-performance-gin-jsonb-path-ops-expression-index-measured</link>
      <guid isPermaLink="true">https://hool.co/reports/postgres-jsonb-performance-gin-jsonb-path-ops-expression-index-measured</guid>
      <pubDate>Mon, 09 Nov 2026 12:00:00 GMT</pubDate>
      <category>Data Platform</category>
      <description>On a million documents, an expression index took a JSONB field lookup from 75 ms to 0.17 ms. On line items, jsonb_path_ops beat the default GIN operator class on every count: 1.3 ms against 4.1 ms per query, a 10% smaller index and a build 2.5 times faster. Plus what 256 KB documents cost to read and update.</description>
    </item>
    <item>
      <title>Postgres as a Job Queue: SKIP LOCKED and LISTEN/NOTIFY Throughput on RDS, Measured</title>
      <link>https://hool.co/reports/postgres-as-a-job-queue-skip-locked-listen-notify-throughput-rds</link>
      <guid isPermaLink="true">https://hool.co/reports/postgres-as-a-job-queue-skip-locked-listen-notify-throughput-rds</guid>
      <pubDate>Mon, 09 Nov 2026 12:00:00 GMT</pubDate>
      <category>Data Platform</category>
      <description>A plain table with FOR UPDATE SKIP LOCKED processed 6,570 jobs a second with 32 workers on a 2-vCPU RDS instance; adding workers past that made it slower. LISTEN/NOTIFY delivered 16,000 notifications a second with a median delivery time of 0.57 ms. When that is enough, and when to reach for SQS.</description>
    </item>
    <item>
      <title>Row-Level Security Performance: A Tenant Policy Turned a 0.3 ms Query Into 58 ms</title>
      <link>https://hool.co/reports/postgres-row-level-security-performance-tenant-policy-measured</link>
      <guid isPermaLink="true">https://hool.co/reports/postgres-row-level-security-performance-tenant-policy-measured</guid>
      <pubDate>Mon, 09 Nov 2026 12:00:00 GMT</pubDate>
      <category>Data Platform</category>
      <description>With a common multi-tenant policy (customer_id = current_setting('app.customer_id')::int), the same &quot;latest 20 orders&quot; query took 58 ms instead of 0.31 ms with an explicit WHERE clause, on a million rows with the right index in place. What we measured, why it happens, and how to write policies that keep their indexes.</description>
    </item>
    <item>
      <title>Postgres Write Performance, Measured: Batch Size, Indexes, Foreign Keys and Prepared Statements</title>
      <link>https://hool.co/reports/postgres-write-performance-batch-size-indexes-foreign-keys-prepared-statements</link>
      <guid isPermaLink="true">https://hool.co/reports/postgres-write-performance-batch-size-indexes-foreign-keys-prepared-statements</guid>
      <pubDate>Mon, 09 Nov 2026 12:00:00 GMT</pubDate>
      <category>Data Platform</category>
      <description>Inserting 20,000 rows one statement at a time ran at 775 rows a second; 1,000 rows per statement ran at 156,789, two hundred times faster on the same connection. Prepared statements nearly doubled read throughput. Each extra index cost about 3–4% of insert throughput, and a foreign key about 8%.</description>
    </item>
    <item>
      <title>Reading Your Own Writes in DynamoDB: A Secondary Index Was Stale 90% of the Time</title>
      <link>https://hool.co/reports/dynamodb-read-your-own-writes-secondary-index-stale-90-percent</link>
      <guid isPermaLink="true">https://hool.co/reports/dynamodb-read-your-own-writes-secondary-index-stale-90-percent</guid>
      <pubDate>Mon, 09 Nov 2026 12:00:00 GMT</pubDate>
      <category>Data Platform</category>
      <description>Right after writing an item, a query on a global secondary index didn't find it in 269 of 300 tries. Secondary indexes are eventually consistent, and &quot;eventually&quot; was longer than one request. What that means for &quot;save, then show the list&quot; screens, what strong consistency costs, and how long adding a new index took.</description>
    </item>
    <item>
      <title>Postgres Pagination, Counting and Bloat, Measured: OFFSET vs Keyset, count(*) and VACUUM</title>
      <link>https://hool.co/reports/postgres-pagination-count-bloat-offset-vs-keyset-vacuum-measured</link>
      <guid isPermaLink="true">https://hool.co/reports/postgres-pagination-count-bloat-offset-vs-keyset-vacuum-measured</guid>
      <pubDate>Mon, 09 Nov 2026 12:00:00 GMT</pubDate>
      <category>Data Platform</category>
      <description>Page 45,000 of a table with OFFSET took 134 ms; the same page by keyset took 0.27 ms. An exact count of a million rows took 103 ms against 0.12 ms for the planner's estimate. Five full-table updates grew a table from 15 MB to 92 MB, and VACUUM didn't give any of it back.</description>
    </item>
    <item>
      <title>Search in Postgres Without Elasticsearch: Full-Text, Trigram and ILIKE, Measured</title>
      <link>https://hool.co/reports/postgres-search-without-elasticsearch-full-text-trigram-ilike-measured</link>
      <guid isPermaLink="true">https://hool.co/reports/postgres-search-without-elasticsearch-full-text-trigram-ilike-measured</guid>
      <pubDate>Mon, 09 Nov 2026 12:00:00 GMT</pubDate>
      <category>Data Platform</category>
      <description>A trigram index took an address search on 5 million rows from 2.7 s to 95 ms. On a million documents of common words, the same kind of index made a phrase search slower than no index at all (1.8 s against 1.2 s), while full-text search answered in 263 ms. When each one works, with build times and sizes.</description>
    </item>
    <item>
      <title>pgvector on RDS, Measured: HNSW and IVFFlat Build Times and Latency on 50,000 Vectors</title>
      <link>https://hool.co/reports/pgvector-on-rds-hnsw-ivfflat-build-time-latency-measured</link>
      <guid isPermaLink="true">https://hool.co/reports/pgvector-on-rds-hnsw-ivfflat-build-time-latency-measured</guid>
      <pubDate>Mon, 09 Nov 2026 12:00:00 GMT</pubDate>
      <category>AI Engineering</category>
      <description>On 50,000 vectors of 768 dimensions on a 2-vCPU RDS instance, an exact nearest-neighbour search took 133 ms. HNSW cut it to 1.9 ms after a 47-second build; IVFFlat to 1.8 ms after 2.4 seconds. What recall looked like, why our numbers are a floor, and how to size this for real embeddings.</description>
    </item>
    <item>
      <title>The Noisy Neighbour, Measured: Key Lookups in Postgres and DynamoDB While a Report Runs</title>
      <link>https://hool.co/reports/noisy-neighbour-postgres-dynamodb-key-lookups-during-reports-and-spikes</link>
      <guid isPermaLink="true">https://hool.co/reports/noisy-neighbour-postgres-dynamodb-key-lookups-during-reports-and-spikes</guid>
      <pubDate>Mon, 09 Nov 2026 12:00:00 GMT</pubDate>
      <category>Data Platform</category>
      <description>Key lookups in Postgres went from 0.16 ms to 9.75 ms, about 60 times slower, while four reporting queries ran on the same 2-vCPU instance. In DynamoDB, lookups stayed at 2.5 ms during a parallel scan of the same table. And what a jump from 10 to 1,000 concurrent clients did to each.</description>
    </item>
    <item>
      <title>What MCP Is: Hosts, Clients, Servers, Tools, and How Sign-In Works</title>
      <link>https://hool.co/guides/what-is-mcp-model-context-protocol-servers-clients-tools-authorization</link>
      <guid isPermaLink="true">https://hool.co/guides/what-is-mcp-model-context-protocol-servers-clients-tools-authorization</guid>
      <pubDate>Mon, 09 Nov 2026 12:00:00 GMT</pubDate>
      <category>AI Engineering</category>
      <description>MCP (the Model Context Protocol) is the standard way an AI application connects to tools and data: Claude, ChatGPT, Cursor and VS Code speak it, and any company can publish a server. MCP explained in plain terms: the parts, what a server exposes, the two transports, how authorization works since the 2026 spec, where the security risks are, and when building a server is worth it.</description>
    </item>
    <item>
      <title>Dev and Test Environments Idle Overnight: How Small Teams Stop Paying for EC2 and RDS Nobody Uses</title>
      <link>https://hool.co/guides/idle-dev-test-ec2-rds-overnight-schedules-and-savings</link>
      <guid isPermaLink="true">https://hool.co/guides/idle-dev-test-ec2-rds-overnight-schedules-and-savings</guid>
      <pubDate>Mon, 09 Nov 2026 12:00:00 GMT</pubDate>
      <category>Cost Optimization</category>
      <description>A dev environment used 12 hours on weekdays sits idle 64% of the week. Scheduling it off saves most of its compute bill, but some charges keep running and RDS restarts itself after seven days. What to schedule, with which AWS tool, what still costs money when everything is stopped, and the settings that keep it from annoying the people who work late.</description>
    </item>
    <item>
      <title>AWS Account Suspended or Closed Without Warning: Why It Happens and How to Keep Production Running</title>
      <link>https://hool.co/guides/aws-account-suspended-or-closed-without-warning-how-to-protect-production</link>
      <guid isPermaLink="true">https://hool.co/guides/aws-account-suspended-or-closed-without-warning-how-to-protect-production</guid>
      <pubDate>Mon, 09 Nov 2026 12:00:00 GMT</pubDate>
      <category>AWS Architecture</category>
      <description>A suspended or closed AWS account takes every workload in it offline at once, and recovery runs through support cases, not engineering. The usual causes (failed payments, a compromised account, abuse reports, unanswered verification requests), how reopening works within 90 days of closure, and the setup that keeps production recoverable when it happens to you.</description>
    </item>
    <item>
      <title>DynamoDB Bulk Put Items: Loading S3 Files Into Existing Tables, and When to Use It</title>
      <link>https://hool.co/reports/dynamodb-bulk-put-items-load-s3-into-existing-tables</link>
      <guid isPermaLink="true">https://hool.co/reports/dynamodb-bulk-put-items-load-s3-into-existing-tables</guid>
      <pubDate>Mon, 09 Nov 2026 12:00:00 GMT</pubDate>
      <category>Data Platform</category>
      <description>Since November 5, 2026, DynamoDB can write data from files in S3 into a table that already exists, with a condition per item, billed by the gigabyte written rather than by write requests. How it compares with Import from S3 (new tables only) and with BatchWriteItem from your own code, what AWS has and hasn't said about capacity, and what to test before a production backfill.</description>
    </item>
    <item>
      <title>Cognito vs Better Auth in 2026: Cost, Control, and Sign-In for AI Agents</title>
      <link>https://hool.co/guides/cognito-vs-better-auth-2026-ai-agents-mcp-cost</link>
      <guid isPermaLink="true">https://hool.co/guides/cognito-vs-better-auth-2026-ai-agents-mcp-cost</guid>
      <pubDate>Mon, 09 Nov 2026 12:00:00 GMT</pubDate>
      <category>Security</category>
      <description>Amazon Cognito is a managed service billed per monthly active user; Better Auth is an open-source TypeScript library that keeps users in your own database. AI changed the comparison in two ways: coding agents now write most of the integration code, and your users increasingly connect AI agents and MCP clients to your product. Prices, what each supports for agents, and how to choose.</description>
    </item>
    <item>
      <title>Lambda Web Functions vs Event Functions: Where the New Model Saves Money, and Where It Doesn't</title>
      <link>https://hool.co/guides/lambda-web-functions-vs-event-functions-cost-when-it-saves-money</link>
      <guid isPermaLink="true">https://hool.co/guides/lambda-web-functions-vs-event-functions-cost-when-it-saves-money</guid>
      <pubDate>Mon, 09 Nov 2026 12:00:00 GMT</pubDate>
      <category>Serverless</category>
      <description>Web Functions bill active CPU and held memory; Event Functions bill wall-clock time multiplied by memory. For AWS's own three example workloads, classic Lambda at 512 MB is cheaper. Once requests spend seconds waiting (LLM streaming, slow APIs, long polls) Web Functions win by 40 times or more: a 10-second stream costs about $3 per million requests instead of $134. The arithmetic, the crossover and a checklist.</description>
    </item>
    <item>
      <title>AWS Business Support+: What It Covers, Where Teams Find It Falls Short, and the Alternatives</title>
      <link>https://hool.co/guides/aws-business-support-plus-what-it-covers-and-alternatives</link>
      <guid isPermaLink="true">https://hool.co/guides/aws-business-support-plus-what-it-covers-and-alternatives</guid>
      <pubDate>Sat, 07 Nov 2026 12:00:00 GMT</pubDate>
      <category>AWS Architecture</category>
      <description>AWS Support now comes as Business Support+ (from $29 a month or a share of your bill), Enterprise (from $5,000 a month) and Unified Operations (from $50,000). What each buys, the common complaints (generic answers, no knowledge of your architecture, nobody to change your code), and when a named engineer on retainer, a partner, or a higher AWS tier is the better fix.</description>
    </item>
    <item>
      <title>Amazon Pinpoint Stopped Working After October 30, 2026: What Broke and What to Do Today</title>
      <link>https://hool.co/reports/pinpoint-stopped-working-after-october-30-2026-what-broke-and-what-to-do</link>
      <guid isPermaLink="true">https://hool.co/reports/pinpoint-stopped-working-after-october-30-2026-what-broke-and-what-to-do</guid>
      <pubDate>Sat, 07 Nov 2026 12:00:00 GMT</pubDate>
      <category>AWS News</category>
      <description>Pinpoint's engagement features (campaigns, journeys, segments and the analytics behind them) reached end of support on October 30, 2026. If messages stopped going out, a dashboard went flat or your app's analytics calls started failing, this is the triage: how to find every place you used Pinpoint, what still works under AWS End User Messaging, and what to put in place today, this week and this month.</description>
    </item>
    <item>
      <title>Rehost, Replatform, Refactor, Rebuild: The Migration Strategies, With How to Choose</title>
      <link>https://hool.co/guides/rehost-replatform-refactor-rebuild-migration-strategies-explained</link>
      <guid isPermaLink="true">https://hool.co/guides/rehost-replatform-refactor-rebuild-migration-strategies-explained</guid>
      <pubDate>Sat, 07 Nov 2026 12:00:00 GMT</pubDate>
      <category>Migration</category>
      <description>AWS lists seven migration strategies (retire, retain, rehost, relocate, repurchase, replatform, refactor) and Gartner's older five include rebuild. What each means, what it costs in effort and risk, the AWS tools for each, and how to pick per application rather than for a whole estate.</description>
    </item>
    <item>
      <title>DynamoDB vs Postgres, Measured: One Orders Dataset, Seven Questions, Three Sizes</title>
      <link>https://hool.co/reports/dynamodb-vs-postgres-benchmark-2026-one-dataset-seven-questions</link>
      <guid isPermaLink="true">https://hool.co/reports/dynamodb-vs-postgres-benchmark-2026-one-dataset-seven-questions</guid>
      <pubDate>Wed, 04 Nov 2026 12:00:00 GMT</pubDate>
      <category>Data Platform</category>
      <description>We loaded the same orders into Postgres 17 and DynamoDB and asked seven questions at 100,000, 1 million and 5 million orders. Lookups by key stayed under 2 ms in Postgres at every size and cost half a read unit in DynamoDB. Every question across customers needed a full Scan in DynamoDB (about 40,000 read units per million orders), and took 0.02 to 1.6 seconds in Postgres. The numbers, and what they mean for choosing.</description>
    </item>
    <item>
      <title>When Postgres Outperforms DynamoDB: Five Situations, With Measurements</title>
      <link>https://hool.co/guides/when-postgres-outperforms-dynamodb-ad-hoc-queries-joins-changing-access-patterns</link>
      <guid isPermaLink="true">https://hool.co/guides/when-postgres-outperforms-dynamodb-ad-hoc-queries-joins-changing-access-patterns</guid>
      <pubDate>Wed, 04 Nov 2026 12:00:00 GMT</pubDate>
      <category>Data Platform</category>
      <description>DynamoDB is excellent at the questions you designed it for. Postgres wins when the questions change: ad-hoc reports, joins, aggregates, filters on any column, and access patterns discovered after launch. Our benchmark: an unplanned query at 5 million orders took 1.2 s in Postgres and 50 ms after a 2-second index build; in DynamoDB it was a full Scan or a new index backfilled across every item.</description>
    </item>
    <item>
      <title>Using DynamoDB Well: A Worked Single-Table Design, From Access Patterns to Keys</title>
      <link>https://hool.co/guides/dynamodb-single-table-design-worked-example-access-patterns-keys-indexes</link>
      <guid isPermaLink="true">https://hool.co/guides/dynamodb-single-table-design-worked-example-access-patterns-keys-indexes</guid>
      <pubDate>Wed, 04 Nov 2026 12:00:00 GMT</pubDate>
      <category>Data Platform</category>
      <description>DynamoDB rewards designing from the questions backwards. A worked example for orders and customers: the access-pattern table, the keys and items, one overloaded secondary index, a sparse index for open orders, and how item size sets the bill (a 4.1 KB item costs twice as much to read as a 4.0 KB one).</description>
    </item>
    <item>
      <title>What a DynamoDB Scan Costs: The Dashboard That Refreshes Every Five Minutes</title>
      <link>https://hool.co/guides/dynamodb-scan-cost-dashboard-every-five-minutes-and-alternatives</link>
      <guid isPermaLink="true">https://hool.co/guides/dynamodb-scan-cost-dashboard-every-five-minutes-and-alternatives</guid>
      <pubDate>Wed, 04 Nov 2026 12:00:00 GMT</pubDate>
      <category>Data Platform</category>
      <description>A Scan of a million 327-byte orders reads about 40,000 request units, half a cent. Run it every five minutes for a dashboard and it is $43 a month; at 100 million orders, $4,337. The arithmetic from measured item sizes, and the four alternatives: Stream-fed aggregates, exports to S3 with Athena, zero-ETL to an analytics store, or Postgres.</description>
    </item>
    <item>
      <title>DynamoDB Hot Partitions: How Many Requests One Key Can Take, by Item Size</title>
      <link>https://hool.co/guides/dynamodb-hot-partitions-per-key-limits-by-item-size</link>
      <guid isPermaLink="true">https://hool.co/guides/dynamodb-hot-partitions-per-key-limits-by-item-size</guid>
      <pubDate>Wed, 04 Nov 2026 12:00:00 GMT</pubDate>
      <category>Data Platform</category>
      <description>Each DynamoDB partition serves up to 3,000 read units and 1,000 write units a second, whatever the table's capacity. One key with 20 KB items tops out at 1,200 eventually consistent reads or 50 writes a second. The limits by item size as a chart, how to spot a hot key, and write sharding when one key really is that busy.</description>
    </item>
    <item>
      <title>DynamoDB vs Aurora Postgres Cost by Traffic: Where Each One Is Cheaper</title>
      <link>https://hool.co/guides/dynamodb-vs-aurora-postgres-cost-by-traffic-where-each-is-cheaper</link>
      <guid isPermaLink="true">https://hool.co/guides/dynamodb-vs-aurora-postgres-cost-by-traffic-where-each-is-cheaper</guid>
      <pubDate>Wed, 04 Nov 2026 12:00:00 GMT</pubDate>
      <category>Data Platform</category>
      <description>For a typical app workload (80% small reads, 20% writes, one secondary index), DynamoDB on-demand costs about $0.30 per million requests: $3 a month at 10 million, $300 at a billion. Aurora Serverless v2 bills for capacity whether or not requests arrive: $43.80 a month at its 0.5 ACU floor, $175 at 2 ACUs. A chart of where the lines cross, and npm data on which way teams are going.</description>
    </item>
    <item>
      <title>Amplify's Share of Backend SDK Downloads Fell From 21% to 3.5% in Two Years</title>
      <link>https://hool.co/reports/amplify-npm-downloads-2026-share-of-backend-sdks-fell-to-3-5-percent</link>
      <guid isPermaLink="true">https://hool.co/reports/amplify-npm-downloads-2026-share-of-backend-sdks-fell-to-3-5-percent</guid>
      <pubDate>Wed, 04 Nov 2026 12:00:00 GMT</pubDate>
      <category>AWS Amplify</category>
      <description>Among the three backend-as-a-service SDKs (aws-amplify, firebase and supabase-js), Amplify went from 21.4% of monthly npm downloads in November 2024 to 3.5% in October 2026, while Supabase went from 15% to 75%. Inside Amplify, the Gen 1 CLI is still downloaded more than twice as often as the Gen 2 backend package. The data, and what it does and doesn't tell you.</description>
    </item>
    <item>
      <title>What an Amplify Gen 2 App Actually Deploys, and the Same App Without Amplify</title>
      <link>https://hool.co/guides/what-amplify-gen-2-deploys-architecture-diagram-and-the-same-app-without-amplify</link>
      <guid isPermaLink="true">https://hool.co/guides/what-amplify-gen-2-deploys-architecture-diagram-and-the-same-app-without-amplify</guid>
      <pubDate>Wed, 04 Nov 2026 12:00:00 GMT</pubDate>
      <category>AWS Amplify</category>
      <description>Behind a few TypeScript files, an Amplify Gen 2 backend is Cognito, AppSync, a DynamoDB table per model, Lambda functions, S3 and nested CloudFormation stacks. Two diagrams: what Amplify creates, and the same app built directly, with a table of each piece, what replaces it, and how hard the move is.</description>
    </item>
    <item>
      <title>One Screen, 241 DynamoDB Requests: How Nested GraphQL Queries Fan Out on AppSync</title>
      <link>https://hool.co/guides/nested-graphql-queries-appsync-amplify-dynamodb-requests-per-screen</link>
      <guid isPermaLink="true">https://hool.co/guides/nested-graphql-queries-appsync-amplify-dynamodb-requests-per-screen</guid>
      <pubDate>Wed, 04 Nov 2026 12:00:00 GMT</pubDate>
      <category>AWS Amplify</category>
      <description>A feed of 20 posts, each with its author and 10 comments with their authors, is one GraphQL query and 241 DynamoDB requests when each relationship resolver fetches per parent. The arithmetic by page size and nesting depth, what it costs per million screen views, and four ways to cut it, from batching to a single Postgres join.</description>
    </item>
    <item>
      <title>GraphQL vs tRPC by the Numbers, and When GraphQL Earns Its Keep</title>
      <link>https://hool.co/reports/graphql-vs-trpc-npm-downloads-2026-and-when-graphql-earns-its-keep</link>
      <guid isPermaLink="true">https://hool.co/reports/graphql-vs-trpc-npm-downloads-2026-and-when-graphql-earns-its-keep</guid>
      <pubDate>Wed, 04 Nov 2026 12:00:00 GMT</pubDate>
      <category>AWS Architecture</category>
      <description>Over two years, @trpc/server went from 4.6% of graphql's npm downloads to 10.2%, growing 8.2 times against graphql's 3.5, while @apollo/client grew 1.8 times. What the trend says about how teams build APIs now, and the cases where GraphQL is still the right call.</description>
    </item>
    <item>
      <title>WebSockets on Vercel Functions Are Generally Available: The Limits, the Bill, and What You Still Build</title>
      <link>https://hool.co/reports/vercel-functions-websockets-generally-available-limits-and-cost</link>
      <guid isPermaLink="true">https://hool.co/reports/vercel-functions-websockets-generally-available-limits-and-cost</guid>
      <pubDate>Mon, 02 Nov 2026 12:00:00 GMT</pubDate>
      <category>AWS Architecture</category>
      <description>Since October 20, 2026, Vercel Functions serve WebSocket connections on every plan, with Express, Hono, Socket.IO, Bun, FastAPI and Next.js. Connections close at the function's maximum duration (300 seconds on Hobby, up to 800 on Pro), each is pinned to one instance, and memory is billed while any connection is open. What that means for your design and your bill.</description>
    </item>
    <item>
      <title>WebSockets Are Easy to Open and Hard to Run: How to Decide if Your Feature Needs One</title>
      <link>https://hool.co/guides/do-you-need-websockets-decide-before-you-build</link>
      <guid isPermaLink="true">https://hool.co/guides/do-you-need-websockets-decide-before-you-build</guid>
      <pubDate>Mon, 02 Nov 2026 12:00:00 GMT</pubDate>
      <category>AWS Architecture</category>
      <description>A WebSocket demo takes an afternoon. Keeping thousands of connections correct through deploys, reconnects, phones changing networks and a second server takes ongoing work. Many &quot;realtime&quot; features are better served by a 15-second poll or a server-sent event stream. A feature-by-feature guide, and the list of what you take on when the answer really is WebSockets.</description>
    </item>
    <item>
      <title>Realtime Pricing Compared: Vercel WebSockets, API Gateway WebSocket APIs and AppSync Events</title>
      <link>https://hool.co/guides/realtime-pricing-vercel-websockets-vs-api-gateway-vs-appsync-events</link>
      <guid isPermaLink="true">https://hool.co/guides/realtime-pricing-vercel-websockets-vs-api-gateway-vs-appsync-events</guid>
      <pubDate>Mon, 02 Nov 2026 12:00:00 GMT</pubDate>
      <category>AWS Architecture</category>
      <description>The same workload priced three ways: 1,000 users connected through the workday, 48 million messages a month. On AWS, API Gateway and AppSync Events charge about $1 per million messages and differ mostly in connection minutes and in who does the fan-out. Vercel charges almost nothing per message but bills memory for every instance holding connections. Where each one wins.</description>
    </item>
    <item>
      <title>Next.js WebSockets on Vercel: upgradeWebSocket, Redis Fan-Out, and Surviving Deploys</title>
      <link>https://hool.co/guides/nextjs-websockets-on-vercel-upgradewebsocket-redis-fan-out-deploys</link>
      <guid isPermaLink="true">https://hool.co/guides/nextjs-websockets-on-vercel-upgradewebsocket-redis-fan-out-deploys</guid>
      <pubDate>Mon, 02 Nov 2026 12:00:00 GMT</pubDate>
      <category>AWS Architecture</category>
      <description>Next.js has no WebSocket API, so Vercel added upgradeWebSocket() to @vercel/functions 3.10.0. Getting an echo server running takes minutes; a chat or presence feature that works across instances and deploys needs four more pieces. A build order for a production-ready Next.js realtime feature on Vercel.</description>
    </item>
    <item>
      <title>An EKS Reference Architecture for 2026, With Diagrams: The Small-Team Version and the Regulated Version</title>
      <link>https://hool.co/guides/eks-reference-architecture-2026-diagram-small-team-and-regulated</link>
      <guid isPermaLink="true">https://hool.co/guides/eks-reference-architecture-2026-diagram-small-team-and-regulated</guid>
      <pubDate>Mon, 02 Nov 2026 12:00:00 GMT</pubDate>
      <category>Kubernetes</category>
      <description>What a production EKS setup looks like in 2026, layer by layer: edge, entry, cluster, platform add-ons, data, security and observability. A lean version for a small team on Auto Mode, and a regulated version with separate node pools, network policies and audit logging, with the choices behind each box.</description>
    </item>
    <item>
      <title>EKS Spend Control: Where Kubernetes Money Leaks, and How to See It Per Team</title>
      <link>https://hool.co/guides/eks-spend-control-requests-consolidation-split-cost-allocation</link>
      <guid isPermaLink="true">https://hool.co/guides/eks-spend-control-requests-consolidation-split-cost-allocation</guid>
      <pubDate>Mon, 02 Nov 2026 12:00:00 GMT</pubDate>
      <category>Kubernetes</category>
      <description>EKS bills are mostly nodes, and nodes are sized by what pods request, not what they use. The leaks we find most (inflated requests, half-empty nodes, cross-AZ chatter, one load balancer per service, clusters on extended support) and how split cost allocation data puts a price on every namespace in the Cost and Usage Report.</description>
    </item>
    <item>
      <title>EKS for HIPAA in 2026: What the BAA Covers and What You Still Have to Configure</title>
      <link>https://hool.co/guides/eks-hipaa-2026-baa-eligible-services-and-what-you-configure</link>
      <guid isPermaLink="true">https://hool.co/guides/eks-hipaa-2026-baa-eligible-services-and-what-you-configure</guid>
      <pubDate>Mon, 02 Nov 2026 12:00:00 GMT</pubDate>
      <category>Healthcare</category>
      <description>EKS, ECR, Fargate, EBS, EFS and GuardDuty are on AWS's HIPAA eligible services list, so you can run workloads with PHI on Kubernetes under a BAA. Eligibility is not compliance: encryption, access, isolation, audit logs and what lands in your logs are yours. A control-by-control checklist, with a diagram.</description>
    </item>
    <item>
      <title>EKS and AI Agents: Running Agents on Kubernetes, and Letting Agents Operate Your Clusters</title>
      <link>https://hool.co/guides/eks-and-ai-agents-running-agents-on-eks-and-letting-agents-operate-clusters</link>
      <guid isPermaLink="true">https://hool.co/guides/eks-and-ai-agents-running-agents-on-eks-and-letting-agents-operate-clusters</guid>
      <pubDate>Mon, 02 Nov 2026 12:00:00 GMT</pubDate>
      <category>AI Engineering</category>
      <description>Two different problems. Running agents on EKS is about long-lived workers, GPUs, sandboxes for code they write, and tight egress. Letting an agent operate EKS, through the EKS MCP server or kubectl, is about read-only by default, separate roles for writes, and approvals. The setups that are safe enough to use.</description>
    </item>
    <item>
      <title>EKS Access in 2026: Access Entries, Pod Identity, and Retiring the aws-auth ConfigMap</title>
      <link>https://hool.co/guides/eks-access-entries-pod-identity-retire-aws-auth-configmap</link>
      <guid isPermaLink="true">https://hool.co/guides/eks-access-entries-pod-identity-retire-aws-auth-configmap</guid>
      <pubDate>Mon, 02 Nov 2026 12:00:00 GMT</pubDate>
      <category>Kubernetes</category>
      <description>Access entries replace the aws-auth ConfigMap for people, and Pod Identity replaces IRSA's OIDC plumbing for pods. What each does, what migrates automatically (only the cluster creator), the limits (5,000 Pod Identity associations, no Fargate or Windows), and a migration order that doesn't lock anyone out.</description>
    </item>
    <item>
      <title>EKS Network Policies With the VPC CNI: Default Deny, Admin Policies, and the Limits to Know</title>
      <link>https://hool.co/guides/eks-network-policies-vpc-cni-admin-policies-default-deny</link>
      <guid isPermaLink="true">https://hool.co/guides/eks-network-policies-vpc-cni-admin-policies-default-deny</guid>
      <pubDate>Mon, 02 Nov 2026 12:00:00 GMT</pubDate>
      <category>Kubernetes</category>
      <description>The VPC CNI enforces Kubernetes network policies natively, and from version 1.21 adds cluster-wide admin policies that namespace owners can't override. How the tiers are evaluated, a default-deny setup, and the limits: EC2 Linux nodes only, 24 port-protocol combinations per CIDR, and pods without an owner.</description>
    </item>
  </channel>
</rss>
