Web App Service plan tiers strict-validated top250-pre130-priority field-manual-complete

Basic App Service tier

Basic App Service tier is a dedicated-compute App Service plan tier for simpler web apps that need more isolation than Free or Shared but fewer features than Standard or Premium. It helps web developers, platform teams, cost owners, startup engineers, and application support teams run low-traffic or early production web apps on dedicated plan resources without paying for higher-tier features too soon. Use it when an app needs custom domains, TLS, predictable dedicated compute, and simple scale choices but not advanced production features.

Aliases
No aliases mapped yet
Difficulty
fundamentals
CLI mappings
5
Last verified
2026-05-11

Microsoft Learn

The Basic App Service tier is a dedicated-compute App Service plan tier intended for lower-scale production, development, or test web apps that need dedicated workers. Microsoft Learn places it in Azure App Service plans; operators confirm scope, configuration, dependencies, and production impact.

Microsoft Learn: Azure App Service plans2026-05-11

Technical context

Technically, Basic App Service tier works through App Service plans, Basic worker sizes, dedicated Azure VMs at the plan level, web apps sharing plan resources, manual scale choices, custom domains, TLS, and platform-managed hosting. It depends on operating system choice, region availability, plan size, number of apps in the plan, deployment model, memory and CPU needs, storage, and networking requirements. Common settings include pricing tier, instance size, instance count where supported, runtime stack, app settings, custom domain, TLS bindings, deployment source, diagnostic logs, and tags.

Why it matters

Basic App Service tier matters because it provides a practical starting point for dedicated App Service hosting before demand justifies higher tiers. Without it, teams often overspend on premium plans for simple apps or under-host apps on shared tiers that cannot meet user expectations. In enterprises, it connects developers, platform operators, FinOps analysts, product owners, security reviewers, and support engineers. It turns cost-aware dedicated web hosting into right-sized plan selection, app density review, monitoring baselines, upgrade criteria, deployment automation, and owner tagging and exposes tradeoffs around monthly plan cost, feature availability, app density, scale headroom, deployment slots, networking needs, and production availability expectations.

Where you see it

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

Signal 01

You see Basic App Service tier in App Service plan scale-up screens where Free, Shared, Basic, Standard, and Premium options are compared during accountable operational reviews.

Signal 02

You see it in cost reviews when low-traffic apps need dedicated workers but do not justify Standard or Premium capabilities during accountable operational reviews during accountable operational reviews.

Signal 03

You see Basic tier evidence during performance triage when multiple apps share one plan and compete for CPU or memory during accountable operational reviews during accountable operational reviews.

When this becomes relevant

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

  • Host smaller production or test web apps on dedicated App Service plan workers without jumping to higher tiers too early.
  • Move a site beyond Free or Shared limits when custom domains, dedicated compute, or steadier performance are needed.
  • Run low-traffic internal tools where predictable dedicated capacity matters more than advanced scale-out features.
  • Use a cost-controlled tier for early production validation before upgrading to Standard, Premium, or isolated plans.
  • Compare scaling, SSL, and deployment slot needs before deciding whether Basic is enough for the workload.

Real-world case studies

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

Case study 01

Operational rollout

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

Scenario

BrightNest Realty, a real estate organization, needed to launch a customer portal quickly without paying for Premium hosting during the pilot.

Business/Technical Objectives
  • Host the pilot on dedicated compute.
  • Keep monthly hosting cost under budget.
  • Support custom domain and TLS.
  • Define upgrade criteria before launch.
Solution Using Basic App Service tier

The architecture team used Basic App Service tier as the primary mechanism: Engineers created a Basic App Service plan, deployed the portal web app, configured custom domain and TLS, and enabled Application Insights. The runbook defined CPU, memory, and response-time thresholds that would trigger migration to Standard. The design included owners, validation steps, rollback criteria, monitoring evidence, and support handoff notes. Before production use, engineers tested the workflow safely, trained the support shift, and captured acceptance criteria in the service runbook. Business owners signed off on success measures, escalation contacts, and the rollback decision point before rollout. Business owners signed off on success measures, escalation contacts, and the rollback decision point before rollout.

Results & Business Impact
  • Pilot hosting stayed 42 percent below the initial Premium estimate.
  • Custom domain and TLS were ready before launch.
  • Average response time stayed under 320 ms.
  • Upgrade criteria were approved before production expansion.
Key Takeaway for Glossary Readers

