Web App Service and Azure Monitor metrics premium field-manual

Memory percentage

The memory percentage metric is a memory utilization value that shows how much of a container or workload memory allocation is being used. Teams use it when operators need to detect memory pressure, tune limits, or drive memory-based scaling decisions. In plain English, it gives operators a named control for earlier visibility into memory-bound behavior, restarts, and capacity risk instead of leaving the decision hidden in a portal setting, script, or deployment file. Treat it as production-ready only when the owner, dependencies, permission boundary, monitoring signal, and rollback evidence are clear.

Aliases
Memory percentage, MemoryPercentage, memory utilization percentage, memory metric, memory usage percentage, container memory percentage, App Service memory percent, Azure Monitor and Azure App Service, App Service and Azure Monitor metrics
Difficulty
intermediate
CLI mappings
4
Last verified
2026-05-16T05:14:53Z

Microsoft Learn

The memory percentage metric is a memory utilization value that shows how much of a container or workload memory allocation is being used. Teams use it when operators need to detect memory pressure, tune limits, or drive memory-based scaling decisions. In plain English, it gives operators a named control for earlier visibility into memory-bound behavior, restarts, and capacity risk instead of leaving the decision hidden in a portal setting, script, or deployment file. Treat it as production-ready only when the owner, dependencies, permission boundary, monitoring signal, and rollback evidence are clear.

Microsoft Learn: Azure App Service quotas and metrics2026-05-16T05:14:53Z

Technical context

Technically, the memory percentage metric sits in the workload metrics, scaling, and resource-limit monitoring layer. Azure represents it through memory utilization metrics, scale-rule metadata, container requests and limits, replica data, and alert thresholds. It usually interacts with Container Apps, containers, workload profiles, memory limits, replicas, alerts, logs, and scale rules. The key boundary is that memory percentage reports pressure, but it does not explain the application leak, cache behavior, or allocation pattern by itself. Architects should document scope, identity path, network assumptions, deployment method, monitoring hooks, and fallback behavior before production use.

Why it matters

The memory percentage metric matters because it makes earlier visibility into memory-bound behavior, restarts, and capacity risk visible, testable, and owned. Without that clarity, teams can change the wrong scope, miss hidden dependencies, or troubleshoot symptoms caused by configuration drift rather than application code. It also gives reviewers a common language for security, reliability, operations, cost, and performance decisions. A good implementation states who owns the setting, what workload depends on it, how changes are approved, and which metric or log proves the result. That keeps audits, migrations, incidents, and release reviews from becoming guesswork. Keep the decision visible in runbooks, diagrams, tags, and support notes.

Where you see it

Signals, screens, and Azure surfaces where this term usually becomes operational.

Signal 01

In the Azure portal, the memory percentage metric appears in configuration, monitoring, or access views where teams verify ownership, dependencies, permissions, readiness, and rollback evidence before changes.

Signal 02

In CLI, IaC, or query output, the memory percentage metric appears as properties, status, scope, and dependency evidence that operators compare with the approved design during reviews.

Signal 03

In architecture reviews, the memory percentage metric appears when teams discuss ownership, access, reliability, cost, performance, and evidence needed to prove the design is safe during reviews.

When this becomes relevant

Specific situations where this term helps solve real Azure design, operations, migration, security, reliability, cost, or governance problems.

  • Use Memory percentage to make ownership, configuration evidence, monitoring, and rollback behavior explicit.
  • Review Memory percentage during design reviews, release readiness checks, incident response, and post-change validation.
  • Document Memory percentage with related identities, network paths, policies, cost drivers, and operational runbooks.

Real-world case studies

Different enterprise-style examples that show the term being used to hit measurable objectives.

Case study 01

Commute-hour memory pressure

Scenario, objectives, solution, measured impact, and takeaway.

Scenario

CityPass Transit, a public transportation organization, had a rider web app recycling during commute peaks because several apps shared one App Service plan. The team used the memory percentage metric to create a controlled Azure pattern with clear ownership, measurable evidence, and safer production handoff.

Business/Technical Objectives
  • Stop commute-hour app recycling.
  • Identify noisy-neighbor apps.
  • Keep P95 page load under 800 milliseconds.
  • Avoid unnecessary blanket scale-up.
Solution Using Memory percentage

Operators queried MemoryPercentage for the App Service plan and compared it with per-app diagnostics, deployment times, and HTTP latency. They found one background export job consuming most worker memory. The export job moved to a separate plan, alerts were set at 80% and 85%, and the rider app kept its existing SKU. Runbooks now require memory evidence before any scale request. Runbooks captured owners, approval evidence, monitoring signals, and rollback steps so support teams could repeat the pattern without guessing during incidents. The design also included CLI validation, activity-log review, and architecture notes that connected the Azure configuration to business accountability. After release, the platform team reviewed metrics weekly and kept the implementation aligned with security, reliability, and cost expectations.

