While most AWS cost optimization guides focus on Reserved Instances and Spot Instances, there are several underutilized services that can provide significant savings. Here’s a detailed look at services that often get overlooked, with actual pricing comparisons.

DynamoDB Provisioned vs On-Demand: 85% Cost Reduction

DynamoDB on-demand is convenient but costs 6-7x more than provisioned capacity for predictable workloads. This difference can mean thousands of dollars per month for active applications.

The Shocking Price Difference (us-east-1)

On-Demand:

  • $0.25 per million write request units
  • $0.25 per million read request units

Provisioned with Auto-scaling:

  • $0.00065 per WCU per hour ($0.468 per month)
  • $0.00013 per RCU per hour ($0.094 per month)

Real-World Example: A Typical API Backend

For an API handling 1000 writes/second and 5000 reads/second:

On-Demand Monthly Cost:

  • Writes: 1000/sec × 2.628M sec/month = 2,628M writes × $0.25/1M = $657
  • Reads: 5000/sec × 2.628M sec/month = 13,140M reads × $0.25/1M = $3,285
  • Total: $3,942/month

Provisioned with Auto-scaling Monthly Cost:

  • 1000 WCU: 1000 × $0.468 = $468
  • 5000 RCU: 5000 × $0.094 = $470
  • Total: $938/month (76% savings)

Setting Up Auto-scaling for Even Better Savings

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

import boto3

autoscaling = boto3.client('application-autoscaling')

# Register the table for auto-scaling
autoscaling.register_scalable_target(
    ServiceNamespace='dynamodb',
    ResourceId='table/my-table',
    ScalableDimension='dynamodb:table:WriteCapacityUnits',
    MinCapacity=500,   # 50% of peak
    MaxCapacity=1500   # 150% of peak for spikes
)

# Set up target tracking
autoscaling.put_scaling_policy(
    PolicyName='DynamoDBWriteCapacityUtilization:table/my-table',
    ServiceNamespace='dynamodb',
    ResourceId='table/my-table',
    ScalableDimension='dynamodb:table:WriteCapacityUnits',
    PolicyType='TargetTrackingScaling',
    TargetTrackingScalingPolicyConfiguration={
        'TargetValue': 70.0,
        'PredefinedMetricSpecification': {
            'PredefinedMetricType': 'DynamoDBWriteCapacityUtilization'
        }
    }
)

With auto-scaling (assuming 70% average utilization):

  • Average 700 WCU: $328/month
  • Average 3500 RCU: $329/month
  • Total: $657/month (83% savings vs on-demand)

DynamoDB Pricing Calculator

S3 Intelligent-Tiering with Archive Configuration

S3 Intelligent-Tiering automatically moves objects between access tiers, but the real savings come from configuring the optional Archive Access tiers.

Standard Storage Approach

1
2

# 10TB in S3 Standard
# Cost: 10,240 GB × $0.023 = $235.52/month

Intelligent-Tiering with Archive Configuration

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

{
  "Id": "archive-old-data",
  "Status": "Enabled",
  "Tierings": [
    {
      "Days": 90,
      "AccessTier": "ARCHIVE_ACCESS"
    },
    {
      "Days": 180,
      "AccessTier": "DEEP_ARCHIVE_ACCESS"
    }
  ]
}

Cost breakdown for 10TB after 180 days:

  • Deep Archive Access tier: 10,240 GB × $0.00099 = $10.14/month
  • Monitoring fee: 10M objects × $0.0025/1000 = $25/month
  • Total: $35.14/month (85% savings)

S3 Intelligent-Tiering Pricing Details

Compute Savings Plans for Lambda and Fargate

While EC2 Reserved Instances are well-known, Compute Savings Plans apply to Lambda, Fargate, and EC2, offering up to 17% discount on Lambda and 52% on Fargate.

Analyzing Your Compute Spend

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

import boto3
from datetime import datetime, timedelta

ce = boto3.client('ce')

response = ce.get_cost_and_usage(
    TimePeriod={
        'Start': (datetime.now() - timedelta(days=30)).strftime('%Y-%m-%d'),
        'End': datetime.now().strftime('%Y-%m-%d')
    },
    Granularity='MONTHLY',
    Metrics=['UnblendedCost'],
    Filter={
        'Dimensions': {
            'Key': 'SERVICE',
            'Values': ['AWS Lambda', 'AWS Fargate']
        }
    }
)

Example savings on $1,000/month Lambda spend:

  • On-Demand: $1,000/month
  • 1-year Compute Savings Plan: $830/month (17% discount)
  • 3-year Compute Savings Plan: $730/month (27% discount)

AWS Savings Plans Pricing

Step Functions Express Workflows vs Standard Workflows

For high-volume, short-duration orchestrations, Express Workflows offer dramatic cost savings.

Pricing Comparison

Standard Workflows:

  • $25 per million state transitions

Express Workflows:

  • $1.00 per million requests
  • $0.00001667 per GB-second of memory

For a simple 3-step workflow executing 10 million times per month:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

{
  "Comment": "File processing pipeline",
  "StartAt": "ValidateFile",
  "States": {
    "ValidateFile": {
      "Type": "Task",
      "Resource": "arn:aws:lambda:us-east-1:123:function:validate",
      "Next": "ProcessFile"
    },
    "ProcessFile": {
      "Type": "Task", 
      "Resource": "arn:aws:lambda:us-east-1:123:function:process",
      "Next": "StoreResult"
    },
    "StoreResult": {
      "Type": "Task",
      "Resource": "arn:aws:lambda:us-east-1:123:function:store",
      "End": true
    }
  }
}

