Azure

Compare Month-Over-Month Azure Cost Usage: A Practical Azure FinOps Guide

The Power of Comparison in Cost Management

A single month of Azure spending data tells you what happened. Two months compared side by side tell you what changed. Month-over-month comparison is the most practical form of cost analysis because it directly answers the question every stakeholder asks: “Why is this month different from last month?” Whether costs went up or down, the answer always lies in the delta between two adjacent periods.

Azure Cost Management provides built-in tools for this comparison, from the Cost by service view that automatically displays month-over-month bars to the Query API that lets you calculate precise percentage changes programmatically. This guide covers every approach: portal-based visual comparisons, REST API queries that compute deltas, PowerShell automation for recurring comparison reports, and KQL analysis for historical month-over-month trending.

Why FinOps Maturity Matters

Cloud financial management is not merely about reducing costs. It is about maximizing the business value of every dollar spent on cloud infrastructure. The FinOps Foundation defines three phases of cloud financial management maturity: Inform, Optimize, and Operate. This guide addresses practical implementation techniques that span all three phases.

In the Inform phase, organizations gain visibility into where their cloud spending goes. Azure Cost Management provides the raw data, but transforming that data into actionable insights requires structured approaches to tagging, cost allocation, and reporting. Without consistent resource tagging and cost center mapping, finance teams cannot attribute cloud costs to the business units that generate them, and engineering teams cannot identify which workloads are driving cost growth.

In the Optimize phase, teams actively reduce waste and improve efficiency. This includes rightsizing underutilized resources, eliminating orphaned resources, leveraging Reserved Instances and Savings Plans for predictable workloads, and implementing auto-scaling to match capacity with demand. The optimization opportunities identified through the Inform phase directly feed the actions in this phase.

In the Operate phase, FinOps practices become embedded in the organization’s standard operating procedures. Cost governance policies are enforced through Azure Policy, budget alerts trigger automated responses, and cost reviews are integrated into sprint planning and architectural decision-making. The goal is continuous financial optimization that happens as a natural part of engineering operations rather than as a periodic cleanup exercise.

Organizational Alignment

Effective cloud cost management requires collaboration between engineering, finance, and business leadership. Engineering teams understand the technical trade-offs between cost and performance. Finance teams understand the budget constraints and reporting requirements. Business leaders understand the revenue impact and strategic priorities that should drive investment decisions.

Establish a FinOps team or practice that brings these perspectives together. This cross-functional team should meet regularly to review spending trends, discuss optimization opportunities, and make joint decisions about investment priorities. The techniques in this guide provide the shared data foundation that enables these cross-functional conversations and ensures that cost decisions are informed by both technical and business context.

Create executive dashboards that translate technical cost data into business language. Instead of showing raw Azure meter costs, show cost per customer, cost per transaction, or cost as a percentage of revenue. These are the metrics that business leaders can act on and that connect cloud spending to business outcomes.

Visual Comparison in Cost Analysis

The Azure portal’s Cost Analysis provides several views that are designed for period-over-period comparison.

Cost by Service View

The Cost by service customizable view is built specifically for month-over-month comparison. It displays the previous month and current month as side-by-side columns grouped by Azure service, making cost growth or reduction immediately visible. Navigate to Cost Management → Cost analysis, select the Cost by service view from the view menu.

This view automatically handles the period alignment — you do not need to manually set date ranges. Each service shows as a grouped bar pair, and the visual difference between the bars tells you which services are driving changes. Sort by the current month’s cost to see the biggest contributors first, or look for bars where the current month significantly exceeds the previous month.

Smart View KPIs

Every smart view (Resources, Resource groups, Services, Subscriptions) displays a total cost KPI tile at the top with a percentage change versus the previous period. This single number provides an instant read: if your costs increased 12% month-over-month, the KPI tile shows that immediately, with an arrow indicating the direction.

Custom Date Range Comparison

For more flexible comparisons (current month versus the same month last year, or any two arbitrary periods), use the date selector in any customizable view. Set the date range to the most recent month, note the total, then switch to the comparison period. While the portal does not overlay two periods on one chart natively, saving both as custom views and opening them in separate tabs gives you a rapid comparison workflow.

Building Automated Comparison Reports with the REST API

The Cost Management Query API enables programmatic comparison by querying two periods and computing the delta. This is the foundation for automated comparison reports.

Querying Two Months of Data

POST https://management.azure.com/subscriptions/{subscriptionId}/providers/Microsoft.CostManagement/query?api-version=2025-03-01

