The Problem: A $6,670/Month AWS Bill That Grew Every Quarter
This growth-stage SaaS company came to us with a familiar story: their AWS bill was climbing 15-20% every quarter while their actual traffic was flat. Engineering leadership knew they were overspending but couldn't identify where the waste was hiding without dedicating engineering time they didn't have.
Their infrastructure had been built by a fast-moving team optimizing for reliability over cost. Every service was oversized "just in case." Every instance ran 24/7 regardless of actual usage patterns. Every feature launch added resources that never got cleaned up after the initial spike.
The $6,670/month bill broke down into what looked like reasonable individual line items. No single service screamed "waste." But in aggregate, they were paying 2-3x what the workload required. Compute services alone (ECS plus supporting EC2 capacity) accounted for nearly half of the total spend, with caching, observability, and CDN making up most of the rest.
What We Found: 7 Areas of Hidden Waste
1. ECS Fargate: Always-On Compute for Part-Time Workloads ($2,924 → $873)
The single largest waste sat in compute tasks configured to run 24/7 for workloads that only needed processing during business hours. Batch processors, report generators, and internal tools were all running around the clock.
Our approach: We implemented intelligent scheduling policies that precisely match compute capacity to actual demand patterns. Workloads now run exactly when needed at exactly the capacity required.
Monthly ECS spend dropped from $2,924 to $873 without any change to application behavior or availability during business hours, recovering more than $2,000/month from a single workstream.
2. AWS Support Plan: A Tier That Did Not Match Actual Usage ($679 → $0)
The team was paying for a Business Support tier sized for an earlier scale of operations. Actual support utilization (case volume, severity profile, response-time needs) had drifted far below what the tier was priced against.
Our approach: We mapped actual support usage against the available tiers and rightsized the plan to match real consumption patterns. The full $679/month line item was eliminated without compromising the team's ability to get help when it was actually needed.
This is the kind of structural saving that almost never shows up in tooling-driven cost dashboards because it is not a workload waste, it is a procurement misfit.
3. ElastiCache: Paying for 5x the Memory They Actually Used ($602 → $107)
The caching layer had been provisioned during a period of rapid growth. Actual utilization? 18% average, 34% peak. They were paying for capacity they would never touch.
Our approach: We analyzed two weeks of peak usage patterns and applied our proprietary rightsizing methodology to match the caching layer precisely to real-world demand. Monthly cost dropped from $602 to $107 with zero impact on cache hit rates or latency.
Risk mitigation: We validated performance metrics in parallel before cutting over, confirming hit rates remained above 99.2% and P99 latency stayed under 2ms.
4. CloudWatch: Verbose Logging With No Diagnostic Payoff ($538 → $354)
CloudWatch had been left at default settings since launch. Log streams retained at maximum verbosity, custom metrics that nobody read, and retention windows measured in years for data nobody had queried in months.
Our approach: We audited every log stream and metric for actual diagnostic value, trimmed verbose payloads, removed unused custom metrics, and tuned retention to match real investigation patterns. Observability quality actually improved because the noise dropped, making real signals easier to spot.
Monthly cost dropped from $538 to $354 with no loss of diagnostic capability.
5. CloudFront: A CDN That Was Costing Money Instead of Saving It ($475 → $50)
This was the most shocking finding. The CDN had a 5% cache hit ratio. 95% of requests were passing through to origin servers, meaning CloudFront was adding cost and latency rather than reducing it.
The root causes were configuration issues that had accumulated over multiple product launches. The CDN was effectively a passthrough proxy billing them $475/month for nothing.
Our approach: We resolved the misconfigurations using our CDN optimization playbook. Cache hit ratio went from 5% to 94%. Monthly cost dropped from $475 to $50 while actually improving end-user latency by roughly 40%.
6. VPC and Networking: Silent Drain from Idle Resources ($230 → $55)
Networking resources had been provisioned for infrastructure that no longer existed. Idle NAT gateways still racking up hourly charges, orphaned security groups, dormant load balancers, and unattached elastic IPs were all silently billing.
Our approach: We mapped every networking resource against actual traffic flows, removed the orphans, and consolidated overlapping configurations.
Monthly networking spend dropped from $230 to $55, eliminating $2,100+/year in pure waste with zero functional impact.
7. RDS: Oversized Database for a Modest Workload ($101 → $41)
The production database was provisioned for a workload 3-4x larger than what it actually served. CPU never exceeded 12% and connections used less than 25% of available capacity.
Our approach: We performed a controlled migration to a right-sized instance during a maintenance window. Monthly cost: $101 → $41 with no measurable change in query performance.
8. Redundant SaaS Subscriptions ($125+/month)
During the infrastructure audit, we discovered overlapping tools: duplicate monitoring platforms, unused seats, and services replicating functionality already available natively. Cancelling the redundancies saved an additional $125+/month ($1,500/year).
The Results: Sustained Savings That Keep Compounding
| Service | Before | After | Monthly Savings | Annual Savings |
|---|---|---|---|---|
| ECS Fargate | $2,924 | $873 | $2,051 | $24,612 |
| ElastiCache | $602 | $107 | $495 | $5,940 |
| CloudFront | $475 | $50 | $425 | $5,100 |
| CloudWatch | $538 | $354 | $184 | $2,208 |
| VPC and networking | $230 | $55 | $175 | $2,100 |
| RDS | $101 | $41 | $60 | $720 |
| Other AWS services | $1,800 | $972 | $828 | $9,936 |
| SaaS subscriptions | $125+ | $0 | $125 | $1,500 |
| Total | $6,670+ | $2,452 | $4,218+ | $50,616+ |
The optimizations were completed in 4 weeks. The engagement paid for itself in the first month. Every month since has been pure savings.
The 6-Month Trajectory: Why Savings Keep Growing
The headline number ($6,670 → $2,452) only tells part of the story. The optimization is not a one-time event. It is an ongoing program where each month uncovers new waste patterns to eliminate.
Here is the directional pattern we have seen across the engagement:
- Month 1 (engagement start): Baseline established. The biggest waste sources were identified and prioritized by dollar impact.
- Month 2: First major optimizations went live. Bill dropped sharply as the largest waste lines (oversized caching, always-on compute) were cut.
- Month 3: Steady-state approached. CDN reconfiguration and database rightsizing landed. Bill stabilized at a fraction of the original.
- Month 4-6: Continuous tuning. Each month surfaces new optimization opportunities. The bill continues to trend down month over month as we refine schedules, eliminate orphaned resources, and tune commitments.
The current month's bill is the lowest yet. We expect the trajectory to continue downward as we work through the long tail of smaller waste patterns and apply commitment-based pricing where appropriate.
This is the pattern most teams miss when they treat cost optimization as a project instead of a program. The first 4 weeks deliver the biggest wins. The next 6 months deliver the wins everyone else leaves on the table.
More Than Cost: Performance, Security, and Reliability Improved End-to-End
Cost reduction often gets framed as a tradeoff against quality. This engagement did the opposite. While the bill was being cut by 63%+, the underlying infrastructure got measurably better across every dimension that matters:
Performance. CDN cache hit ratio went from 5% to 94%, cutting origin load dramatically and reducing end-user latency by roughly 40%. Compute services now provision capacity precisely when demand requires it instead of running flat at peak sizing, which improved tail-latency consistency for batch and async workloads. Database response times stayed flat or improved despite the rightsizing, because the previous oversized instance was burning capacity on overhead, not workload. CloudWatch noise was cut so real signals surface faster during incidents.
Security. The cost audit doubled as a security audit. Unused networking surface area (idle VPC resources, orphaned security groups, dormant load balancers) was eliminated, shrinking the attack surface. Encryption posture and IAM access patterns were reviewed across every touched service. Observability was tightened so anomalies (cost or behavioral) get caught within hours instead of weeks. Several misconfigurations that had cost implications also had latent security implications, and both were resolved together.
Reliability. Every optimization went through performance validation gates and rollback plans before going live. No incident was caused by the optimization work. Several existing fragility patterns (a CDN that was actively hurting performance, caching layers running at thermal limits during traffic spikes, networking hairpins from idle resources) were eliminated, so the post-optimization infrastructure is more reliable than the pre-optimization version, not less.
This is the difference between cost-cutting and cost optimization. Cost-cutting picks numbers off the bill and degrades the system. Cost optimization aligns spend with actual demand and engineering excellence; the bill drops because the system gets better, not worse.
What Made This Work
We did not guess. Every optimization was backed by real utilization data and validated against three measurable criteria: cost, performance, and risk posture.
- Comprehensive monitoring analysis across all services
- Detailed cost attribution using AWS Cost Explorer
- Access pattern analysis to understand actual demand
- Performance validation before and after every change
- Security review parallel to every cost change
- Reliability gates and rollback plans for every deployment
No optimization went live without a rollback plan. Every change was deployed incrementally with monitoring gates. The client's engineering team reviewed and approved each change before execution. Cost reductions, performance improvements, and security hardening were treated as a single end-to-end program rather than separate workstreams.
Could Your AWS Bill Look Like This?
If your monthly AWS spend has grown faster than your traffic, you likely have similar patterns hiding in plain sight. The most common waste we find across clients:
- 60-80% of compute spend goes to resources sized for peak but running at average
- 70%+ of caching spend is on capacity that never gets used
- CDN misconfigurations often mean you pay for a service while getting no benefit from it
- Database instances are almost always significantly larger than the workload requires
Our cloud cost optimization service identifies and implements these optimizations with a 30% savings guarantee. If we don't find at least 30% in savings, you don't pay.
Get your free Cloud Waste Assessment and we'll show you exactly where your bill is bloated within one week.