How to Reduce Azure Costs by 40-70%: Complete Cloud Optimization Guide for CTOs

Azure costs average $50,000-$200,000/month for mid-sized enterprises, but 40-70% of that spend is waste from overprovisioned VMs, pay-as-you-go pricing, orphaned resources, and underutilized reserved capacity. A typical organization runs 200 VMs at $8,760/year each (Standard_D4s_v3 pay-as-you-go), totaling $1.75M annually. With Reserved Instances (40-72% savings), rightsizing (30-50% reduction), storage optimization (60% savings), and automated resource management, that drops to $600K-$900K annually while maintaining or improving performance.

This guide provides 12 proven strategies to optimize Azure costs. You'll learn Reserved Instance purchasing, VM rightsizing with Azure Advisor, storage tier optimization, automated shutdown policies, Azure Hybrid Benefit, and cost governance frameworks. Each strategy includes implementation code, cost impact analysis, and real-world results from our client engagements.

Understanding Azure Cost Structure

Primary Cost Drivers

• Compute (40-50%): Virtual Machines, App Services, AKS, Functions
• Storage (15-25%): Blob, Disk, File Storage, managed disks
• Networking (10-15%): Bandwidth, Load Balancers, VPN Gateway, ExpressRoute
• Database (10-20%): SQL Database, Cosmos DB, PostgreSQL
• Other (5-10%): Monitoring, Backup, Key Vault, Log Analytics

Example Cost Breakdown (Before Optimization)

Scenario: 150-person company, moderate Azure usage

• 50 VMs (Standard_D4s_v3): $8,760/year × 50 = $438,000
• 20 TB Premium SSD storage: $150/TB/month × 20 × 12 = $36,000
• 10 TB outbound bandwidth: $87/TB × 10 × 12 = $10,440
• Azure SQL Database (Business Critical): $3,000/month × 12 = $36,000
• Load Balancers, VPN, monitoring: $2,000/month × 12 = $24,000
• Total annual cost: $544,440

After Optimization

• 50 VMs (3-year Reserved, rightsized to D2s_v3): $2,500/year × 50 = $125,000
• 20 TB Hot/Cool tiered storage: $25/TB/month × 20 × 12 = $6,000
• CDN + reduced bandwidth: $2,500/month × 12 = $30,000
• Azure SQL (optimized tier): $1,200/month × 12 = $14,400
• Optimized networking: $1,000/month × 12 = $12,000
• Total annual cost: $187,400 (66% reduction)
• Annual savings: $357,040

Strategy 1: Reserved Instances (40-72% Savings)

How Reserved Instances Work

Reserved Instances (RIs) provide 1-year or 3-year commitments in exchange for steep discounts. Unlike pay-as-you-go, you commit to specific VM sizes and regions. RIs are ideal for production workloads with predictable usage patterns.

Discount Breakdown

• 1-year commitment: 40-43% savings vs pay-as-you-go
• 3-year commitment: 62-72% savings vs pay-as-you-go
• Pay-as-you-go: Standard_D4s_v3 (4 vCPU, 16 GB RAM) = $350/month = $4,200/year
• 1-year Reserved: $2,450/year (42% savings = $1,750/year saved)
• 3-year Reserved: $1,450/year (65% savings = $2,750/year saved)

When to Use Reserved Instances

• Production VMs running 24/7
• Stable workload patterns (no major scaling planned)
• At least 70% utilization for 1-year, 80%+ for 3-year
• VMs that won't be migrated or decommissioned

Implementation: Analyze and Purchase RIs

# Azure CLI: Analyze RI recommendations
az consumption reservation recommendation list \
  --resource-group production-rg \
  --term P3Y \
  --scope Shared \
  --output table

# Shows recommended RIs based on usage patterns:
# VM Series: Standard_D4s_v3
# Quantity: 25
# Term: 3 years
# Estimated Savings: $68,750/year

# Purchase Reserved Instance
az reservations reservation-order purchase \
  --reservation-order-id /providers/Microsoft.Capacity/reservationOrders/abc123 \
  --sku Standard_D4s_v3 \
  --location eastus \
  --quantity 25 \
  --term P3Y \
  --billing-plan Monthly

# Track RI utilization
az consumption reservation summary list \
  --grain daily \
  --reservation-order-id abc123 \
  --start-date 2026-06-01 \
  --end-date 2026-06-21

Reserved Instance Best Practices