{
  "type": "ActualCost",
  "timeframe": "Custom",
  "timePeriod": {
    "from": "2026-02-01T00:00:00Z",
    "to": "2026-03-31T23:59:59Z"
  },
  "dataset": {
    "granularity": "Monthly",
    "aggregation": {
      "totalCost": {
        "name": "PreTaxCost",
        "function": "Sum"
      }
    },
    "grouping": [
      {
        "name": "ServiceName",
        "type": "Dimension"
      }
    ]
  }
}

This query returns two rows per service — one for February and one for March — with monthly granularity. The consumer (script, dashboard, or application) then calculates the difference and percentage change for each service.

Filtering for Specific Comparisons

Add filter clauses to narrow the comparison to specific resource groups, tags, or services. For example, to compare month-over-month compute costs only:

{
  "type": "ActualCost",
  "timeframe": "Custom",
  "timePeriod": {
    "from": "2026-02-01T00:00:00Z",
    "to": "2026-03-31T23:59:59Z"
  },
  "dataset": {
    "granularity": "Monthly",
    "aggregation": {
      "totalCost": {
        "name": "PreTaxCost",
        "function": "Sum"
      }
    },
    "grouping": [
      {
        "name": "ResourceGroup",
        "type": "Dimension"
      }
    ],
    "filter": {
      "dimensions": {
        "name": "ServiceName",
        "operator": "In",
        "values": ["Virtual Machines", "Virtual Machines Licenses"]
      }
    }
  }
}

This returns compute costs by resource group for both months, making it easy to pinpoint which team or application drove changes in VM spending.

PowerShell Script for Month-Over-Month Comparison

A PowerShell script that runs monthly produces a formatted comparison report with absolute and percentage changes.

# Month-over-month cost comparison by service
$scope = "/subscriptions/your-subscription-id"
$currentMonth = (Get-Date).ToString("yyyy-MM-01")
$lastMonth = (Get-Date).AddMonths(-1).ToString("yyyy-MM-01")
$endCurrent = (Get-Date -Day 1).AddDays(-1).AddMonths(1).ToString("yyyy-MM-dd")
$endLast = (Get-Date -Day 1).AddDays(-1).ToString("yyyy-MM-dd")

$groupBySvc = New-AzCostManagementQueryGroupingObject `
    -Name 'ServiceName' -Type 'Dimension'

# Query current month
$current = Invoke-AzCostManagementQuery `
    -Scope $scope -Type ActualCost `
    -Timeframe Custom `
    -TimePeriodFrom $currentMonth `
    -TimePeriodTo $endCurrent `
    -DatasetGrouping @($groupBySvc) `
    -DatasetAggregation @{ "totalCost" = @{ "name" = "PreTaxCost"; "function" = "Sum" } }

# Query previous month
$previous = Invoke-AzCostManagementQuery `
    -Scope $scope -Type ActualCost `
    -Timeframe Custom `
    -TimePeriodFrom $lastMonth `
    -TimePeriodTo $endLast `
    -DatasetGrouping @($groupBySvc) `
    -DatasetAggregation @{ "totalCost" = @{ "name" = "PreTaxCost"; "function" = "Sum" } }

# Build lookup for previous month
$prevLookup = @{}
$previous.Row | ForEach-Object { $prevLookup[$_[1]] = [double]$_[0] }

# Calculate comparison
$comparison = $current.Row | ForEach-Object {
    $service = $_[1]
    $currCost = [math]::Round([double]$_[0], 2)
    $prevCost = if ($prevLookup.ContainsKey($service)) { [math]::Round($prevLookup[$service], 2) } else { 0 }
    $delta = $currCost - $prevCost
    $pctChange = if ($prevCost -gt 0) { [math]::Round($delta / $prevCost * 100, 1) } else { "New" }
    
    [PSCustomObject]@{
        Service = $service
        PreviousMonth = $prevCost
        CurrentMonth = $currCost
        Change = [math]::Round($delta, 2)
        ChangePercent = $pctChange
    }
} | Sort-Object { [math]::Abs($_.Change) } -Descending

$comparison | Format-Table -AutoSize

This script produces a table sorted by the absolute magnitude of change, putting the biggest movers at the top regardless of whether they increased or decreased. Services that appear in the current month but not in the previous month show as “New” in the percentage column.

Advanced Cost Optimization Techniques

Beyond the basic optimization strategies, consider these advanced techniques that can yield significant additional savings.

Spot Instances and Low-Priority VMs: For fault-tolerant batch processing, machine learning training, dev/test environments, and CI/CD build agents, use Azure Spot VMs that offer up to 90 percent discount compared to pay-as-you-go pricing. Implement graceful shutdown handlers that checkpoint progress when Azure reclaims the capacity, and design your workloads to resume from the last checkpoint on a new instance.

Reserved Instance Exchange and Return: Azure Reservations can be exchanged for different VM families, regions, or terms without penalty. If your workload characteristics change, exchange your existing reservation rather than letting it go unused. This flexibility makes reservations less risky than they might appear, as you can adjust your commitments as your infrastructure evolves.

Hybrid Benefit: If your organization has existing Windows Server or SQL Server licenses with Software Assurance, apply Azure Hybrid Benefit to reduce VM and managed database costs by up to 80 percent when combined with Reserved Instances. Track license utilization to ensure you are maximizing the value of your existing license investments.

Resource Lifecycle Automation: Implement automation that shuts down development and testing environments outside of business hours and weekends. A typical dev/test VM that runs 10 hours per day, 5 days per week costs 70 percent less than one that runs 24/7. Azure Automation schedules, Azure DevTest Labs auto-shutdown, and Azure Functions with timer triggers can all implement this pattern with minimal effort.

Right-Sizing Based on Actual Usage: Azure Advisor provides right-sizing recommendations based on CPU and memory utilization over the past 14 days. Review these recommendations weekly and act on them. A VM that consistently uses less than 20 percent of its allocated CPU should be downsized to the next smaller SKU. For databases, review DTU or vCore utilization and adjust the service tier accordingly.

Advanced Comparison Patterns

Resource Group Comparison for Team Accountability

Replace the service grouping with resource group grouping to compare team-level spending. This feeds directly into chargeback conversations:

# Same pattern but grouped by ResourceGroup
$groupByRG = New-AzCostManagementQueryGroupingObject `
    -Name 'ResourceGroup' -Type 'Dimension'

