> Navigation: ← Tool Selection Guide | Power Overview
This steering file provides comprehensive guidance for measuring overall efficiency aligned with the AWS Well-Architected Cost Optimization Pillar's third design principle: Measure Overall Efficiency.
Quantify business outcomes relative to costs to ensure cloud investments deliver maximum value and enable data-driven optimization decisions.
Goal: Establish correlation between cloud costs and business value metrics
1. Define Business Value Metrics
Identify key business metrics such as:
- Revenue per customer
- Transactions processed
- Active users
- Business outcomes delivered
2. Correlate Costs with Business Metrics
Use session_sql to create correlations:
- Cost per customer acquisition
- Cost per transaction
- Cost per active user
- Cost per business outcome
3. Track Efficiency Trends
Use getCostAndUsageComparisons to:
- Monitor cost efficiency improvements
- Track business value per dollar spent
- Identify efficiency trend patterns
- Measure optimization impact
// Step 1: Analyze cost per business metric trends
const businessValueAnalysis = usePower("aws-cost-optimization", "aws-billing-cost-management", "session_sql", {
"query": `
WITH monthly_costs AS (
SELECT
DATE_TRUNC('month', date) as month,
SUM(cost) as total_cost
FROM cost_data
WHERE date >= '2024-06-01'
GROUP BY DATE_TRUNC('month', date)
),
business_metrics AS (
SELECT
month,
active_users,
transactions,
revenue
FROM business_data
WHERE month >= '2024-06-01'
)
SELECT
c.month,
c.total_cost,
b.active_users,
b.transactions,
b.revenue,
c.total_cost / b.active_users as cost_per_user,
c.total_cost / b.transactions as cost_per_transaction,
b.revenue / c.total_cost as revenue_per_cost_dollar
FROM monthly_costs c
JOIN business_metrics b ON c.month = b.month
ORDER BY c.month
`
})
// Step 2: Compare efficiency across different services
const serviceEfficiency = usePower("aws-cost-optimization", "aws-billing-cost-management", "cost_explorer", {
"operation": "getCostAndUsage",
"start_date": "2024-11-01",
"end_date": "2024-12-01",
"granularity": "MONTHLY",
"group_by": "[{\"Type\": \"DIMENSION\", \"Key\": \"SERVICE\"}]",
"metrics": "[\"UnblendedCost\"]"
})
// Step 3: Calculate efficiency improvements over time
const efficiencyTrends = usePower("aws-cost-optimization", "aws-billing-cost-management", "cost_comparison", {
"operation": "getCostAndUsageComparisons",
"baseline_start_date": "2024-06-01",
"baseline_end_date": "2024-07-01",
"comparison_start_date": "2024-11-01",
"comparison_end_date": "2024-12-01",
"metric_for_comparison": "UnblendedCost",
"group_by": "[{\"Type\": \"DIMENSION\", \"Key\": \"SERVICE\"}]"
})
// Step 4: Forecast future efficiency based on trends
const efficiencyForecast = usePower("aws-cost-optimization", "aws-billing-cost-management", "cost_explorer", {
"operation": "getCostForecast",
"start_date": "2024-12-01",
"end_date": "2025-03-01",
"granularity": "MONTHLY",
"metric": "UNBLENDED_COST"
})
Goal: Measure and optimize resource utilization efficiency across all services
1. Analyze Resource Utilization Patterns
Use compute_optimizer to measure:
- CPU utilization efficiency
- Memory utilization patterns
- Storage utilization rates
- Network utilization optimization
2. Calculate Utilization Efficiency Ratios
Use getCostAndUsage to determine:
- Cost per utilized resource hour
- Efficiency ratios across instance types
- Utilization trends over time
- Optimization opportunity quantification
3. Measure Optimization Impact
Use rec_details to track:
- Savings from optimization implementations
- Performance impact of efficiency improvements
- ROI of optimization initiatives
- Efficiency improvement velocity
// Step 1: Get comprehensive utilization analysis
const utilizationAnalysis = usePower("aws-cost-optimization", "awslabs.billing-cost-management-mcp-server", "compute_optimizer", {
"operation": "get_ec2_instance_recommendations"
})
// Step 2: Get real-time utilization metrics from CloudWatch
const realtimeUtilization = usePower("aws-cost-optimization", "awslabs.cloudwatch-mcp-server", "get_metric_statistics", {
"namespace": "AWS/EC2",
"metric_name": "CPUUtilization",
"start_time": "2024-11-01T00:00:00Z",
"end_time": "2024-12-01T00:00:00Z",
"period": 3600,
"statistics": ["Average", "Maximum"]
})
// Step 3: Create efficiency correlation metrics
const efficiencyCorrelation = usePower("aws-cost-optimization", "awslabs.cloudwatch-mcp-server", "get_metric_data", {
"metric_data_queries": [
{
"id": "cpu_utilization",
"metric_stat": {
"metric": {
"namespace": "AWS/EC2",
"metric_name": "CPUUtilization"
},
"period": 3600,
"stat": "Average"
}
},
{
"id": "cost_efficiency",
"expression": "cpu_utilization / 100 * cost_per_hour"
}
],
"start_time": "2024-11-01T00:00:00Z",
"end_time": "2024-12-01T00:00:00Z"
})
// Step 4: Calculate utilization efficiency metrics
const utilizationEfficiency = usePower("aws-cost-optimization", "awslabs.billing-cost-management-mcp-server", "session_sql", {
"query": `
WITH utilization_data AS (
SELECT
instance_type,
AVG(cpu_utilization) as avg_cpu,
AVG(memory_utilization) as avg_memory,
SUM(cost) as total_cost,
COUNT(*) as instance_count
FROM resource_utilization
WHERE month = '2024-11'
GROUP BY instance_type
)
SELECT
instance_type,
avg_cpu,
avg_memory,
total_cost,
instance_count,
total_cost / (avg_cpu / 100) as cost_per_utilized_cpu,
total_cost / (avg_memory / 100) as cost_per_utilized_memory,
(avg_cpu + avg_memory) / 2 as overall_utilization_efficiency
FROM utilization_data
ORDER BY overall_utilization_efficiency DESC
`
})
// Step 5: Set up efficiency monitoring alarms
const efficiencyAlarms = usePower("aws-cost-optimization", "awslabs.cloudwatch-mcp-server", "describe_alarms", {
"alarm_name_prefix": "Efficiency-",
"state_value": "ALARM"
})
// Step 6: Track utilization improvement over time
const utilizationTrends = usePower("aws-cost-optimization", "awslabs.billing-cost-management-mcp-server", "cost_explorer", {
"operation": "getCostAndUsage",
"start_date": "2024-09-01",
"end_date": "2024-12-01",
"granularity": "MONTHLY",
"group_by": "[{\"Type\": \"DIMENSION\", \"Key\": \"USAGE_TYPE_GROUP\"}]",
"filter": "{\"Dimensions\": {\"Key\": \"USAGE_TYPE_GROUP\", \"Values\": [\"EC2: Running Hours\"], \"MatchOptions\": [\"EQUALS\"]}}",
"metrics": "[\"UsageQuantity\"]"
})
// Step 7: Measure optimization impact
const optimizationImpact = usePower("aws-cost-optimization", "awslabs.billing-cost-management-mcp-server", "cost_optimization", {
"operation": "list_recommendations",
"filters": "{\"resourceTypes\": [\"Ec2Instance\"], \"actionTypes\": [\"Rightsize\"]}"
})
Goal: Measure the efficiency and impact of automation on cost optimization
1. Track Automation Coverage
Use cost_optimization to measure:
- Percentage of resources under automated management
- Automation effectiveness in cost reduction
- Time savings from automation
- Error reduction through automation
2. Measure Automation ROI
Use session_sql to calculate:
- Cost savings from automated optimization
- Operational efficiency improvements
- Time-to-optimization improvements
- Automation investment vs returns
3. Monitor Automation Performance
Use getCostAndUsageComparisons to:
- Compare automated vs manual optimization results
- Track automation accuracy and effectiveness
- Measure continuous improvement from automation
- Identify automation enhancement opportunities
// Step 1: Analyze automated vs manual optimization results
const automationEffectiveness = usePower("aws-cost-optimization", "aws-billing-cost-management", "session_sql", {
"query": `
WITH optimization_results AS (
SELECT
optimization_type,
COUNT(*) as total_optimizations,
SUM(cost_savings) as total_savings,
AVG(implementation_time_hours) as avg_implementation_time,
AVG(accuracy_percentage) as avg_accuracy
FROM optimization_tracking
WHERE date >= '2024-09-01'
GROUP BY optimization_type
)
SELECT
optimization_type,
total_optimizations,
total_savings,
avg_implementation_time,
avg_accuracy,
total_savings / avg_implementation_time as savings_per_hour,
total_savings / total_optimizations as avg_savings_per_optimization
FROM optimization_results
ORDER BY savings_per_hour DESC
`
})
// Step 2: Track automation coverage expansion
const automationCoverage = usePower("aws-cost-optimization", "aws-billing-cost-management", "session_sql", {
"query": `
SELECT
month,
total_resources,
automated_resources,
(automated_resources * 100.0 / total_resources) as automation_coverage_percentage,
manual_optimizations,
automated_optimizations,
(automated_optimizations * 100.0 / (manual_optimizations + automated_optimizations)) as automation_optimization_percentage
FROM automation_metrics
WHERE month >= '2024-06-01'
ORDER BY month
`
})
// Step 3: Measure automation impact on efficiency
const automationImpact = usePower("aws-cost-optimization", "aws-billing-cost-management", "cost_comparison", {
"operation": "getCostAndUsageComparisons",
"baseline_start_date": "2024-06-01", // Before automation
"baseline_end_date": "2024-07-01",
"comparison_start_date": "2024-11-01", // After automation
"comparison_end_date": "2024-12-01",
"metric_for_comparison": "UnblendedCost"
})
// Step 4: Calculate automation ROI
const automationROI = usePower("aws-cost-optimization", "aws-billing-cost-management", "session_sql", {
"query": `
WITH automation_investment AS (
SELECT SUM(development_cost + maintenance_cost) as total_investment
FROM automation_costs
WHERE year = 2024
),
automation_savings AS (
SELECT SUM(cost_savings) as total_savings
FROM optimization_results
WHERE optimization_type = 'Automated' AND year = 2024
)
SELECT
ai.total_investment,
as.total_savings,
(as.total_savings - ai.total_investment) as net_benefit,
((as.total_savings - ai.total_investment) / ai.total_investment * 100) as roi_percentage
FROM automation_investment ai
CROSS JOIN automation_savings as
`
})
Goal: Analyze the relationship between performance improvements and cost optimization
1. Correlate Performance with Costs
Use compute_optimizer to analyze:
- Performance impact of cost optimizations
- Cost impact of performance improvements
- Optimal performance-cost balance points
- Trade-off analysis for different scenarios
2. Measure Performance Efficiency
Use session_sql to calculate:
- Performance per dollar spent
- Efficiency improvements over time
- Performance optimization ROI
- Cost-performance optimization opportunities
3. Track Optimization Balance
Use rec_details to evaluate:
- Performance risk of cost optimizations
- Cost impact of performance requirements
- Balanced optimization strategies
- Multi-objective optimization results
// Step 1: Get performance metrics from CloudWatch
const performanceMetrics = usePower("aws-cost-optimization", "awslabs.cloudwatch-mcp-server", "get_metric_data", {
"metric_data_queries": [
{
"id": "response_time",
"metric_stat": {
"metric": {
"namespace": "AWS/ApplicationELB",
"metric_name": "TargetResponseTime"
},
"period": 3600,
"stat": "Average"
}
},
{
"id": "throughput",
"metric_stat": {
"metric": {
"namespace": "AWS/ApplicationELB",
"metric_name": "RequestCount"
},
"period": 3600,
"stat": "Sum"
}
},
{
"id": "error_rate",
"metric_stat": {
"metric": {
"namespace": "AWS/ApplicationELB",
"metric_name": "HTTPCode_Target_5XX_Count"
},
"period": 3600,
"stat": "Sum"
}
}
],
"start_time": "2024-11-01T00:00:00Z",
"end_time": "2024-12-01T00:00:00Z"
})
// Step 2: Analyze performance impact of cost optimizations
const performanceCostCorrelation = usePower("aws-cost-optimization", "awslabs.billing-cost-management-mcp-server", "session_sql", {
"query": `
WITH performance_metrics AS (
SELECT
month,
service,
AVG(response_time_ms) as avg_response_time,
AVG(throughput_rps) as avg_throughput,
AVG(error_rate_percent) as avg_error_rate,
SUM(cost) as total_cost
FROM performance_cost_data
WHERE month >= '2024-09-01'
GROUP BY month, service
)
SELECT
month,
service,
avg_response_time,
avg_throughput,
avg_error_rate,
total_cost,
avg_throughput / total_cost as throughput_per_dollar,
total_cost / avg_response_time as cost_per_ms_response_time,
(100 - avg_error_rate) / total_cost as reliability_per_dollar
FROM performance_metrics
ORDER BY month, throughput_per_dollar DESC
`
})
// Step 3: Monitor performance efficiency alarms
const performanceAlarms = usePower("aws-cost-optimization", "awslabs.cloudwatch-mcp-server", "describe_alarms", {
"alarm_name_prefix": "Performance-Efficiency",
"state_value": "ALARM"
})
// Step 4: Get performance-aware optimization recommendations
const performanceOptimization = usePower("aws-cost-optimization", "awslabs.billing-cost-management-mcp-server", "compute_optimizer", {
"operation": "get_ec2_instance_recommendations",
"filters": "{\"finding\": [\"Optimized\", \"Overprovisioned\"]}"
})
// Step 5: Create performance efficiency dashboard
const performanceDashboard = usePower("aws-cost-optimization", "awslabs.cloudwatch-mcp-server", "get_dashboard", {
"dashboard_name": "Performance-Cost-Efficiency"
})
// Step 6: Analyze performance efficiency trends
const performanceEfficiencyTrends = usePower("aws-cost-optimization", "awslabs.billing-cost-management-mcp-server", "session_sql", {
"query": `
SELECT
month,
SUM(total_cost) as monthly_cost,
AVG(performance_score) as avg_performance_score,
AVG(performance_score) / SUM(total_cost) as performance_per_dollar,
LAG(AVG(performance_score) / SUM(total_cost)) OVER (ORDER BY month) as prev_performance_per_dollar,
((AVG(performance_score) / SUM(total_cost)) - LAG(AVG(performance_score) / SUM(total_cost)) OVER (ORDER BY month)) / LAG(AVG(performance_score) / SUM(total_cost)) OVER (ORDER BY month) * 100 as efficiency_improvement_percent
FROM performance_efficiency_data
WHERE month >= '2024-06-01'
GROUP BY month
ORDER BY month
`
})
// Step 7: Calculate balanced optimization opportunities
const balancedOptimization = usePower("aws-cost-optimization", "awslabs.billing-cost-management-mcp-server", "rec_details", {
"recommendation_id": "sample-recommendation-id" // Use actual recommendation ID
})
// Establish efficiency baseline
const efficiencyBaseline = usePower("aws-cost-optimization", "aws-billing-cost-management", "session_sql", {
"query": `
SELECT
'Baseline' as period,
AVG(cost_per_user) as avg_cost_per_user,
AVG(cost_per_transaction) as avg_cost_per_transaction,
AVG(resource_utilization) as avg_utilization,
AVG(performance_score) as avg_performance
FROM efficiency_metrics
WHERE date BETWEEN '2024-06-01' AND '2024-08-31'
`
})
// Track efficiency trends over time
const efficiencyTrends = usePower("aws-cost-optimization", "aws-billing-cost-management", "session_sql", {
"query": `
SELECT
month,
cost_per_user,
cost_per_transaction,
resource_utilization,
performance_score,
LAG(cost_per_user) OVER (ORDER BY month) as prev_cost_per_user,
(cost_per_user - LAG(cost_per_user) OVER (ORDER BY month)) / LAG(cost_per_user) OVER (ORDER BY month) * 100 as cost_per_user_change_percent
FROM monthly_efficiency_metrics
WHERE month >= '2024-06-01'
ORDER BY month
`
})
// Compare efficiency against benchmarks
const benchmarkComparison = usePower("aws-cost-optimization", "aws-billing-cost-management", "session_sql", {
"query": `
SELECT
metric_name,
current_value,
industry_benchmark,
internal_target,
CASE
WHEN current_value <= industry_benchmark THEN 'Above Industry Average'
WHEN current_value <= internal_target THEN 'Meeting Internal Target'
ELSE 'Below Target'
END as performance_status
FROM efficiency_benchmarks
WHERE month = '2024-11'
`
})
1. Efficiency metrics analysis: Review all efficiency KPIs
2. Trend identification: Identify positive and negative trends
3. Root cause analysis: Understand drivers of efficiency changes
4. Action planning: Plan optimization initiatives for next month
1. Comprehensive efficiency audit: Deep dive into all efficiency aspects
2. Benchmark comparison: Compare against industry and internal benchmarks
3. Strategy adjustment: Adjust efficiency strategy based on results
4. Investment planning: Plan efficiency improvement investments
1. Efficiency maturity assessment: Evaluate overall efficiency maturity
2. Strategic goal setting: Set efficiency goals for next year
3. Investment prioritization: Prioritize efficiency improvement investments
4. Process optimization: Optimize efficiency measurement processes