💰 AWS Cost Optimization Interview

Comprehensive interview preparation for cost optimization, FinOps, pricing models, and budget management on AWS.

Module: AWS Data Engineering • Topic 56 of 65 • Premium Content

Cost Optimization Framework

Architecture Diagram

┌─────────────────────────────────────────────────────────────────────┐
│                    AWS Cost Optimization Framework                  │
├─────────────────────────────────────────────────────────────────────┤
│                                                                     │
│  Visibility            Optimization          Governance            │
│  ┌──────────────┐     ┌──────────────┐      ┌──────────────┐     │
│  │ Cost Explorer│     │ Right-sizing │      │ Budgets      │     │
│  │ Budgets      │     │ Reserved     │      │ Policies     │     │
│  │ Cost & Usage │     │ Spot/On-Demand│     │ Tagging      │     │
│  └──────────────┘     └──────────────┘      └──────────────┘     │
│                                                                     │
│  Automation            Monitoring          Continuous Improvement │
│  ┌──────────────┐     ┌──────────────┐      ┌──────────────┐     │
│  │ Lambda       │     │ CloudWatch   │      │ Reviews      │     │
│  │ Scheduler    │     │ Alarms       │      │ Optimization │     │
│  │ Auto-scaling │     │ Reports      │      │ Experiments  │     │
│  └──────────────┘     └──────────────┘      └──────────────┘     │
│                                                                     │
└─────────────────────────────────────────────────────────────────────┘

Q1: How do you implement a FinOps framework on AWS?

Answer:

FinOps Pillars:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              FinOps Framework Pillars                           │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Inform                                                         │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Cost visibility & allocation                          │   │
│  │ • Unit economics (cost per transaction/user)            │   │
│  │ • Benchmarking against industry                         │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Optimize                                                       │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Rightsizing recommendations                           │   │
│  │ • Reserved Instances / Savings Plans                     │   │
│  │ • Spot Instances for fault-tolerant workloads            │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Operate                                                        │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Continuous cost monitoring                            │   │
│  │ • Anomaly detection                                     │   │
│  │ • Budget accountability                                 │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

Cost Allocation Tags:

# Enable cost allocation tags
ce = boto3.client('ce')

ce.create_cost_allocation_tag_status(
    Statuses=[
        {'TagKey': 'CostCenter', 'Status': 'Active'},
        {'TagKey': 'Environment', 'Status': 'Active'},
        {'TagKey': 'Team', 'Status': 'Active'}
    ]
)

# Tag enforcement policy
tag_policy = {
    "Version": "2012-10-17",
    "Statement": [
        {
            "Sid": "RequireCostTags",
            "Effect": "Deny",
            "Action": [
                "ec2:RunInstances",
                "rds:CreateDBInstance",
                "redshift:CreateCluster"
            ],
            "Resource": "*",
            "Condition": {
                "Null": {
                    "aws:RequestTag/CostCenter": "true"
                }
            }
        }
    ]
}

Q2: How do you analyze and reduce AWS costs?

Answer:

Cost Analysis Architecture:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              Cost Analysis & Reduction                          │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Data Collection       Analysis            Recommendations    │
│  ┌─────────────┐      ┌─────────────┐     ┌─────────────┐     │
│  │ Cost & Usage│─────▶│ Cost        │────▶│ Rightsizing  │     │
│  │ Reports     │      │ Explorer    │     │ Recommendations│    │
│  └─────────────┘      └─────────────┘     └─────────────┘     │
│         │                    │                    │             │
│         ▼                    ▼                    ▼             │
│  ┌─────────────┐      ┌─────────────┐     ┌─────────────┐     │
│  │ S3          │      │ QuickSight  │     │ Automation  │     │
│  │ (Archive)   │      │ Dashboard   │     │ Actions     │     │
│  └─────────────┘      └─────────────┘     └─────────────┘     │
└─────────────────────────────────────────────────────────────────┘

Cost Reduction Strategies:

class CostOptimizer:
    def __init__(self):
        self.ce = boto3.client('ce')
        self.ec2 = boto3.client('ec2')
    
    def analyze_monthly_costs(self):
        # Get cost breakdown by service
        response = self.ce.get_cost_and_usage(
            TimePeriod={
                'Start': (datetime.now().replace(day=1)).strftime('%Y-%m-%d'),
                'End': datetime.now().strftime('%Y-%m-%d')
            },
            Granularity='MONTHLY',
            Metrics=['BlendedCost', 'UsageQuantity'],
            GroupBy=[
                {'Type': 'DIMENSION', 'Key': 'SERVICE'}
            ]
        )
        
        return response['ResultsByTime']
    
    def get_rightsizing_recommendations(self):
        response = self.ce.get_rightsizing_recommendations(
            AccountId='123456789',
            LookBackPeriodInDays=14,
            TermInDays=30
        )
        
        return response['RightsizingRecommendations']
    
    def calculate_ri_savings(self):
        # Analyze Reserved Instance opportunities
        response = self.ce.get_reservation_purchase_recommendation(
            AccountId='123456789',
            Service='Amazon EC2',
            LookbackPeriodInDays=60,
            TermInYears='ONE_YEAR',
            PaymentOption='ALL_UPFRONT'
        )
        
        return response['RecommendationDetails']

Cost Comparison Table:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              EC2 Cost Comparison (m5.xlarge)                    │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  On-Demand:           $0.192/hr     = $139.78/month            │
│  1yr Reserved:        $0.121/hr     = $87.87/month (37% off)  │
│  3yr Reserved:        $0.077/hr     = $56.10/month (59% off)  │
│  Spot (avg):          $0.058/hr     = $42.15/month (70% off)  │
│                                                                 │
│  Savings Plan Options:                                         │
│  Compute SP (1yr):    $0.110/hr     = $79.99/month (43% off)  │
│  EC2 SP (1yr):        $0.116/hr     = $84.41/month (39% off)  │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

Q3: How do you implement auto-scaling for cost optimization?

Answer:

Auto-Scaling Architecture:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              Auto-Scaling Cost Optimization                      │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Demand-Based Scaling                                         │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ CloudWatch Metrics → Auto Scaling → EC2 Instances       │   │
│  │ CPU > 70% → Scale Out (Add instances)                   │   │
│  │ CPU < 30% → Scale In (Remove instances)                 │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Schedule-Based Scaling                                        │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ Business Hours (9-5) → Full capacity                    │   │
│  │ Off Hours → Reduced capacity                            │   │
│  │ Weekends → Minimal capacity                             │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Predictive Scaling                                            │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ ML-based prediction → Proactive scaling                 │   │
│  │ Historical patterns → Capacity planning                 │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

EMR Auto-Scaling:

# Configure EMR auto-scaling
emr = boto3.client('emr')

cluster = emr.run_job_flow(
    Name='cost-optimized-cluster',
    Instances={
        'MasterInstanceType': 'm5.xlarge',
        'SlaveInstanceType': 'm5.xlarge',
        'InstanceCount': 2,
        'Ec2KeyName': 'my-key',
        'Placement': {'AvailabilityZone': 'us-east-1a'},
        'KeepJobFlowAliveWhenNoSteps': True,
        'TerminationProtected': False,
        'AutoScalingPolicy': {
            'Constraints': {
                'MinCapacity': 2,
                'MaxCapacity': 10
            },
            'Rules': [
                {
                    'Name': 'ScaleOutCPU',
                    'ActionParameters': {
                        'InstanceType': 'm5.xlarge',
                        'InstanceCount': 1
                    },
                    'Trigger': {
                        'CloudWatchAlarmDefinition': {
                            'MetricName': 'CPUUtilization',
                            'Statistic': 'Average',
                            'Period': 300,
                            'Threshold': 70,
                            'ComparisonOperator': 'GreaterThanThreshold'
                        }
                    }
                },
                {
                    'Name': 'ScaleInCPU',
                    'ActionParameters': {
                        'InstanceCount': -1
                    },
                    'Trigger': {
                        'CloudWatchAlarmDefinition': {
                            'MetricName': 'CPUUtilization',
                            'Statistic': 'Average',
                            'Period': 600,
                            'Threshold': 30,
                            'ComparisonOperator': 'LessThanThreshold'
                        }
                    }
                }
            ]
        }
    }
)

Q4: How do you implement spot instances for batch workloads?

Answer:

Spot Instance Strategy:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              Spot Instance Cost Optimization                    │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Instance Fleet Configuration                                  │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ Master: 1x On-Demand (required)                         │   │
│  │ Core: Mix of On-Demand + Spot (70/30)                   │   │
│  │ Task: 100% Spot (maximize savings)                      │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Spot Pricing Strategy                                         │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Set max price = On-Demand price                       │   │
│  │ • Use multiple instance types for diversity             │   │
│  │ • Implement interruption handling                       │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Cost Comparison                                               │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ On-Demand: $0.192/hr                                    │   │
│  │ Spot:      $0.058/hr (70% savings)                      │   │
│  │ Monthly:   $139 → $42 (per instance)                   │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

EMR Spot Implementation:

# Create cost-optimized EMR cluster
emr = boto3.client('emr')

cluster = emr.run_job_flow(
    Name='spot-optimized-cluster',
    Instances={
        'MasterInstanceType': 'm5.xlarge',  # On-Demand for stability
        'MasterInstanceCount': 1,
        'InstanceFleets': [
            {
                'Name': 'CoreFleet',
                'InstanceFleetType': 'CORE',
                'TargetOnDemandCapacity': 2,
                'TargetSpotCapacity': 8,
                'InstanceTypeConfigs': [
                    {
                        'InstanceType': 'm5.xlarge',
                        'WeightedCapacity': 1,
                        'SpotPrice': 0.192
                    },
                    {
                        'InstanceType': 'm5a.xlarge',
                        'WeightedCapacity': 1,
                        'SpotPrice': 0.186
                    },
                    {
                        'InstanceType': 'm4.xlarge',
                        'WeightedCapacity': 1,
                        'SpotPrice': 0.175
                    }
                ]
            },
            {
                'Name': 'TaskFleet',
                'InstanceFleetType': 'TASK',
                'TargetOnDemandCapacity': 0,
                'TargetSpotCapacity': 10,
                'InstanceTypeConfigs': [
                    {
                        'InstanceType': 'm5.xlarge',
                        'WeightedCapacity': 1
                    },
                    {
                        'InstanceType': 'm5.2xlarge',
                        'WeightedCapacity': 2
                    }
                ]
            }
        ]
    }
)

Q5: How do you optimize storage costs?

Answer:

Storage Optimization Strategies:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              Storage Cost Optimization                          │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  S3 Storage Classes                                            │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ Standard: $0.023/GB (frequent access)                   │   │
│  │ Standard-IA: $0.0125/GB (infrequent)                    │   │
│  │ One Zone-IA: $0.01/GB (re-creatable)                    │   │
│  │ Glacier Instant: $0.004/GB (archive, ms access)         │   │
│  │ Glacier Flexible: $0.0036/GB (archive, min access)      │   │
│  │ Deep Archive: $0.00099/GB (long-term archive)           │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Lifecycle Policies                                            │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ Day 1: Standard → Day 30: Standard-IA                  │   │
│  │ Day 90: Glacier → Day 365: Deep Archive                │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Compression                                                   │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ Parquet + Snappy: 60-70% size reduction                │   │
│  │ Gzip: 70-80% size reduction (CPU intensive)            │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

Lifecycle Policy Implementation:

s3 = boto3.client('s3')

# Create lifecycle policy
lifecycle_config = {
    'Rules': [
        {
            'ID': 'OptimizeDataLakeStorage',
            'Status': 'Enabled',
            'Filter': {
                'And': {
                    'Prefix': 'raw/',
                    'Tags': [
                        {'Key': 'DataTier', 'Value': 'hot'}
                    ]
                }
            },
            'Transitions': [
                {
                    'Days': 30,
                    'StorageClass': 'STANDARD_IA'
                },
                {
                    'Days': 90,
                    'StorageClass': 'GLACIER'
                },
                {
                    'Days': 365,
                    'StorageClass': 'DEEP_ARCHIVE'
                }
            ],
            'Expiration': {
                'Days': 2555  # 7 years
            }
        }
    ]
}

