AWS New Services August 2026: 5 Performance Wins

Identify CPU and Memory Pressure Before Scaling

The first place to look is compute resources. Not because it's always the problem, but because it's fast to check and cheap to fix.

Open CloudWatch and pull up the CPUUtilization and MemoryUtilization metrics for your EC2 instances or ECS tasks. Look at the maximum values over the past week, not the averages. If you see sustained periods above 80%, you have pressure. For T-series instances, check CPUCreditBalance too. When that metric hits zero, AWS throttles your CPU to the baseline rate, and your application turns into molasses.

Memory pressure is harder to spot because the OS will use swap before it fails. If your instances have swap configured, check the swap usage metric. Any consistent swap activity means you're out of physical RAM and performance is suffering. I've seen API response times drop from 200ms to 4 seconds just because the instance was swapping.

The fix: increase instance size or switch families. T3 instances are cheap but throttle. M6i or C6i instances cost more but deliver predictable performance. Before you resize, document your current CPU and memory usage so you can measure the improvement. After the change, expect response times to drop by 30-60% if CPU or memory was the bottleneck.

• Pull max CPU and memory metrics over 7 days, not averages
• Check CPUCreditBalance on T-series instances; zero means throttling
• Look for swap usage as a sign of memory exhaustion
• Switch to fixed-performance instance types (M6i, C6i) if workload needs predictability
• Measure response time before and after to confirm the bottleneck

Reduce Network Latency with AZ and VPC Tuning

Network latency shows up in two places: between your services and between your services and AWS APIs. Both are fixable.

Cross-AZ latency is 1-3ms per hop. That sounds small. Multiply it by 50 database calls per request and you've added 50-150ms to every page load. Use the AWS CLI or a simple ping test between instances in different zones to measure the actual latency in your environment. If your application server and database are in different AZs and latency matters, move them to the same zone. Yes, you lose a bit of availability. In practice, most availability problems come from software bugs, not entire AZ failures.

For AWS service calls—S3, DynamoDB, Secrets Manager—use VPC endpoints. Without them, traffic routes out to the internet gateway and back through AWS's public network. VPC endpoints keep everything on the backbone. I've seen S3 API latency drop from 30ms to under 5ms just by adding an endpoint. The cost is minimal and the setup takes five minutes.

• Measure cross-AZ latency with ping or application health checks
• Colocate application and database in the same AZ if latency > availability
• Deploy VPC endpoints for S3, DynamoDB, and other AWS services you call frequently
• Expect 5-10ms improvement on AWS service API calls with VPC endpoints
• Monitor network latency in CloudWatch with custom metrics if needed

Provision Storage IOPS to Match Your Workload

EBS volume performance is limited by two things: IOPS and throughput. Default gp2 volumes give you 3 IOPS per GB, with a minimum of 100 IOPS and a burst bucket for short spikes. That works fine until it doesn't.

Check the VolumeReadOps and VolumeWriteOps metrics in CloudWatch. If you're consistently hitting the IOPS limit—usually visible as maxed-out metrics combined with increased disk latency—your volume is the bottleneck. This shows up as slow database queries, long file writes, or application pauses that don't correlate with CPU or memory.

The fix depends on your volume type. For gp2, you can increase volume size to get more baseline IOPS, but that's wasteful if you don't need the storage. Switch to gp3 instead. gp3 lets you set IOPS and throughput independently. A 100 GB gp3 volume can deliver 16,000 IOPS if you pay for it. That's the same performance as a 5 TB gp2 volume.

Provision 20% above your current peak IOPS usage to leave headroom. Monitor the change for a week. If IOPS utilization stays below 80%, you're good. If it climbs back up, provision more.

• Check VolumeReadOps and VolumeWriteOps in CloudWatch for IOPS saturation
• Look for increased disk latency that coincides with IOPS limits
• Switch from gp2 to gp3 for independent IOPS and throughput tuning
• Provision 20% above peak observed IOPS to avoid future bottlenecks
• For databases, consider io2 volumes if you need sub-millisecond latency