$current = Invoke-AzCostManagementQuery `
    -Scope $scope -Type ActualCost `
    -Timeframe TheCurrentMonth `
    -DatasetGrouping @($groupByRG) `
    -DatasetAggregation @{ "totalCost" = @{ "name" = "PreTaxCost"; "function" = "Sum" } }

$previous = Invoke-AzCostManagementQuery `
    -Scope $scope -Type ActualCost `
    -Timeframe TheLastMonth `
    -DatasetGrouping @($groupByRG) `
    -DatasetAggregation @{ "totalCost" = @{ "name" = "PreTaxCost"; "function" = "Sum" } }

When a resource group shows 40% growth while others remain stable, the conversation with that team’s lead is focused and data-driven: “Your group spent $3,200 more than last month. What changed?”

Identifying New and Disappeared Costs

Month-over-month comparison reveals more than growth rates. Services or resource groups that appear in the current month but not the previous month represent new spending — potentially from new projects, experiments, or mistakes. Conversely, items that existed last month but disappeared this month indicate deleted or moved resources.

# Find new services this month
$newServices = $current.Row | Where-Object {
    -not $prevLookup.ContainsKey($_[1])
} | ForEach-Object {
    [PSCustomObject]@{
        Service = $_[1]
        Cost = [math]::Round([double]$_[0], 2)
    }
}

if ($newServices) {
    Write-Output "`nNew costs this month:"
    $newServices | Format-Table -AutoSize
}

KQL Analysis for Historical Month-Over-Month Trends

While the REST API efficiently compares two adjacent months, KQL enables multi-month trend analysis that shows the trajectory of month-over-month changes over time.

// Rolling month-over-month change by service
CostExports
| where ChargePeriodStart >= ago(365d)
| summarize MonthlyCost = sum(BilledCost) 
    by ServiceCategory, Month = startofmonth(ChargePeriodStart)
| order by ServiceCategory, Month asc
| serialize
| extend PrevMonthCost = prev(MonthlyCost, 1)
| extend PrevService = prev(ServiceCategory, 1)
| extend MoMChange = iff(
    PrevService == ServiceCategory and PrevMonthCost > 0,
    round((MonthlyCost - PrevMonthCost) / PrevMonthCost * 100, 1),
    real(null))
| where isnotnull(MoMChange)
| project Month, ServiceCategory, MonthlyCost, PrevMonthCost, MoMChange
| order by Month desc, MoMChange desc

This query produces a 12-month history of month-over-month percentage changes for each service. When you see a service consistently growing at 10%+ per month for six consecutive months, that is a structural trend that requires a strategic response — not a one-time spike that will resolve itself.

Detecting Acceleration and Deceleration

// Find services with accelerating growth
CostExports
| where ChargePeriodStart >= ago(180d)
| summarize MonthlyCost = sum(BilledCost) 
    by ServiceCategory, Month = startofmonth(ChargePeriodStart)