s3.put_bucket_lifecycle_configuration(
    Bucket='data-lake-bucket',
    LifecycleConfiguration=lifecycle_config
)

Q6: How do you implement cost anomaly detection?

Answer:

Cost Anomaly Detection Architecture:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              Cost Anomaly Detection                             │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Data Sources          Analysis            Response            │
│  ┌─────────────┐      ┌─────────────┐     ┌─────────────┐     │
│  │ Cost & Usage│─────▶│ Cost Anomaly│────▶│ SNS Alerts  │     │
│  │ Reports     │      │ Detection   │     │ Lambda      │     │
│  └─────────────┘      └─────────────┘     └─────────────┘     │
│         │                    │                    │             │
│         ▼                    ▼                    ▼             │
│  ┌─────────────┐      ┌─────────────┐     ┌─────────────┐     │
│  │ CloudWatch  │      │ ML Model    │     │ Remediation │     │
│  │ Metrics     │      │ (Historical)│     │ Actions     │     │
│  └─────────────┘      └─────────────┘     └─────────────┘     │
└─────────────────────────────────────────────────────────────────┘

AWS Cost Anomaly Detection:

# Create cost anomaly detector
ce = boto3.client('ce')

ce.create_cost_anomaly_detector(
    AnomalyDetector={
        'DimensionKey': 'SERVICE',
        'MatchOptions': ['EQUALS'],
        'Values': ['Amazon Elastic Compute Cloud - Compute']
    },
    MonitorFrequency='DAILY'
)

# Create anomaly monitor
ce.create_cost_monitor(
    Monitor={
        'MonitorType': 'DIMENSIONAL',
        'DimensionKey': 'SERVICE',
        'MatchOptions': ['EQUALS'],
        'Values': ['Amazon Elastic Compute Cloud - Compute']
    }
)

# Subscribe to alerts
ce.create_cost_anomaly_subscription(
    Subscription={
        'AlertSubscription': {
            'Channel': 'EMAIL',
            'AddrESS': 'finops@example.com'
        },
        'MonitorArnList': ['arn:aws:ce::123456789:anomaly-detector/12345678'],
        'Subscriber': {
            'Type': 'EMAIL',
            'Address': 'finops@example.com'
        }
    }
)

Q7: How do you implement tagging strategy for cost allocation?

Answer:

Tagging Strategy:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              Cost Allocation Tagging Strategy                    │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Required Tags                                                 │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • CostCenter: Department/Business Unit                  │   │
│  │ • Environment: Production/Dev/Test                      │   │
│  │ • Team: Ownership team                                  │   │
│  │ • Project: Project name                                 │   │
│  │ • Owner: Individual responsible                         │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Optional Tags                                                 │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Application: Application name                         │   │
│  │ • Tier: Data tier (hot/warm/cold)                      │   │
│  │ • Compliance: Regulatory requirement                    │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Tag Enforcement                                               │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Service Control Policies (SCPs)                       │   │
│  │ • IAM policies                                          │   │
│  │ • Config rules                                          │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

Tag Enforcement via SCP:

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Sid": "RequireCostCenterTag",
            "Effect": "Deny",
            "Action": [
                "ec2:RunInstances",
                "rds:CreateDBInstance",
                "redshift:CreateCluster",
                "s3:CreateBucket"
            ],
            "Resource": "*",
            "Condition": {
                "StringNotEquals": {
                    "aws:RequestTag/CostCenter": [
                        "Engineering",
                        "Marketing",
                        "Sales",
                        "Finance"
                    ]
                }
            }
        }
    ]
}

Q8: How do you calculate cost per transaction?

Answer:

Unit Economics Implementation:

class UnitEconomics:
    def __init__(self):
        self.ce = boto3.client('ce')
    
    def calculate_cost_per_transaction(self):
        # Get total cost
        cost_response = self.ce.get_cost_and_usage(
            TimePeriod={
                'Start': (datetime.now().replace(day=1)).strftime('%Y-%m-%d'),
                'End': datetime.now().strftime('%Y-%m-%d')
            },
            Granularity='MONTHLY',
            Metrics=['BlendedCost']
        )
        
        total_cost = float(cost_response['ResultsByTime'][0]['Total']['BlendedCost']['Amount'])
        
        # Get transaction count (from application metrics)
        transactions = self.get_transaction_count()
        
        cost_per_transaction = total_cost / transactions if transactions > 0 else 0
        
        return {
            'total_cost': total_cost,
            'transactions': transactions,
            'cost_per_transaction': cost_per_transaction,
            'period': datetime.now().strftime('%Y-%m')
        }
    
    def get_transaction_count(self):
        # Query CloudWatch or application metrics
        cloudwatch = boto3.client('cloudwatch')
        
        response = cloudwatch.get_metric_statistics(
            Namespace='Application/Transactions',
            MetricName='TransactionCount',
            StartTime=datetime.now().replace(day=1),
            EndTime=datetime.now(),
            Period=86400 * 30,
            Statistics=['Sum']
        )
        
        return sum(datapoint['Sum'] for datapoint in response['Datapoints'])

Cost Dashboard:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              Unit Economics Dashboard                            │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Monthly Costs        Transactions      Cost/Transaction       │
│  ┌─────────────┐     ┌─────────────┐   ┌─────────────┐        │
│  │ $15,234     │     │ 2,456,789   │   │ $0.0062     │        │
│  └─────────────┘     └─────────────┘   └─────────────┘        │
│                                                                 │
│  Cost by Service          Cost by Team                        │
│  ┌─────────────────────┐ ┌─────────────────────┐              │
│  │ EC2:     35%        │ │ Engineering: 45%    │              │
│  │ RDS:     25%        │ │ Data: 30%           │              │
│  │ S3:      15%        │ │ Analytics: 15%      │              │
│  │ Lambda:  10%        │ │ DevOps: 10%         │              │
│  │ Other:   15%        │ │                     │              │
│  └─────────────────────┘ └─────────────────────┘              │
│                                                                 │
│  Trends                                                          │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ Cost per transaction: $0.0062 → $0.0058 (↓6.5%)       │   │
│  │ Total cost: $15,234 → $14,892 (↓2.2%)                 │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

