Cost & Resource Optimization in Azure — A Practical FinOps Playbook

Cloud & FinOps — Azure

Cost & Resource Optimization in Azure — A Practical FinOps Playbook

Stop the bill shock. This long-form, WordPress-ready guide gives architects and ops teams step-by-step tactics, governance patterns, and troubleshooting scripts (PowerShell + Resource Graph + REST) to control Azure spend and get operational overhead under control.

Includes actionable scripts, tagging templates, governance checklist and internal links to cloudknowledge.in for more deep dives.

Short summary (120 chars): Control bill shock in Azure: practical FinOps playbook — right-sizing, tagging, Savings Plans, budgets + ready PowerShell/Graph scripts.

Why Cost & Resource Optimization in Azure is a Persistent Pain

Organizations migrate to Azure expecting predictable savings and operational flexibility — but many encounter “bill shock” after migration. The usual culprits: idle or oversized resources, complex pricing constructs (SKUs, families, regions, reserved capacity vs savings plans), and insufficient post-migration FinOps practices. This guide focuses on practical, repeatable fixes you can implement in weeks, not months.

Common Cost Drivers & Why They Persist

Here are the frequent cost drivers that organizations encounter and why they keep happening:

Idle and underutilized VMs and PaaS resources: Non-production resources left running, or VMs sized for peak but running low CPU/memory most of the time.
Complex pricing constructs: Difference between pay-as-you-go, reservations, and savings plans make it hard to pick the right commitment model at scale.
Poor tagging and cost allocation: Without tags and cost scopes, chargeback and showback are inaccurate, reducing accountability.
Snapshots & storage over-retention: Unreviewed snapshots, unmanaged Blob tiers, and temp storage add hidden recurring costs.
Lack of automation: Manual shutdown/start processes and no autoscale cause waste.

All of these issues are addressable with visibility, governance, commitments, and automation — described in the playbook below.

At-a-Glance Strategy (The Playbook)

Visibility: Centralize cost views and export to a cost lake or Power BI dashboards.
Tagging & chargeback: Enforce tags at deploy time; map billing views to business units and owners.
Right-size & autoscale: Use telemetry to resize compute; prefer autoscale for variable workloads.
Commit wisely: Combine Reservations and Savings Plans; use Hybrid Benefit where applicable.
Automate waste removal: Scheduled shutdowns for dev/test, cleanup of unattached disks and old snapshots.
Governance & FinOps: Budget alerts, approval gates, and monthly optimization sprints.

Right-Sizing Compute & Autoscale

Right-sizing is often the single largest immediate lever. Follow this pattern:

Collect performance telemetry (CPU, memory, disk IO, network) for a representative window (30–90 days).
Classify workloads (steady, bursty, batch) and pick families accordingly.
Apply autoscale policies or migrate to PaaS/serverless where feasible (App Service, Functions, AKS with autoscaling).

Use Azure Monitor metrics and Advisor recommendations as inputs to your decisions. Below are practical commands you can use to discover and export recommendations.

PowerShell: list cost recommendations (Advisor)


# Requires Az.Advisor module
Connect-AzAccount
Select-AzSubscription -SubscriptionId <SUBSCRIPTION_ID>

Get-AzAdvisorRecommendation -Category Cost |
  Select-Object SubscriptionId, ResourceGroup, ResourceId, ShortDescription, Impact, ImpactedField

Automated right-size workflow (pattern)

Export Advisor recommendations daily to storage or Log Analytics.
Filter high-confidence items (e.g., VMs with <5% avg CPU for 30 days).
Create staged test resize tasks and validate in staging.
Apply in production with change approvals and record cost impact.

Reservations vs Savings Plans

Commitment options help reduce cost but must be chosen carefully:

Reservations: Commit to specific instance families/sizes in a region for 1 or 3 years — high savings for stable workloads.
Savings Plans for Compute: Commit to a dollar-per-hour compute spend across families and regions — more flexible for dynamic usage.

Best practice: gather 30–90 days of steady-state usage before making large reservation purchases. A mixed strategy (savings plans + targeted reservations) often delivers the best balance of flexibility and savings.