• Start with 1-year: Test commitment levels before 3-year purchases
• Target 80%+ utilization: Monitor usage to ensure RIs are fully utilized
• Use instance flexibility: Enable size flexibility within VM series (D2s_v3 RI covers D4s_v3)
• Regional vs shared: Shared scope provides flexibility across subscriptions
• Review quarterly: Adjust RI purchases as workloads change

Strategy 2: VM Rightsizing (30-50% Cost Reduction)

The Overprovisioning Problem

Most VMs are overprovisioned by 2-4x. Developers request Standard_D8s_v3 (8 vCPU, 32 GB) "to be safe," but actual usage averages 15% CPU and 40% memory. A D8s_v3 costs $350/month; a properly sized D2s_v3 (2 vCPU, 8 GB) costs $88/month — 75% savings.

Rightsizing Analysis with Azure Advisor

# Get VM rightsizing recommendations
az advisor recommendation list \
  --category Cost \
  --query "[?contains(shortDescription.solution, 'virtual machine')]" \
  --output json > vm-recommendations.json

# Example output:
# {
#   "resourceId": "/subscriptions/.../vm-web-01",
#   "shortDescription": {
#     "problem": "Virtual machine is underutilized",
#     "solution": "Resize to Standard_D2s_v3"
#   },
#   "extendedProperties": {
#     "currentSku": "Standard_D8s_v3",
#     "targetSku": "Standard_D2s_v3",
#     "savingsAmount": "262",
#     "savingsCurrency": "USD",
#     "annualSavingsAmount": "3144"
#   }
# }

Automated Rightsizing Script

#!/bin/bash
# rightsize-vms.sh: Analyze and resize underutilized VMs

RG="production-rg"
THRESHOLD_CPU=20  # Resize if CPU < 20% for 30 days
THRESHOLD_MEM=40  # Resize if memory < 40% for 30 days

for VM in $(az vm list -g $RG --query "[].name" -o tsv); do
  echo "Analyzing $VM..."
  
  # Get 30-day average CPU (requires metrics)
  AVG_CPU=$(az monitor metrics list \
    --resource $(az vm show -g $RG -n $VM --query id -o tsv) \
    --metric "Percentage CPU" \
    --start-time 2026-05-21T00:00:00Z \
    --end-time 2026-06-21T00:00:00Z \
    --interval PT1H \
    --aggregation Average \
    --query "value[0].timeseries[0].data[].average" \
    | jq 'add/length')
  
  echo "  Average CPU: $AVG_CPU%"
  
  if (( $(echo "$AVG_CPU < $THRESHOLD_CPU" | bc -l) )); then
    CURRENT_SIZE=$(az vm show -g $RG -n $VM --query hardwareProfile.vmSize -o tsv)
    echo "  Current: $CURRENT_SIZE"
    echo "  ACTION: Candidate for downsizing"
    echo "  Review Azure Advisor for target size recommendation"
  fi
done

Rightsizing Decision Matrix

• CPU < 20%, Memory < 40%: Downsize by 50% (D8s → D4s)
• CPU < 10%, Memory < 30%: Downsize by 75% (D8s → D2s)
• CPU > 80%, Memory > 80%: Upsize by 50% to prevent bottlenecks
• Inconsistent spikes: Consider Autoscale instead of larger VM

Strategy 3: Automated Shutdown for Dev/Test (60% Savings)

The Dev/Test Waste Problem

Development and test environments run 24/7 but are only used 40 hours/week (24% of the time). A Standard_D4s_v3 costs $350/month running continuously, or $84/month running only business hours (Mon-Fri 8am-6pm). Automated shutdown saves $266/month per VM, or $3,192/year.

Implementation: Azure Automation Runbook

# Create automation account
az automation account create \
  --resource-group automation-rg \
  --name auto-shutdown-account \
  --location eastus \
  --sku Basic

# Import Azure PowerShell modules
az automation module create \
  --resource-group automation-rg \
  --automation-account-name auto-shutdown-account \
  --name Az.Accounts

az automation module create \
  --resource-group automation-rg \
  --automation-account-name auto-shutdown-account \
  --name Az.Compute

PowerShell Runbook: Auto-Shutdown

param(
  [string]$ResourceGroupName = "dev-test-rg",
  [string]$Action = "Stop"  # Stop or Start
)

# Authenticate with managed identity
Connect-AzAccount -Identity

# Get all VMs with 'AutoShutdown' tag
$VMs = Get-AzVM -ResourceGroupName $ResourceGroupName | Where-Object {
  $_.Tags["AutoShutdown"] -eq "true"
}