Q9: How do you implement budget controls?

Answer:

Budget Control Architecture:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              Budget Control Architecture                        │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Budget Definition        Monitoring          Enforcement       │
│  ┌──────────────────┐    ┌──────────────┐   ┌──────────────┐  │
│  │ Monthly Budget   │───▶│ CloudWatch   │──▶│ SCP/Quotas   │  │
│  │ Service Budget   │    │ Alarms       │   │ Auto-shutdown│  │
│  │ Team Budget      │    │ Alerts       │   │              │  │
│  └──────────────────┘    └──────────────┘   └──────────────┘  │
│                                                                 │
│  Thresholds                                                     │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ 50%: Informational alert                                │   │
│  │ 70%: Warning alert                                      │   │
│  │ 90%: Critical alert (auto-actions)                      │   │
│  │ 100%: Quota enforcement                                 │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

Budget Implementation:

# Create budget
budgets = boto3.client('budgets')

budgets.create_budget(
    AccountId='123456789',
    Budget={
        'BudgetName': 'Monthly-Data-Engineering',
        'BudgetLimit': {
            'Amount': '10000',
            'Unit': 'USD'
        },
        'TimeUnit': 'MONTHLY',
        'BudgetType': 'COST',
        'CostFilters': {
            'TagKeyValue': [
                'user:CostCenter$DataEngineering'
            ]
        }
    },
    NotificationsWithSubscribers=[
        {
            'Notification': {
                'NotificationType': 'ACTUAL',
                'ComparisonOperator': 'GREATER_THAN',
                'Threshold': 70,
                'ThresholdType': 'PERCENTAGE'
            },
            'Subscribers': [
                {
                    'SubscriptionType': 'EMAIL',
                    'Address': 'finops@example.com'
                }
            ]
        }
    ]
)

Q10: How do you optimize data transfer costs?

Answer:

Data Transfer Cost Optimization:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              Data Transfer Cost Optimization                    │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Transfer Types & Costs                                        │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ S3 → Internet: $0.09/GB                                 │   │
│  │ S3 → Same Region: $0.01/GB                              │   │
│  │ S3 → Cross-Region: $0.02/GB                             │   │
│  │ EC2 → Internet: $0.09/GB                                │   │
│  │ EC2 → Same AZ: Free                                     │   │
│  │ EC2 → Cross-AZ: $0.01/GB                                │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Optimization Strategies                                       │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Use VPC endpoints for S3/DynamoDB                     │   │
│  │ • Keep processing in same region                        │   │
│  │ • Use CloudFront for internet delivery                  │   │
│  │ • Compress data before transfer                         │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

VPC Endpoint for Cost Reduction:

# Create VPC endpoint (saves $0.08/GB)
ec2 = boto3.client('ec2')

ec2.create_vpc_endpoint(
    VpcId='vpc-12345678',
    ServiceName='com.amazonaws.us-east-1.s3',
    RouteTableIds=['rtb-12345678'],
    VpcEndpointType='Gateway'
)

# Cost savings calculation
def calculate_endpoint_savings():
    monthly_gb = 10000  # 10TB transfer
    without_endpoint = monthly_gb * 0.09  # $900
    with_endpoint = monthly_gb * 0.01     # $100
    
    return {
        'monthly_savings': without_endpoint - with_endpoint,
        'annual_savings': (without_endpoint - with_endpoint) * 12,
        'savings_percentage': 89
    }

Q11: How do you implement cost optimization for Redshift?

Answer:

Redshift Cost Optimization:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              Redshift Cost Optimization                         │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Instance Strategy                                             │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ Provisioned (Reserved): Predictable workloads           │   │
│  │ Serverless: Variable workloads                          │   │
│  │ Auto-suspend: Dev/test environments                     │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Cost Comparison (ra3.xlplus)                                  │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ On-Demand: $0.25/hr = $180/month                       │   │
│  │ 1yr Reserved: $0.16/hr = $115/month (36% savings)      │   │
│  │ 3yr Reserved: $0.10/hr = $72/month (60% savings)       │   │
│  │ Serverless: $0.375/RPU-hr (variable)                   │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Auto-Suspend Strategy                                         │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ Business Hours (9-6): Running                           │   │
│  │ Off Hours (6-9am, weekends): Suspended                  │   │
│  │ Savings: 60-70%                                        │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

Auto-Suspend Lambda:

def lambda_handler(event, context):
    redshift = boto3.client('redshift')
    
    # Check current hour (UTC)
    current_hour = datetime.now().hour
    
    # Business hours: 9 AM - 6 PM UTC
    business_hours = range(9, 18)
    
    clusters = redshift.describe_clusters()['Clusters']
    
    for cluster in clusters:
        cluster_id = cluster['ClusterIdentifier']
        status = cluster['ClusterStatus']
        
        if current_hour not in business_hours and status == 'available':
            # Suspend cluster
            redshift.pause_cluster(ClusterIdentifier=cluster_id)
            
        elif current_hour in business_hours and status == 'paused':
            # Resume cluster
            redshift.resume_cluster(ClusterIdentifier=cluster_id)

Q12: How do you implement cost reporting and dashboards?

Answer:

Cost Reporting Architecture:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              Cost Reporting Architecture                        │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Data Collection       Visualization        Distribution       │
│  ┌─────────────┐      ┌─────────────┐     ┌─────────────┐     │
│  │ Cost & Usage│─────▶│ QuickSight  │────▶│ Email       │     │
│  │ Reports     │      │ Dashboard   │     │ Reports     │     │
│  └─────────────┘      └─────────────┘     └─────────────┘     │
│         │                    │                    │             │
│         ▼                    ▼                    ▼             │
│  ┌─────────────┐      ┌─────────────┐     ┌─────────────┐     │
│  │ S3          │      │ CloudWatch  │     │ Slack       │     │
│  │ (Archive)   │      │ Metrics     │     │ Notifications│    │
│  └─────────────┘      └─────────────┘     └─────────────┘     │
└─────────────────────────────────────────────────────────────────┘