Results & Business Impact
  • Unexpected recycles stopped during commute peaks.
  • P95 page load improved to 620 milliseconds.
  • Avoided scaling five unrelated apps.
  • Memory alerts provided 20 minutes of warning before pressure.
Key Takeaway for Glossary Readers

The memory percentage metric helps teams decide whether the problem is capacity, app placement, or one misbehaving workload.

Case study 02

Release memory regression detection

Scenario, objectives, solution, measured impact, and takeaway.

Scenario

SilverTrail Finance, a financial planning SaaS organization, saw slow portal performance after releases but could not prove whether memory leaks or customer traffic caused it. The team used the memory percentage metric to create a controlled Azure pattern with clear ownership, measurable evidence, and safer production handoff.

Business/Technical Objectives
  • Detect memory regressions within one hour.
  • Reduce false scale-up requests.
  • Keep advisor portal availability above 99.9%.
  • Capture evidence for developers.
Solution Using Memory percentage

The operations team charted MemoryPercentage alongside request duration, error rate, and deployment slots. A new release showed a steady memory climb even after traffic normalized. Engineers rolled back the slot, captured dumps, and fixed an object caching bug. The final dashboard included plan-level memory percentage, app-level memory working set, and alert rules that notified both operations and the owning development team. Runbooks captured owners, approval evidence, monitoring signals, and rollback steps so support teams could repeat the pattern without guessing during incidents. The design also included CLI validation, activity-log review, and architecture notes that connected the Azure configuration to business accountability.

Results & Business Impact
  • The regression was detected in 37 minutes.
  • Advisor portal availability stayed at 99.95%.
  • False scale-up requests dropped 64%.
  • Developers fixed the leak before the next release.
Key Takeaway for Glossary Readers

Memory percentage becomes useful when it is connected to release history, app metrics, and owner accountability.

Case study 03

Ticket sale capacity validation

Scenario, objectives, solution, measured impact, and takeaway.

Scenario

NorthCoast Events, an event ticketing organization, needed to decide whether to scale up its App Service plan before a national ticket sale. The team used the memory percentage metric to create a controlled Azure pattern with clear ownership, measurable evidence, and safer production handoff.

Business/Technical Objectives
  • Validate memory headroom before launch.
  • Support 4x expected traffic.
  • Keep compute cost within forecast.
  • Create a go/no-go evidence pack.
Solution Using Memory percentage

Platform engineers ran load tests while querying MemoryPercentage every minute. The plan held CPU well but memory rose above the acceptable threshold when cache warmup and payment calls overlapped. The team moved image processing to a worker plan, adjusted cache size, and kept a scheduled scale-up ready only for the sale window. The evidence pack included metric charts, CLI output, and rollback steps. Runbooks captured owners, approval evidence, monitoring signals, and rollback steps so support teams could repeat the pattern without guessing during incidents. The design also included CLI validation, activity-log review, and architecture notes that connected the Azure configuration to business accountability.

Results & Business Impact
  • Load test passed at 4.3x expected traffic.
  • Memory stayed below 76% during launch.
  • Scheduled scale-up was limited to eight hours.
  • The ticket sale completed without memory-related incidents.
Key Takeaway for Glossary Readers

Memory percentage gives launch teams a measurable capacity signal instead of relying on hope before high-traffic events.

Why use Azure CLI for this?

Azure CLI is useful for the memory percentage metric because it turns the live configuration into repeatable evidence. Operators can inventory scope, compare settings with IaC, confirm identity and network assumptions, and export facts for change reviews or incidents without relying on screenshots.

CLI use cases

  • Inventory Memory percentage settings across subscriptions or resource groups before reviews, migrations, and ownership cleanup.
  • Inspect live Memory percentage configuration before a release, audit, incident, rollback, or support handoff.
  • Export Memory percentage evidence so teams can compare portal state, IaC intent, activity logs, and monitoring results.

Before you run CLI

  • Confirm tenant, subscription, resource group, scope, and service-specific permissions before inspecting or changing Memory percentage.
  • Know whether the command is read-only or changes production behavior, cost, routing, identity, or network exposure.
  • Choose JSON, table, or TSV output deliberately so the result can be reviewed, scripted, or attached to evidence.

What output tells you

  • The output shows whether the memory percentage metric exists, where it is scoped, and which resource or workload currently owns it.
  • Status, identity, network, SKU, policy, metric, or dependency fields reveal whether live configuration matches the intended design.
  • Repeated output over time can prove drift, confirm remediation, or show that a change reached the correct Azure resource.