| order by ServiceCategory, Month asc
| serialize
| extend PrevCost = prev(MonthlyCost, 1), PrevService = prev(ServiceCategory, 1)
| where PrevService == ServiceCategory and PrevCost > 0
| extend GrowthRate = (MonthlyCost - PrevCost) / PrevCost
| extend PrevGrowth = prev(GrowthRate, 1)
| where prev(ServiceCategory, 1) == ServiceCategory
| where GrowthRate > PrevGrowth and GrowthRate > 0.05
| project Month, ServiceCategory, 
    GrowthPct = round(GrowthRate * 100, 1),
    PrevGrowthPct = round(PrevGrowth * 100, 1)

This query identifies services where the growth rate itself is increasing — not just growing, but growing faster. This is the early warning signal that a cost trajectory is heading toward an exponential curve and needs intervention before it becomes a budget-breaking problem.

Interpreting Month-Over-Month Changes

Raw percentage changes without context lead to overreaction. Understanding common causes helps separate signal from noise in month-over-month comparisons.

Expected Variations

Some month-over-month changes are perfectly normal:

  • Calendar effects — February has fewer days than March, so even flat daily spending produces different monthly totals. Normalize by cost-per-day when comparing months with different lengths.
  • Billing timing — Reservation purchases appear as large one-time charges in actual cost view. Switch to amortized cost for apples-to-apples comparison across months with and without purchases.
  • Seasonal patterns — Retail workloads spike during holiday months, financial applications spike at quarter-end, and training environments shut down during company vacation periods. These are expected and should not trigger alarm.
  • Planned growth — New projects, expansions, and migrations create legitimate cost increases. The comparison should identify these as planned rather than flagging them as problems.

Warning Signals

These month-over-month patterns warrant investigation:

  • Large single-service jump — One service growing 30%+ while others stay flat usually indicates a specific resource or scaling event that needs review.
  • New resource groups — Unknown new spending sources may be unauthorized deployments, forgotten experimental environments, or shadow IT projects.
  • Consistent growth without business justification — If the business did not grow 15% this month but Azure spending did, the cost increase lacks a business driver and represents waste or inefficiency.
  • Disappeared savings — If reservation savings drop month-over-month, it may indicate utilization problems or expired commitments that were not renewed.

Governance and Automation

Manual cost management does not scale. As your Azure footprint grows beyond a handful of subscriptions, you need automated governance to maintain cost discipline.

Azure Policy can enforce tagging requirements at deployment time, ensuring that every resource is tagged with the cost center, environment, application name, and owner before it is created. Without consistent tagging, cost allocation becomes a manual, error-prone guessing game. Define a mandatory tag set and use a deny policy effect to prevent untagged resources from being deployed.

Budget alerts with action groups can trigger automated responses when spending thresholds are crossed. At 80 percent of budget, send a notification to the engineering team lead. At 100 percent, notify the engineering manager and finance partner. At 120 percent, trigger an automated workflow that inventories recently created resources and flags potential cost anomalies for immediate review.

Consider implementing a cost anomaly detection pipeline. Azure Cost Management provides anomaly detection capabilities that flag unusual spending patterns. Supplement this with custom KQL queries in Log Analytics that monitor resource creation events, SKU changes, and scaling operations. When an anomaly is detected, an automated investigation workflow can gather the relevant context (who created the resource, which pipeline deployed it, what business justification was provided) and route it to the responsible team for review.

Regular cost optimization reviews should be scheduled on a monthly cadence. Use the Azure Advisor cost recommendations as a starting point, then layer in your organization-specific optimization criteria. Track optimization actions and their measured impact over time to demonstrate the ROI of your FinOps program to leadership. A well-run FinOps program typically achieves 20 to 30 percent cost reduction in the first year, with ongoing annual optimization of 5 to 10 percent as the program matures.

Building a Monthly Comparison Cadence

Month-over-month comparison works best as a structured practice rather than an ad-hoc investigation triggered by a surprising invoice.

Schedule the PowerShell comparison script to run on the 5th of each month (giving charges 72 hours to finalize after month-end). Output the results to a shared location — a Teams channel, a shared mailbox, or a wiki page. Include a brief summary of the top five changes with preliminary explanations.

During the monthly FinOps review, walk through the comparison with the teams responsible for the biggest changes. Most changes have straightforward explanations: a new deployment, a scaling event, a pricing change. The few that do not have easy explanations are the ones that drive optimization actions.

Over time, the monthly comparison becomes a feedback loop. Teams know their costs will be compared and discussed. This knowledge alone changes behavior — engineers think twice about leaving oversized resources running when they know the cost increase will appear in next month’s comparison report with their resource group’s name attached to it.

The simplicity of month-over-month comparison is its strength. It does not require sophisticated analytics or machine learning. It requires two numbers and a subtraction. But that simple subtraction, applied consistently across every service and resource group, produces the accountability and visibility that drives continuous cost optimization.

Leave a Reply