Storage Optimization: Tiering, Snapshots & Lifecycle

Storage waste is common and often hidden. Use these tactics:

Implement lifecycle management policies for Blob (hot → cool → archive).
Clean up unattached managed disks left after VM deletions.
Limit snapshot retention with automation (incremental snapshots where supported).

Resource Graph: find unattached managed disks (Kusto)


Resources
| where type == "microsoft.compute/disks"
| extend diskState = properties.diskState, attachedVM = properties.ownerId
| where isempty(attachedVM)
| project subscriptionId, resourceGroup, name, sku = sku.name, sizeGB = properties.diskSizeGb, diskState

Use the query as input to a runbook that performs a dry-run export for review and then a staged deletion after approvals.

Tagging & Cost Allocation (Make Chargeback Work)

Tags are essential for accurate reporting and accountability. Core tags to enforce:

CostCenter — finance code
Environment — prod, preprod, dev, test
Owner — team or person responsible
Project or Application

Enforce these using Azure Policy at subscription or management group scope. Policy can deny or append tags at resource creation time, making showback/chargeback accurate and actionable.

Budgets, Alerts & Chargeback

Budgets in Azure Cost Management enable tracking and automated response:

Create monthly budgets per subscription or cost center and configure email/webhook alerts.
Use webhooks to trigger Logic Apps or Automation runbooks when thresholds are exceeded.
Implement showback dashboards for engineering teams and chargeback for internal billing.

Automation: Scheduled Shutdowns, Cleanup & Policy Enforcement

Automation makes savings persistent. Example automations:

Auto-shutdown schedules for non-prod VMs (Automation Accounts, Logic Apps, or DevTest Labs).
Orphaned disk and snapshot cleanup runbooks with dry-run and approval stages.
Rightsizing pipelines that tag candidate resources with 'OptimizationCandidate' and require owner review.

Below are ready-to-adapt snippets to jumpstart automation.

Implementation — Ready PowerShell, Resource Graph & REST snippets

Use these scripts as the basis for automation pipelines. Always run in read-only/dry-run first and include approvals for destructive actions.

1) Export Azure Advisor cost recommendations to a CSV (PowerShell)


# Export Advisor cost recommendations for a subscription
Connect-AzAccount
Select-AzSubscription -SubscriptionId <SUBSCRIPTION_ID>

$recs = Get-AzAdvisorRecommendation -Category Cost
$csvPath = "C:\temp\advisor-cost-recommendations.csv"

