Who this is for: anyone who’s standardized on IAM database authentication for RDS and has hit connection throttling during a traffic spike or a fleet scale-out event, and wants to know what actually changed with the June 2026 update.
We had a Lambda-backed ingestion service scale from a handful of warm containers to a few hundred during a traffic spike, and within about ninety seconds our RDS for PostgreSQL instance started rejecting new connections with an IAM authentication throttling error. Every new Lambda execution environment was minting its own auth token and opening a fresh connection, and we blew right through what turned out to be a fixed 200 connections-per-second ceiling on IAM auth that nobody on my team had ever needed to think about before that day.
Why This Matters
IAM database authentication is the recommended way to connect to RDS without managing static database passwords: your application requests a short-lived auth token (valid 15 minutes) signed with AWS Signature Version 4, and RDS validates it against IAM instead of a stored credential. It’s a genuinely better security posture than password rotation. The problem, until this June, was that IAM auth had a hard, undocumented-until-you-hit-it ceiling of around 200 new connections per second regardless of instance size. A db.r6g.4xlarge and a db.t3.micro had the same cap, which meant the instances best equipped to handle a connection storm were exactly as throttled as the smallest ones. Amazon RDS now offers dynamic connection scaling for IAM database authentication, where the rate you can sustain scales with the instance’s available resources instead of a flat number.
What the old ceiling actually looked like
The failure mode isn’t a clean error message pointing at IAM auth specifically; it shows up as connection refusals or timeouts under load, and you have to go digging in CloudWatch or the Postgres log to connect it back to authentication throttling rather than a generic connection limit problem. If you’re chasing this down, the RDS/Aurora IAM authentication CloudWatch metrics (added in an earlier release) are the fastest way to confirm it’s actually the auth layer throttling you and not max_connections or a security group issue.
aws cloudwatch get-metric-statistics \ --namespace AWS/RDS \ --metric-name IAMDBAuthThrottles \ --dimensions Name=DBInstanceIdentifier,Value=ingestion-primary \ --start-time 2026-06-01T00:00:00Z \ --end-time 2026-06-01T01:00:00Z \ --period 60 \ --statistics Sum
If that metric is climbing during your spike, you’re hitting the IAM auth rate limit, not a general connection cap.
What changed, and what we still do anyway
The dynamic scaling is automatic; there’s no setting to flip on. Once your instance is running a supported engine version, the connection rate you can sustain scales with available instance resources instead of being pinned to the old flat ceiling. That alone would have absorbed most of our spike. But we didn’t stop there, because the underlying problem, minting a brand-new IAM token per connection instead of reusing one, was still wasteful even with a higher ceiling.
import boto3import time_token_cache = {"token": None, "expires_at": 0}def get_auth_token(client, host, port, user): now = time.time() if _token_cache["token"] and now < _token_cache["expires_at"] - 60: return _token_cache["token"] token = client.generate_db_auth_token( DBHostname=host, Port=port, DBUsername=user ) _token_cache["token"] = token _token_cache["expires_at"] = now + 900 # tokens are valid 15 minutes return token
Caching the token across warm Lambda invocations (rather than regenerating on every call) cut our new-connection rate dramatically on its own, independent of the RDS-side fix. We also moved the ingestion service behind RDS Proxy, which pools connections so a burst of Lambda invocations reuses a much smaller number of actual database connections instead of each one authenticating fresh.
Where This Requires Care
Dynamic scaling raises the ceiling, it doesn’t remove it. A connection storm large enough can still throttle a properly sized instance; token caching and connection pooling are still worth doing rather than relying on the higher limit alone.
The new behavior scales with “available instance resources,” which means a busy instance under heavy query load has less headroom for a simultaneous connection storm than an idle one. Don’t assume the new ceiling is a fixed higher number; it’s still variable.
If you’re fronting RDS with RDS Proxy and IAM auth together, remember the throttling can also originate from AWS STS rate limits when generating tokens under very high concurrency, which is a separate limit from the RDS-side IAM auth ceiling this update addresses.
This applies to Aurora and RDS for PostgreSQL, MySQL, and MariaDB. If you’re on a different engine, IAM auth connection limits may behave differently.
Quick Reference
- Before June 2026, IAM database authentication had a flat ~200 connections-per-second ceiling regardless of instance size. It now scales dynamically with available instance resources.
- Use the IAM DB auth CloudWatch metrics to confirm throttling is coming from the auth layer before chasing max_connections or security group settings.
- Cache and reuse IAM auth tokens across warm invocations; each token is valid for 15 minutes, so regenerating one per connection is wasted overhead regardless of the RDS-side limit.
- Put RDS Proxy in front of high-fanout, short-lived connection patterns (like Lambda) to pool connections instead of authenticating fresh on every invocation.
- Remember STS token-generation rate limits are a separate throttling source from the RDS-side IAM auth ceiling this update raises.
My Take
This is a quiet fix for a problem that mostly bites people during exactly the wrong moment, a traffic spike, when a fixed-size ceiling meant your biggest, best-provisioned instance had no more headroom than your smallest one. I’m glad it’s automatic and didn’t require a migration or a config change to benefit from. That said, I wouldn’t treat the higher ceiling as a substitute for token caching and connection pooling; those practices would have prevented most of our incident even under the old limit, and they’re still the right default for any IAM-authenticated, high-connection-churn workload.