QuickSight Dashboard:

# Create QuickSight dashboard
quicksight = boto3.client('quicksight')

# Create data source from Cost Explorer
response = quicksight.create_data_source(
    AwsAccountId='123456789',
    DataSourceId='cost-data-source',
    Name='Cost Explorer Data',
    Type='ATHENA',
    Parameters={
        'Athena': {
            'WorkGroup': 'cost-analysis'
        }
    }
)

# Create dashboard
dashboard = quicksight.create_dashboard(
    AwsAccountId='123456789',
    DashboardId='cost-dashboard',
    Name='Cost Optimization Dashboard',
    SourceEntity={
        'SourceTemplate': {
            'DataSetReferences': [
                {
                    'DataSetArn': 'arn:aws:quicksight:us-east-1:123456789:dataset/cost-data',
                    'DataSetPlaceholder': 'CostData'
                }
            ],
            'Arn': 'arn:aws:quicksight:us-east-1:123456789:template/cost-template'
        }
    }
)

Q13: How do you optimize Lambda costs?

Answer:

Lambda Cost Optimization:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              Lambda Cost Optimization                           │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Pricing Model                                                 │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ Requests: $0.20 per 1M requests                         │   │
│  │ Duration: $0.0000166667 per GB-second                   │   │
│  │ Free tier: 1M requests + 400,000 GB-seconds/month       │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Optimization Strategies                                       │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ Right-size memory (CPU scales with memory)              │   │
│  │ Optimize code execution time                            │   │
│  │ Use provisioned concurrency for steady workloads        │   │
│  │ Batch operations to reduce invocations                  │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Cost Comparison                                               │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ 1M requests @ 100ms, 128MB: ~$2.08/month               │   │
│  │ 1M requests @ 100ms, 256MB: ~$4.17/month               │   │
│  │ 1M requests @ 50ms, 128MB: ~$1.04/month (50% less)     │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

Lambda Right-Sizing:

import boto3
import json

cloudwatch = boto3.client('cloudwatch')

def analyze_lambda_performance(function_name):
    # Get duration metrics
    response = cloudwatch.get_metric_statistics(
        Namespace='AWS/Lambda',
        MetricName='Duration',
        Dimensions=[{'Name': 'FunctionName', 'Value': function_name}],
        StartTime=datetime.now() - timedelta(days=30),
        EndTime=datetime.now(),
        Period=86400,
        Statistics=['Average', 'Maximum', 'p99']
    )
    
    avg_duration = response['Datapoints'][0]['Average']
    max_duration = response['Datapoints'][0]['Maximum']
    
    # Recommend memory based on duration
    if avg_duration < 50:
        recommended_memory = 128
    elif avg_duration < 100:
        recommended_memory = 256
    elif avg_duration < 200:
        recommended_memory = 512
    else:
        recommended_memory = 1024
    
    return {
        'function': function_name,
        'avg_duration': avg_duration,
        'max_duration': max_duration,
        'recommended_memory': recommended_memory,
        'cost_savings': calculate_savings(function_name, recommended_memory)
    }

Q14: How do you implement cost anomaly detection and response?

Answer:

Anomaly Detection and Response:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              Cost Anomaly Detection & Response                  │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Detection          Classification         Response            │
│  ┌─────────────┐    ┌─────────────┐      ┌─────────────┐      │
│  │ Cost Anomaly│───▶│ Severity    │─────▶│ Auto-Stop   │      │
│  │ Detection   │    │ Classification│    │ Scale Down  │      │
│  └─────────────┘    └─────────────┘      └─────────────┘      │
│         │                  │                    │               │
│         ▼                  ▼                    ▼               │
│  ┌─────────────┐    ┌─────────────┐      ┌─────────────┐      │
│  │ CloudWatch  │    │ ML Model    │      │ Notify      │      │
│  │ Metrics     │    │ (Patterns)  │      │ FinOps Team │      │
│  └─────────────┘    └─────────────┘      └─────────────┘      │
└─────────────────────────────────────────────────────────────────┘

Automated Response Lambda:

def lambda_handler(event, context):
    # Parse anomaly alert
    anomaly = json.loads(event['Records'][0]['Sns']['Message'])
    
    severity = anomaly['severity']
    service = anomaly['service']
    amount = anomaly['amount']
    
    # Classification and response
    if severity > 80:  # Critical
        # Immediate action
        if service == 'EC2':
            # Stop non-critical instances
            stop_non_critical_instances()
        elif service == 'RDS':
            # Pause dev/test instances
            pause_dev_instances()
        
        notify_finops_team(anomaly, 'CRITICAL')
        
    elif severity > 60:  # High
        # Scale down
        if service == 'EC2':
            scale_down_instances()
        
        notify_finops_team(anomaly, 'HIGH')
        
    elif severity > 40:  # Medium
        # Investigate
        create_investigation_ticket(anomaly)
        
    else:  # Low
        # Log for review
        log_anomaly(anomaly)

Q15: How do you implement cost optimization for S3?

Answer:

S3 Cost Optimization:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              S3 Cost Optimization                               │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Storage Classes                                               │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ Standard: $0.023/GB-month                               │   │
│  │ Intelligent-Tiering: $0.023-0.0025/GB-month            │   │
│  │ Standard-IA: $0.0125/GB-month                           │   │
│  │ One Zone-IA: $0.01/GB-month                             │   │
│  │ Glacier: $0.0036-0.00099/GB-month                       │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Request Costs                                                 │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ PUT/COPY/POST: $0.005/1,000 requests                    │   │
│  │ GET/SELECT: $0.0004/1,000 requests                      │   │
│  │ Lifecycle transitions: $0.01/1,000 requests             │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Optimization Strategies                                       │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Intelligent-Tiering for unknown access patterns       │   │
│  │ • Lifecycle policies for automatic tiering              │   │
│  │ • S3 Batch Operations for bulk transitions              │   │
│  │ • S3 Inventory for cleanup                              │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

Intelligent-Tiering Configuration:

# Enable Intelligent-Tiering
s3 = boto3.client('s3')

