Az Cost Optimize

Azure cost optimize

Analyze Azure Infrastructure-as-Code and deployed resources, transform usage and pricing evidence into prioritized cost recommendations, and output issue-ready optimization work items plus an EPIC coordination issue.

When to invoke

• "Azure cost optimize this app."
• "Find Azure cost savings and create GitHub issues."
• "Right-size our App Service, Cosmos DB, SQL, Redis, and storage resources."
• "Review IaC for Azure cost optimization opportunities."
• "Create an EPIC for Azure monthly savings work."

Prerequisites and context

Analyze IaC files and/or resources in a target resource group; do not broaden repository scope beyond IaC.

• Azure MCP server should be configured and authenticated; prefer Azure MCP tools such as azmcp-* over Azure CLI when available.
• GitHub MCP server or gh CLI should be authenticated when creating issues.
• Target GitHub repository and target subscription/resource group must be known or discoverable.
• Azure resources must exist; IaC files are optional for discovery but required as the source of truth for implementation recommendations.
• Do not read arbitrary application source. Only IaC files are valid repository evidence: **/*.bicep, **/*.tf, **/main.json, and **/*template*.json.
• If no IaC files are found, stop and report that no IaC files were found.

Azure discovery and evidence

Use IaC parsing to compare intended configuration with deployed resources. Extract SKUs, tiers, capacity, autoscale settings, retention settings, backup settings, and deployment paths before making recommendations.

Usage metrics and current cost validation

Use azmcp-monitor-workspace-list --subscription <id> and azmcp-monitor-table-list --subscription <id> --workspace <name> --table-type "CustomLog" to find telemetry. Use azmcp-monitor-log-query for predefined recent and errors queries, then run targeted KQL when tables exist:

// CPU utilization for App Services
AppServiceAppLogs
| where TimeGenerated > ago(7d)
| summarize avg(CpuTime) by Resource, bin(TimeGenerated, 1h)

// Cosmos DB RU consumption
AzureDiagnostics
| where ResourceProvider == "MICROSOFT.DOCUMENTDB"
| where TimeGenerated > ago(7d)
| summarize avg(RequestCharge) by Resource

// Storage account access patterns
StorageBlobLogs
| where TimeGenerated > ago(7d)
| summarize RequestCount=count() by AccountName, bin(TimeGenerated, 1d)

Calculate CPU and memory utilization averages, database throughput patterns, storage access frequency, and Function execution rates. Validate current monthly cost before recommendations by mapping Resource -> Current SKU -> Estimated monthly cost; use https://azure.microsoft.com/en-us/pricing/ or az billing commands as the pricing source.

Optimization patterns

Preserve strict cost terminology during analysis: Step 3 must VALIDATE CURRENT COSTS before recommendations; if estimates look wrong, re-verify pricing. Record CPU/Memory and CPU/memory evidence, each SKU/tier, any error-level logs, and whether savings are X/month, Y/month, or Z/month. If no IaC files are present, STOP. Issues may be created with create_issue after approval. Include auto-scaling and unused/redundant resource checks.

Compute priority for each recommendation:

Priority Score = (Value Score × Monthly Savings) / (Risk Score × Implementation Days)
High Priority: Score > 20
Medium Priority: Score 5-20
Low Priority: Score < 5

Every savings estimate must show current validated cost, target cost, monthly savings, pricing source, implementation risk, and prerequisites.

Procedure

1. Run azmcp-bestpractices-get and keep cited best-practice evidence with the analysis.
2. Discover subscriptions, resource groups, and resources with MCP tools first and Azure CLI fallback second.
3. Search only IaC files: **/*.bicep, **/*.tf, **/main.json, **/*template*.json; stop if none are found.
4. Extract deployed and intended SKUs, tiers, relationships, usage metrics, and current estimated monthly cost.
5. Apply the optimization patterns and calculate validated monthly savings and priority scores.
6. Present a summary before issue creation. In interactive contexts, wait for user approval; in non-interactive contexts, output issue-ready markdown and do not create issues.
7. Create individual issues labeled cost-optimization and azure only after approval.
8. Create one EPIC issue labeled cost-optimization, azure, and epic after individual issues exist.

Issue templates

Individual issue title:

[COST-OPT] [Resource Type] - [Brief Description] - $X/month savings

Individual issue body:

## Cost Optimization: [Brief Title]

**Monthly Savings**: $X | **Risk Level**: [Low/Medium/High] | **Implementation Effort**: X days

### Description
[Clear explanation of the optimization and why it's needed]

### Implementation

**IaC Files Detected**: [Yes/No - based on file_search results]

```bash
# If IaC files found: show IaC modifications and deployment
# File: infrastructure/bicep/modules/app-service.bicep
# Change: sku.name: 'S3' -> 'B2'
az deployment group create --resource-group [rg] --template-file infrastructure/bicep/main.bicep

# If no IaC files: direct Azure CLI commands plus warning
# No IaC files found. If they exist elsewhere, modify those instead.
az appservice plan update --name [plan] --sku B2

Evidence

• Current Configuration: [details]
• Usage Pattern: [evidence from monitoring data]
• Cost Impact: $X/month -> $Y/month
• Best Practice Alignment: [reference to Azure best practices if applicable]

Validation Steps

• Test in non-production environment
• Verify no performance degradation
• Confirm cost reduction in Azure Cost Management
• Update monitoring and alerts if needed

Risks & Considerations

• [Risk 1 and mitigation]
• [Risk 2 and mitigation]

Priority Score: X | Value: X/10 | Risk: X/10

EPIC issue title:

```text
[EPIC] Azure Cost Optimization Initiative - $X/month potential savings

EPIC issue body:

# Azure Cost Optimization EPIC

**Total Potential Savings**: $X/month | **Implementation Timeline**: X weeks

## Executive Summary
- **Resources Analyzed**: X
- **Optimization Opportunities**: Y
- **Total Monthly Savings Potential**: $X
- **High Priority Items**: N

## Current Architecture Overview

```mermaid
graph TB
    subgraph "Resource Group: [name]"
        [Generated architecture diagram showing current resources and costs]
    end

Implementation Tracking

High Priority (Implement First)

• #[issue-number]: [Title] - $X/month savings

Medium Priority

• #[issue-number]: [Title] - $X/month savings

Low Priority (Nice to Have)

• #[issue-number]: [Title] - $X/month savings

Progress Tracking

• Completed: 0 of Y optimizations
• Savings Realized: $0 of $X/month
• Implementation Status: Not Started

Success Criteria

• All high-priority optimizations implemented

• 80% of estimated savings realized

• No performance degradation observed
• Cost monitoring dashboard updated

Notes

• Review and update this EPIC as issues are completed
• Monitor actual vs. estimated savings
• Consider scheduling regular cost optimization reviews

Verify Mermaid syntax and use accessible labels and colors if styling is added.

## Troubleshooting

| Symptom | Likely cause | Resolution |
| --- | --- | --- |
| Savings estimate lacks evidence | Pricing source, SKU, or usage metric is missing. | Re-verify configuration and pricing before recommending. |
| Azure authentication fails | MCP or CLI profile is not authenticated. | Provide manual Azure CLI setup steps and stop resource discovery. |
| No resources found | Wrong subscription/resource group or no deployment. | Create an informational issue only if approved. |
| GitHub issue creation fails | Missing GitHub auth or repository target. | Output the formatted recommendations to console. |
| Usage data is insufficient | Monitoring tables are absent or retention is too short. | Mark recommendations as configuration-based only. |

## Output template

```markdown
## Azure cost optimization summary

**Status:** ready for approval | issues created | blocked
**Resources analyzed:** <count>
**Current monthly cost:** $<amount>
**Potential monthly savings:** $<amount>
**Optimization opportunities:** <count>
**High priority items:** <count>

| Resource | Current SKU/config | Target SKU/config | Monthly savings | Risk | Effort | Priority score | Evidence |
| --- | --- | --- | --- | --- | --- | --- | --- |
| <name> | <current> | <target> | $<amount> | Low/Medium/High | <days> | <score> | <pricing and usage source> |

**Issues**
- Individual issues: <created count or issue-ready markdown>
- EPIC issue: <created issue or issue-ready markdown>

**Validation**
- IaC scan: <patterns scanned and result>
- Cost validation: <pricing source>
- User confirmation: <approved/not requested/non-interactive>

Quality gate

• azmcp-bestpractices-get was used or an unavailable-tool limitation was reported.
• Only IaC files were read from the repository: **/*.bicep, **/*.tf, **/main.json, **/*template*.json.
• If no IaC files were found, the workflow stopped and reported that result.
• Every current cost maps a resource to a SKU and a pricing source.
• Every recommendation includes current cost, target cost, monthly savings, risk, effort, and priority score.
• Azure CLI commands are executable and use placeholders only where values are unknown.
• GitHub issues are created only after approval; otherwise issue-ready markdown is returned.
• The EPIC references individual issue numbers when issues were actually created.