Cost Optimization¶

Azure Functions on Consumption and Flex Consumption offers cost-effective serverless pricing models. This guide explains how pricing works, how to take advantage of the free grant, when to choose Flex or Premium, and how to control costs through scale limits, Application Insights sampling, and operational practices.

Prerequisites¶

• Azure CLI access to the subscription.
• Access to Azure Cost Management + Billing.
• Access to Application Insights and Log Analytics.

When to Use¶

Azure Functions serverless pricing means you pay only for what you use — but ancillary services (storage, Application Insights, networking) can silently exceed function compute costs. Understanding the full cost picture prevents budget surprises.

graph TD
    A[Azure Functions Total Cost] --> B[Compute Cost]
    A --> C[Storage Cost]
    A --> D[Monitoring Cost]
    A --> E[Networking Cost]
    B --> B1["Executions × $0.20/million"]
    B --> B2[GB-seconds × $0.000016]
    C --> C1["Blob/Queue/Table operations"]
    C --> C2[File share for deployment]
    D --> D1[Application Insights ingestion]
    D --> D2[Log Analytics retention]
    E --> E1[Outbound data transfer]
    E --> E2[VNet integration baseline]

Procedure¶

Consumption Plan Pricing¶

The Consumption plan charges based on two dimensions:

How GB-Seconds Are Calculated¶

Azure measures the memory your function uses during execution and multiplies it by the execution duration in seconds. Memory is measured in 128 MB increments, rounded up:

GB-seconds = (Memory in GB, rounded to nearest 128 MB) × (Execution time in seconds)

For example, a function that uses 200 MB of memory and runs for 0.5 seconds:

Memory: 200 MB → rounds to 256 MB = 0.25 GB
GB-seconds: 0.25 × 0.5 = 0.125 GB-s
Cost: 0.125 × $0.000016 = $0.000002

At this rate, you would need millions of executions per month to generate meaningful charges.

Free Grant¶

For the legacy Consumption (Y1) plan, each Azure subscription includes this monthly free grant:

This free grant resets every month. For many development, staging, and low-traffic production workloads on Y1, it can cover 100% of Azure Functions compute cost. Flex Consumption billing differs (consumption-based execution plus optional always-ready baseline cost), so validate current Flex pricing separately.

What the Free Grant Covers (Example)¶

Consider a function that averages 200 MB memory and 100 ms execution time:

Per execution: 0.25 GB × 0.1s = 0.025 GB-s
Monthly budget: 400,000 GB-s ÷ 0.025 = 16,000,000 executions on resource alone

Combined with the 1M execution grant, you can run approximately 1,000,000 invocations per month completely free (the execution count limit is reached before the GB-s limit in this scenario).

What You Still Pay For¶

The free grant covers Functions compute only. You still incur charges for: Pricing examples below are illustrative only and vary by region, agreement, and offer type.

Application Insights log ingestion is often the largest cost component for low-traffic function apps. See the sampling section below to control this.

Cost Comparison by Plan¶

Price examples in this section are approximate as of 2026-04 and can change over time by region and offer.

Break-even analysis¶

graph LR
    A[Monthly Executions] --> B{Volume?}
    B -->|< 1M| C[Consumption: $0]
    B -->|1M - 10M| D[Consumption: $0.20 - $2.00]
    B -->|10M - 50M| E[Consumption: $2 - $10]
    B -->|> 50M + cold start concerns| F[Consider Premium: ~$175 baseline]
    B -->|Any + VNet required| G[Flex Consumption or Premium]

Rule of thumb: Premium breaks even with Consumption at roughly 50-100 million executions/month depending on execution duration and memory usage. Below that threshold, Consumption is cheaper.

When to Upgrade to Premium¶

The Premium plan has a base cost (starting at approximately $175/month for the smallest tier, EP1), so it only makes sense when you need specific capabilities:

Rule of thumb: Move from Consumption to Flex Consumption first when you need private networking or better cold-start control without committing to Premium baseline costs.

Flex Consumption Billing Note¶