s3.put_bucket_intelligent_tiering_configuration(
    Bucket='data-lake-bucket',
    Id='full-bucket',
    IntelligentTieringConfiguration={
        'Status': 'Enabled',
        'Filter': {'Prefix': ''},
        'Tierings': [
            {
                'AccessTier': 'ARCHIVE_ACCESS',
                'Days': 90
            },
            {
                'AccessTier': 'DEEP_ARCHIVE_ACCESS',
                'Days': 180
            }
        ]
    }
)

# Monitor tiering savings
def calculate_intelligent_tiering_savings():
    # Before: All Standard
    before_cost = 1000 * 0.023  # $23/GB-month
    
    # After: Intelligent-Tiering (assuming 60% moves to IA, 30% to Archive)
    after_cost = (1000 * 0.4 * 0.023) + (1000 * 0.6 * 0.0125)  # $14.95/GB-month
    
    return {
        'monthly_savings': before_cost - after_cost,
        'savings_percentage': 35
    }

Q16: How do you implement FinOps culture in an organization?

Answer:

FinOps Culture Implementation:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              FinOps Culture Framework                           │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Education          Accountability        Governance           │
│  ┌──────────────┐   ┌──────────────┐     ┌──────────────┐    │
│  │ Training     │   │ Team Budgets │     │ Policies     │    │
│  │ Workshops    │   │ Cost Owners  │     │ Standards    │    │
│  │ Best Practices│  │ KPIs         │     │ Reviews      │    │
│  └──────────────┘   └──────────────┘     └──────────────┘    │
│                                                                 │
│  Visibility          Optimization         Continuous Improv.  │
│  ┌──────────────┐   ┌──────────────┐     ┌──────────────┐    │
│  │ Dashboards   │   │ Recommendations│    │ Monthly Reviews│   │
│  │ Reports      │   │ Experiments   │    │ Optimization │    │
│  │ Alerts       │   │ Automation    │    │ Roadmap      │    │
│  └──────────────┘   └──────────────┘     └──────────────┘    │
└─────────────────────────────────────────────────────────────────┘

FinOps Maturity Model:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              FinOps Maturity Levels                             │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Level 1: Crawl (Basic)                                       │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Basic cost visibility                                 │   │
│  │ • Manual optimization                                   │   │
│  │ • Ad-hoc reporting                                      │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Level 2: Walk (Intermediate)                                  │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Automated alerts                                      │   │
│  │ • Rightsizing recommendations                           │   │
│  │ • Tag enforcement                                       │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Level 3: Run (Advanced)                                       │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Full unit economics                                   │   │
│  │ • Predictive analytics                                  │   │
│  │ • Automated optimization                                │   │
│  │ • Continuous improvement                                │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

Q17: How do you optimize EMR costs?

Answer:

EMR Cost Optimization:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              EMR Cost Optimization Strategies                   │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Instance Selection                                            │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Graviton instances: 20% cheaper                       │   │
│  │ • Spot instances: 60-70% cheaper                        │   │
│  │ • Right-size based on workload                          │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Cluster Management                                            │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Auto-scaling: Match capacity to demand                │   │
│  │ • Auto-terminate: Shut down when idle                   │   │
│  │ • Use EMR Serverless for variable workloads             │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Cost Comparison                                               │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ m5.xlarge On-Demand: $0.192/hr                         │   │
│  │ m6g.xlarge On-Demand: $0.154/hr (20% savings)         │   │
│  │ m5.xlarge Spot: $0.058/hr (70% savings)                │   │
│  │ m6g.xlarge Spot: $0.046/hr (76% savings)               │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

EMR Cost Optimizer:

class EMRCostOptimizer:
    def __init__(self):
        self.emr = boto3.client('emr')
    
    def optimize_cluster(self, cluster_id):
        # Get cluster details
        response = self.emr.describe_cluster(ClusterId=cluster_id)
        cluster = response['Cluster']
        
        # Analyze utilization
        utilization = self.analyze_utilization(cluster_id)
        
        recommendations = []
        
        # Right-sizing recommendation
        if utilization['avg_cpu'] < 30:
            recommendations.append({
                'type': 'RIGHT_SIZE',
                'current': cluster['Ec2InstanceAttributes']['Ec2InstanceType'],
                'recommended': 'm5.large',
                'savings': 50
            })
        
        # Spot recommendation
        if cluster['Ec2InstanceAttributes']['RequestedInstanceType'] != 'spot':
            recommendations.append({
                'type': 'USE_SPOT',
                'current': 'On-Demand',
                'recommended': 'Spot',
                'savings': 70
            })
        
        # Graviton recommendation
        if 'm5' in cluster['Ec2InstanceAttributes']['Ec2InstanceType']:
            recommendations.append({
                'type': 'USE_GRAVITON',
                'current': 'm5.xlarge',
                'recommended': 'm6g.xlarge',
                'savings': 20
            })
        
        return recommendations

Q18: How do you implement cost controls for development environments?

Answer:

Dev Environment Cost Controls:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              Development Environment Cost Controls              │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Time-Based Controls                                           │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Auto-suspend outside business hours                   │   │
│  │ • Auto-terminate on weekends                            │   │
│  │ • Maximum runtime limits                                │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Resource Limits                                               │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Instance size restrictions                            │   │
│  │ • Maximum instance count                                │   │
│  │ • Storage quotas                                        │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Monitoring & Alerts                                           │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Daily cost alerts                                     │   │
│  │ • Budget thresholds                                     │   │
│  │ • Anomaly detection                                     │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

Dev Environment Scheduler:

def lambda_handler(event, context):
    # Auto-suspend dev resources
    ec2 = boto3.client('ec2')
    rds = boto3.client('rds')
    
    current_hour = datetime.now().hour
    is_weekday = datetime.now().weekday() < 5
    
    # Business hours: 9 AM - 7 PM UTC, weekdays only
    business_hours = is_weekday and 9 <= current_hour <= 19
    
    if not business_hours:
        # Stop dev EC2 instances
        instances = ec2.describe_instances(
            Filters=[{'Name': 'tag:Environment', 'Values': ['development']}]
        )
        
        for reservation in instances['Reservations']:
            for instance in reservation['Instances']:
                if instance['State']['Name'] == 'running':
                    ec2.stop_instances(InstanceIds=[instance['InstanceId']])
        
        # Pause dev RDS instances
        db_instances = rds.describe_db_instances()
        for db in db_instances['DBInstances']:
            if db['DBInstanceIdentifier'].startswith('dev-'):
                if db['DBInstanceStatus'] == 'available':
                    rds.stop_db_instance(DBInstanceIdentifier=db['DBInstanceIdentifier'])