Basic App Service tier is valuable when teams connect the Azure feature to measurable outcomes, accountable operations, and practical risk reduction.

Case study 02

Governed modernization

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

Scenario

HarborStone Legal, a legal services organization, had several internal web tools running on old VMs with low traffic but frequent patching effort.

Business/Technical Objectives
  • Move three internal apps to managed hosting.
  • Retire one Windows VM.
  • Keep apps on dedicated plan resources.
  • Create monitoring for response-time regressions.
Solution Using Basic App Service tier

The architecture team used Basic App Service tier as the primary mechanism: The platform team moved low-traffic tools into one Basic App Service plan, using separate web apps and managed identity for storage access. Azure Monitor tracked CPU and response time, and app owners agreed on density limits for the shared plan. The design included owners, validation steps, rollback criteria, monitoring evidence, and support handoff notes. Before production use, engineers tested the workflow safely, trained the support shift, and captured acceptance criteria in the service runbook. Business owners signed off on success measures, escalation contacts, and the rollback decision point before rollout. Business owners signed off on success measures, escalation contacts, and the rollback decision point before rollout.

Results & Business Impact
  • One patched VM was retired.
  • Three apps ran on dedicated App Service plan resources.
  • Response-time alerts found one inefficient reporting page.
  • Operations reduced monthly patch work by six hours.
Key Takeaway for Glossary Readers

Basic App Service tier is valuable when teams connect the Azure feature to measurable outcomes, accountable operations, and practical risk reduction.

Case study 03

Incident-ready optimization

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

Scenario

NorthStar Camps, a education organization, wanted a registration website for seasonal programs with predictable traffic and a small cloud budget.

Business/Technical Objectives
  • Launch registration before enrollment week.
  • Avoid shared compute tiers.
  • Keep web hosting simple for volunteers.
  • Prepare a scale-up option if demand doubled.
Solution Using Basic App Service tier

The architecture team used Basic App Service tier as the primary mechanism: Developers deployed the registration app to a Basic App Service plan, enabled deployment from GitHub Actions, and documented a scale-up path to Standard if enrollment traffic exceeded baseline. Support volunteers used portal dashboards to watch requests and errors. The design included owners, validation steps, rollback criteria, monitoring evidence, and support handoff notes. Before production use, engineers tested the workflow safely, trained the support shift, and captured acceptance criteria in the service runbook. Business owners signed off on success measures, escalation contacts, and the rollback decision point before rollout. Business owners signed off on success measures, escalation contacts, and the rollback decision point before rollout. Business owners signed off on success measures, escalation contacts, and the rollback decision point before rollout.

Results & Business Impact
  • Registration launched two days early.
  • Hosting cost stayed within the seasonal budget.
  • No shared-tier CPU quota issues occurred.
  • The scale-up runbook was tested before enrollment opened.
Key Takeaway for Glossary Readers

Basic App Service tier is valuable when teams connect the Azure feature to measurable outcomes, accountable operations, and practical risk reduction.

Why use Azure CLI for this?

Use command-line evidence for Basic App Service tier when portal views or desktop tools are too slow, inconsistent, or hard to audit. CLI output helps operators inspect App Service plan SKU, worker size, app list, metrics, scale changes, and web app configuration, capture repeatable JSON, compare environments, and prove current state before production changes.

CLI use cases

  • Inspect App Service plan SKU, worker size, app list, metrics, scale changes, and web app configuration during reviews, incidents, migrations, or release readiness checks.
  • Compare development, test, and production configuration without relying on screenshots or memory.
  • Capture JSON or table output for change tickets, audits, rollback decisions, and support escalations.
  • Validate resource group, subscription, identity, region, and target resource before any mutating command.

Before you run CLI

  • Confirm the active tenant, subscription, resource group, region, and exact resource name before running commands.
  • Start with read-only show, list, or metrics commands before create, update, delete, failover, or migration actions.
  • Check whether the command changes cost, access, data placement, encryption, retention, or workload connectivity.
  • Make sure approval, rollback, owner contact, and evidence requirements are clear for production-impacting work.

What output tells you

  • Resource IDs, regions, SKUs, tags, identities, and states show whether live Azure configuration matches design intent.
  • Empty, missing, or unexpected fields often reveal wrong scope, unsupported features, drift, or incomplete deployment steps.
  • Operation state, timestamps, counts, errors, and report fields show whether a requested change completed successfully.
  • Metric and configuration values help separate platform settings from application behavior during troubleshooting.

Mapped Azure CLI commands