foreach ($VM in $VMs) {
  $VMName = $VM.Name
  
  if ($Action -eq "Stop") {
    Write-Output "Stopping VM: $VMName"
    Stop-AzVM -ResourceGroupName $ResourceGroupName -Name $VMName -Force
  }
  elseif ($Action -eq "Start") {
    Write-Output "Starting VM: $VMName"
    Start-AzVM -ResourceGroupName $ResourceGroupName -Name $VMName
  }
}

Write-Output "Completed $Action action for $($VMs.Count) VMs"

Schedule Configuration

# Create schedule: Stop at 6 PM weekdays
az automation schedule create \
  --resource-group automation-rg \
  --automation-account-name auto-shutdown-account \
  --name "Stop-DevVMs-6PM" \
  --frequency Day \
  --interval 1 \
  --start-time "2026-06-21T18:00:00-07:00" \
  --time-zone "America/Los_Angeles" \
  --description "Stop dev VMs at 6 PM"

# Create schedule: Start at 8 AM weekdays
az automation schedule create \
  --resource-group automation-rg \
  --automation-account-name auto-shutdown-account \
  --name "Start-DevVMs-8AM" \
  --frequency Day \
  --interval 1 \
  --start-time "2026-06-22T08:00:00-07:00" \
  --time-zone "America/Los_Angeles" \
  --description "Start dev VMs at 8 AM"

Tag VMs for Auto-Shutdown

# Tag all dev/test VMs
for VM in $(az vm list -g dev-test-rg --query "[].name" -o tsv); do
  az vm update \
    -g dev-test-rg \
    -n $VM \
    --set tags.AutoShutdown=true tags.Environment=dev
done

Strategy 4: Storage Optimization (60% Savings)

Azure Storage Tiers

• Premium SSD: $150/TB/month, high IOPS, production databases
• Standard SSD: $20/TB/month, moderate IOPS, general workloads
• Standard HDD: $5/TB/month, low IOPS, archival, backups
• Blob Hot: $18/TB/month, frequent access
• Blob Cool: $10/TB/month, infrequent access (30+ days)
• Blob Archive: $0.99/TB/month, rare access (180+ days)

Identify Storage Tier Opportunities

# List all managed disks with size and tier
az disk list --query "[].[name, sku.name, diskSizeGb, diskState]" -o table

# Example output:
# Name              Tier          Size    State
# vm-web-01-os     Premium_LRS   128     Attached
# vm-web-01-data   Premium_LRS   1024    Attached
# vm-db-01-data    Premium_LRS   4096    Attached
# backup-disk-old  Premium_LRS   512     Unattached  <-- Waste

# Analyze blob access patterns
az storage blob list \
  --account-name mystorageacct \
  --container-name backups \
  --query "[].{Name:name, LastModified:properties.lastModified, Tier:properties.blobTier}" \
  --output table

Automated Tier Migration Script

#!/bin/bash
# migrate-storage-tiers.sh: Move old blobs to Cool/Archive tiers

STORAGE_ACCOUNT="mycompanystorage"
CONTAINER="backups"
COOL_DAYS=30    # Move to Cool after 30 days
ARCHIVE_DAYS=180  # Move to Archive after 180 days

# Get storage account key
ACCOUNT_KEY=$(az storage account keys list \
  --account-name $STORAGE_ACCOUNT \
  --query "[0].value" -o tsv)

# Find blobs older than 30 days, currently in Hot tier
az storage blob list \
  --account-name $STORAGE_ACCOUNT \
  --account-key $ACCOUNT_KEY \
  --container-name $CONTAINER \
  --query "[?properties.blobTier=='Hot'].name" -o tsv | \
while read BLOB; do
  LAST_MODIFIED=$(az storage blob show \
    --account-name $STORAGE_ACCOUNT \
    --account-key $ACCOUNT_KEY \
    --container-name $CONTAINER \
    --name "$BLOB" \
    --query "properties.lastModified" -o tsv)
  
  DAYS_OLD=$(( ($(date +%s) - $(date -d "$LAST_MODIFIED" +%s)) / 86400 ))
  
  if [ $DAYS_OLD -gt $ARCHIVE_DAYS ]; then
    echo "Moving $BLOB to Archive tier ($DAYS_OLD days old)"
    az storage blob set-tier \
      --account-name $STORAGE_ACCOUNT \
      --account-key $ACCOUNT_KEY \
      --container-name $CONTAINER \
      --name "$BLOB" \
      --tier Archive
  elif [ $DAYS_OLD -gt $COOL_DAYS ]; then
    echo "Moving $BLOB to Cool tier ($DAYS_OLD days old)"
    az storage blob set-tier \
      --account-name $STORAGE_ACCOUNT \
      --account-key $ACCOUNT_KEY \
      --container-name $CONTAINER \
      --name "$BLOB" \
      --tier Cool
  fi
