Data Transfer Costs: How to Save $100k+/year

Inbound traffic:        FREE
Outbound traffic:       $0.02/GB (first 10 TB/month)
                        $0.02/GB (10-100 TB/month)
                        $0.015/GB (>100 TB/month)

Cross-region traffic:   $0.02/GB between regions
Cross-AZ traffic:       $0.01/GB between availability zones

Scenario: SaaS with 10 TB outbound traffic/month

Cost calculation:
- First 10 TB: 10,000 × $0.02 = $200/month

Seems small? At scale:
- 100 TB/month: $2,000/month
- 1 PB/month: $20,000/month
- 10 PB/month: $200,000/month
- 100 PB/month: $2,000,000/month

NAT Gateway pricing (AWS US-East-1):
- Fixed hourly: $0.045/hour = $33/month
- Data processing: $0.045/GB

Example: 100 GB outbound/month
Cost = $33 + (100 × $0.045) = $37.50/month

At scale (100 TB/month):
Cost = $33 + (100,000 × $0.045) = $4,533/month

For 10 production clusters:
$45,330/month in NAT gateways alone!

AWS S3 VPC Endpoint:
- Cost: $7.20/month per endpoint
- Data transfer: FREE (instead of $0.045/GB)

100 TB/month without endpoint: $4,533/month
100 TB/month with endpoint: $7.20/month
Savings: $4,526/month

DynamoDB VPC Endpoint: $7.20/month + FREE data
API Gateway VPC Endpoint: $7.20/month + FREE data

# S3 Endpoint
resource "aws_vpc_endpoint" "s3" {
  vpc_id            = aws_vpc.main.id
  service_name      = "com.amazonaws.us-east-1.s3"
  route_table_ids   = [aws_route_table.private.id]
  vpc_endpoint_type = "Gateway"
}

# DynamoDB Endpoint
resource "aws_vpc_endpoint" "dynamodb" {
  vpc_id            = aws_vpc.main.id
  service_name      = "com.amazonaws.us-east-1.dynamodb"
  route_table_ids   = [aws_route_table.private.id]
  vpc_endpoint_type = "Gateway"
}

# API Gateway Endpoint (Interface type)
resource "aws_vpc_endpoint" "api" {
  vpc_id              = aws_vpc.main.id
  service_name        = "com.amazonaws.us-east-1.apigateway"
  vpc_endpoint_type   = "Interface"
  subnet_ids          = [aws_subnet.private.id]
  security_group_ids  = [aws_security_group.vpc_endpoint.id]
}

Scenario: Multi-region replication

Primary region (us-east-1) → Secondary region (eu-west-1)
- 1 TB/day replication
- Cost: 1 TB × $0.02 × 30 = $600/month

Daily sync of 1 GB files:
- 365 GB/year × $0.02 × 12 = $87.60/month seems cheap

At scale (100 TB/day):
- $600/month becomes $18,000/month

Without optimization:
- 100 TB/month cross-region: $2,000/month

With CloudFront caching:
- CDN cost: ~$500/month
- Cache hit rate: 95%
- Data transfer cost: 5 TB × $0.02 = $100/month
- Total: $600/month
- Savings: $1,400/month (70%)

resource "aws_cloudfront_distribution" "s3" {
  origin {
    domain_name = aws_s3_bucket.data.bucket_regional_domain_name
    origin_id   = "S3Origin"
  }

  enabled = true
  is_ipv6_enabled = true

  default_cache_behavior {
    allowed_methods = ["GET", "HEAD", "OPTIONS"]
    cached_methods = ["GET", "HEAD"]
    
    forwarded_values {
      query_string = false
      cookies {
        forward = "none"
      }
    }
    
    viewer_protocol_policy = "redirect-to-https"
    min_ttl = 0
    default_ttl = 86400        # 1 day
    max_ttl = 31536000         # 1 year
    compress = true
  }
}

Within AWS VPC, same AZ:       FREE
Different AZ (same region):    $0.01/GB
Different region:              $0.02/GB