Q19: How do you calculate ROI for cloud cost optimization?

Answer:

ROI Calculation Framework:

class CloudROI:
    def calculate_roi(self, optimization_data):
        # Cost savings
        monthly_savings = optimization_data['monthly_savings']
        annual_savings = monthly_savings * 12
        
        # Implementation costs
        implementation_cost = optimization_data['implementation_cost']
        ongoing_cost = optimization_data['ongoing_cost']
        
        # Time to value
        time_to_value_months = optimization_data['time_to_value']
        
        # ROI calculation
        total_benefit = annual_savings
        total_cost = implementation_cost + (ongoing_cost * 12)
        
        roi = ((total_benefit - total_cost) / total_cost) * 100
        
        # Payback period
        payback_months = implementation_cost / monthly_savings
        
        return {
            'annual_savings': annual_savings,
            'implementation_cost': implementation_cost,
            'annual_ongoing_cost': ongoing_cost * 12,
            'roi_percentage': roi,
            'payback_months': payback_months,
            'npv_3_year': self.calculate_npv(annual_savings, ongoing_cost, implementation_cost)
        }
    
    def calculate_npv(self, annual_savings, annual_cost, initial_cost, discount_rate=0.1):
        npv = -initial_cost
        for year in range(1, 4):
            cash_flow = annual_savings - annual_cost
            npv += cash_flow / ((1 + discount_rate) ** year)
        return npv

ROI Dashboard:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              Cost Optimization ROI Dashboard                    │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Annual Savings          Implementation Cost    ROI            │
│  ┌─────────────┐        ┌─────────────┐       ┌─────────────┐ │
│  │ $125,000    │        │ $15,000     │       │ 733%        │ │
│  └─────────────┘        └─────────────┘       └─────────────┘ │
│                                                                 │
│  Payback Period          NPV (3 Year)                         │
│  ┌─────────────┐        ┌─────────────┐                       │
│  │ 1.4 months  │        │ $298,000    │                       │
│  └─────────────┘        └─────────────┘                       │
│                                                                 │
│  Optimization Breakdown                                        │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ Reserved Instances: $45,000 (36%)                       │   │
│  │ Spot Instances: $35,000 (28%)                           │   │
│  │ Rightsizing: $25,000 (20%)                              │   │
│  │ Storage Tiering: $20,000 (16%)                          │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

Q20: How do you implement cost governance policies?

Answer:

Cost Governance Framework:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              Cost Governance Framework                          │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Policies              Enforcement          Monitoring          │
│  ┌──────────────────┐ ┌──────────────────┐ ┌────────────────┐ │
│  │ Spending Limits  │ │ SCPs             │ │ Budget Alerts  │ │
│  │ Resource Limits  │ │ IAM Policies     │ │ Cost Reports   │ │
│  │ Tag Requirements │ │ Config Rules     │ │ Anomaly Detect │ │
│  └──────────────────┘ └──────────────────┘ └────────────────┘ │
│                                                                 │
│  Approval Workflows                                            │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Large purchase approval                               │   │
│  │ • New service approval                                  │   │
│  │ • Reserved Instance purchases                           │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

Service Control Policy for Cost Control:

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Sid": "DenyExpensiveInstances",
            "Effect": "Deny",
            "Action": "ec2:RunInstances",
            "Resource": "arn:aws:ec2:*:*:instance/*",
            "Condition": {
                "ForAnyValue:StringNotLike": {
                    "ec2:InstanceType": [
                        "t3.*",
                        "t2.*",
                        "m5.*",
                        "m4.*",
                        "c5.*",
                        "c4.*",
                        "r5.*",
                        "r4.*"
                    ]
                }
            }
        },
        {
            "Sid": "DenyHighStorage",
            "Effect": "Deny",
            "Action": "ec2:RunInstances",
            "Resource": "arn:aws:ec2:*:*:volume/*",
            "Condition": {
                "NumericGreaterThan": {
                    "ebs:volumeSize": "500"
                }
            }
        }
    ]
}

Q21: How do you optimize data processing costs?

Answer:

Data Processing Cost Optimization:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              Data Processing Cost Optimization                  │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Glue Optimization                                             │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Right-size DPUs (start with 10, scale as needed)      │   │
│  │ • Use bookmarking for incremental processing            │   │
│  │ • Optimize partitions (128MB-1GB per file)             │   │
│  │ • Use Python Shell for simple jobs (0.0625 DPU)        │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  EMR Optimization                                              │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Use Spot instances for task nodes                     │   │
│  │ • Auto-scaling based on workload                        │   │
│  │ • Right-size instance types                             │   │
│  │ • Use EMR Serverless for variable workloads             │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Athena Optimization                                           │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Partition data for query pruning                      │   │
│  │ • Use columnar formats (Parquet, ORC)                   │   │
│  │ • Enable result caching                                 │   │
│  │ • Use reserved capacity for predictable queries         │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

Q22: How do you implement cost allocation for multi-tenant systems?

Answer:

Multi-Tenant Cost Allocation:

class TenantCostAllocator:
    def __init__(self):
        self.ce = boto3.client('ce')
    
    def allocate_costs(self, tenant_id, period):
        # Get costs by tenant tag
        response = self.ce.get_cost_and_usage(
            TimePeriod={
                'Start': period['start'],
                'End': period['end']
            },
            Granularity='MONTHLY',
            Metrics=['BlendedCost'],
            Filter={
                'Tags': {
                    'Key': 'TenantId',
                    'Values': [tenant_id]
                }
            }
        )
        
        total_cost = float(response['ResultsByTime'][0]['Total']['BlendedCost']['Amount'])
        
        # Get tenant usage metrics
        usage = self.get_tenant_usage(tenant_id, period)
        
        # Calculate cost per unit
        cost_per_query = total_cost / usage['total_queries'] if usage['total_queries'] > 0 else 0
        cost_per_gb = total_cost / usage['data_processed_gb'] if usage['data_processed_gb'] > 0 else 0
        
        return {
            'tenant_id': tenant_id,
            'period': period,
            'total_cost': total_cost,
            'usage': usage,
            'cost_per_query': cost_per_query,
            'cost_per_gb': cost_per_gb
        }