done

Lifecycle Management Policies

# Create lifecycle policy JSON
cat > lifecycle-policy.json << EOF
{
  "rules": [
    {
      "enabled": true,
      "name": "move-to-cool",
      "type": "Lifecycle",
      "definition": {
        "actions": {
          "baseBlob": {
            "tierToCool": {
              "daysAfterModificationGreaterThan": 30
            },
            "tierToArchive": {
              "daysAfterModificationGreaterThan": 180
            },
            "delete": {
              "daysAfterModificationGreaterThan": 365
            }
          }
        },
        "filters": {
          "blobTypes": ["blockBlob"],
          "prefixMatch": ["backups/"]
        }
      }
    }
  ]
}
EOF

# Apply lifecycle policy
az storage account management-policy create \
  --account-name mystorageacct \
  --policy @lifecycle-policy.json \
  --resource-group storage-rg

Strategy 5: Azure Hybrid Benefit (40% Windows Licensing Savings)

How Azure Hybrid Benefit Works

If you have existing Windows Server licenses with Software Assurance, Azure Hybrid Benefit (AHB) allows you to use those licenses in Azure instead of paying for new ones. This reduces Windows VM costs by 40% (saves ~$0.13/hour per vCPU).

Cost Impact

• Standard_D4s_v3 Windows (without AHB): $350/month
• Standard_D4s_v3 Windows (with AHB): $210/month
• Savings: $140/month = $1,680/year per VM
• 50 Windows VMs: $84,000/year saved

Enable Azure Hybrid Benefit

# Enable AHB on existing VM
az vm update \
  --resource-group production-rg \
  --name vm-web-01 \
  --license-type Windows_Server

# Enable AHB on all Windows VMs in subscription
for VM in $(az vm list --query "[?storageProfile.osDisk.osType=='Windows'].{Name:name, RG:resourceGroup}" -o json | jq -r '.[] | "\(.RG),\(.Name)"'); do
  RG=$(echo $VM | cut -d, -f1)
  NAME=$(echo $VM | cut -d, -f2)
  echo "Enabling AHB for $NAME in $RG"
  az vm update -g $RG -n $NAME --license-type Windows_Server
done

# Verify AHB status
az vm show \
  --resource-group production-rg \
  --name vm-web-01 \
  --query "licenseType"

Strategy 6: Delete Orphaned Resources

Common Orphaned Resources

• Unattached disks: Disks from deleted VMs still incur charges ($5-$150/month each)
• Old snapshots: VM snapshots for deleted VMs ($0.05/GB/month)
• Unused public IPs: Static IPs not attached to resources ($3.65/month each)
• Old load balancers: Load balancers with no backend pools ($25/month)
• Stopped-but-allocated VMs: VMs in "Stopped (allocated)" state still charge for compute

Find and Delete Orphaned Disks

# List unattached disks
az disk list --query "[?diskState=='Unattached'].[name, resourceGroup, diskSizeGb, sku.name]" -o table

# Calculate cost of orphaned disks
echo "Orphaned Disk Cost Analysis:"
az disk list --query "[?diskState=='Unattached']" -o json | jq -r '.[] | "\(.name),\(.sku.name),\(.diskSizeGb)"' | while IFS=, read NAME TIER SIZE; do
  case $TIER in
    Premium_LRS) COST=$(echo "$SIZE * 0.15" | bc);;
    StandardSSD_LRS) COST=$(echo "$SIZE * 0.02" | bc);;
    Standard_LRS) COST=$(echo "$SIZE * 0.005" | bc);;
  esac
  echo "$NAME: \${COST}/month"
done

# Delete orphaned disks (after verification!)
az disk list --query "[?diskState=='Unattached'].{Name:name, RG:resourceGroup}" -o json | jq -r '.[] | "\(.RG),\(.Name)"' | while IFS=, read RG NAME; do
  echo "Deleting disk: $NAME"
  az disk delete --resource-group $RG --name $NAME --yes --no-wait