Monthly costs:

  • Standard: 30M state transitions × $25/1M = $750
  • Express: 10M requests × $1/1M = $10

Step Functions Pricing

CloudFront Functions vs Lambda@Edge

For simple request/response manipulation at the edge, CloudFront Functions are significantly cheaper than Lambda@Edge.

Pricing Per Million Requests

Lambda@Edge:

  • $0.60 per million requests
  • $0.00001667 per GB-second

CloudFront Functions:

  • $0.10 per million invocations

Use Case: Adding Security Headers

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

// CloudFront Function
function handler(event) {
    var request = event.request;
    var headers = request.headers;
    
    headers['strict-transport-security'] = { value: 'max-age=63072000' };
    headers['x-frame-options'] = { value: 'DENY' };
    headers['x-content-type-options'] = { value: 'nosniff' };
    headers['x-xss-protection'] = { value: '1; mode=block' };
    
    return request;
}

For 100 million requests/month:

  • Lambda@Edge: $60 + compute costs
  • CloudFront Functions: $10 (83% savings)

CloudFront Functions Pricing

EventBridge Scheduler vs Lambda for Scheduled Tasks

While the individual cost difference seems small, EventBridge Scheduler becomes valuable at scale and eliminates Lambda cold starts, complexity, and maintenance overhead.

When This Matters: Multiple Scheduled Tasks

Consider a SaaS application with these scheduled jobs:

  • 50 customer data exports (hourly)
  • 100 metric calculations (every 5 minutes)
  • 200 status checks (every minute)
  • 30 cleanup tasks (daily)

Traditional Approach: Lambda Functions

1
2
3
4
5
6
7
8

# One Lambda function per scheduled task type
def export_handler(event, context):
    customer_id = event['customer_id']
    # Export logic here
    
def metric_handler(event, context):
    metric_type = event['metric_type']
    # Calculation logic here

Monthly Lambda Costs:

  • 50 hourly: 36,000 invocations
  • 100 per 5 min: 864,000 invocations
  • 200 per minute: 8,640,000 invocations
  • 30 daily: 900 invocations
  • Total: ~9.5M invocations

At minimum 128MB, 100ms per execution:

  • Compute: 9.5M × $0.0000000167 × 100ms/1000 = $15.87/month
  • Requests: 9.5M × $0.20/1M = $1.90/month
  • Plus: Cold start latency, Lambda management overhead

Optimized: Direct EventBridge Scheduler

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

# Direct API Gateway or Step Functions invocation
scheduler.create_schedule(
    Name=f'export-customer-{customer_id}',
    ScheduleExpression='rate(1 hour)',
    Target={
        'Arn': 'arn:aws:states:us-east-1:123:stateMachine:export-workflow',
        'RoleArn': 'arn:aws:iam::123:role/scheduler-role',
        'Input': json.dumps({'customerId': customer_id})
    }
)

Monthly EventBridge Costs:

  • 9.5M invocations × $1.00/1M = $9.50/month
  • Benefit: No cold starts, no Lambda management, 50% cost reduction

The real value: simplified architecture, better debugging, and no Lambda concurrency limits.

EventBridge Scheduler Pricing

Cost Allocation Tags for Visibility

While not a service that directly saves money, Cost Allocation Tags reveal hidden costs. Enable them in the Billing Console and tag all resources consistently.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

# Tag resources consistently
aws ec2 create-tags \
    --resources i-1234567890abcdef0 \
    --tags Key=Environment,Value=Development \
           Key=Project,Value=api-v2 \
           Key=CostCenter,Value=engineering

# Query costs by tag
aws ce get-cost-and_usage \
    --time-period Start=2025-01-01,End=2025-01-31 \
    --granularity MONTHLY \
    --metrics UnblendedCost \
    --group-by Type=TAG,Key=Environment

Quick Wins for Immediate Savings

1. CloudWatch Logs Retention

Default retention is “Never Expire”. Set appropriate retention periods:

1
2
3

aws logs put-retention-policy \
    --log-group-name /aws/lambda/my-function \
    --retention-in-days 7

Cost savings: 90% reduction after retention period

2. NAT Instance vs NAT Gateway (Dev Environments)

  • NAT Gateway: $0.045/hour = $32.40/month minimum
  • NAT Instance (t3.nano): $0.0052/hour = $3.74/month

3. GP3 vs GP2 EBS Volumes

GP3 is 20% cheaper and allows independent IOPS/throughput configuration:

1
2
3

aws ec2 modify-volume \
    --volume-id vol-1234567890abcdef0 \
    --volume-type gp3
  • GP2 (1TB): $100/month
  • GP3 (1TB): $80/month

EBS Pricing

Implementation Priority

Based on potential savings and implementation effort:

  1. High Impact, Low Effort:

    • Enable S3 Intelligent-Tiering with archive tiers
    • Set CloudWatch Logs retention policies
    • Switch to GP3 volumes

  2. High Impact, Medium Effort:

    • Implement Compute Savings Plans for consistent Lambda/Fargate usage
    • Move from Lambda@Edge to CloudFront Functions where applicable
    • Switch from DynamoDB on-demand to provisioned for predictable workloads

  3. Medium Impact, Low Effort:

    • Replace Lambda + CloudWatch Events with EventBridge Scheduler
    • Use NAT Instances in development environments
    • Implement Cost Allocation Tags

The actual savings depend on your specific usage patterns. Use AWS Cost Explorer to identify your largest cost centers and focus optimization efforts there first.

What underutilized AWS services have you found that reduce costs? Share your discoveries in the comments.