Q23: How do you optimize network costs?

Answer:

Network Cost Optimization:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              Network Cost Optimization                          │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Data Transfer Costs                                           │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ Internet → S3: $0.09/GB                                 │   │
│  │ S3 → Internet: $0.09/GB                                 │   │
│  │ Same Region (AZ to AZ): $0.01/GB                        │   │
│  │ Cross-Region: $0.02/GB                                  │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Optimization Strategies                                       │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • VPC Endpoints: Free data transfer to S3/DynamoDB     │   │
│  │ • CloudFront: $0.085/GB (vs $0.09 direct)              │   │
│  │ • Same-region processing: Minimize cross-region        │   │
│  │ • Data compression: Reduce transfer volume             │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

Q24: How do you implement cost optimization automation?

Answer:

Cost Optimization Automation:

class CostOptimizationAutomation:
    def __init__(self):
        self.ec2 = boto3.client('ec2')
        self.ce = boto3.client('ce')
    
    def auto_terminate_idle_instances(self):
        # Find idle instances (CPU < 5% for 7 days)
        cloudwatch = boto3.client('cloudwatch')
        
        instances = self.ec2.describe_instances(
            Filters=[{'Name': 'instance-state-name', 'Values': ['running']}]
        )
        
        for reservation in instances['Reservations']:
            for instance in reservation['Instances']:
                instance_id = instance['InstanceId']
                
                # Check CPU utilization
                response = cloudwatch.get_metric_statistics(
                    Namespace='AWS/EC2',
                    MetricName='CPUUtilization',
                    Dimensions=[{'Name': 'InstanceId', 'Value': instance_id}],
                    StartTime=datetime.now() - timedelta(days=7),
                    EndTime=datetime.now(),
                    Period=86400,
                    Statistics=['Average']
                )
                
                if response['Datapoints']:
                    avg_cpu = sum(dp['Average'] for dp in response['Datapoints']) / len(response['Datapoints'])
                    
                    if avg_cpu < 5:
                        # Terminate idle instance
                        self.ec2.stop_instances(InstanceIds=[instance_id])
                        print(f"Stopped idle instance {instance_id} (CPU: {avg_cpu:.2f}%)")
    
    def auto_snapshot_volumes(self):
        # Snapshot volumes before termination
        volumes = self.ec2.describe_volumes(
            Filters=[{'Name': 'status', 'Values': ['available']}]
        )
        
        for volume in volumes['Volumes']:
            # Check age
            launch_time = volume['CreateTime']
            age_days = (datetime.now(launch_time.tzinfo) - launch_time).days
            
            if age_days > 30:
                # Create snapshot
                self.ec2.create_snapshot(
                    VolumeId=volume['VolumeId'],
                    Description=f"Auto-snapshot after {age_days} days"
                )

Q25: How do you present cost optimization to leadership?

Answer:

Executive Cost Report:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              Executive Cost Report                              │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Current State                                                 │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ Monthly Spend: $45,234                                  │   │
│  │ Budget: $50,000                                         │   │
│  │ Variance: -9.5% (Under Budget)                         │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Optimization Achievements                                     │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ Reserved Instances: Saved $12,450/month                 │   │
│  │ Spot Instances: Saved $8,230/month                      │   │
│  │ Rightsizing: Saved $5,670/month                         │   │
│  │ Storage Tiering: Saved $3,890/month                     │   │
│  │ Total Savings: $30,240/month (40%)                      │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  ROI Metrics                                                   │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ Annual Savings: $362,880                                │   │
│  │ Implementation Cost: $25,000                            │   │
│  │ ROI: 1,351%                                             │   │
│  │ Payback Period: < 1 month                              │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Recommendations                                               │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Migrate to Graviton instances (additional 20% savings)│   │
│  │ • Implement auto-scaling (additional 15% savings)       │   │
│  │ • Use S3 Intelligent-Tiering (additional 10% savings)   │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

Summary

Mastering AWS cost optimization requires understanding:

Pricing Models: On-Demand, Reserved, Spot, Savings Plans
Optimization Strategies: Rightsizing, auto-scaling, storage tiering
FinOps Practices: Cost visibility, accountability, governance
Automation: Auto-termination, auto-scaling, budget controls
Reporting: Dashboards, ROI calculations, executive reporting

These concepts form the foundation for building cost-effective, efficient data systems on AWS.

AWS Cost Optimization Interview Questions

💰 AWS Cost Optimization Interview

Cost Optimization Framework

Q1: How do you implement a FinOps framework on AWS?

Q2: How do you analyze and reduce AWS costs?

Q3: How do you implement auto-scaling for cost optimization?

Q4: How do you implement spot instances for batch workloads?

Q5: How do you optimize storage costs?

Q6: How do you implement cost anomaly detection?

Q7: How do you implement tagging strategy for cost allocation?

Q8: How do you calculate cost per transaction?

Q9: How do you implement budget controls?

Q10: How do you optimize data transfer costs?

Q11: How do you implement cost optimization for Redshift?

Q12: How do you implement cost reporting and dashboards?

Q13: How do you optimize Lambda costs?

Q14: How do you implement cost anomaly detection and response?

Q15: How do you implement cost optimization for S3?

Q16: How do you implement FinOps culture in an organization?

Q17: How do you optimize EMR costs?

Q18: How do you implement cost controls for development environments?

Q19: How do you calculate ROI for cloud cost optimization?

Q20: How do you implement cost governance policies?

Q21: How do you optimize data processing costs?

Q22: How do you implement cost allocation for multi-tenant systems?

Q23: How do you optimize network costs?

Q24: How do you implement cost optimization automation?

Q25: How do you present cost optimization to leadership?

Summary