$recs | Select-Object `
  @{n='ResourceId';e={$_.ResourceId}},
  @{n='ShortDescription';e={$_.ShortDescription}},
  @{n='Impact';e={$_.Impact}},
  @{n='EstimatedMonthlySavings';e={($_.ExtendedProperties | Where-Object Name -eq "EstimatedMonthlySavings").Value}} |
  Export-Csv -Path $csvPath -NoTypeInformation

Write-Host "Exported to $csvPath"

2) Resource Graph query: list underutilized VMs (Kusto)


Resources
| where type =~ 'microsoft.compute/virtualmachines'
| extend vmSize = properties.hardwareProfile.vmSize, os = properties.storageProfile.osDisk.osType
| join kind=leftouter (
    Perf
    | where CounterName == '% Processor Time'
    | summarize avgCpu = avg(CounterValue) by ResourceId, bin(TimeGenerated, 1d)
    | summarize avgCpu30d = avg(avgCpu) by ResourceId
) on $left.id == $right.ResourceId
| where avgCpu30d < 5
| project id, name, resourceGroup, subscriptionId, vmSize, avgCpu30d

3) Simple REST call to list Advisor recommendations (for automation)


GET https://management.azure.com/subscriptions/{subscriptionId}/providers/Microsoft.Advisor/recommendations?api-version=2025-01-01
Authorization: Bearer <ACCESS_TOKEN>

4) PowerShell: find unattached managed disks and delete (dry-run first)


# Find unattached managed disks (review before deletion)
$disks = Get-AzDisk | Where-Object { -not $_.ManagedBy }
$disks | Select-Object ResourceGroupName, Name, DiskSizeGB, Sku

# To delete after careful review:
# foreach ($d in $disks) { Remove-AzDisk -ResourceGroupName $d.ResourceGroupName -DiskName $d.Name -Force }

5) Query cost details via Cost Management (example using REST)


POST https://management.azure.com/subscriptions/{subscriptionId}/providers/Microsoft.CostManagement/query?api-version=2021-10-01
Authorization: Bearer <ACCESS_TOKEN>
Content-Type: application/json

{
  "type": "Usage",
  "timeframe": "Custom",
  "timePeriod": {
    "from": "2025-01-01T00:00:00Z",
    "to": "2025-01-31T23:59:59Z"
  },
  "dataset": {
    "granularity": "Daily",
    "aggregation": { "totalCost": { "name": "PreTaxCost", "function": "Sum" } },
    "grouping": [{ "type": "Dimension", "name": "ResourceGroup" }]
  }
}

Use this query to feed Power BI or your FinOps data lake for trend analysis and forecasting.

Governance & FinOps: Process, People & Tools

Optimization is as much about culture as it is about tooling. Institutionalize cost control with these steps:

Assign ownership: Each subscription/cost center must have a named owner with budget responsibility.
Monthly FinOps sprints: Turn Advisor items and cost export findings into sprint work for engineering teams.
Approval gates: Changes that increase expected cost above defined thresholds require approvals.
Visibility: Share weekly dashboards and monthly executive summaries with engineering and finance.

Enforce policies with Azure Policy and RBAC to prevent non-compliant deployments (e.g., missing tags, disallowed SKUs).

Tie-in with Migration & Post-Migration Optimization

Optimization should be part of the migration plan:

Perform cost modeling and sensitivity analysis prior to migration.
Validate SKU and packaging choices during cutover and observe 30–90 days for rightsizing decisions.
Delay large reservation purchases until you have at least 30 days of steady-state usage where possible.

Short Case Example (Hypothetical)

Acme Corp migrated 120 VMs and hit a 60% higher bill in month 2. Actions taken:

Exported Advisor recommendations and found 30 VMs with <5% CPU and 45 unattached disks.
Scheduled non-prod shutdowns and deleted orphan disks — saved 18% of monthly spend.
Implemented autoscale and purchased targeted 1-year reservations for three large SQL VMs — net savings 32% vs. month 2 baseline.

Outcome: 45% reduction vs. the worst month and governance to keep waste from returning.

30-Day FinOps Checklist (Quick Start)

Enable Cost Management exports to storage or Log Analytics.
Run Advisor recommendations and export high-impact items.
Implement mandatory tagging policy via Azure Policy.
Deploy automated shutdown schedules for non-prod environments.
Clean up unattached disks and old snapshots (dry-run first).
Analyze usage for Savings Plan vs Reservation decisions (30–90 days).
Create budgets & webhook alerts to trigger automation on over-spend.
Schedule monthly FinOps review (owner, trends, actions).

Conclusion — Make Optimization Continuous

Cost optimization in Azure is an ongoing practice combining visibility, policy, automation, and organizational accountability. Use Advisor & Cost Management to get quick wins, govern with tags and budgets, automate cleanup, and run monthly FinOps rituals to prevent regression. Adopt a staged, approval-driven approach to remediation to avoid service impact while realizing savings.

Explore more on cloudknowledge.in

Sources & Acknowledgments

This article is based on practical FinOps patterns and vendor documentation. For up-to-date API references and command details, consult official Microsoft Azure documentation and the Azure portal when implementing automation and purchases.

FinOps Checklist

Quick start

Export cost & advisor data
Enforce tags (CostCenter, Owner, Environment)
Schedule non-prod shutdown
Delete unattached disks (after review)
Evaluate Savings Plans vs Reservations

Deep dives on cloudknowledge.in

Key Scripts

Get-AzAdvisorRecommendation export (PowerShell)
Resource Graph: find low CPU VMs (Kusto)
Remove unattached disks (PowerShell dry-run)

Note

Always test remediation in a staging environment and include stakeholders in approvals before mass changes.

Cloud Knowledge