Flex Consumption combines consumption-based execution billing with optional always-ready baseline billing. If always-ready is set to 0, idle cost behavior is similar to classic Consumption. If always-ready instances are configured, you incur a baseline cost even with low traffic.

Controlling Application Insights Costs¶

Application Insights charges for data ingestion. For function apps that process millions of requests, this can add up quickly. Control costs with sampling in host.json:

{
  "version": "2.0",
  "logging": {
    "applicationInsights": {
      "samplingSettings": {
        "isEnabled": true,
        "maxTelemetryItemsPerSecond": 5,
        "excludedTypes": "Request;Exception"
      }
    }
  }
}

Key settings:

• isEnabled: true — Enable adaptive sampling (enabled by default)
• maxTelemetryItemsPerSecond — Target rate of telemetry items per second per instance. Lower values = more aggressive sampling = lower cost
• excludedTypes — Telemetry types that are never sampled (always collected). Exclude Request and Exception to ensure you never miss errors

Estimating Application Insights Cost¶

Monthly cost = (Ingested GB) × $2.30/GB
First 5 GB/month are free

A typical function invocation generates approximately 1–3 KB of telemetry. At 1M invocations/month with no sampling:

1,000,000 × 2 KB = 2 GB → (2 - 5 free) = $0 (within free tier)

At 10M invocations/month:

10,000,000 × 2 KB = 20 GB → (20 - 5) × $2.30 = $34.50/month

With maxTelemetryItemsPerSecond: 5 on a single instance, you can reduce this dramatically.

Additional Application Insights Cost Controls¶

Scale Limits to Control Runaway Costs¶

Set a maximum instance count to prevent unexpected cost spikes from traffic surges or DoS attacks.

For Flex Consumption, configure via the Azure portal or Bicep template (scaleAndConcurrency.maximumInstanceCount). To update an existing app:

az functionapp scale config set \
  --resource-group $RG \
  --name $APP_NAME \
  --maximum-instance-count 20

For Consumption and Premium plans:

az resource update \
  --resource-group $RG \
  --name $APP_NAME \
  --resource-type "Microsoft.Web/sites" \
  --set properties.siteConfig.functionAppScaleLimit=20

This caps your function app at 20 concurrent instances. Requests beyond capacity are queued rather than triggering new instances. The trade-off is higher latency under extreme load rather than higher cost.

Cost Monitoring¶

Set up a budget alert so you are notified before costs exceed expectations:

az consumption budget create \
  --budget-name "functions-monthly" \
  --amount 50 \
  --time-grain Monthly \
  --category Cost \
  --start-date "2026-04-01" \
  --end-date "2027-03-31" \
  --resource-group $RG \
  --notifications "{\"Actual_GreaterThan_80_Percent\":{\"enabled\":true,\"operator\":\"GreaterThan\",\"threshold\":80,\"contactEmails\":[\"<your-email>\"]}}"

Cost Analysis KQL¶

Track Application Insights ingestion volume to catch cost spikes early:

let appName = "func-myapp-prod";
union requests, traces, exceptions, dependencies
| where timestamp > ago(7d)
| where cloud_RoleName =~ appName
| summarize
    Records = count(),
    EstimatedMB = round(sum(itemCount * 2.0) / 1024, 2)
  by bin(timestamp, 1d), itemType
| order by timestamp desc

Verification¶

• [ ] Application Insights sampling enabled in host.json
• [ ] Scale limit configured for production function apps
• [ ] Budget alert set with notification threshold
• [ ] Correct plan selected based on traffic volume and requirements
• [ ] Log Analytics retention period reviewed (30 days for non-production)
• [ ] Storage account lifecycle rules configured for deployment packages

Rollback / Troubleshooting¶

See Also¶

• Monitoring
• Alerts
• Cold Start
• Hosting Plans
• Scaling

Sources¶

• Consumption Plan (Microsoft Learn)
• Premium Plan (Microsoft Learn)
• Azure Functions Scaling (Microsoft Learn)
• Flex Consumption Plan (Microsoft Learn)
• Application Insights pricing (Microsoft Learn)