Basic App Service tier

direct
az appservice plan show --resource-group <rg> --name <plan>
az appservice plandiscoverWeb
az appservice plan list --resource-group <rg> --output table
az appservice plandiscoverWeb
az webapp list --resource-group <rg> --query "[?serverFarmId.contains(@, '<plan>')]"
az webappdiscoverWeb
az appservice plan update --resource-group <rg> --name <plan> --sku B1
az appservice planconfigureWeb
az monitor metrics list --resource <plan-resource-id> --metric "CpuPercentage,MemoryPercentage"
az monitor metricsdiscoverWeb

Architecture context

Technically, Basic App Service tier works through App Service plans, Basic worker sizes, dedicated Azure VMs at the plan level, web apps sharing plan resources, manual scale choices, custom domains, TLS, and platform-managed hosting. It depends on operating system choice, region availability, plan size, number of apps in the plan, deployment model, memory and CPU needs, storage, and networking requirements. Common settings include pricing tier, instance size, instance count where supported, runtime stack, app settings, custom domain, TLS bindings, deployment source, diagnostic logs, and tags.

Security

Security for Basic App Service tier starts with knowing who can configure it, who can view its output, and what sensitive data, credentials, or network paths may be affected. Important controls include managed identity, TLS configuration, app settings protection, deployment credential review, role assignments, diagnostic logs, custom domain ownership, and Key Vault references for secrets. Operators should prefer managed identities or reviewed automation where possible, avoid broad contributor access, and record changes in Activity Log, audit trails, or approved tickets. Security teams should check whether logs, reports, copies, keys, or migrated data reveal customer data or topology details. The safest deployments document approval paths, break-glass use, retention expectations, and audit evidence.

Cost

Cost considerations for Basic App Service tier come from resources it controls, telemetry it produces, and operational choices it encourages. Key factors include App Service plan instance charges, idle dedicated workers, multiple apps sharing one plan, monitoring logs, domain and certificate costs, scale-up decisions, and unused plan cleanup. Teams should separate direct platform charges from avoided labor, avoided downtime, and reduced waste. Reviews should ask whether the configuration is oversized, underused, duplicated, or retaining more data than policy requires. Budgets, tags, and amortized reporting help connect spend to owners. The best cost outcome is not simply the lowest bill; it is spending enough to meet risk, recovery, performance, and compliance goals without hidden waste.

Reliability

Reliability depends on whether Basic App Service tier is tested under realistic operating conditions, not just enabled once during deployment. The most important practices are plan resource headroom, uptime monitoring, backup availability review, deployment rollback approach, error alerts, app-density checks, and documented criteria for moving to Standard or Premium. Teams should define expected state, monitor drift, and rehearse the failure modes that would make the capability necessary. Alerts need owners, thresholds, and escalation paths that match business impact. Good designs capture recovery or validation evidence because incident responders need to know what worked, what failed, and whether assumptions still support stated objectives after upgrades, migrations, or regional changes.

Performance

Performance for Basic App Service tier is about how quickly and predictably the capability supports the workload or operator action. Important concerns include CPU, memory, cold start behavior for app code, request latency, app density, worker size, dependency calls, logging overhead, and plan-level resource contention. Teams should measure the user-visible result rather than assuming the Azure feature is fast enough by default. For data and database services, check latency, throttling, concurrency, storage behavior, wait patterns, and query efficiency. For governance or migration capabilities, measure how long decisions, scans, transfers, and validations take during real events. Keep baselines so later tuning has evidence.

Operations

Operationally, Basic App Service tier should fit into support, release, and review routines. Useful practices include plan inventory, app-to-plan mapping, metric dashboards, deployment runbooks, scale-up criteria, cost tagging, log retention, and support ownership for each hosted app. Owners should keep runbooks current, define who approves production changes, and make important state visible without tribal knowledge. During incidents, operators need quick ways to inspect configuration, confirm scope, and compare current behavior with intended design. After changes, teams should update diagrams, tags, alerts, and evidence repositories. The goal is a capability support staff can run confidently during off-hours, not a feature only the original architect understands.

Common mistakes

  • Treating Basic App Service tier as a simple label instead of a production operating decision with owners and evidence.
  • Running a mutating command before collecting read-only state and confirming the target subscription and resource.
  • Copying examples into production without adjusting names, regions, identities, network rules, SKUs, or limits.
  • Ignoring service-specific permissions, private networking, monitoring, rollback behavior, and cost impact before rollout.