done

Find Orphaned Public IPs

# List unused public IPs
az network public-ip list --query "[?ipConfiguration==null].[name, resourceGroup]" -o table

# Delete unused public IPs
az network public-ip list --query "[?ipConfiguration==null].{Name:name, RG:resourceGroup}" -o json | jq -r '.[] | "\(.RG),\(.Name)"' | while IFS=, read RG NAME; do
  echo "Deleting public IP: $NAME"
  az network public-ip delete --resource-group $RG --name $NAME --no-wait
done

Strategy 7: Use Azure Cost Management Budgets and Alerts

Set Up Cost Alerts

# Create budget with alerts at 50%, 80%, 100%
az consumption budget create \
  --budget-name monthly-budget-2026 \
  --amount 50000 \
  --time-grain Monthly \
  --start-date 2026-06-01 \
  --end-date 2027-06-01 \
  --resource-group production-rg \
  --notifications \
    threshold=50 \
    operator=GreaterThan \
    contact-emails=cto@company.com,finance@company.com \
  --notifications \
    threshold=80 \
    operator=GreaterThan \
    contact-emails=cto@company.com,finance@company.com \
  --notifications \
    threshold=100 \
    operator=GreaterThan \
    contact-emails=cto@company.com,ceo@company.com,finance@company.com

Strategy 8: Use Spot VMs for Non-Critical Workloads (90% Savings)

Spot VM Pricing

Spot VMs use Azure's excess capacity at up to 90% discount. They can be evicted with 30 seconds notice when Azure needs capacity back. Ideal for batch processing, dev/test, stateless applications, CI/CD runners.

Cost Comparison

• Standard_D4s_v3 pay-as-you-go: $350/month
• Standard_D4s_v3 Spot: $35-$70/month (80-90% discount)
• Use case: CI/CD build agents, machine learning training, rendering farms

Create Spot VM

# Create Spot VM for CI/CD runner
az vm create \
  --resource-group devops-rg \
  --name ci-runner-spot-01 \
  --image Ubuntu2204 \
  --size Standard_D4s_v3 \
  --priority Spot \
  --max-price 0.10 \
  --eviction-policy Deallocate \
  --admin-username azureuser \
  --generate-ssh-keys

# --max-price 0.10: Only run if spot price < $0.10/hour
# --eviction-policy Deallocate: Stop VM (keep disk) when evicted

Real-World Cost Optimization Results

Case Study 1: Healthcare SaaS Company

• Environment: 120 VMs, 40 TB storage, Azure SQL, AKS cluster
• Original cost: $87,000/month ($1.04M/year)
• Optimizations:
  • Reserved Instances (3-year): 60 production VMs = $24K/month saved
  • VM rightsizing: 40 VMs downsized = $8K/month saved
  • Auto-shutdown dev/test: 20 VMs = $5K/month saved
  • Storage tier optimization: 30 TB to Cool = $4K/month saved
  • Deleted orphaned resources: $2K/month saved
• New cost: $44,000/month ($528K/year)
• Savings: $43K/month = $516K/year (49% reduction)

Case Study 2: Financial Services Firm

• Environment: 200 VMs, SQL Managed Instance, ExpressRoute, 80 TB storage
• Original cost: $156,000/month ($1.87M/year)
• Optimizations:
  • Reserved Instances (1-year + 3-year mix): $48K/month saved
  • Azure Hybrid Benefit (80 Windows VMs): $11K/month saved
  • VM rightsizing: $18K/month saved
  • Storage optimization (Blob tiering): $9K/month saved
  • Network optimization (CDN): $4K/month saved
• New cost: $66,000/month ($792K/year)
• Savings: $90K/month = $1.08M/year (58% reduction)

30-Day Azure Cost Optimization Roadmap

Week 1: Discovery and Analysis

• Day 1-2: Install Azure Cost Management, review current spending by resource type
• Day 3-4: Run Azure Advisor, export all recommendations
• Day 5-7: Analyze VM utilization (CPU, memory) over 30 days, identify rightsizing candidates

Week 2: Quick Wins

• Day 8-10: Delete orphaned disks, public IPs, old snapshots
• Day 11-12: Implement storage lifecycle policies (move to Cool/Archive)
• Day 13-14: Set up auto-shutdown for dev/test VMs, tag resources

Week 3: Reserved Instances and Rightsizing