Mapped Azure CLI commands

Memory percentage Azure CLI checks

az monitor metrics list --resource <app-service-plan-id> --metric MemoryPercentage --interval PT1M
az monitor metricsdiscoverWeb
az monitor metrics list --resource <app-id> --metric MemoryWorkingSet,AverageMemoryWorkingSet
az monitor metricsdiscoverWeb
az monitor metrics alert create --name <alert> --resource-group <group> --scopes <app-service-plan-id> --condition "avg MemoryPercentage > 85"
az monitor metrics alertprovisionWeb
az appservice plan show --resource-group <group> --name <plan>
az appservice plandiscoverWeb

Architecture context

Technically, the memory percentage metric sits in the workload metrics, scaling, and resource-limit monitoring layer. Azure represents it through memory utilization metrics, scale-rule metadata, container requests and limits, replica data, and alert thresholds. It usually interacts with Container Apps, containers, workload profiles, memory limits, replicas, alerts, logs, and scale rules. The key boundary is that memory percentage reports pressure, but it does not explain the application leak, cache behavior, or allocation pattern by itself. Architects should document scope, identity path, network assumptions, deployment method, monitoring hooks, and fallback behavior before production use.

Security

Security for Memory percentage starts with least privilege and clear ownership. The main risk is ignoring memory pressure that can trigger crashes, expose partial logs, or interrupt services that handle sensitive requests. Review who can create, update, delete, assign, invoke, or read it, and whether access comes from direct roles, inherited roles, managed identities, secrets, or deployment pipelines. Prefer managed identity, scoped RBAC, private access, encryption, and logged approvals when the service supports them. For production, keep evidence of permission scope, network exposure, diagnostic logging, and rollback authority so a security review can verify live state rather than trusting documentation alone.

Cost

Cost for Memory percentage is driven by larger memory allocations, more replicas, workload profile choices, idle capacity, logging, and repeated incidents. The spend may be direct, such as SKU, capacity, storage, throughput, replicas, retention, or network transfer, or indirect through support time and failed changes. FinOps reviews should identify the owner, billing tag, usage metric, and cheaper configuration that still meets the workload requirement. Do not reduce cost by weakening security, durability, compliance, or recovery needs without written approval. Track changes over time so teams can distinguish intentional scaling from forgotten resources, stale test deployments, and inefficient defaults. Keep the decision visible in runbooks, diagrams, tags, and support notes.

Reliability

Reliability for the memory percentage metric depends on memory utilization trend, restart count, OOM events, replica health, scale events, and alert response. Operators should know what happens during deployment, scale changes, failover, maintenance, dependency loss, and operator error. Some effects are direct, such as availability, recovery, throughput, or dead-letter behavior; others are indirect because the setting makes drift easier to detect and reverse. Document region assumptions, backups, health probes, retry behavior, dependency limits, and rollback steps. A reliable implementation lets support teams prove current state quickly before making emergency changes. Keep the decision visible in runbooks, diagrams, tags, and support notes. Review the evidence again after deployment so drift is caught early.

Performance

Performance for the memory percentage metric depends on memory utilization, garbage collection, OOM events, restart count, latency, backlog, and replica saturation. The effect may appear as latency, throughput, IOPS, connection wait time, replica behavior, query duration, pipeline runtime, or faster operational troubleshooting. Measure before and after important changes instead of assuming the setting helps. Useful evidence includes metrics, logs, traces, activity records, deployment output, load-test results, and user-impact signals. When performance is indirect, state that clearly and focus on how the term improves diagnosis speed, configuration consistency, or workload routing. Keep the decision visible in runbooks, diagrams, tags, and support notes. Review the evidence again after deployment so drift is caught early.

Operations

Operationally, the memory percentage metric needs a repeatable inspection path. Teams should know which portal blade, CLI command, Resource Graph query, metric, activity log, workbook, or deployment artifact shows the live state. Runbooks should describe normal ownership, approved change windows, escalation contacts, rollback steps, and evidence to capture after changes. Avoid undocumented portal-only edits in production. Use IaC, tags, CLI exports, and monitoring so operators can compare actual configuration with the intended design during releases, incidents, and audits. Keep the decision visible in runbooks, diagrams, tags, and support notes. Review the evidence again after deployment so drift is caught early. Tie every change to an owner, monitoring signal, and rollback path.

Common mistakes

  • Changing the memory percentage metric without checking dependent resources, owner tags, alerts, permissions, and rollback steps first.
  • Assuming the portal label is complete instead of validating live state through CLI, IaC, metrics, or activity logs.
  • Granting broad permissions for convenience, then forgetting to remove temporary access after troubleshooting or deployment.