Cut Lambda Cold Start Latency with Memory and Provisioned Concurrency

Cold starts kill Lambda performance. A function that runs in 50ms when warm can take 2 seconds when cold. That's a terrible user experience, especially for APIs.

First, understand what's causing the delay. Enable AWS X-Ray on your Lambda functions and look at the initialization trace. If most of the time is spent loading dependencies, you can't do much except optimize your imports. If the runtime is taking a long time to spin up, increasing memory helps. Lambda allocates CPU proportionally to memory. A 512 MB function gets twice the CPU of a 256 MB function and initializes faster.

I've measured this on production functions. Doubling memory from 512 MB to 1024 MB cut cold start time from 1.8 seconds to 700ms. Yes, it costs more per invocation, but the improvement in user-facing latency is worth it for anything customer-facing.

For critical paths, use provisioned concurrency. It keeps a pool of warm instances ready. You pay for the idle time, but cold starts disappear. Set provisioned concurrency to match your baseline traffic, not your peak. Let autoscaling handle the spikes.

• Enable X-Ray to measure cold start duration and identify bottlenecks
• Increase memory allocation to 1024 MB or higher for compute-bound initialization
• Expect 50-70% cold start reduction by doubling memory
• Use provisioned concurrency for user-facing APIs with strict latency requirements
• Set provisioned capacity to baseline traffic; let autoscaling handle peaks

Monitor P99 Latency, Not Averages

Averages lie. Your API can have a mean response time of 120ms and still deliver a miserable experience to 5% of users.

The problem is outliers. A few slow requests pull the average up a bit, but they destroy the experience for the people who hit them. If your p99 latency is 3 seconds, that means one in a hundred requests takes at least three seconds. At any meaningful scale, that's a lot of angry users.

CloudWatch supports percentile metrics. Add p95, p99, and p99.9 alarms for your critical endpoints. When p99 latency crosses your threshold—say, 500ms for an API—you know there's a performance problem even if the average still looks fine. In my experience, p99 issues come from resource contention, garbage collection pauses, or tail database queries that don't get indexed properly.

Once you have the alarms, dig into the slow requests. Enable detailed logging or tracing for requests above your p99 threshold. Find the common pattern—usually it's a specific query, a cold cache, or a downstream service that's having a bad day.

• Configure CloudWatch alarms for p95, p99, and p99.9 latency on all user-facing endpoints
• Set p99 thresholds based on user experience requirements, not system capacity
• Enable detailed logging or tracing for requests that exceed p99 latency
• Investigate common patterns in slow requests: queries, cache misses, downstream calls
• Track p99 improvements after each optimization to confirm impact

Testing Changes Safely and Measuring Results

Performance tuning fails when you change three things at once and can't tell which one helped. Make one change at a time. Measure it. Move on.

Before you touch production, test in staging with realistic load. Use tools like Apache Bench, wrk, or Locust to simulate your traffic patterns. If you don't have a staging environment that matches production, at least run the change on a canary instance or a single container and monitor it for an hour before rolling out.

Document your baseline metrics: CPU utilization, memory usage, network latency, storage IOPS, and response time at p50, p95, and p99. After you apply a change, wait at least 30 minutes for metrics to stabilize. Compare the new numbers to baseline. If performance improves by less than 10%, the change didn't address the real bottleneck. Revert and try something else.

Keep your previous configurations or launch templates. If something breaks, you need to roll back fast. CloudWatch alarms should catch problems automatically, but check the metrics yourself for the first few hours after a change.

• Change one variable at a time so you know what worked
• Test configuration changes in staging with production-like load before deploying
• Document baseline metrics for CPU, memory, network, storage, and response time
• Wait 30 minutes after a change for metrics to stabilize before evaluating impact
• Keep previous configurations available for fast rollback if needed