• Day 15-17: Purchase 1-year Reserved Instances for production VMs with 80%+ utilization
• Day 18-20: Rightsize 10-20 VMs (start with dev/test environments)
• Day 21: Enable Azure Hybrid Benefit on all Windows VMs

Week 4: Governance and Monitoring

• Day 22-24: Create budgets and alerts for each resource group
• Day 25-27: Implement Azure Policy for cost governance (enforce tagging, VM size limits)
• Day 28-30: Review savings, document optimizations, plan 3-year RI purchases

Azure Cost Governance Framework

Tagging Strategy

# Enforce tagging policy
az policy definition create \
  --name require-cost-tags \
  --display-name "Require Cost Center and Environment tags" \
  --description "All resources must have CostCenter and Environment tags" \
  --rules '{
    "if": {
      "anyOf": [
        {
          "field": "tags['CostCenter']",
          "exists": "false"
        },
        {
          "field": "tags['Environment']",
          "exists": "false"
        }
      ]
    },
    "then": {
      "effect": "deny"
    }
  }'

# Apply policy to subscription
az policy assignment create \
  --name require-tags \
  --policy require-cost-tags \
  --scope /subscriptions/your-subscription-id

VM Size Restrictions

# Restrict VM sizes in dev/test environments
az policy definition create \
  --name restrict-vm-sizes-dev \
  --display-name "Restrict VM sizes in dev/test" \
  --description "Dev/test can only use D2s, D4s, or smaller VMs" \
  --rules '{
    "if": {
      "allOf": [
        {
          "field": "type",
          "equals": "Microsoft.Compute/virtualMachines"
        },
        {
          "field": "tags['Environment']",
          "in": ["dev", "test"]
        },
        {
          "field": "Microsoft.Compute/virtualMachines/sku.name",
          "notIn": [
            "Standard_B2s",
            "Standard_B4ms",
            "Standard_D2s_v3",
            "Standard_D4s_v3"
          ]
        }
      ]
    },
    "then": {
      "effect": "deny"
    }
  }'

Monitoring and Continuous Optimization

Weekly Cost Review Script

#!/bin/bash
# weekly-cost-review.sh: Generate cost report

START_DATE=$(date -d "7 days ago" +%Y-%m-%d)
END_DATE=$(date +%Y-%m-%d)

echo "Azure Cost Report: $START_DATE to $END_DATE"
echo "==========================================="

# Get cost by resource group
echo "\nTop 10 Resource Groups by Cost:"
az consumption usage list \
  --start-date $START_DATE \
  --end-date $END_DATE \
  --query "sort_by([].{RG:instanceName, Cost:pretaxCost}, &Cost)[:10]" \
  --output table

# Get cost by resource type
echo "\nTop 10 Resource Types by Cost:"
az consumption usage list \
  --start-date $START_DATE \
  --end-date $END_DATE \
  --query "sort_by([].{Type:meterCategory, Cost:pretaxCost}, &Cost)[:10]" \
  --output table

# Check for cost anomalies (>20% increase week-over-week)
CURRENT=$(az consumption usage list --start-date $START_DATE --end-date $END_DATE --query "sum([].pretaxCost)")
PREVIOUS=$(az consumption usage list --start-date $(date -d "14 days ago" +%Y-%m-%d) --end-date $(date -d "7 days ago" +%Y-%m-%d) --query "sum([].pretaxCost)")

if (( $(echo "$CURRENT > $PREVIOUS * 1.2" | bc -l) )); then
  echo "\n⚠️ ALERT: Cost increased by >20% this week"
  echo "Previous week: \$PREVIOUS"
  echo "Current week: \$CURRENT"
fi

Key Takeaways

• Reserved Instances first: Largest single savings opportunity (40-72%), start with 1-year commitments
• Rightsize immediately: Most VMs are 2-4x overprovisioned, easy 30-50% savings
• Automate dev/test shutdown: 60% savings on non-production environments
• Storage tiering: Move infrequently accessed data to Cool/Archive, 60-90% savings
• Delete orphaned resources: Hidden waste from old disks, IPs, snapshots
• Use Azure Hybrid Benefit: 40% savings on Windows licensing if you have SA
• Implement governance early: Tagging, budgets, policies prevent future waste
• Review weekly: Continuous monitoring catches cost anomalies before they compound

Start with Week 1 discovery, implement quick wins in Week 2, then tackle Reserved Instances and rightsizing. Most organizations achieve 40-60% cost reduction in 30 days with these strategies.