Example: Load balancer → EC2 in different AZ
- 1 TB/day cross-AZ: 1,000 × $0.01 × 30 = $300/month

For highly chatty microservices:
- 100 TB/month: $1,000/month

# Force pods in same AZ
podAffinity:
  requiredDuringSchedulingIgnoredDuringExecution:
    - labelSelector:
        matchLabels:
          app: db
      topologyKey: topology.kubernetes.io/zone

# Result: Reduces cross-AZ traffic 90%
# Savings: $900/month

Architecture:
- Primary region (us-east-1): 50 TB/month outbound
- Secondary region (eu-west-1): 30 TB/month outbound
- Log replication (cross-region): 20 TB/month
- Database replication: 10 TB/month

Costs:
- Outbound EC2: (50 + 30) × $0.02 = $1,600/month
- Log replication: 20 × $0.02 = $400/month
- DB replication: 10 × $0.02 = $200/month
- NAT gateways (2 regions): 2 × $33 = $66/month
- Cross-AZ within regions: $800/month
- Total: $3,066/month ($36,792/year)

Changes:
- Replaced NAT gateways with VPC endpoints (S3, DynamoDB)
- Added CloudFront distribution ($500/month cost)
- Enabled S3 cross-region replication (uses S3 endpoints)
- Consolidated logging to single region
- Optimized pod affinity for same-AZ deployment

New Costs:
- Outbound EC2: (50 + 30) × $0.02 = $1,600/month
- Log replication: (20 × 0.05 via CloudFront) = $20/month
- DB replication via private link: FREE
- VPC endpoints (3): $22/month
- CloudFront: $500/month
- Cross-AZ (reduced 90%): $80/month
- Total: $2,222/month

Savings: $844/month ($10,128/year or 73%)

Migrating 100 TB of data from AWS S3:
- Egress fees at $0.09/GB: 100,000 × $0.09 = $9,000
- If via NAT Gateway: additional $4,500
- Total: $13,500 to leave

The same 100 TB stored in Cloudflare R2:
- Egress: FREE
- Total: $0

# Gateway Endpoints (FREE)
- S3
- DynamoDB

# Interface Endpoints ($0.01/hour + $0.01/GB)
- SNS, SQS, ECR, KMS, CloudWatch
- Cost: ~$22/month per endpoint

# Kubernetes topology-aware routing
apiVersion: v1
kind: Service
metadata:
  name: app-service
spec:
  topologyKeys:
    - "kubernetes.io/zone"
    - "*"

# Enable gzip in nginx
gzip on;
gzip_types text/plain text/css application/json application/javascript;
gzip_min_length 1024;

# AWS Cost Explorer: filter by usage type
# NAT-GW-Bytes, CloudFront-Bytes, S3-Out-Bytes

# VPC Flow Logs: identify high-volume IPs and destinations

# Ensure pods land in same AZ
apiVersion: apps/v1
kind: Deployment
metadata:
  name: backend
spec:
  template:
    spec:
      affinity:
        podAffinity:
          requiredDuringSchedulingIgnoredDuringExecution:
          - labelSelector:
              matchExpressions:
              - key: app
                operator: In
                values: ["frontend"]
            topologyKey: topology.kubernetes.io/zone

# Restrict service routing to same zone first
apiVersion: v1
kind: Service
metadata:
  name: internal-service
spec:
  topologyKeys:
    - "topology.kubernetes.io/zone"
    - "*"

# EKS node groups per AZ
eks_node_groups:
  az-a:
    availability_zone: us-east-1a
    desired_size: 3
  az-b:
    availability_zone: us-east-1b
    desired_size: 3

# Monitor and improve cache hit rate
def analyze_cache_metrics(cloudwatch_metrics):
    hit_rate = cloudwatch_metrics['CloudFrontHitRate']
    requests = cloudwatch_metrics['CloudFrontRequests']
    
    if hit_rate < 0.90:
        return {
            'action': 'Optimize cache headers',
            'recommendations': [
                'Add Cache-Control headers to responses',
                'Increase TTL for static assets',
                'Normalize URLs (remove query strings)',
                'Enable origin shield',
                'Preload popular content'
            ]
        }
    return {'action': 'No action needed', 'hit_rate': hit_rate}

# CloudWatch dashboard for data transfer costs
import boto3

def create_cost_dashboard():
    cloudwatch = boto3.client('cloudwatch')
    
    dashboard_body = {
        "widgets": [
            {
                "type": "metric",
                "properties": {
                    "metrics": [
                        ["AWS/Usage", "ResourceCount", 
                         {"stat": "Sum", "region": "us-east-1"}]
                    ],
                    "title": "NAT Gateway Bytes",
                    "period": 300
                }
            },
            {
                "type": "metric",
                "properties": {
                    "metrics": [
                        ["AWS/CloudFront", "BytesDownloaded",
                         {"stat": "Sum", "region": "us-east-1"}]
                    ],
                    "title": "CloudFront Egress",
                    "period": 300
                }
            },
            {
                "type": "metric",
                "properties": {
                    "metrics": [
                        ["AWS/EC2", "NetworkOut",
                         {"stat": "Sum", "region": "us-east-1"}]
                    ],
                    "title": "EC2 Network Out",
                    "period": 300
                }
            }
        ]
    }
    
    cloudwatch.put_dashboard(
        DashboardName='DataTransferCosts',
        DashboardBody=str(dashboard_body).replace("'", '"')
    )

# Tag resources for cost tracking
aws ec2 create-tags --resources i-1234567890abcdef0 \
  --tags Key=CostCenter,Value=Analytics

# AWS Cost Explorer by tag
aws ce get-cost-and-usage \
  --time-period Start=2026-07-01,End=2026-07-31 \
  --granularity MONTHLY \
  --metrics "UnblendedCost" \
  --group-by Type=TAG,Key=CostCenter

def route_for_lowest_egress(destination_region, volume_tb):
    providers = {
        'aws': {'rate': 0.09, 'free_gb': 100},
        'azure': {'rate': 0.087, 'free_gb': 100},
        'gcp_standard': {'rate': 0.085, 'free_gb': 200},
    }
    
    best_provider = min(
        providers.items(),
        key=lambda kv: max(volume_tb * 1024 - kv[1]['free_gb'], 0) * kv[1]['rate']
    )
    return best_provider[0]

# Serve API responses from edge with short TTL
api_cache:
  cache_control: "public, max-age=5"
  origin_shield: true
  vary: "Accept-Encoding"
  normalize_urls: true
  purge_on_invalidations: true

# Use S3 Transfer Acceleration for large uploads
aws s3 cp large-dataset/ s3://bucket/data/ \
  --endpoint-url https://s3-accelerate.amazonaws.com \
  --recursive

# Use multipart upload for large files
aws s3 cp big-file.bin s3://bucket/ \
  --cli-read-timeout 0 \
  --cli-connect-timeout 0

def calculate_data_transfer_cost(
    volume_gb, rate_per_gb, free_tier_gb=100,
    nat_processing=False, cdn=False, monthly_fixed=0
):
    """Calculate monthly data transfer cost."""
    billable = max(volume_gb - free_tier_gb, 0)
    transfer_cost = billable * rate_per_gb
    
    # NAT Gateway adds processing fee
    if nat_processing:
        transfer_cost += billable * 0.045
    
    # CDN has fixed monthly + lower egress
    if cdn:
        transfer_cost = billable * 0.085
    
    return {
        'volume_gb': volume_gb,
        'billable_gb': billable,
        'transfer_cost': round(transfer_cost, 2),
        'nat_processing': round(billable * 0.045, 2) if nat_processing else 0,
        'fixed_cost': monthly_fixed,
        'total_monthly': round(transfer_cost + monthly_fixed, 2),
        'total_annual': round((transfer_cost + monthly_fixed) * 12, 2)
    }

# Example: 10 TB/month direct egress
print(calculate_data_transfer_cost(10240, 0.09))
# Example: 10 TB/month via CDN
print(calculate_data_transfer_cost(10240, 0.09, cdn=True))