Back to interview questions

100+ Azure Interview Questions and Answers

100+ Azure Interview Questions and Answers

Explore 120 Azure interview questions and answers on identity, compute, networking, storage, governance, monitoring, resilience, and cloud deployment.

Explore 120 Azure interview questions and answers on identity, compute, networking, storage, governance, monitoring, resilience, and cloud deployment.

By

Team Sherlock.sh

Add Sherlock as a preferred source on Google

Azure interviews test whether a candidate can connect cloud services to a workloadโ€™s requirements. Choosing a service is only part of the answer. Candidates also need to explain identity and access, network paths, data protection, failure behavior, deployment choices, and the cost of operating what they propose.

This guide to 100+ Azure Interview Questions and Answers contains 120 questions across beginner, intermediate, and experienced levels. It covers Azure foundations and practical decisions across compute, storage, networking, governance, monitoring, and resilience. The questions emphasize service boundaries and trade-offs rather than memorizing portal screens or assuming every feature is available in every region and tier.

How can recruiters detect AI-assisted cheating, deepfakes, and impersonation during Azure interviews?

Azure interviews often combine an architecture scenario with a deployment excerpt, access-control decision, or explanation of a failed request. A convincing service list does not show whether the candidate understands the dependencies or security implications. Unauthorized real-time assistance can make that independent judgment harder to assess.

Sherlock AI helps recruiters detect potential AI-assisted cheating, deepfakes, candidate impersonation, and unauthorized real-time assistance during Azure interviews.

Pair interview-integrity checks with a specific workload scenario. Change the target region, remove public access, or ask how the design behaves when a dependency fails. Have the candidate explain permissions, verification, recovery, and cost implications without requiring a live deployment. Review suspicious activity in context rather than treating a signal as proof of misconduct.

Azure Interview Questions

Choose questions that match the roleโ€™s Azure responsibilities and the workload being discussed. State the region, service tier, identity model, and relevant deployment assumptions. Ask candidates to explain the limits of their answer as well as the feature they would use.

Azure Interview Questions for Beginners

These beginner questions cover Azure resource organization, identity, compute, storage, networking, monitoring, and basic reliability concepts. They test whether a candidate can explain what a service does and where its responsibility ends.

  1. What is Microsoft Azure, and when would you use it?

  2. How do IaaS, PaaS and SaaS change the customer's responsibilities?

  3. What is the relationship between a tenant, subscription and resource group?

  4. How does Azure Resource Manager organize and manage resources?

  5. How do Azure regions, availability zones and region pairs differ?

  6. What is the difference between scalability, elasticity and availability?

  7. What does shared responsibility mean for Azure security?

  8. How does Microsoft Entra ID differ from Active Directory Domain Services?

  9. How do authentication and authorization differ in Azure?

  10. How does Azure role-based access control work?

  11. How do Microsoft Entra roles differ from Azure resource roles?

  12. What are managed identities, and how do their two types differ?

  13. What are Azure Policy and resource locks used for?

  14. How do tags help organize Azure resources?

  15. When would you choose an Azure virtual machine?

  16. How do VM availability sets and availability zones differ?

  17. What are Virtual Machine Scale Sets?

  18. How does Azure App Service differ from hosting on a VM?

  19. What are Azure Functions triggers and bindings?

  20. How do Azure Container Instances, Container Apps and AKS differ?

  21. What is an Azure virtual network?

  22. How do subnets, network security groups and route tables differ?

  23. What is the difference between a public IP address and a private IP address?

  24. How do Azure Load Balancer, Application Gateway and Front Door differ?

  25. How do VPN Gateway and ExpressRoute connect an on-premises network?

  26. What is Azure DNS, and when is Private DNS useful?

  27. How do Blob Storage, Azure Files and managed disks differ?

  28. What do LRS, ZRS, GRS and GZRS mean for Azure Storage?

  29. How do Blob Storage access tiers affect data retrieval and cost?

  30. How do storage account keys, SAS and Microsoft Entra authorization differ?

  31. How do Azure SQL Database, SQL Managed Instance and SQL Server on VMs differ?

  32. What is Azure Cosmos DB, and what does a partition key do?

  33. How do Azure Service Bus, Event Grid and Event Hubs differ?

  34. What is Azure Key Vault used for?

  35. How do Azure Monitor, Log Analytics and Application Insights relate?

  36. How do metrics, logs and distributed traces differ?

  37. What is the difference between Azure Backup and Azure Site Recovery?

  38. What are RTO and RPO?

  39. What do an Azure SLA and an application SLO measure?

  40. What practical steps help control Azure spending?

Azure Interview Questions for Intermediate

These intermediate questions examine service integration, deployment, network access, data protection, monitoring, and workload reliability. They ask candidates to account for configuration details and dependencies rather than rely on a default setting.

  1. How would you design resource-group boundaries for an application?

  2. How do management groups and Azure Policy initiatives support governance?

  3. How do you diagnose an Azure RBAC authorization failure?

  4. How should an application access Key Vault without a stored client secret?

  5. How do control-plane permissions differ from data-plane permissions?

  6. How do private endpoints differ from service endpoints?

  7. How does private-endpoint DNS resolution work across connected networks?

  8. How would you diagnose a VM that cannot reach an external service?

  9. How do VNet peering, gateway transit and routing interact?

  10. When would you choose Azure Firewall instead of relying only on NSGs?

  11. How do NAT Gateway and load-balancer outbound rules affect outbound connectivity?

  12. How do Application Gateway health probes and backend HTTP settings affect routing?

  13. How would you choose between Front Door and Traffic Manager?

  14. How do App Service deployment slots support safer releases?

  15. How do App Service VNet integration and private endpoints differ?

  16. How do Azure Functions hosting plans affect scaling and execution?

  17. How should an Azure Functions handler process duplicate events?

  18. How do Container Apps revisions, ingress and scale rules work together?

  19. How do AKS workload identity and cluster identity differ?

  20. What are the responsibilities of AKS readiness probes, liveness probes and resource limits?

  21. How do VM Scale Set autoscale rules and application health interact?

  22. How do Bicep parameters, modules and dependencies improve deployments?

  23. What does an ARM or Bicep what-if operation verify, and what does it miss?

  24. How should a CI/CD pipeline authenticate to Azure securely?

  25. How would you design blob lifecycle management without breaking retention requirements?

  26. How do Blob soft delete, versioning and immutability solve different problems?

  27. How do Azure Storage firewalls and authorization combine?

  28. How do Azure SQL service tiers and compute models affect architecture choices?

  29. How do Azure SQL failover groups support disaster recovery?

  30. How do Cosmos DB partitioning and request units affect performance?

  31. How do Cosmos DB consistency levels affect reads and availability?

  32. How do Service Bus locks, retries and dead-letter queues work?

  33. When should you use Event Hubs consumer groups and checkpoints?

  34. How would you configure useful Azure Monitor diagnostic settings?

  35. How do you write a KQL query to investigate failed application requests?

  36. How should alert rules, action groups and runbooks work together?

  37. How do Azure Backup policies and restore tests establish recoverability?

  38. How would you manage VM patching and configuration drift?

  39. How do Azure reservations, savings plans and Spot VMs differ?

  40. How would you estimate a workload's Azure cost before deployment?

Azure Interview Questions for Experienced

These experienced-level questions focus on architecture trade-offs, governance at scale, security boundaries, recovery, cost control, and changes across a cloud estate. They assess how a candidate turns business requirements into a defensible and testable Azure design.

  1. How would you design an Azure landing zone for several product teams?

  2. How would you choose a subscription and tenant separation strategy?

  3. How would you establish least privilege without blocking engineering teams?

  4. How would you design privileged access and emergency access for Azure operations?

  5. How would you assess an Azure architecture using the Well-Architected Framework?

  6. How would you derive a multiregion design from RTO and RPO requirements?

  7. How would you decide between active-active and active-passive deployment?

  8. How would you design for an availability-zone failure without assuming every dependency is zonal?

  9. How would you identify hidden single points of failure in an Azure workload?

  10. How would you test disaster recovery safely and prove that it works?

  11. How would you design a hub-and-spoke network across subscriptions?

  12. When would Azure Virtual WAN be preferable to a self-managed hub design?

  13. How would you design private DNS for hybrid and multiregion workloads?

  14. How would you secure outbound traffic without breaking Azure service dependencies?

  15. How would you design internet ingress with layered protection and origin isolation?

  16. How would you choose among App Service, Container Apps and AKS for a new product?

  17. How would you operate a multi-tenant application securely on Azure?

  18. How would you design AKS upgrades and node maintenance to minimize disruption?

  19. How would you handle an unreliable downstream dependency in a serverless workload?

  20. How would you design a high-volume asynchronous order-processing system?

  21. How would you make a cross-service workflow consistent without a distributed transaction?

  22. How would you design a Cosmos DB partition strategy for uneven tenant workloads?

  23. How would you decide whether to use a relational database or Cosmos DB?

  24. How would you protect Azure data from accidental deletion and malicious changes?

  25. How would you plan an Azure SQL migration with a bounded cutover window?

  26. How would you design infrastructure-as-code delivery across environments?

  27. How would you control Azure Policy rollout and handle legitimate exceptions?

  28. How would you manage secrets, certificates and rotation across many services?

  29. How would you investigate an application incident when Azure reports no platform outage?

  30. How would you define actionable SLOs and an error-budget policy?

  31. How would you reduce telemetry cost without losing incident visibility?

  32. How would you investigate a sudden Azure cost increase?

  33. How would you validate a capacity plan before a major traffic event?

  34. How would you design for quotas, rate limits and regional capacity constraints?

  35. How would you balance data residency, resilience and service availability?

  36. How would you respond to suspected compromise of an Azure workload identity?

  37. How would you manage Azure service retirement and breaking changes?

  38. How would you decide whether a workload should be migrated, modernized or retained?

  39. How would you evaluate the real cost of an Azure architecture?

  40. How would you explain and defend an Azure architecture decision in a design review?

Azure Interview Questions and Answers

The answers follow the question bank in order and connect Azure concepts to practical design and operational decisions. Code and configuration excerpts are illustrative, not instructions to provision or change a live subscription. Check the stated API, tooling, service tier, permissions, and prerequisites before adapting an example.

Azure Interview Questions and Answers for Beginners

The beginner answers establish the distinctions needed to reason about Azure safely, including resource scope, access control, service models, and regional capabilities. Related products are compared without treating them as interchangeable.

1. What is Microsoft Azure, and when would you use it?

Microsoft Azure is Microsoft's cloud platform for running applications and using services such as compute, databases, storage, networking and identity. A team can rent infrastructure or use managed services instead of purchasing and operating every underlying component itself. Azure also supports hybrid arrangements in which some systems remain on premises.

A useful reason to choose Azure is a requirement for rapid provisioning, access to managed capabilities or deployment near users. For example, a small product team could run its API on App Service and store relational data in Azure SQL Database. That is a workload choice, not proof that cloud hosting is cheaper or automatically resilient. The decision still needs a cost model, operational ownership, security requirements and a check that the required services exist in the intended region.

2. How do IaaS, PaaS and SaaS change the customer's responsibilities?

IaaS gives the customer substantial control over infrastructure configuration, including a VM's operating system and applications. PaaS shifts more platform maintenance to the provider while the customer deploys and secures the application. SaaS provides a finished application that the customer configures and uses.

Model

Typical customer work

Example

IaaS

Guest OS, application and configuration

Azure VM

PaaS

Application code, data and access settings

App Service

SaaS

Users, data use and application settings

Microsoft 365

Moving toward SaaS reduces some operational tasks but does not transfer accountability for customer data, identities or appropriate access. The actual division depends on the service and deployment model.

3. What is the relationship between a tenant, subscription and resource group?

A Microsoft Entra tenant is an identity directory. An Azure subscription provides a resource-management and billing boundary and trusts one Entra tenant at a time. A tenant can be associated with multiple subscriptions. A resource group belongs to one subscription and groups resources for management, usually around a shared lifecycle.

For example, an organization might use one tenant, separate production and development subscriptions, and a resource group for each application environment. Resource groups are not nested directories, and their names alone do not establish isolation. Access assignments, policy and network configuration establish the relevant controls.

This read-only Azure CLI example lists groups visible in the selected subscription. It assumes an already authenticated, authorized session; it does not switch subscriptions or create anything.

Bash command

az group list --query '[].{Name:name,Location:location}' --output
az group list --query '[].{Name:name,Location:location}' --output
az group list --query '[].{Name:name,Location:location}' --output

4. How does Azure Resource Manager organize and manage resources?

Azure Resource Manager, or ARM, is Azure's control-plane management layer. Tools such as the portal, Azure CLI and infrastructure-as-code deployments send management requests through ARM to resource providers. ARM applies management controls and exposes resource scopes such as subscriptions and resource groups.

Declarative templates describe a desired resource configuration rather than a sequence of portal clicks. They make repeatable deployment easier, but a successful resource deployment does not prove that an application works or its data is correct. Data-plane operations, such as reading a blob, have their own service endpoints and authorization behavior.

For an existing authorized environment, this Bash-compatible CLI example inventories resources in one group:

Bash command

az resource list --resource-group rg-orders-dev   --query '[].{Name:name,Type:type}' --output
az resource list --resource-group rg-orders-dev   --query '[].{Name:name,Type:type}' --output
az resource list --resource-group rg-orders-dev   --query '[].{Name:name,Type:type}' --output

The output identifies resource types; it is not an application dependency map.

5. How do Azure regions, availability zones and region pairs differ?

A region is a geographic deployment area containing Azure datacenter infrastructure. An availability zone is a separated infrastructure location within a supporting region, with independent power, cooling and networking. A region pair is a relationship between certain regions used by specific platform capabilities and operational processes.

These concepts address different failure boundaries. Distributing suitable resources across zones can reduce exposure to one zone failing; a second-region design addresses a broader regional interruption. Neither happens merely because an application has a resource in Azure.

Not every region has availability zones or a paired region, and individual services differ in zone support and replication behavior. Selecting two paired regions does not automatically replicate application data, configure failover or meet a recovery objective. Each dependency needs an explicit design.

6. What is the difference between scalability, elasticity and availability?

Scalability is the ability to accommodate a change in load by changing capacity. Vertical scaling changes the size of a resource; horizontal scaling changes the number of instances. Elasticity is the ability to adjust that capacity as demand changes, often automatically. Availability concerns whether users can successfully use the service when they need it.

A web application can be scalable but unavailable during a failed deployment. It can also be highly available at a modest fixed capacity without automatic scaling. The properties complement rather than replace one another.

For a checkout service, adding web instances will not solve a saturated database or an external payment bottleneck. A sound design identifies the limiting dependency, accounts for startup time, and tests scaling while watching user latency and failure rates.

7. What does shared responsibility mean for Azure security?

Shared responsibility divides security duties between Microsoft and the customer. Microsoft operates physical infrastructure; the customer controls identities, data use and workload configuration. IaaS also leaves guest-OS maintenance with the customer.

For example, PaaS hosting does not fix an authorization bug exposing another customer's records. The team still owns that application behavior. A useful review assigns a named owner to each required control instead of assuming that a managed service makes the whole workload secure.

8. How does Microsoft Entra ID differ from Active Directory Domain Services?

Microsoft Entra ID is a cloud identity service for users, applications and devices. Active Directory Domain Services is a directory service commonly used for domain-joined Windows environments, domain controllers, Group Policy and protocols such as Kerberos and LDAP. Entra ID is not simply an Active Directory domain controller hosted by Microsoft.

A company can connect the two using supported hybrid identity arrangements, but synchronization does not make all capabilities identical. A legacy application requiring LDAP or Windows-integrated domain behavior needs an explicit compatibility design. Microsoft Entra Domain Services is another product and should not be confused with Entra ID itself.

For a modern web application, Entra ID can provide token-based sign-in. The application must still validate those tokens and enforce its own resource-level authorization.

9. How do authentication and authorization differ in Azure?

Authentication establishes the caller's identity. Authorization determines what that caller may do. A valid sign-in therefore does not imply permission to modify a VM, read a storage object or view another application's customer data.

Microsoft Entra ID can authenticate users and issue tokens. The receiving service validates the token and evaluates its applicable authorization model, which might include Azure RBAC, a data-plane role or application permissions. The token's intended audience matters: a token issued for one API is not a general access pass to all services.

When diagnosing a rejected request, first distinguish an identity or token problem from a permissions problem. Confirm the actual principal, target resource and operation before adding any role; granting broad access can hide the original configuration error.

10. How does Azure role-based access control work?

Azure RBAC grants permissions through a role assignment combining a security principal, a role definition and a scope. Principals include users, groups, service principals and managed identities. A role defines allowed operations; the scope determines where those permissions apply. Assignments at a parent scope can apply to resources below it.

For example, a support group assigned Reader at an application's resource group can inspect resource configuration without receiving general modification rights. Contributor can manage many resources but does not ordinarily grant role-assignment management. Owner includes that additional authority.

Choose the narrowest useful role and scope, and check inherited assignments as well as direct ones. Data access may require a separate data-plane role. Deny assignments and other controls can also affect the effective result.

11. How do Microsoft Entra roles differ from Azure resource roles?

Microsoft Entra roles administer directory objects and identity capabilities, such as users, groups and application registrations. Azure resource roles authorize operations on Azure resources, such as virtual machines, storage accounts and resource groups. They are separate permission systems even though they can refer to the same person.

A directory administrator is not automatically the owner of every Azure subscription. Likewise, owning an application resource group does not generally authorize managing all tenant users. There are specific elevation and delegation mechanisms, so unusual access must be explained rather than assumed.

For example, resetting an employee's directory password and resizing a VM require different authorities. Keeping those responsibilities separate reduces the impact of an overprivileged account and makes access reviews more meaningful.

12. What are managed identities, and how do their two types differ?

A managed identity lets a supported Azure workload obtain Microsoft Entra tokens without the application storing a client secret. Azure manages its credential lifecycle. The identity still needs authorization to access the target service.

A system-assigned identity is tied to the lifecycle of one supporting resource. A user-assigned identity is a separate Azure resource that can be attached to supported workloads and can survive their replacement. Reuse can simplify deployment, but sharing an identity across unrelated applications also shares its permissions and audit identity.

For example, a web app can use a managed identity with a narrowly scoped storage data role. Enabling the identity alone is insufficient: the target must support that authentication path, the role must be assigned, and network connectivity must allow the request.

13. What are Azure Policy and resource locks used for?

Azure Policy evaluates resources against governance rules. Depending on the policy effect and configuration, it can audit, deny or help remediate noncompliant configurations. A resource lock instead restricts management operations on a scope: CanNotDelete blocks deletion, while ReadOnly also blocks updates.

For example, Policy could restrict approved deployment regions, while a delete lock helps protect an important resource group from accidental removal. Neither grants a user permission to operate resources, and a lock is not a backup strategy.

Management locks do not generally protect service data-plane operations, such as deleting an individual stored object. ReadOnly locks can also interfere with operations implemented as control-plane POST requests. Test governance and lock behavior against the actual service before applying them broadly.

14. How do tags help organize Azure resources?

Tags are key-value metadata used to classify resources, resource groups and subscriptions. Common keys include Environment, Owner and CostCenter. A consistent tag convention helps teams locate resources, allocate costs and identify who should approve a change.

Tags are not a security boundary, and resources do not automatically inherit resource-group or subscription tags. A governance process or policy can help apply the required values. Avoid passwords, personal data and other confidential values in tags because they appear in management and reporting surfaces.

A simple intended tag set might look like this; it is metadata, not a complete deployment template:

JSON example

{
  "Environment": "Development",
  "Owner": "OrdersTeam",
  "CostCenter": "ProductEngineering"
}
{
  "Environment": "Development",
  "Owner": "OrdersTeam",
  "CostCenter": "ProductEngineering"
}
{
  "Environment": "Development",
  "Owner": "OrdersTeam",
  "CostCenter": "ProductEngineering"
}

Agree on spelling and permitted values so that Development, dev and DEV do not unintentionally fragment reports.

15. When would you choose an Azure virtual machine?

An Azure VM is appropriate when the workload needs control over the operating system, installed software or host configuration that a more managed service does not provide. Examples include a legacy application with specific system dependencies or a supported appliance deployment.

That flexibility brings responsibility for guest-OS patching, application maintenance, secure administration, backup and recovery. VM sizing must consider memory, CPU, disk throughput and network limits rather than just a machine's name. Related disks and network services can continue to incur charges independently of compute.

This read-only Azure CLI example inspects the size and operating-system type of an existing authorized VM; the names are illustrative:

Bash command

az vm show --resource-group rg-orders-dev --name vm-orders-01   --query '{Size:hardwareProfile.vmSize,OS:storageProfile.osDisk.osType}'   --output
az vm show --resource-group rg-orders-dev --name vm-orders-01   --query '{Size:hardwareProfile.vmSize,OS:storageProfile.osDisk.osType}'   --output
az vm show --resource-group rg-orders-dev --name vm-orders-01   --query '{Size:hardwareProfile.vmSize,OS:storageProfile.osDisk.osType}'   --output

It does not test application health.

16. How do VM availability sets and availability zones differ?

An availability set distributes multiple VMs across fault domains and update domains to reduce correlated hardware and planned-maintenance disruption. Availability zones provide a broader separation within a supporting region, with independent infrastructure boundaries.

An availability set does not protect against every datacenter-wide failure, and putting two VMs into one does not replicate the application's state. A zone-based design requires separate instances across zones and appropriate load distribution, data resilience and capacity. A single zonal VM is still one VM in one zone.

For a stateless API, multiple instances across zones may be a useful choice, provided its database and other dependencies are also designed for the target failure scenario. Verify region, VM-size, disk and service support; do not treat either placement option as an automatic application-availability guarantee.

17. What are Virtual Machine Scale Sets?

Virtual Machine Scale Sets manage groups of VM instances and support patterns such as consistent configuration, autoscaling and coordinated maintenance. They are useful when an application can run across several machines instead of relying on one large server.

The orchestration mode and configuration affect how instances are created and managed. A scale set is not automatically an application load balancer or a complete availability design; traffic distribution, health detection, image maintenance and state management still need configuration. Placement across zones can improve protection against a zone failure where supported.

For an API tier, scaling from three instances to six only helps if new instances become healthy quickly and the database can handle the extra work. Scale-in also needs care so that in-flight work is drained rather than lost.

18. How does Azure App Service differ from hosting on a VM?

App Service is a managed hosting platform for web applications and APIs. It removes much of the work of maintaining the underlying host infrastructure and supports code-based or containerized deployments. A VM provides more direct operating-system control but also leaves more platform operations to the customer.

For a conventional web API, App Service can simplify deployment, scaling and operational setup. The application still needs secure dependencies, appropriate configuration, monitoring and a recovery strategy. Features such as deployment slots, network integration and zone redundancy depend on the selected plan and supported configuration.

The choice is driven by requirements rather than a rule that PaaS is always best. Check runtime and dependency compatibility, workload behavior and isolation needs. Avoid choosing a VM merely because it resembles an existing server if a managed platform meets the real requirements.

19. What are Azure Functions triggers and bindings?

A trigger specifies what starts a function invocation, such as an HTTP request, timer or queue message. Each function has exactly one trigger. Bindings optionally connect the function to other data sources or destinations: input bindings supply data, and output bindings write data.

For example, a queue-triggered function could validate a work item and write a result through an output binding. It could also use an SDK client directly when it needs finer control over an operation or error handling. Bindings reduce repetitive integration code; they do not remove the need for identity, network access or correct business logic.

The supported bindings and their configuration depend on the language, programming model and extension version. Delivery retries can cause repeated invocations, so processing should be safe when an event is received more than once.

20. How do Azure Container Instances, Container Apps and AKS differ?

Azure Container Instances provides a relatively low-level way to run container groups without managing a VM directly. Container Apps adds application-oriented capabilities such as revisions, ingress and event-driven scaling. AKS provides a Kubernetes environment with access to the Kubernetes API and its ecosystem.

Option

Typical fit

Important responsibility

Container Instances

Isolated task or simple container execution

Arrange application orchestration when needed

Container Apps

Managed containerized services and jobs

Configure revisions, scaling and dependencies

AKS

Workloads needing Kubernetes capabilities

Operate the workload and relevant cluster configuration

Choose based on deployment requirements and operational capacity. Container Apps does not expose the underlying Kubernetes API. AKS service models can reduce some cluster work, but no option removes image security, application configuration, data protection or observability responsibilities.

21. What is an Azure virtual network?

An Azure virtual network, or VNet, defines a private network address space for Azure resources. Subnets divide that space for placement and policy. Connected resources can communicate subject to routing, filtering and the service's own network capabilities.

A VNet belongs to a region and can support resources across that region's availability zones. Separate VNets can be connected through supported mechanisms such as peering or gateways. Address planning matters because overlapping ranges can prevent straightforward connectivity with another VNet or an on-premises network.

For example, an application VNet could use separate subnets for application and integration components. Merely placing resources in different subnets does not create an automatic isolation policy. Explicit security rules and appropriate routes are required. Internet egress must also be designed rather than assumed from a private address alone.

22. How do subnets, network security groups and route tables differ?

A subnet is a range of addresses inside a VNet. An NSG filters supported inbound and outbound traffic using rules based on factors such as source, destination, protocol and port. A route table supplies user-defined routing decisions, such as sending a destination prefix through a network appliance.

These are complementary controls. A route can identify where traffic goes without allowing it through an NSG, and an allow rule does not create a missing route. NSG rules are stateful and evaluated by priority, with lower numbers taking precedence.

For example, an application subnet might route external traffic through a firewall while an NSG permits only required application traffic. Troubleshooting must consider the complete forward and return paths, including subnet and NIC-level filtering, rather than changing the first rule that looks restrictive.

23. What is the difference between a public IP address and a private IP address?

A private IP address identifies a resource on a private network path, such as a VNet or a connected hybrid network. A public IP resource can provide internet-facing addressing when associated with a supported Azure component. Whether traffic succeeds still depends on routing, security controls and the listening application.

A VM does not need its own public IP to make outbound connections if an explicit egress mechanism, such as NAT Gateway or a firewall, provides them. Conversely, assigning a public IP does not mean every port should be reachable. Current public-IP SKU and resource-compatibility requirements must be checked.

For an internal service, keep its endpoint private and expose only an intended gateway if public access is required. Public addressing, encryption and user authentication solve separate problems and should not be treated as interchangeable protections.

24. How do Azure Load Balancer, Application Gateway and Front Door differ?

Azure Load Balancer distributes supported TCP and UDP flows at layer 4. Application Gateway is a regional application-delivery service commonly used for HTTP routing, TLS termination and WAF integration. Front Door operates at the global edge for web traffic, with routing and acceleration capabilities across origins.

Requirement

Common starting point

Regional TCP or UDP balancing

Azure Load Balancer

Regional web routing to private backends

Application Gateway

Global web entry point and origin selection

Front Door

This is a starting distinction, not an exhaustive feature matrix. Application Gateway also has supported TCP/TLS capabilities, and specific SKUs change the options. Health probes, origin protection, certificate management and failure behavior still require design. A load balancer cannot make unhealthy application dependencies reliable.

25. How do VPN Gateway and ExpressRoute connect an on-premises network?

VPN Gateway can connect an on-premises network to Azure through an encrypted IPsec/IKE tunnel over the internet. ExpressRoute uses private connectivity through a supported connectivity provider or direct connectivity arrangement, rather than carrying the connection over the public internet.

VPN can suit smaller connectivity requirements or act as part of a backup design. ExpressRoute can suit sustained hybrid traffic and more predictable connectivity, but it requires provider coordination, routing and an end-to-end resilience plan. A private circuit is not automatically encrypted; encryption requirements need a separate design using supported options.

For either choice, verify nonoverlapping addresses, routes, DNS and redundant paths. Two connections that share the same failing on-premises device or provider path are not truly independent. The application also needs tested behavior when the connection is interrupted.

26. What is Azure DNS, and when is Private DNS useful?

Azure DNS hosts DNS zones and records for name resolution. Public DNS publishes records that internet resolvers can use. Azure Private DNS provides name resolution for private zones available through linked VNets and appropriately configured resolvers.

For example, an internal application name can resolve to a private address without publishing that record on public DNS. A private zone must be linked to the appropriate VNet, or reachable through a correctly designed forwarding path. Autoregistration is optional for supported VM records; it does not automatically discover every service endpoint.

DNS does not create network connectivity or authorize application access. A correct private answer can still point to a resource blocked by routing or a firewall. Conversely, peering two VNets does not by itself establish all the private-zone resolution arrangements a workload needs.

27. How do Blob Storage, Azure Files and managed disks differ?

Blob Storage is object storage for data such as images, documents and analytics files. Azure Files provides managed file shares using supported file protocols. Managed disks provide block storage associated with VM workloads. These interfaces serve different application expectations.

For a document-upload API, blobs are often a natural fit because the application accesses individual objects. A legacy application requiring a shared filesystem may need Azure Files. A VM database may use managed data disks with performance settings matched to its workload.

Do not assume an object store behaves exactly like a traditional mounted filesystem, or that a disk is an ordinary shared file service. Compare access protocol, concurrency, permissions, performance and backup behavior. Redundancy choices and feature availability also differ by storage service, account type and region.

28. What do LRS, ZRS, GRS and GZRS mean for Azure Storage?

LRS keeps redundant copies within a single primary-region location. ZRS synchronously spreads copies across availability zones in the primary region. GRS adds asynchronous replication from an LRS primary to a secondary region. GZRS combines a zone-redundant primary with asynchronous replication to a secondary region.

Option

Primary-region layout

Secondary-region copy

LRS

Local redundancy

No

ZRS

Zone redundancy

No

GRS

Local redundancy

Yes, asynchronous

GZRS

Zone redundancy

Yes, asynchronous

Asynchronous replication can leave a gap in the newest data during a regional failure. Ordinary GRS/GZRS does not automatically give applications readable secondary access; read-access variants and failover capabilities depend on the service. Check supported combinations, and remember that replication can copy an accidental deletion rather than replace backup.

29. How do Blob Storage access tiers affect data retrieval and cost?

Blob access tiers trade storage price against access cost and retrieval requirements. Hot suits frequent access. Cool and cold are online tiers for less frequent reads. Archive is offline and requires rehydration before ordinary reading, so it is unsuitable when the application needs immediate retrieval.

For example, recent support attachments may stay hot while older, rarely accessed records move to a colder tier. The saving must include read operations, retrieval, rehydration and applicable early-deletion charges, not just the price per stored gigabyte. Retention rules and legal holds must also be respected.

Tier support depends on blob type, account configuration and redundancy. Smart-tier capabilities can automate online-tier selection where supported, but they do not eliminate the need to understand access patterns and cost. Test a realistic retrieval scenario before choosing archive for recovery-critical data.

30. How do storage account keys, SAS and Microsoft Entra authorization differ?

An account key authorizes broad Shared Key access and therefore carries a large exposure risk if leaked. A shared access signature, or SAS, grants a bearer limited access according to its signed permissions, resource scope and validity period. Microsoft Entra authorization uses an identity and applicable data permissions instead of handing the application an account key.

For supported services, prefer identity-based access with a managed identity. When delegated blob access is required, a user-delegation SAS avoids signing with the account key. A SAS is still a secret capability: whoever obtains it may use its permitted access until its validity or revocation conditions stop it.

Network rules remain separate. A correct identity or SAS does not override an unreachable private endpoint or firewall restriction. Never place real keys or SAS tokens in source code or diagnostic logs.

31. How do Azure SQL Database, SQL Managed Instance and SQL Server on VMs differ?

Azure SQL Database is a managed database service suited to database-level application requirements. SQL Managed Instance provides a managed instance model with broader SQL Server instance compatibility. SQL Server on Azure VMs provides control of the guest operating system and installed SQL Server configuration, with more maintenance responsibility.

Option

Main attraction

Trade-off

SQL Database

Managed database operations

Verify required instance-level features

Managed Instance

Broader instance compatibility

Validate migration and network constraints

SQL Server on VM

OS and SQL configuration control

More operational ownership

A migration should start with an inventory of actual dependencies, not just the SQL dialect. Check SQL Agent jobs, cross-database behavior, extensions, networking and recovery requirements. Managed services reduce platform work, but application performance, permissions and data correctness remain the team's responsibility.

32. What is Azure Cosmos DB, and what does a partition key do?

Azure Cosmos DB is a distributed database service whose supported APIs and configurations are designed for scalable application data access. In a partitioned container, the partition-key value determines the logical partition for an item. That choice strongly affects how data and requests distribute and how efficiently common queries can be served.

For a tenant-oriented application, a tenant identifier may appear attractive because tenant-scoped requests can target related data. It can be a poor choice if one tenant dominates traffic or grows beyond the design's supported partition boundaries. Choose based on expected distribution and access patterns rather than naming convenience.

A point read uses the item's identifier and partition-key value. Queries spanning many partitions can do more work. Increasing throughput alone may not cure a hot partition; model the key and workload together.

33. How do Azure Service Bus, Event Grid and Event Hubs differ?

Service Bus is suited to brokered business messages, such as processing an order with controlled settlement and retries. Event Grid routes discrete events, such as a notification that an object changed. Event Hubs ingests streams such as device telemetry for independent consumers to process.

For example, an order command might go to Service Bus, a new-file notification through Event Grid, and a continuous sensor feed to Event Hubs. These are different interaction patterns, not simply three interchangeable queues.

Ordering, replay, dead-lettering, throughput and protocol requirements determine the final choice, and features vary by tier and configuration. Consumers should account for redelivery. Broker duplicate detection or ordered sessions do not by themselves guarantee that every external side effect occurs exactly once; application-level idempotency is still important.

34. What is Azure Key Vault used for?

Azure Key Vault stores and controls access to secrets, cryptographic keys and certificates. It centralizes sensitive material so applications do not have to embed credentials in source code or ordinary configuration files. Applications authenticate and need permission for the specific operations they perform.

For example, an application can use a managed identity to retrieve a required secret. That avoids storing a second client secret merely to unlock the first one. Where the downstream service supports identity-based access directly, eliminating the secret entirely can be preferable.

Vault management permissions and permissions to read secrets are distinct. Also plan network access, rotation, recovery and monitoring. Storing a password in a vault does not automatically rotate it in the external system, update every consumer safely or prevent an authorized application from accidentally logging it.

35. How do Azure Monitor, Log Analytics and Application Insights relate?

Azure Monitor is the broader platform for collecting and acting on operational telemetry. Log Analytics provides the query experience for log data in a workspace, commonly using KQL. Application Insights supplies application-performance monitoring capabilities, including request and dependency visibility when the application is appropriately instrumented.

They work together rather than competing as three unrelated monitoring products. Infrastructure metrics can indicate saturation, application telemetry can reveal a failing dependency, and logs can provide the details of a specific request.

Collection still needs deliberate configuration. Not every useful application event or resource log appears automatically. Decide what to collect, where it belongs, who can access it and how long to retain it. Alerts should connect signals to an owner and a useful response, rather than generating notifications with no action attached.

36. How do metrics, logs and distributed traces differ?

Metrics are numerical measurements over time, such as request count or CPU usage. Logs are timestamped event records with contextual details. Distributed traces connect the steps of a request across components so a team can see where time or failures occurred.

Use the signals together: a latency metric identifies a trend, a trace can locate the slow dependency, and related logs can explain the failure. Aggregation, sampling and collection gaps affect what conclusions are justified.

This illustrative Bash CLI query lists the available metric definitions for an authorized resource ID, rather than guessing a metric name:

Bash command

resource_id='/subscriptions/SUBSCRIPTION_ID/resourceGroups/rg-orders-dev/providers/Microsoft.Compute/virtualMachines/vm-orders-01'
az monitor metrics list-definitions --resource "$resource_id"   --query '[].{Name:name.value,Unit:unit}' --output

resource_id='/subscriptions/SUBSCRIPTION_ID/resourceGroups/rg-orders-dev/providers/Microsoft.Compute/virtualMachines/vm-orders-01'
az monitor metrics list-definitions --resource "$resource_id"   --query '[].{Name:name.value,Unit:unit}' --output

resource_id='/subscriptions/SUBSCRIPTION_ID/resourceGroups/rg-orders-dev/providers/Microsoft.Compute/virtualMachines/vm-orders-01'
az monitor metrics list-definitions --resource "$resource_id"   --query '[].{Name:name.value,Unit:unit}' --output

Replace the placeholder with a verified ID before separately authorized use. Definitions describe available metrics, not current values.

37. What is the difference between Azure Backup and Azure Site Recovery?

Azure Backup focuses on retaining recovery points and restoring supported data or workloads. Azure Site Recovery focuses on replicating supported machines and orchestrating recovery to a secondary location during an outage. Backup and disaster-recovery replication address related but different needs.

A backup can recover an older state after accidental deletion or corruption. Replication can reduce the time required to resume a replicated workload elsewhere, but it may also replicate unwanted changes. A recovery design can therefore need both, along with service-native backup or replication features for managed databases.

Neither service automatically validates the whole business application. Confirm support for the workload, recovery-point consistency, network and identity dependencies, and the order in which components start. A successful job status is useful evidence, but a tested restore and application check are what establish recoverability.

38. What are RTO and RPO?

Recovery time objective, or RTO, is the target maximum time to restore an acceptable service after disruption. Recovery point objective, or RPO, is the target maximum data-loss window measured backward in time from the disruption. They express business requirements, not automatic guarantees of a chosen Azure service.

For an illustrative order system, an RTO of one hour and an RPO of five minutes means recovery planning should aim to resume the agreed service within an hour while losing no more than five minutes of accepted data. Whether that is feasible depends on replication, backup cadence, detection, failover steps and reconciliation.

Measure the complete recovery process. A database becoming available in ten minutes does not satisfy the application RTO if DNS, credentials or dependent services take another two hours to recover.

39. What do an Azure SLA and an application SLO measure?

An SLA is a service agreement defining commitments and the conditions under which remedies such as service credits may apply. An SLO is a target for the service experience a team intends to deliver, measured through chosen indicators such as successful requests or latency. An Azure service SLA is not automatically the SLO or measured availability of an entire application.

For example, an application might target 99.9% successful checkouts over a month. That indicator must specify what counts as a checkout, which failures count and where measurement occurs. A healthy VM does not prove a successful checkout if the database or payment dependency fails.

Review the exact SLA terms for the service configuration. Use end-to-end measurements and failure analysis for workload targets rather than adding or averaging provider percentages.

40. What practical steps help control Azure spending?

Start with cost visibility and ownership, then remove waste and select capacity that matches the workload. Use an inventory, clear tags and cost analysis to identify idle resources, unexpected growth and expensive usage patterns. Establish budgets and alerts, but do not treat a budget notification as an automatic hard spending cap.

For example, a development environment might use a planned shutdown schedule while production is rightsized from observed demand. Evaluate the full bill: compute, disks, network transfer, backups, logs and ancillary services can all matter. Deallocating a VM does not remove every associated charge.

Only consider longer-term purchasing commitments after understanding stable usage and their terms. Cost optimization should preserve required security and recovery outcomes. A cheaper configuration that repeatedly fails or creates heavy operational work may cost more overall.

Azure Interview Questions and Answers for Intermediate

The intermediate answers explain implementation choices through their prerequisites, operational effects, and validation needs. Region, tier, identity, and API-specific behavior remain explicit where they affect the result.

41. How would you design resource-group boundaries for an application?

Resource groups should follow lifecycle, ownership and operational boundaries, not simply mirror every service type. Resources deployed and retired together can share a group; shared networking or a long-lived database may belong separately when their owners and change cycles differ. Resource-group RBAC and policy scope then reflect those boundaries.

For an order service, separate production from development and consider keeping shared connectivity outside either application's disposable group. Document cross-group dependencies in infrastructure as code. A resource group is not a network isolation boundary, and placing services together does not make them communicate or fail over together. Its location identifies where group metadata is held, not a requirement that every contained resource use that region.

Before deletion or migration, inspect dependent services, locks and supported move operations. The design should make safe changes straightforward without giving an application deployment unnecessary control over shared infrastructure.

42. How do management groups and Azure Policy initiatives support governance?

Management groups provide a hierarchy above subscriptions so common governance can be inherited. Azure Policy initiatives bundle related policy definitions into a named control set that can be assigned at an appropriate scope. RBAC determines who may act; policy evaluates whether resource configurations or operations meet the assigned rules.

For example, a production management group can inherit approved-region and diagnostic-logging policies while application subscriptions retain local ownership. Start a new policy in an appropriate audit or non-enforcing rollout, inspect real exceptions, and move to enforcement after validating the impact. An initiative's compliance dashboard is evidence about evaluated controls, not proof that the whole organization meets a regulation.

Existing noncompliant resources are not universally fixed merely by assignment. Remediation depends on the policy effect, supported resource properties, required identity permissions and a remediation process. Keep exemptions narrow, owned and time-bounded rather than weakening the hierarchy for one application.

43. How do you diagnose an Azure RBAC authorization failure?

Identify the actual principal, requested operation and resource scope from the failed request before changing a role. Confirm the token's tenant, the selected subscription, inherited role assignments, any assignment conditions or deny assignments, and whether Privileged Identity Management activation is required. A management-plane role may not grant the data operation the application is attempting.

For an already authorized Azure CLI session, this read-only Bash example checks context and assignments for a known principal at a known scope:

Bash command

az account show --query '{tenant:tenantId,subscription:id}' -o json
az role assignment list --assignee "$PRINCIPAL_OBJECT_ID"   --scope "$RESOURCE_ID" --include-inherited -o

az account show --query '{tenant:tenantId,subscription:id}' -o json
az role assignment list --assignee "$PRINCIPAL_OBJECT_ID"   --scope "$RESOURCE_ID" --include-inherited -o

az account show --query '{tenant:tenantId,subscription:id}' -o json
az role assignment list --assignee "$PRINCIPAL_OBJECT_ID"   --scope "$RESOURCE_ID" --include-inherited -o

Interpret the result alongside group membership and the exact error; an empty list alone is not a complete effective-access evaluation. Recent changes may require propagation and fresh credentials. Grant only the missing permission at the narrowest practical scope, rather than using Owner as a troubleshooting shortcut.

44. How should an application access Key Vault without a stored client secret?

Use a managed identity supported by the hosting service, then give that identity the required Key Vault data-plane permission. With the vault's Azure RBAC permission model, a secret-reading application commonly needs a role such as Key Vault Secrets User, scoped appropriately. Enabling an identity does not itself authorize secret access or bypass network restrictions.

This illustrative Python excerpt assumes the Azure Identity and Key Vault Secrets packages, a configured system-assigned identity in Azure, an existing vault and separately authorized access:

Python example

from azure.identity import ManagedIdentityCredential
from azure.keyvault.secrets import SecretClient

credential = ManagedIdentityCredential()
client = SecretClient(vault_url="https://example-vault.vault.azure.net/",
                      credential=credential)
secret = client.get_secret("database-password")
# Pass secret.value only to its intended client; never log it.
from azure.identity import ManagedIdentityCredential
from azure.keyvault.secrets import SecretClient

credential = ManagedIdentityCredential()
client = SecretClient(vault_url="https://example-vault.vault.azure.net/",
                      credential=credential)
secret = client.get_secret("database-password")
# Pass secret.value only to its intended client; never log it.
from azure.identity import ManagedIdentityCredential
from azure.keyvault.secrets import SecretClient

credential = ManagedIdentityCredential()
client = SecretClient(vault_url="https://example-vault.vault.azure.net/",
                      credential=credential)
secret = client.get_secret("database-password")
# Pass secret.value only to its intended client; never log it.

Select a user-assigned identity explicitly when needed. For local development, use a separately approved developer identity rather than copying a production credential. Also design secret caching, rotation and dependency-failure behavior.

45. How do control-plane permissions differ from data-plane permissions?

Control-plane operations manage the Azure resource, while data-plane operations use its service. Creating a storage account or changing its configuration uses the management plane; reading a blob uses the storage data plane. The endpoints, permission models and logs can therefore differ.

Operation

Plane

Permission implication

Change a storage account setting

Control

Azure resource management authorization

Read a blob using Entra ID

Data

An appropriate storage data role

Read a Key Vault secret

Data

Vault data access permission

A resource Contributor should not be treated as equivalent to every service's data reader. However, management privileges that retrieve keys or alter authorization can indirectly expose data, so assess effective capabilities rather than role names alone. Likewise, a Resource Manager lock primarily constrains management operations; it is not a universal safeguard against deleting service data. Test the precise operation and authorization mechanism in question.

46. How do private endpoints differ from service endpoints?

A private endpoint places a network interface with a private IP in your VNet and connects it to a specific supported service resource or subresource through Private Link. A service endpoint lets traffic from an enabled subnet reach a supported service's public endpoint over the Azure backbone, with subnet identity available to the service's network rules.

Private endpoints are useful when clients in connected networks need private addressing and public access must be disabled. They require correct DNS and resource-side approval/configuration. Classic service endpoints are simpler for some Azure-subnet-to-service restrictions but do not give the service a private IP in your VNet or automatically extend the subnet identity to on-premises clients.

Neither option grants application data permissions. Also, creating a private endpoint does not universally disable the service's public endpoint. Confirm the service-specific public-access setting, supported subresources and network policy behavior before claiming that the service is private.

47. How does private-endpoint DNS resolution work across connected networks?

Keep the application's normal service hostname, but make its resolution from private clients return the private endpoint address. For Azure SQL Database, the public hostname can lead through a private-link alias to an A record in the linked private DNS zone. Connecting directly to an IP can break hostname-based TLS validation or service routing.

Plain-text example

Client: example.database.windows.net
  -> service DNS alias for Private Link
  -> example.privatelink.database.windows.net
  -> private endpoint IP visible through linked private DNS
Client: example.database.windows.net
  -> service DNS alias for Private Link
  -> example.privatelink.database.windows.net
  -> private endpoint IP visible through linked private DNS
Client: example.database.windows.net
  -> service DNS alias for Private Link
  -> example.privatelink.database.windows.net
  -> private endpoint IP visible through linked private DNS

Peering alone does not make every private DNS zone visible to every VNet. Link the required networks or use an intentional resolver/forwarder design. On-premises clients commonly forward the documented service domain to an Azure DNS Private Resolver inbound endpoint or approved DNS forwarder. Validate resolution from each client location, then test routing and authorization separately. Avoid replacing an entire public service zone with incomplete private records that break unrelated resources.

48. How would you diagnose a VM that cannot reach an external service?

Separate name resolution, routing, transport connectivity, TLS and application authorization. Confirm the destination hostname, resolved address, port, time of failure and source VM. Then inspect effective routes and NSG rules, the guest firewall, outbound translation, any network appliance and the destination's allow list. A successful ping is not proof that an HTTPS connection works.

For a known NIC in an already authorized Azure CLI session, these Bash commands inspect effective configuration without changing it:

Bash command

az network nic show-effective-route-table   --resource-group "$RESOURCE_GROUP" --name "$NIC_NAME" -o table
az network nic list-effective-nsg   --resource-group "$RESOURCE_GROUP" --name "$NIC_NAME" -o

az network nic show-effective-route-table   --resource-group "$RESOURCE_GROUP" --name "$NIC_NAME" -o table
az network nic list-effective-nsg   --resource-group "$RESOURCE_GROUP" --name "$NIC_NAME" -o

az network nic show-effective-route-table   --resource-group "$RESOURCE_GROUP" --name "$NIC_NAME" -o table
az network nic list-effective-nsg   --resource-group "$RESOURCE_GROUP" --name "$NIC_NAME" -o

Use Network Watcher connection troubleshooting when permitted and supported for the target scenario. Compare working and failing instances and recent changes. Check SNAT exhaustion or a missing explicit outbound path before broadening firewall rules; preserve the intended security boundary while isolating the failure.

49. How do VNet peering, gateway transit and routing interact?

VNet peering provides direct connectivity between the peered networks, but it is not automatically transitive. A spoke peered with a hub does not gain ordinary spoke-to-spoke connectivity just because another spoke shares that hub. Gateway transit lets a peered network use a supported gateway in the hub when the corresponding peering options and route propagation are configured.

Plain-text example

Spoke A <-> Hub <-> Spoke B
Two peerings alone do not create A <-> B transit.
Transit requires an intentional routing and forwarding design

Spoke A <-> Hub <-> Spoke B
Two peerings alone do not create A <-> B transit.
Transit requires an intentional routing and forwarding design

Spoke A <-> Hub <-> Spoke B
Two peerings alone do not create A <-> B transit.
Transit requires an intentional routing and forwarding design

For a network virtual appliance, check user-defined routes, forwarded-traffic settings, IP forwarding, appliance policies and the return path. Address spaces must meet peering requirements and must not conflict with relevant connected networks. Inspect effective routes rather than assuming a peering's connected status proves application reachability. A central hub is also an operational dependency, so its gateway or firewall needs suitable capacity, availability and ownership.

50. When would you choose Azure Firewall instead of relying only on NSGs?

NSGs are useful for distributed stateful filtering by addresses, ports and protocol at subnets or network interfaces. Azure Firewall adds a centrally managed inspection point with features such as application rules and threat-intelligence capabilities, depending on the SKU. Choose it when the workload needs consistent outbound policy, controlled transit or inspection beyond basic network segmentation.

For example, an application subnet may use NSGs to restrict lateral access while its outbound route traverses Azure Firewall for approved destination rules and centralized logging. The firewall does not become effective just because it exists: traffic must actually follow the intended path in both directions.

Select Basic, Standard or Premium according to the required features, throughput and budget. TLS inspection and intrusion detection/prevention are SKU-specific, not universal firewall capabilities. Keep NSGs where they provide defense in depth, and test DNS, service dependencies, asymmetric routing and failure behavior before enforcing a new central path.

51. How do NAT Gateway and load-balancer outbound rules affect outbound connectivity?

NAT Gateway provides explicit outbound source NAT for supported subnets and dynamically allocates SNAT ports from its configured public addresses. Standard Load Balancer outbound rules provide outbound translation for configured backend resources, but require appropriate port allocation and backend design. Neither is a general-purpose inbound application proxy.

For supported internet-bound flows, a subnet-associated NAT Gateway takes precedence over other outbound methods such as load-balancer outbound rules. A user-defined route to a firewall or virtual appliance changes the actual path, so NAT Gateway is not a substitute for inspecting effective routes. Choose an explicit outbound design rather than depending on historical default outbound access behavior.

Size for concurrent connections, connection reuse and destination patterns, not just bandwidth. Monitor translation failures and idle-timeout behavior. NAT Gateway SKU and regional support affect zone resilience and other capabilities; do not assume that every NAT gateway is zone-redundant. A stable outbound IP also needs to be allowed by the destination service.

52. How do Application Gateway health probes and backend HTTP settings affect routing?

Application Gateway routes requests only to backends it considers healthy for the relevant backend-setting combination. A probe must match the application's expected protocol, port, hostname, path and acceptable response. Backend settings also affect connection behavior such as HTTPS, hostname handling and request timeout.

Plain-text example

Probe target: HTTPS backend.example.internal:443/health/ready
Expected: approved success status and correct hostname/TLS behavior
Failure: backend excluded from routing until healthy again
Probe target: HTTPS backend.example.internal:443/health/ready
Expected: approved success status and correct hostname/TLS behavior
Failure: backend excluded from routing until healthy again
Probe target: HTTPS backend.example.internal:443/health/ready
Expected: approved success status and correct hostname/TLS behavior
Failure: backend excluded from routing until healthy again

A default probe can fail when the application requires a particular Host header or does not serve the default path. Inspect backend health details, certificate trust and name validation, DNS, NSGs and routes before declaring the application down. Conversely, a shallow health page can return success while a critical dependency is unusable. Design a readiness check that represents the backend's ability to serve traffic without causing every instance to fail merely because a shared, optional dependency is slow.

53. How would you choose between Front Door and Traffic Manager?

Azure Front Door is a global HTTP(S) reverse-proxy service that can provide edge routing, TLS termination, caching and web application protection according to the chosen tier. Traffic Manager makes DNS-based routing decisions and returns an endpoint; the client then connects directly to that endpoint. It does not proxy the application's requests.

Front Door fits a web application that benefits from a global edge entry point and HTTP-aware routing. Traffic Manager can fit DNS-routable services where direct endpoint connectivity or non-HTTP protocols matter. Existing DNS caches and connection reuse affect how quickly clients respond to a Traffic Manager routing change.

Evaluate health probes, origin exposure, certificate ownership, caching correctness, regional dependencies and cost. Neither service replicates application data or makes a backend region recoverable on its own. A global routing choice must be paired with an application and data architecture that can safely handle requests in the selected region.

54. How do App Service deployment slots support safer releases?

Deployment slots let an App Service application run a staged version with its own hostname before a controlled swap. Validate the staged build, warm it up, and check configuration differences before shifting production traffic. Slots are available only in supported App Service tiers and share the plan's underlying capacity.

This read-only Azure CLI example in Bash lists existing slots for an authorized app:

Bash command

az webapp deployment slot list --resource-group "$RESOURCE_GROUP"   --name "$APP_NAME" --query '[].name' -o
az webapp deployment slot list --resource-group "$RESOURCE_GROUP"   --name "$APP_NAME" --query '[].name' -o
az webapp deployment slot list --resource-group "$RESOURCE_GROUP"   --name "$APP_NAME" --query '[].name' -o

Mark environment-specific settings appropriately so production credentials or endpoints do not accidentally move with a release. Some settings and identities do not swap, so review documented behavior rather than assuming the slot is a complete environment clone. A swap does not roll back a database migration or external side effect. Use backward-compatible schema changes, staged traffic validation and a tested rollback plan; also ensure the staging load cannot starve production.

55. How do App Service VNet integration and private endpoints differ?

VNet integration controls outbound connectivity from an App Service app into a virtual network. A private endpoint provides private inbound connectivity to the app. They solve opposite directions of the connection and can be used together, subject to plan support and subnet requirements.

For an internal API that reads a private database, clients reach the API through its private endpoint, while the API reaches the database through its VNet integration path. Configure private DNS for each service and explicitly review public network access. Integration alone does not make the API private, and the app's private endpoint does not route its outbound database calls.

Use separate appropriate subnets for integration and the private endpoint. Confirm route-all behavior, NSGs, route tables, address capacity and deployment access for the app's SCM endpoint. Test from both a permitted private client and an untrusted public location rather than inferring isolation from a successful private request.

56. How do Azure Functions hosting plans affect scaling and execution?

The hosting plan determines the function app's scaling model, available compute, networking options, billing and execution constraints. Flex Consumption suits event-driven serverless workloads that need its supported scaling and networking features. Premium can provide prewarmed capacity and additional capabilities; Dedicated uses provisioned App Service capacity. Container Apps is another hosting choice with its own operational model.

Choose from the actual workload: latency sensitivity, event source, concurrency, runtime, regional availability, network restrictions and sustained utilization. Treat legacy Consumption separately and check current OS support and migration notices rather than recommending it automatically for a new application.

A longer function timeout does not make an HTTP request able to wait indefinitely, and scale-out cannot remove downstream database limits. Configure concurrency and retry behavior deliberately. Long-running work often belongs behind an asynchronous request pattern or an orchestrated workflow. Load-test cold starts, burst handling and dependency saturation on the selected plan instead of comparing only headline instance limits.

57. How should an Azure Functions handler process duplicate events?

Assume an event can be delivered more than once and make the business effect idempotent. Use a stable business operation ID and persist the processed state with the state change atomically where possible. A check followed by an unrelated write is vulnerable to concurrent deliveries and crashes.

Plain-text example

Begin database transaction
  Insert operation ID into a table with a unique constraint
  Apply the associated business state change
Commit
A duplicate operation ID returns the already-recorded outcome

Begin database transaction
  Insert operation ID into a table with a unique constraint
  Apply the associated business state change
Commit
A duplicate operation ID returns the already-recorded outcome

Begin database transaction
  Insert operation ID into a table with a unique constraint
  Apply the associated business state change
Commit
A duplicate operation ID returns the already-recorded outcome

This pseudocode assumes both changes share a database transaction; it is not sufficient for an external payment or email. For external effects, use an outbox and a destination-supported idempotency key, or a reconciliation workflow. Acknowledge the event only after the durable outcome is established. Preserve retryable failures, route permanently invalid inputs to an owned failure path, and define how long deduplication records remain valid. Broker duplicate detection can help but does not replace application-level correctness.

58. How do Container Apps revisions, ingress and scale rules work together?

A Container Apps revision is an immutable snapshot of revision-scoped application configuration. In multiple-revision mode, traffic can be split among active revisions for staged rollout; single-revision mode simplifies replacement. Ingress determines how clients reach the app, while scale rules determine replica demand for each revision.

An HTTP API might route a small share to a new revision, compare errors and latency, then expand traffic. A queue worker needs a scale rule tied to its event source; setting the minimum replica count to zero without a suitable trigger can leave work unprocessed. Some settings are application-scoped and can affect all revisions, so a revision rollback is not a complete rollback of every configuration change.

Check readiness, image availability, identity, secret references, workload-profile capacity and downstream limits. Scaling to zero introduces startup considerations. Maintain explicit minimum/maximum replicas and observe the actual revision receiving traffic rather than assuming the newest deployed revision is serving users.

59. How do AKS workload identity and cluster identity differ?

AKS workload identity lets a pod authenticate to Microsoft Entra-protected services using a federated Kubernetes service-account token. The cluster identity supports AKS control-plane operations against Azure resources, and the kubelet identity has node-level responsibilities such as image pulls. Those identities should not be reused as a broad application credential.

This partial Kubernetes YAML illustrates the service-account annotation and required workload label; the cluster OIDC setup, federated credential, matching subject and Azure permissions must already be configured:

YAML example

apiVersion: v1
kind: ServiceAccount
metadata:
  name: orders
  namespace: apps
  annotations:
    azure.workload.identity/client-id: "<managed-identity-client-id>"
---
# Excerpt from the workload's Pod template metadata:
metadata:
  labels:
    azure.workload.identity/use: "true"
apiVersion: v1
kind: ServiceAccount
metadata:
  name: orders
  namespace: apps
  annotations:
    azure.workload.identity/client-id: "<managed-identity-client-id>"
---
# Excerpt from the workload's Pod template metadata:
metadata:
  labels:
    azure.workload.identity/use: "true"
apiVersion: v1
kind: ServiceAccount
metadata:
  name: orders
  namespace: apps
  annotations:
    azure.workload.identity/client-id: "<managed-identity-client-id>"
---
# Excerpt from the workload's Pod template metadata:
metadata:
  labels:
    azure.workload.identity/use: "true"

Set the pod's serviceAccountName to orders and use a supported Azure Identity SDK. Check issuer, subject, audience and token propagation when debugging. Federation removes a stored secret, but it still requires narrowly scoped trust and data access.

60. What are the responsibilities of AKS readiness probes, liveness probes and resource limits?

Readiness determines whether a pod should receive service traffic; liveness determines when a failing container should be restarted. A startup probe protects slow initialization from premature liveness checks. Resource requests guide scheduling, while limits constrain usage: CPU can be throttled and exceeding a memory limit can result in termination.

This partial container YAML assumes an application with distinct health endpoints:

YAML example

resources:
  requests: {cpu: "250m", memory: "256Mi"}
  limits: {cpu: "1", memory: "512Mi"}
readinessProbe:
  httpGet: {path: /ready, port: 8080}
  periodSeconds: 5
livenessProbe:
  httpGet: {path: /live, port: 8080}
  periodSeconds: 10
resources:
  requests: {cpu: "250m", memory: "256Mi"}
  limits: {cpu: "1", memory: "512Mi"}
readinessProbe:
  httpGet: {path: /ready, port: 8080}
  periodSeconds: 5
livenessProbe:
  httpGet: {path: /live, port: 8080}
  periodSeconds: 10
resources:
  requests: {cpu: "250m", memory: "256Mi"}
  limits: {cpu: "1", memory: "512Mi"}
readinessProbe:
  httpGet: {path: /ready, port: 8080}
  periodSeconds: 5
livenessProbe:
  httpGet: {path: /live, port: 8080}
  periodSeconds: 10

These values are illustrative, not a production sizing recommendation. A liveness check should not restart every pod just because a shared database is briefly unavailable. Measure startup and load behavior, set thresholds intentionally, and verify that readiness reflects the ability to serve useful requests. Probes alone do not guarantee capacity or safe disruption during upgrades.

61. How do VM Scale Set autoscale rules and application health interact?

Autoscale adjusts VM instance count in response to configured metrics or schedules. Application health determines whether an individual instance can serve work and can support orchestration features such as repairs or rolling upgrades. More instances are not useful if they are unhealthy or cannot initialize required dependencies.

For a queue worker, scale on sustained backlog or processing delay rather than CPU alone. Set minimum and maximum capacity, cooldowns and scale-in behavior so the service does not oscillate or terminate active work unnecessarily. The application needs a startup process that registers readiness and a graceful shutdown/drain strategy.

Choose the supported health signal for the scale-set orchestration mode and feature. The Application Health extension and load-balancer health probes are not interchangeable in every scenario; avoid assuming both can simultaneously drive the same orchestration feature. Verify that repair policies do not repeatedly replace healthy infrastructure when the real fault is a shared dependency or a broken health endpoint.

62. How do Bicep parameters, modules and dependencies improve deployments?

Bicep parameters separate environment inputs from resource definitions; modules package a reusable deployment unit. Symbolic references express dependencies, allowing Resource Manager to order dependent operations while running unrelated work in parallel. This is safer than a long imperative script whose state is implicit.

This resource-group-scope excerpt defines a minimal storage resource with an explicit API version. It is illustrative and must be reviewed before any deployment or charge:

Bicep example

param storageName string
param location string = resourceGroup().location

resource store 'Microsoft.Storage/storageAccounts@2023-05-01' = {
  name: storageName
  location: location
  kind: 'StorageV2'
  sku: { name: 'Standard_LRS' }
  properties: {
    minimumTlsVersion: 'TLS1_2'
    allowBlobPublicAccess: false
    supportsHttpsTrafficOnly: true
  }
}
output storageId string = store.id
param storageName string
param location string = resourceGroup().location

resource store 'Microsoft.Storage/storageAccounts@2023-05-01' = {
  name: storageName
  location: location
  kind: 'StorageV2'
  sku: { name: 'Standard_LRS' }
  properties: {
    minimumTlsVersion: 'TLS1_2'
    allowBlobPublicAccess: false
    supportsHttpsTrafficOnly: true
  }
}
output storageId string = store.id
param storageName string
param location string = resourceGroup().location

resource store 'Microsoft.Storage/storageAccounts@2023-05-01' = {
  name: storageName
  location: location
  kind: 'StorageV2'
  sku: { name: 'Standard_LRS' }
  properties: {
    minimumTlsVersion: 'TLS1_2'
    allowBlobPublicAccess: false
    supportsHttpsTrafficOnly: true
  }
}
output storageId string = store.id

The caller must supply a valid unique name. This example does not disable public network access or define data roles. Add requirements explicitly, lint and review the template, and avoid secret outputs or unnecessary manual dependsOn entries.

63. What does an ARM or Bicep what-if operation verify, and what does it miss?

What-if predicts resource changes from an ARM or Bicep deployment without applying those resource changes. It helps reviewers identify unexpected creates, updates or deletions and compare an intended template with the current environment. It is a deployment preview, not a proof that the application will work or that every runtime condition has been validated.

For an authorized account and known resource group, this Bash command illustrates the preview operation:

Bash command

az deployment group what-if --resource-group "$RESOURCE_GROUP"   --template-file main.bicep --parameters
az deployment group what-if --resource-group "$RESOURCE_GROUP"   --template-file main.bicep --parameters
az deployment group what-if --resource-group "$RESOURCE_GROUP"   --template-file main.bicep --parameters

What-if still requires the documented Azure permissions and network access. Some expressions or linked resources may not be fully evaluated, and provider defaults can make results noisy. Review unsupported or unresolved output rather than accepting it blindly. Pair the preview with static validation, policy checks, environment-specific tests and post-deployment verification. It does not reserve regional capacity, test data-plane connectivity, or prove that an application's rollback is safe.

64. How should a CI/CD pipeline authenticate to Azure securely?

Prefer workload identity federation, such as OIDC from a supported CI/CD system, rather than storing a long-lived Azure client secret. Configure the trust narrowly for the intended repository, branch or protected environment, then grant the deployment identity only the resource permissions it needs. Authentication and authorization are separate controls.

A GitHub Actions job using Azure Login with OIDC needs permission to request an identity token:

YAML example

permissions:
  id-token: write
  contents

permissions:
  id-token: write
  contents

permissions:
  id-token: write
  contents

This fragment alone neither authenticates nor deploys anything. The job also needs the Azure Login action, tenant/client/subscription identifiers and a matching federated credential configured in Azure. Pin actions appropriately for the team's supply-chain policy and protect production environments with review gates. Prevent untrusted pull-request code from running in a privileged deployment context. Separate build from deployment, avoid printing tokens, and make deployments auditable with a traceable artifact and narrowly scoped identity.

65. How would you design blob lifecycle management without breaking retention requirements?

Translate retention and access requirements into lifecycle rules before optimizing storage tier cost. Select the intended containers or prefixes and distinguish current blobs, previous versions and snapshots. Tiering and deletion are different actions; an age-based rule must not override a required retention or recovery policy.

This illustrative rule moves eligible block blobs in the reports container (the reports/ prefix) to Cool after 30 days since modification. It does not delete data:

JSON example

{"rules":[{"enabled":true,"name":"cool-reports","type":"Lifecycle",
 "definition":{"filters":{"blobTypes":["blockBlob"],"prefixMatch":["reports/"]},
 "actions":{"baseBlob":{"tierToCool":{"daysAfterModificationGreaterThan":30}}}}}]}
{"rules":[{"enabled":true,"name":"cool-reports","type":"Lifecycle",
 "definition":{"filters":{"blobTypes":["blockBlob"],"prefixMatch":["reports/"]},
 "actions":{"baseBlob":{"tierToCool":{"daysAfterModificationGreaterThan":30}}}}}]}
{"rules":[{"enabled":true,"name":"cool-reports","type":"Lifecycle",
 "definition":{"filters":{"blobTypes":["blockBlob"],"prefixMatch":["reports/"]},
 "actions":{"baseBlob":{"tierToCool":{"daysAfterModificationGreaterThan":30}}}}}]}

Confirm account, blob type and tier support and test the rule against representative data before approval. Lifecycle execution is asynchronous, not an exact scheduled job. Include minimum storage-duration charges, retrieval costs and archive rehydration delays in the decision. Immutability or legal holds can prevent deletion, and previous versions can continue consuming capacity unless their lifecycle is intentionally managed.

66. How do Blob soft delete, versioning and immutability solve different problems?

Soft delete offers a recovery window after supported deletions or overwrites. Versioning preserves earlier states when a blob changes. Immutability prevents protected data from being modified or deleted for a configured retention period or legal hold. They address different failure modes and should be selected together where appropriate.

Mechanism

Main purpose

Important boundary

Soft delete

Recover within retention window

Recovery expires and support varies

Versioning

Keep previous blob states

Versions consume storage

Immutability

Prevent prohibited changes

Retention configuration needs careful control

Replication primarily addresses infrastructure failure; it can also replicate unwanted logical changes. A management lock on the storage account does not replace blob-level protection. Verify hierarchical-namespace and account-feature compatibility, recovery permissions and account-deletion risks. Test restoring a representative object and its required metadata. For stronger isolation or broader recovery scenarios, assess backup and protection outside the same mutable application boundary.

67. How do Azure Storage firewalls and authorization combine?

Storage network rules decide whether a request can reach the public endpoint from its source; authorization decides whether the caller can perform the requested data operation. Both must succeed. Allowing a subnet does not make blobs public, and a valid token or SAS does not automatically bypass the account's network restrictions.

For a VM using a service endpoint, verify the subnet endpoint and the account's matching virtual-network rule, then verify the principal's data role. For a private endpoint, check approval, DNS and private routing; public-endpoint firewall rules are not the mechanism that controls that private path. Review public network access independently.

A 403 can therefore mean different things: inspect the service error code and request context rather than immediately widening access. Evaluate trusted-service exceptions and resource-instance rules deliberately. Avoid unrestricted network access as a permanent fix, and remember that account keys and broad SAS tokens can grant more authority than the application's intended operation.

68. How do Azure SQL service tiers and compute models affect architecture choices?

Choose the Azure SQL Database service tier around latency, storage architecture, availability features, scale and workload pattern, not just CPU count. In the vCore model, General Purpose, Business Critical and Hyperscale offer different architectural trade-offs. The DTU model is a separate bundled purchasing model where supported.

Provisioned compute suits sustained demand. Serverless can fit supported intermittent workloads, but scaling, auto-pause availability and resume behavior depend on the tier and configuration. Do not assume every serverless database pauses or that every service tier supports the same limits and features. Elastic pools can share capacity among databases with complementary usage patterns.

Validate transaction log rate, I/O latency, memory, connection behavior and storage growth using representative tests. Include backup retention, replicas and licensing eligibility in the cost model. A low average CPU percentage can hide short bursts or storage bottlenecks, so retain performance evidence before resizing or changing compute models.

69. How do Azure SQL failover groups support disaster recovery?

Azure SQL Database failover groups manage geo-replication and failover for a set of databases between logical servers. Stable read-write and read-only listener names reduce the need to change application connection strings after a geo-failover. Applications still need connection retry logic because existing connections can break and DNS changes take time to be observed.

Geo-replication is asynchronous, so a forced failover can lose transactions not yet replicated. A planned failover and a disaster failover have different conditions; do not promise zero data loss for every event. Define the failover policy, decision owner, acceptable lag and recovery validation before an incident.

Prepare the secondary region's networking, permissions and application dependencies as well as the databases. A database listener does not recreate the rest of the workload. Rehearse failover and failback, verify data consistency and measure actual restoration of business transactions against the required RTO and RPO.

70. How do Cosmos DB partitioning and request units affect performance?

For Azure Cosmos DB for NoSQL, a partition key determines how items are grouped into logical partitions and distributed for scale. Choose a high-cardinality key that spreads storage and request load while matching common access patterns. A key that sends most traffic to one tenant can create a hot partition even when the account has unused total throughput.

JSON example

{"id":"order-1042","tenantId":"tenant-17","status":"pending"}
{"id":"order-1042","tenantId":"tenant-17","status":"pending"}
{"id":"order-1042","tenantId":"tenant-17","status":"pending"}

If /tenantId is the partition key, a point read of this item uses both tenant-17 and order-1042. That can be efficient for tenant-scoped reads, but tenant size and skew must be considered before choosing it. Request units represent the cost of database operations; item size, indexing, query shape and consistency affect consumption.

Use request-charge telemetry, throttling metrics and partition-level observations to distinguish insufficient throughput from a poor model. Autoscale does not eliminate hot-key constraints or make cross-partition queries free. Evaluate hierarchical partition keys where supported and useful, rather than adding throughput to conceal an unsuitable key.

71. How do Cosmos DB consistency levels affect reads and availability?

Cosmos DB offers strong, bounded staleness, session, consistent prefix and eventual consistency, with API-specific behavior to verify. Strong consistency prioritizes a single up-to-date view at the cost of additional coordination and possible latency or availability trade-offs. Eventual consistency relaxes freshness; session consistency offers useful read-your-writes behavior within the relevant client session context.

Choose the weakest guarantee that still preserves the application's business rules. A user's profile update may need read-your-writes, while a replicated analytics view may tolerate delay. A financial invariant cannot be made correct merely by labeling reads strong; transaction scope and the write design still matter.

Understand account defaults, permitted per-request overrides and session-token handling when requests pass through multiple application instances. Also check restrictions involving write regions and APIs. Test the actual failure and replication scenarios rather than treating the five levels as interchangeable performance settings. Stronger read consistency can increase RU consumption and cross-region coordination costs.

72. How do Service Bus locks, retries and dead-letter queues work?

In Peek-Lock mode, Service Bus temporarily locks a received message while the consumer processes it. Completing settles successful processing; abandoning makes it available again; dead-lettering separates a message that cannot be processed normally. A lock can expire or be lost, so successful business processing can still be followed by redelivery.

Plain-text example

Receive under lock -> apply idempotent business operation -> Complete
Transient failure -> bounded retry or Abandon
Permanent invalid input -> Dead-letter with useful reason
Receive under lock -> apply idempotent business operation -> Complete
Transient failure -> bounded retry or Abandon
Permanent invalid input -> Dead-letter with useful reason
Receive under lock -> apply idempotent business operation -> Complete
Transient failure -> bounded retry or Abandon
Permanent invalid input -> Dead-letter with useful reason

Renew locks for supported long processing, but do not rely on renewal as a guarantee against duplicates. Receive-and-Delete instead removes the message on transfer and can lose work if the consumer fails. Distinguish SDK transport retries from application retries and broker delivery count. Excessive retries can amplify an outage.

Monitor dead-letter growth, preserve diagnostic context without leaking sensitive payloads, and give an owner a safe replay procedure. Completing a message is not atomically coupled to an arbitrary external API call, so use idempotency or a suitable transactional pattern.

73. When should you use Event Hubs consumer groups and checkpoints?

Use separate Event Hubs consumer groups when independent applications need their own view and progress through the same event stream. Within a processing application, partitions provide the unit of ordered reading and parallelism. A checkpoint records processed progress for a partition and consumer group so processing can resume after a restart.

Checkpoint only after the intended durable work is complete. Checkpointing first risks skipping unfinished work after a crash; checkpointing later may replay already processed events, which requires idempotent handling. The event processor and checkpoint store coordinate partition ownership among participating instances, but they do not make an arbitrary downstream side effect exactly once.

Partition count and key distribution constrain useful parallelism and ordering. Adding consumers beyond the available partitions does not necessarily increase throughput. Keep retention long enough for expected outages and recovery, monitor consumer lag, and test replay. A checkpoint does not extend event retention, and ordering across all partitions is not guaranteed.

74. How would you configure useful Azure Monitor diagnostic settings?

Select diagnostic log categories that answer specific operational or security questions, then send them to appropriate destinations such as Log Analytics, Event Hubs or Storage. Platform metrics and the Activity Log have automatic collection behavior, but resource logs generally need diagnostic settings to be collected. Guest OS and application telemetry may require other agents or instrumentation.

For a database, collect the supported categories needed to investigate performance and access; for a gateway, collect traffic and health evidence. Check destination region and network requirements, permissions, table mode, ingestion delay and costs. Diagnostic settings are not a universal switch for all telemetry from a resource.

After configuration, generate a safe known event and verify that it arrives with the expected fields. Define retention and access controls, and avoid indiscriminate payload logging. Use policy to standardize supported settings across the estate, while tracking exceptions and new resource types. An enabled setting without observed data is not sufficient monitoring evidence.

75. How do you write a KQL query to investigate failed application requests?

Start with a bounded time range and the actual table schema, then group failures by operation, response code and application role. In a Log Analytics workspace receiving workspace-based Application Insights telemetry, AppRequests uses fields such as TimeGenerated, Success, ResultCode and ItemCount.

Code example (language tag: kusto)

AppRequests
| where TimeGenerated >= ago(1h)
| where Success == false
| summarize EstimatedFailures=sum(ItemCount),
            P95DurationMs=percentile(DurationMs, 95)
    by AppRoleName, Name, ResultCode
| order by EstimatedFailures desc
AppRequests
| where TimeGenerated >= ago(1h)
| where Success == false
| summarize EstimatedFailures=sum(ItemCount),
            P95DurationMs=percentile(DurationMs, 95)
    by AppRoleName, Name, ResultCode
| order by EstimatedFailures desc
AppRequests
| where TimeGenerated >= ago(1h)
| where Success == false
| summarize EstimatedFailures=sum(ItemCount),
            P95DurationMs=percentile(DurationMs, 95)
    by AppRoleName, Name, ResultCode
| order by EstimatedFailures desc

The count uses ItemCount to account for sampling weights; the duration percentile above is over retained rows, not a sampling-corrected full-population percentile. Compare the failures with total traffic and correlate OperationId with dependencies and exceptions. The application-centric requests table uses different field names, so do not paste this unchanged into every query context. Confirm instrumentation and sampling before concluding that missing rows mean no failures, and avoid exposing personal data in shared query results.

76. How should alert rules, action groups and runbooks work together?

An alert rule defines the condition that needs attention, an action group routes notifications or approved automation, and a runbook provides the response procedure. The useful unit is an actionable symptom with an owner, severity and next step, not simply a threshold on every available metric.

For an API, sustained elevated failure rate combined with enough request volume is usually more meaningful than a single error. Choose evaluation windows and thresholds that fit the service's response objectives. Action groups can be reused, but do not assume actions execute in a particular order or that a notification proves an operator responded.

Test the complete path, including escalation and recovery notifications. Automated remediation needs least-privilege identity, bounded retries, idempotency and safeguards against making an outage worse. Include diagnostic links and safe instructions in the runbook. Use maintenance handling deliberately so expected changes do not produce noise while real customer impact remains visible.

77. How do Azure Backup policies and restore tests establish recoverability?

A backup policy defines when recovery points are taken and how long they are retained; a successful backup job only shows that a recovery point was created. Recoverability requires a restore test that validates usable data, application consistency, permissions and the time needed to return the service to operation.

Choose a policy supported by the workload and required recovery objectives. For VMs, assess agent and extension health, disk support, consistency mode, vault protection and region/redundancy choices. Database or application-specific recovery may need additional coordination beyond a VM image restore.

Restore into an isolated, authorized test environment so recovered applications cannot send real emails, process live queues or conflict with production identities. Verify representative records and dependencies, measure elapsed recovery time and record the result. Monitor missed backups and protect backup administration separately from routine application access. Retention, immutability and soft-delete controls reduce risk, but none eliminates the need to rehearse recovery.

78. How would you manage VM patching and configuration drift?

Treat patching as a controlled operational change and drift as deviation from an approved configuration baseline. Azure Update Manager can assess and schedule supported Windows and Linux updates across Azure VMs and Arc-enabled machines. It does not replace application compatibility testing or define every desired configuration setting.

Use deployment rings: test, a representative canary, then the broader estate. Define maintenance windows, reboot behavior, dependency order, health checks and rollback or rebuild options. Keep evidence of assessment, attempted installation and resulting compliance; a scheduled window does not prove that every machine was patched successfully.

For drift, use maintained images, infrastructure as code and a suitable configuration or machine-configuration mechanism. Distinguish an approved emergency change from unauthorized drift and reconcile the baseline afterward. Verify OS/image support, update-source reachability and extension health. Do not rely on retired automation components or assume that every patch can be applied without restart; supported hotpatch scenarios have specific prerequisites.

79. How do Azure reservations, savings plans and Spot VMs differ?

Reservations and savings plans are commitment-based pricing mechanisms; Spot VMs use spare capacity that can be reclaimed. For compute, a reservation fits stable eligible usage matching its resource characteristics and region, while a savings plan commits to hourly spend across eligible usage within its scope. Neither should be confused with a guarantee that a VM can be allocated when needed.

Spot fits interruptible work with checkpoints and retry capacity. It is unsuitable as the only capacity for an application that cannot tolerate eviction. Price, availability and eviction behavior require planning, including the cost of retained disks and recovery work.

Choose commitments only after right-sizing and examining durable baseline demand. Unused hourly benefits can be wasted, and cancellation or exchange terms differ between offers. Keep burst capacity separate from the committed baseline and model eligible versus excluded charges. The headline discount is less important than realized utilization, flexibility and the workload's required availability.

80. How would you estimate a workload's Azure cost before deployment?

Build a resource and usage model before opening the pricing calculator. Specify region, tier, instance count, runtime hours, storage growth, operations, network transfer, telemetry, backup and standby capacity. Use the organization's actual agreement and currency when available, and separate one-time migration costs from ongoing operation.

Plain-text example

Illustrative monthly model, not an Azure price quote:
Compute = instance count x hours x effective hourly rate
Storage = average billable capacity x capacity rate
Add requests, data transfer, logs, backup and support as

Illustrative monthly model, not an Azure price quote:
Compute = instance count x hours x effective hourly rate
Storage = average billable capacity x capacity rate
Add requests, data transfer, logs, backup and support as

Illustrative monthly model, not an Azure price quote:
Compute = instance count x hours x effective hourly rate
Storage = average billable capacity x capacity rate
Add requests, data transfer, logs, backup and support as

Estimate normal, peak and failure-mode scenarios. A secondary region or a traffic burst can materially change the bill, even if steady-state compute looks inexpensive. Record assumptions and sensitivity to the largest cost drivers, then validate them through a bounded pilot or representative measurements. Budgets and alerts provide visibility rather than a universal automatic spending cap. Revisit the estimate after deployment as real utilization and architecture choices become clearer.

Azure Interview Questions and Answers for Experienced

The experienced answers examine failure modes and competing requirements across services. They distinguish a documented capability from a configured and validated workload, and connect design choices to ownership, evidence, and recovery procedures.

81. How would you design an Azure landing zone for several product teams?

A landing zone should give product teams a repeatable, governed starting point rather than a shared subscription with informal rules. Separate the platform responsibilities, such as connectivity, identity integration, security monitoring and subscription provisioning, from application-team responsibilities. Use management groups to apply a small number of stable policy and access boundaries, then provide workload subscriptions with approved networking, logging, budgets and deployment identities.

For three product teams, a reasonable starting design is separate production and nonproduction application subscriptions, plus dedicated platform subscriptions where justified. It is a starting hypothesis, not a mandatory subscription count. Define who owns incidents, policy exceptions, address allocation and costs before automating onboarding. Version the landing-zone modules and test changes in a representative canary subscription. Success means a team can deploy an approved workload without waiting for manual platform tickets, while the platform team can demonstrate which controls are actually enforced.

82. How would you choose a subscription and tenant separation strategy?

Subscriptions provide useful boundaries for resource governance, billing attribution, quotas and administrative scope. A Microsoft Entra tenant is an identity-directory boundary. I normally keep subscriptions in the organization's established tenant unless a concrete requirement justifies separate directories, because cross-tenant identity, monitoring and operational processes introduce additional work.

Separate production from experimentation where the risk or ownership warrants it. A regulated business unit or acquired company might require a different tenant, but a project name alone is not a strong reason. Document the identity administrators, resource administrators, network connectivity and data-sharing paths across each proposed boundary. Subscription separation does not prevent communication or data access if permissions and network paths still allow them.

For a rapidly growing product, reserve a way to add subscriptions without rebuilding its identity model. Account for subscription-scoped quotas, commercial arrangements and supported resource-move constraints. The decision should make ownership and blast radius clearer, not merely produce a visually tidy hierarchy.

83. How would you establish least privilege without blocking engineering teams?

Least privilege works best when the normal delivery path already has the right permissions. Define job functions and deployment tasks, assign suitable roles to groups or dedicated workload identities at the narrowest practical scope, and separate resource deployment from permission administration. Prefer a reviewed built-in role when it fits; a custom role needs a clear owner and maintenance process.

For example, application developers might read production diagnostics while a constrained pipeline deploys approved application changes. Elevation for an unusual repair is time-bound and logged instead of becoming a permanent Owner assignment. Verify the data plane separately: being able to manage a storage account should not automatically mean that a person should read customer blobs.

A useful access test includes both the expected successful operation and a prohibited operation in an isolated environment. Review inactive assignments and direct user grants periodically. Measure failed deployments and support requests as well as access risk, so teams do not solve friction by sharing privileged credentials.

84. How would you design privileged access and emergency access for Azure operations?

Routine privileged work and emergency recovery need different paths. Use separate administrative identities, strong phishing-resistant authentication, and eligible, time-bound elevation through Microsoft Entra Privileged Identity Management where supported and licensed. Require the appropriate approval and record why the elevation occurred. Azure resource roles and Microsoft Entra directory roles must both be considered; one does not automatically replace the other.

Maintain at least two carefully controlled emergency access accounts following Microsoft's current guidance. Their authentication method and dependencies should be sufficiently independent of the normal administrator path to remain useful during an outage. Emergency access is not permission to operate anonymously or to disable strong authentication. Alert on every use, test the recovery procedure periodically, and keep an approved, securely held access process.

A rehearsal should prove that the designated responders can recover the intended administrative capability, then review all actions afterward. Account creation alone does not establish recoverability if its credential, device or documentation is unavailable during the same incident.

85. How would you assess an Azure architecture using the Well-Architected Framework?

I assess the critical business flows against the five Well-Architected pillars: Reliability, Security, Cost Optimization, Operational Excellence and Performance Efficiency. First establish measurable requirements and constraints, then inspect the deployed design and operational evidence. A diagram showing redundant resources is weaker evidence than a recovery drill demonstrating that checkout remains usable when a dependency fails.

For an order service, the review might examine order durability, customer-data isolation, cost per completed order, deployment rollback and peak-load latency. Record each material risk with its affected flow, owner, mitigation and validation method. Prioritize risks by business impact rather than averaging pillar scores into a misleading overall grade.

Trade-offs should remain visible. A second region can improve recovery options but adds replication, testing and operational costs. A smaller platform may be preferable when it meets the actual targets. Finish with a short improvement backlog and decision records, then reassess after major changes instead of treating the review as a one-time certification.

86. How would you derive a multiregion design from RTO and RPO requirements?

Translate recovery objectives into a complete recovery path. RTO constrains the time from the relevant disruption to acceptable service restoration; RPO constrains acceptable data loss. Include detection, decision-making, data recovery or promotion, application startup, traffic movement and business validation. A database replication setting covers only part of that path.

For an illustrative 30-minute RTO, a planning budget might be:

Plain-text example

Detection and decision       5 minutes
Data recovery or promotion 10 minutes
Application and routing     8 minutes
Business validation         7 minutes
Total                      30 minutes
Detection and decision       5 minutes
Data recovery or promotion 10 minutes
Application and routing     8 minutes
Business validation         7 minutes
Total                      30 minutes
Detection and decision       5 minutes
Data recovery or promotion 10 minutes
Application and routing     8 minutes
Business validation         7 minutes
Total                      30 minutes

These are proposed budgets, not measured Azure timings. A five-minute RPO requires evidence that the chosen replication or backup approach meets that loss tolerance during relevant failures. Asynchronous replication can lag, and failover decisions may trade availability against data loss. Confirm regional service availability, capacity, identities, configuration and dependencies before selecting the secondary region. Then test the end-to-end process, including failback, and revise the design if measured results miss either objective.

87. How would you decide between active-active and active-passive deployment?

Choose active-active when serving from multiple locations provides a justified latency, availability or capacity benefit and the application can handle its data-consistency model. Choose active-passive when a single active location simplifies writes and operations while a prepared recovery environment can meet the agreed recovery targets. Neither topology determines data correctness by itself.

Decision

Active-active

Active-passive

Normal traffic

Multiple serving locations

Primarily one serving location

Data challenge

Coordination and conflict behavior

Replication lag and promotion

Operational concern

Continuous cross-region correctness

Standby readiness and cutover

An active-passive environment can be cold, warm or hot, with different cost and startup behavior. An active-active web tier may still depend on a single-writer database. For a booking system, explicitly decide which region owns a reservation and what happens during a network partition. Validate remaining-region capacity and failover traffic behavior. Do not select the more complex topology solely because its name sounds more resilient.

88. How would you design for an availability-zone failure without assuming every dependency is zonal?

Start with a dependency inventory and classify each resource as zonal, zone-redundant or regional under its exact service, tier and region. Spread application instances across supported zones and ensure the remaining instances can carry the required load. Check storage, database, ingress, secrets, DNS and messaging rather than stopping at compute.

A zone-redundant managed service and three individually zonal resources can have very different failover behavior. Also inspect application-level dependencies: a singleton scheduler, a zone-bound disk, or all replicas accidentally scheduled together can defeat the intended design. Map zone identifiers carefully when coordinating zonal resources across subscriptions; do not assume matching zone numbers imply matching physical zones without verification.

For a three-zone design that must survive one zone, test performance with the affected capacity unavailable and account for degraded dependencies. Document which failures the service manages and which require application retries or operator action. A zone-resilient design does not automatically protect against a whole-region outage or logical data corruption.

89. How would you identify hidden single points of failure in an Azure workload?

Trace one important user action through every dependency and ask what happens if each component is unavailable, slow, misconfigured or returns incorrect results. Include identity, DNS, certificates, configuration, deployment artifacts, network routes and operator access. These supporting services often disappear from simplified architecture diagrams even though the application cannot function without them.

A small failure-mode record makes the analysis actionable:

Dependency

Failure effect

Detection and mitigation

Order database

New orders fail

Synthetic order check; tested recovery path

Secret retrieval

New instances cannot start

Startup telemetry; bounded cache and rotation design

Deployment pipeline

Recovery release blocked

Independent approved recovery procedure

The entries are illustrative and require workload-specific validation. Examine correlated failures too: two regions using one external identity integration or one shared deployment mistake are not fully independent. Assign owners to material gaps and exercise selected scenarios safely. Avoid claiming a precise composite availability from service SLAs unless the model's independence and operational assumptions are defensible.

90. How would you test disaster recovery safely and prove that it works?

A useful disaster-recovery test proves that a business flow and its data can be recovered, not merely that a restore job reports success. Define the failure scenario, expected RTO and RPO, scope, safety limits, rollback path and observers before starting. Begin with tabletop exercises and isolated recovery environments; production failure injection requires an explicitly approved plan.

Use representative data with appropriate privacy controls. Record disruption time, detection time, recovery decision, restored service time and the most recent verified business transaction. Compare records and application invariants, not only VM health or database availability. Exercise identity, networking, certificates, secrets and dependencies in the recovery location.

The evidence should include measured results, missing steps, responsible owners and a retest date. Test failback and reconciliation after the original environment returns, especially if either side accepted writes. A successful drill establishes confidence only for the tested scenario and configuration. Repeat after substantial architecture, operational or personnel changes rather than assuming last year's result still applies.

91. How would you design a hub-and-spoke network across subscriptions?

Use a hub for shared connectivity and inspection services, and spokes for workload isolation. Allocate nonoverlapping address spaces with growth capacity, define route ownership, and arrange access for peering and shared-resource management across subscriptions. Peering provides connectivity between its participants; ordinary VNet peering is not automatically transitive between spokes.

An illustrative topology is:

Plain-text example

On-premises
    |
VPN or ExpressRoute gateway
    |
Hub: shared routing, firewall, DNS
    |                       |
Spoke A: product A       Spoke B: product B
On-premises
    |
VPN or ExpressRoute gateway
    |
Hub: shared routing, firewall, DNS
    |                       |
Spoke A: product A       Spoke B: product B
On-premises
    |
VPN or ExpressRoute gateway
    |
Hub: shared routing, firewall, DNS
    |                       |
Spoke A: product A       Spoke B: product B

The diagram expresses intent, not a complete routing configuration. Decide whether spoke-to-spoke traffic is permitted and whether it must traverse inspection. Validate effective routes in both directions, gateway-transit settings, DNS resolution and network-security rules. Avoid asymmetric routing through stateful devices. Isolate production and nonproduction according to risk, and do not make the central hub an untested recovery dependency. Monitor gateway and firewall throughput, SNAT use and costs. Keep application authorization in place even when networks can communicate.

92. When would Azure Virtual WAN be preferable to a self-managed hub design?

Azure Virtual WAN is attractive when many branches, users and Azure networks need a managed transit design across regions. Its managed virtual hubs combine connectivity and routing capabilities, reducing some of the work of building and maintaining a large custom hub estate. Standard Virtual WAN supports features such as inter-hub and VNet-to-VNet transit; capabilities differ from Basic.

A self-managed hub remains worth considering when requirements depend on specialized appliances, bespoke routing behavior, or a small topology where the managed service's cost and constraints are not justified. Compare the actual supported routing and security design, not simply the number of sites.

For a company adding dozens of branch connections, evaluate partner-device integration, routing intent, segmentation, DNS integration, failure recovery, throughput and operational visibility. Model gateway, hub, processing and connectivity charges. Test representative branch-to-branch, branch-to-cloud and cloud-to-cloud paths before migration. Virtual WAN does not remove the need to plan address spaces, access control or application-level resilience.

93. How would you design private DNS for hybrid and multiregion workloads?

Private DNS should follow a documented resolution flow for Azure clients, on-premises clients and each recovery region. Centralize ownership of private zones where appropriate, link the required VNets, and use Azure DNS Private Resolver or supported DNS forwarders for hybrid resolution. An inbound resolver endpoint gives on-premises DNS a forwarding target; outbound endpoints and rulesets support forwarding Azure queries to other DNS servers.

For a storage private endpoint, clients should use the service's normal hostname and resolve it through the appropriate private-link DNS chain to the intended private address. Creating the endpoint alone does not make every client resolve it correctly. Avoid competing private zones, forwarding loops and records that direct clients to an unreachable region.

Test from every client location and include negative cases. A multiregion design needs an explicit plan for records, network reachability and resolver availability during failover. DNS Private Resolver supplies recursive resolution and forwarding; do not treat its inbound endpoint as an authoritative name server for NS delegation.

94. How would you secure outbound traffic without breaking Azure service dependencies?

Build outbound controls from a dependency inventory rather than blocking all internet traffic and adding exceptions reactively. Identify application destinations, identity endpoints, image registries, package sources, monitoring and platform-management requirements. Then select the supported egress model for each hosting service, with explicit routing, DNS and firewall policy.

For an AKS workload using Azure Firewall, Microsoft's required outbound destinations and supported FQDN tags are a starting point, not a complete application allowlist. Include the application's own APIs and registries. Confirm which traffic reaches the firewall and which service-managed paths behave differently. A NAT gateway supplies outbound address translation; it is not an application-layer allowlist.

Validate provisioning, scaling, image pulls, certificate renewal, telemetry and recovery under the proposed restrictions. Monitor denied connections and SNAT exhaustion without broadly reopening access. TLS inspection needs compatibility and trust-chain review because some dependencies will not tolerate interception. Version the rules and recheck them when services, regions or deployment models change.

95. How would you design internet ingress with layered protection and origin isolation?

Separate traffic admission, web-attack filtering, application authentication and origin protection. For a global HTTP application, Azure Front Door Standard or Premium can provide an edge entry point; configure the suitable WAF policy and TLS behavior, then ensure clients cannot bypass that entry point by contacting the origin directly. Region-local ingress may have separate requirements.

With a supported Front Door Premium origin, Private Link can remove the need for a public origin path. For a public origin, combine network restrictions with validation of the expected Front Door identifier, such as the documented X-Azure-FDID header. Checking a header alone on an otherwise open public endpoint is insufficient because a direct client can forge it.

Test legitimate requests, health probes, blocked paths and direct-origin attempts. Tune WAF rules with application owners to avoid breaking valid traffic. Keep authorization in the application and rate-limit expensive operations appropriately. These controls reduce exposure; they do not prove immunity to abuse, compromised identities or every denial-of-service scenario.

96. How would you choose among App Service, Container Apps and AKS for a new product?

Choose the least operationally demanding platform that meets the workload's requirements. App Service is a strong candidate for conventional web applications and APIs that fit its managed hosting model. Container Apps fits containerized services or jobs that benefit from managed revisions and event-driven scaling without requiring direct Kubernetes administration. AKS fits workloads needing Kubernetes APIs, ecosystem integrations or greater orchestration control, with a corresponding operational burden.

Requirement

First option to evaluate

Standard web app with simple deployment

App Service

Independently scaled containerized API or job

Container Apps

Kubernetes-specific operators or platform control

AKS

This is an evaluation starting point, not a universal ranking. Compare networking, runtime compatibility, persistent state, scaling behavior, isolation, observability, regional availability and recovery. Prototype the hardest requirement before committing. Include staffing, upgrade ownership and incident response in cost estimates. Packaging software in a container does not by itself justify adopting Kubernetes or prove that a managed alternative is insufficient.

97. How would you operate a multi-tenant application securely on Azure?

Treat tenant isolation as an end-to-end property of identity, authorization, data access, caching, messaging and operations. Authenticate with a suitable identity platform, establish the caller's authorized tenant context, and enforce that context at every resource access. A tenant identifier supplied by the client is not sufficient evidence of authorization.

Choose a shared, dedicated or mixed deployment model based on security, performance and commercial requirements. A large tenant might need a dedicated deployment stamp while smaller tenants share capacity. Include tenant identity in cache keys, background jobs and audit records, and test cross-tenant access attempts. Do not allow a support feature to silently bypass isolation.

Operationally, define per-tenant quotas, rate limits, restore options, deletion workflows and cost attribution. Shared infrastructure needs protection against noisy neighbors; dedicated infrastructure still needs correct application authorization. For an export job, verify the initiating user's tenant rights both when accepting the request and when serving the completed file. Isolation tests should be part of release validation, not only an annual review.

98. How would you design AKS upgrades and node maintenance to minimize disruption?

Plan an AKS upgrade as an application change, not only a cluster operation. Check supported upgrade paths, removed APIs, add-on compatibility, node images, admission policies and workloads in a representative environment. Use supported maintenance and upgrade controls for the selected AKS model, and confirm quota and subnet capacity for surge nodes.

Replicas, topology distribution, readiness probes and graceful termination must allow nodes to drain safely. A PodDisruptionBudget limits supported voluntary evictions; it does not create replicas or protect against every involuntary failure. This illustrative manifest assumes a Deployment with three healthy replicas and the matching label:

YAML example

apiVersion: policy/v1
kind: PodDisruptionBudget
metadata:
  name: orders-api
spec:
  minAvailable: 2
  selector:
    matchLabels:
      app

apiVersion: policy/v1
kind: PodDisruptionBudget
metadata:
  name: orders-api
spec:
  minAvailable: 2
  selector:
    matchLabels:
      app

apiVersion: policy/v1
kind: PodDisruptionBudget
metadata:
  name: orders-api
spec:
  minAvailable: 2
  selector:
    matchLabels:
      app

Review whether remaining replicas can carry traffic and whether persistent volumes impose zone constraints. Rehearse a drain and measure errors and latency. Upgrade progressively, monitor readiness and business flows, and retain a supported recovery strategy. Do not promise zero downtime or assume a blocked drain should simply be forced.

99. How would you handle an unreliable downstream dependency in a serverless workload?

Bound the amount of time and capacity an unreliable dependency can consume. Use explicit timeouts, bounded retries with backoff and jitter for transient failures, and a circuit breaker where repeated calls would worsen an outage. Retry only when the operation is safe to repeat or protected by an idempotency design. A payment timeout, for example, does not prove the payment failed.

For asynchronous work, queue requests durably, limit concurrency and monitor message age. Move poison work to an inspectable failure path after an appropriate policy instead of retrying forever. Choose a meaningful fallback only when it preserves business correctness; returning invented inventory is worse than reporting temporary unavailability.

Serverless scale-out can amplify a downstream outage by creating more simultaneous callers. Set concurrency and scaling limits in relation to the dependency's capacity and allow recovery probes rather than a synchronized flood. Correlate attempts under one business operation and record the final outcome. Test slow responses, partial failures and recovery, not only explicit error codes.

100. How would you design a high-volume asynchronous order-processing system?

Separate durable order acceptance from slower fulfillment. Validate and authorize the request, record the accepted order with a stable identifier, and publish work through a durable messaging design. Azure Service Bus is a candidate when brokered enterprise messaging features fit the requirements. Scale competing consumers according to queue age, processing time and downstream capacity, rather than queue length alone.

Plain-text example

Client -> Order API -> Durable order record + outbox
                              |
                        Outbox publisher
                              |
                        Service Bus queue
                              |
                     Idempotent worker pool
                              |
                    Fulfillment and status
Client -> Order API -> Durable order record + outbox
                              |
                        Outbox publisher
                              |
                        Service Bus queue
                              |
                     Idempotent worker pool
                              |
                    Fulfillment and status
Client -> Order API -> Durable order record + outbox
                              |
                        Outbox publisher
                              |
                        Service Bus queue
                              |
                     Idempotent worker pool
                              |
                    Fulfillment and status

This conceptual flow assumes a transactional outbox or equivalent mechanism prevents a committed order from losing its work notification. It is not executable infrastructure. Consumers must tolerate redelivery and acknowledge work only at the correct durable boundary. If ordering matters, define its scope instead of serializing every order globally. Track acceptance latency, oldest-message age, completion rate, dead letters and reconciliation gaps. Load-test peak arrivals and degraded downstream services, and provide a status endpoint so acceptance is not mistaken for completed fulfillment.

101. How would you make a cross-service workflow consistent without a distributed transaction?

Use a sequence of local transactions with explicit business states, reliable event publication and compensating actions. A saga coordinates progress across services without pretending that a database transaction spans every participant. Each step must be idempotent, and the workflow needs durable state so that a process restart does not lose its place.

Plain-text example

Reserve stock -> Authorize payment -> Confirm order
      |                |
      |                +-- failure -> Release stock
      +-- failure -> Reject order
Reserve stock -> Authorize payment -> Confirm order
      |                |
      |                +-- failure -> Release stock
      +-- failure -> Reject order
Reserve stock -> Authorize payment -> Confirm order
      |                |
      |                +-- failure -> Release stock
      +-- failure -> Reject order

This is a simplified business flow, not a complete payment implementation. Compensation is a new business action, not a guaranteed reversal of history. A captured payment may require a refund, and a shipment may no longer be cancellable. Define timeouts, retries, reconciliation and manual review for ambiguous outcomes. Use an outbox where a local state change and an event must be recorded atomically, then tolerate duplicate publication. Avoid claiming exactly-once end-to-end effects merely because a broker offers duplicate detection. Verify the final business invariants under failures between every pair of steps.

102. How would you design a Cosmos DB partition strategy for uneven tenant workloads?

Choose the partition strategy from tenant size, request distribution and query patterns, not simply from the presence of a tenant ID. A single tenant ID can be convenient for tenant-scoped queries but create a hot or oversized logical partition when one customer dominates. High cardinality alone also fails if common queries must fan out across all partitions.

For a NoSQL order workload, evaluate a synthetic or supported hierarchical key that includes tenant context and a meaningful subdivision, such as order or time bucket. Measure the trade-off between write distribution and tenant-wide queries. Very large tenants may justify separate containers or deployment stamps, but that changes provisioning, cost and operations.

Test representative skew, including the largest tenant and bursts to one key. Examine normalized RU consumption, throttling, storage growth and query costs at the relevant partition level. Increasing total throughput does not automatically fix a hot key. Partition-key changes are not an in-place schema tweak; plan data migration and application routing if the original choice no longer fits.

103. How would you decide whether to use a relational database or Cosmos DB?

Start with the transactions and access patterns that must remain simple and correct. A relational database is often the stronger fit for rich joins, relational constraints and transactions across related entities. Cosmos DB can fit document-oriented access patterns, predictable partition-local operations and geographically distributed workloads when its API, consistency and partitioning model match the application.

A product catalog read by document ID and partition key has different needs from a ledger with strict cross-entity invariants. Do not label SQL as unscalable or assume NoSQL removes schema design. Compare query behavior, indexing, transaction boundaries, latency, consistency, data growth, operational skills and cost under a representative workload.

A mixed design can be justified, but every additional store introduces synchronization and recovery responsibilities. Define a source of truth and acceptable projection lag. Build a small benchmark around the hardest queries and updates, including failures and throttling. Select the service and tier from measured requirements rather than from a generic preference for relational or document databases.

104. How would you protect Azure data from accidental deletion and malicious changes?

Use layered recovery and prevention controls because no single feature covers accidental deletion, malicious deletion and logical corruption. Restrict who can modify production data, backup policies and recovery infrastructure. Enable the appropriate versioning, soft-delete, backup and immutable-retention capabilities for each supported workload, and verify their actual scope.

For Azure Backup, an immutable vault can block destructive operations affecting protected recovery points. Locking immutability is irreversible, so retention, costs and operational consequences need review before that decision. Check the current workload and vault support matrix; do not assume every operational backup inherits vault immutability. Separate backup administration from application administration where practical.

Backups must remain usable if the production identity or subscription is compromised. Protect encryption keys and recovery access, monitor deletion and policy-change events, and rehearse restore into an isolated environment. Replication can copy bad changes, while soft delete has a retention window. Demonstrate that a known-good point exists and that the team can restore business-consistent data within its target.

105. How would you plan an Azure SQL migration with a bounded cutover window?

Begin with the exact source and target: Azure SQL Database, Azure SQL Managed Instance and SQL Server on an Azure VM have different compatibility and migration paths. Assess features, dependencies, database size, authentication, jobs and performance before selecting a supported migration method. Online migration reduces some downtime but does not eliminate the need for a controlled cutover.

Rehearse with representative data and measure initial transfer, ongoing change replication and application validation. Define a cutover gate: acceptable replication lag, completed compatibility fixes, tested connectivity, available operators and a verified recovery option. During the approved window, quiesce or otherwise control writes, complete the final synchronization, switch clients and validate business transactions.

The rollback plan must say what happens after the target accepts new writes; switching a connection string back may lose or diverge data. Set an explicit abort point before irreversible steps. Compare row counts, checksums where appropriate, key business totals and performance after cutover. Tool success is evidence of migration progress, not proof that every application dependency works.

106. How would you design infrastructure-as-code delivery across environments?

Keep infrastructure definitions versioned and promote reviewed artifacts through environments. Separate reusable modules from environment parameters, pin tested module and API versions, and give each deployment identity only the scope it needs. Prefer federated or managed authentication over a long-lived secret where the delivery platform supports it.

A practical delivery sequence is:

Plain-text example

Pull request
  -> lint and validate
  -> policy and security checks
  -> deployment preview
  -> nonproduction deployment and tests
  -> approval for production
  -> progressive rollout and health verification
Pull request
  -> lint and validate
  -> policy and security checks
  -> deployment preview
  -> nonproduction deployment and tests
  -> approval for production
  -> progressive rollout and health verification
Pull request
  -> lint and validate
  -> policy and security checks
  -> deployment preview
  -> nonproduction deployment and tests
  -> approval for production
  -> progressive rollout and health verification

This is a workflow outline, not an executable pipeline. Preview output is useful but cannot prove runtime connectivity, available capacity or application correctness. Review destructive changes and distinguish infrastructure rollback from data recovery. Use the same module versions across environments while allowing explicit differences in scale and approved regional features. Detect drift and reconcile emergency changes back into source control. Secrets must not appear in parameters committed to the repository, deployment outputs or logs. Record which artifact and parameters created each production state.

107. How would you control Azure Policy rollout and handle legitimate exceptions?

Roll out policy as a production change with measurable gates. Test the definition and parameters on representative resources, begin with audit or a nonenforcing stage where supported, inspect compliance results, and progressively expand scope. Before enabling deny behavior, verify that ordinary deployments and recovery operations still work. Modify and deployIfNotExists effects need particular care because remediation can change existing resources and requires appropriate identities and permissions.

Legitimate exceptions should be explicit, narrow and owned. Use a policy exemption where appropriate, record the business reason and compensating controls, and set an expiry when the exception is temporary. An exclusion hidden in a broad assignment is harder to govern than a reviewed exception with a lifecycle.

For example, a legacy application may temporarily need an unsupported configuration while its replacement is built. The exception should identify the resource, risk owner, migration milestone and review date. Monitor application health and enforcement results during rollout, retain a tested reversal procedure, and prevent an emergency exception from becoming an undocumented permanent baseline.

108. How would you manage secrets, certificates and rotation across many services?

First remove secrets where managed or federated identities provide a suitable authentication path. For remaining credentials, assign an owner, purpose, consumers, expiry and rotation process. Store them in the appropriate Key Vault resource with least-privilege access, logging and recovery protections; storage alone does not implement rotation.

Key, secret and certificate automation have different behavior. Key rotation can create a new key version under a policy. Secret rotation normally needs integration that updates the actual target system as well as the vault. Certificate renewal depends on the issuer and integration, and applications still need to load the replacement certificate.

Design an overlap period when the target supports two valid credentials, verify consumer refresh behavior, then retire the old credential. A version-pinned consumer will not automatically adopt a newly created secret version. Test failure between each rotation step and preserve a safe recovery path. Monitor impending expiry and failed rotations centrally, but avoid putting secret values in logs, alerts or deployment outputs.

109. How would you investigate an application incident when Azure reports no platform outage?

Treat Azure platform health as one signal, not a verdict on application health. Establish the affected user flows, onset, regions, tenants and error pattern, then correlate application requests, dependencies, logs, metrics and recent deployments. A certificate expiry, policy change, DNS error, exhausted connection pool or database hot partition can break an application without a broad platform incident.

Use a correlation identifier to follow an affected request and compare it with successful requests. Distinguish client failures, ingress rejection, application exceptions and downstream timeouts. Check the resource-specific view and subscription-relevant Service Health alongside the public status page. Confirm that missing telemetry is not itself a collection or sampling problem.

Prioritize safe mitigation based on evidence, such as reversing a known bad release through the approved procedure or reducing load on an overloaded dependency. Preserve incident timelines and relevant diagnostics. Record hypotheses with observations that would disprove them, and avoid changing several unrelated settings at once. Restore the business flow first, then complete root-cause and prevention work.

110. How would you define actionable SLOs and an error-budget policy?

Define SLOs around user-visible outcomes, with a clear population, measurement source and time window. For an order API, an availability SLI might count valid eligible requests completed successfully; a separate latency SLI measures the fraction completed within an agreed threshold. Decide how client errors, retries, maintenance and missing telemetry are handled before an incident.

For an illustrative request-based SLO:

Plain-text example

Eligible requests in window: 2,000,000
Success target:                99.9%
Allowed unsuccessful requests: 2,000
Observed unsuccessful:          800
Remaining request budget:     1,200
Eligible requests in window: 2,000,000
Success target:                99.9%
Allowed unsuccessful requests: 2,000
Observed unsuccessful:          800
Remaining request budget:     1,200
Eligible requests in window: 2,000,000
Success target:                99.9%
Allowed unsuccessful requests: 2,000
Observed unsuccessful:          800
Remaining request budget:     1,200

This arithmetic is not an Azure SLA or a time-based downtime allowance. A fast budget burn should trigger an operational response, while persistent consumption can justify slowing risky releases and prioritizing reliability work. Agree those decisions with product and engineering owners. Measure critical flows separately so a healthy high-volume endpoint cannot hide a failing checkout flow. Validate telemetry and review targets as usage and business expectations change.

111. How would you reduce telemetry cost without losing incident visibility?

Start with the bill and actual investigative needs: identify high-volume tables, redundant collection, verbose application logs and excessive retention. Preserve the signals needed for security, SLOs, incident diagnosis and required records. Then reduce noise at the source, apply supported collection filtering or transformations, and choose suitable table plans and retention settings for the access pattern.

Sampling can reduce application telemetry volume, but it changes how counts and traces must be interpreted. Use a supported approach that preserves useful correlation, and verify that important errors and rare events remain visible. Dropping an entire dependency category may save money while making the next outage much harder to diagnose.

For a chatty health-check endpoint, aggregate routine success measurements while retaining actionable failures and latency signals. Compare a representative incident investigation before and after the change. Include query, export and retention charges in the model, not just ingestion. Roll out gradually and document known visibility gaps. The cheapest telemetry configuration is not necessarily the lowest-cost operational choice.

112. How would you investigate a sudden Azure cost increase?

First verify the billing scope, date range, currency and cost view so that a commitment purchase or reporting change is not mistaken for a usage incident. Use Cost Analysis and detailed usage to group the increase by service, resource, meter, region and owner. Compare the affected period with a suitable baseline and correlate it with deployments, scaling, traffic and configuration changes.

Typical causes include runaway scale-out, retained unattached resources, increased log ingestion, data transfer, storage operations, or lost discount coverage. A deleted resource can still have legitimate earlier charges, and reporting can lag. Cost views and the final invoice may also differ because of credits, taxes and other adjustments.

Identify the responsible workload and quantify the recurring portion before acting. For an unexpectedly large telemetry bill, stop the unnecessary collection through an approved change rather than deleting the observability system. Check user impact and contractual commitments before resizing or shutting down anything. Add a targeted budget or anomaly response after the cause is understood; a budget alert is not itself a hard spending cap.

113. How would you validate a capacity plan before a major traffic event?

Turn the forecast into a testable workload model: arrival rate, request mix, payload size, read/write ratio, concurrency, geographic distribution and burst duration. Include realistic dependencies and data size, then test in a production-like environment with explicit spend and safety limits. Measure throughput and latency percentiles alongside errors, saturation and queue growth.

For a simplified steady-state estimate:

Plain-text example

Arrival rate:           800 requests/second
Mean service time:      0.25 seconds
Mean in-flight work:    800 * 0.25 = 200 requests
Arrival rate:           800 requests/second
Mean service time:      0.25 seconds
Mean in-flight work:    800 * 0.25 = 200 requests
Arrival rate:           800 requests/second
Mean service time:      0.25 seconds
Mean in-flight work:    800 * 0.25 = 200 requests

Little's Law gives an average under its assumptions; it does not size every thread pool or predict tail latency. Test bursts, cold starts, autoscale delay and one-instance or one-zone loss. Confirm downstream connection limits, database capacity and network constraints before increasing front-end instances. A useful result is the maximum sustainable workload within the target, with its bottleneck and safety margin identified. Rehearse the event's scale settings and rollback plan, and monitor the live workload against the assumptions rather than treating a benchmark as a guarantee.

114. How would you design for quotas, rate limits and regional capacity constraints?

Distinguish an adjustable quota, a fixed service limit, a request-rate limit and actual regional resource capacity. An approved vCPU quota does not guarantee that the requested VM SKU is available when needed. Inventory limits for normal operation, deployment surges and recovery, including compute, IP addresses, storage, connections and service API calls.

Request necessary quota increases well before a launch, and validate the intended region and SKU. Where supported and justified, evaluate capacity reservation separately from billing discounts. Define tested alternatives, such as a compatible SKU or recovery region, rather than assuming substitution will work during an incident.

Applications should handle throttling with bounded retries, backoff and the service's retry guidance. Control concurrency and queue work when that preserves business semantics. Monitor headroom and rate-limit responses at the relevant scope. Capacity planning must include failover concentration: a secondary region receiving all traffic may need more than its normal allocation. Do not discover during recovery that the deployment identity, quota or network address space prevents scaling.

115. How would you balance data residency, resilience and service availability?

Start with a precise data classification and approved residency requirements, then map every copy and processing path. Primary storage, replicas, backups, logs, support exports and global services may have different location behavior. A resource group's region or an allowed-locations policy does not prove where every category of data is processed or stored.

Build a service-by-service matrix of permitted regions, required features, redundancy options and documented data-handling commitments. If only one region in the permitted geography supports a required capability, explicitly present the trade-off among changing the service, changing the recovery objective or obtaining a reviewed exception. Do not quietly replicate outside the approved boundary for convenience.

Include encryption, access, retention and operational access in the design, while recognizing that these are separate from residency. Obtain the organization's legal and compliance interpretation rather than claiming an architecture is compliant because Azure offers certifications. Test recovery using the approved destinations and document residual risks, including global identity and telemetry dependencies.

116. How would you respond to suspected compromise of an Azure workload identity?

Treat the identity as a route into every resource it can access, and preserve evidence while containing that route under the incident-response plan. Identify the application or service principal, its credentials or federation configuration, recent sign-ins, permissions, accessed resources and possible data exposure. For a managed identity, investigate the host or workload that can request its tokens; rotating an unrelated secret will not fix a compromised host.

Containment may include disabling the affected workload path, removing unnecessary permissions, replacing exposed credentials, correcting a federated trust or isolating a compromised host. Select actions with the incident owner because they can interrupt production. Existing tokens and authorization caches may not become unusable instantly, so verify actual containment rather than assuming a control change has immediate universal effect.

Review persistence, new role assignments and downstream credentials that the identity could retrieve. Restore service with a clean, least-privileged identity path and monitor it closely. Workload risk signals are useful evidence, but coverage and licensing differ; an absent alert does not establish that no compromise occurred.

117. How would you manage Azure service retirement and breaking changes?

Maintain an inventory linking services, SKUs, API versions, runtimes, SDKs and operating-system images to owners and business flows. Track relevant Azure Service Health advisories, official retirement notices and vendor release notes. A service retirement, SDK end of support and API behavior change are different events and can require different migrations.

For each material notice, record the exact affected configuration, deadline, replacement, test plan and owner. Assess dependencies and commercial or regional differences before assuming that a replacement is drop-in compatible. Build a representative migration environment, compare behavior and costs, then roll out with observable acceptance gates and a recovery option.

Prioritize by lead time and blast radius rather than waiting for the last reminder. An automated inventory rule can flag known affected versions, but a human still needs to confirm business impact. Keep evidence that production moved off the retiring component, including background jobs and recovery environments. Avoid hard-coding retirement dates into long-lived runbooks without a process to recheck the official source.

118. How would you decide whether a workload should be migrated, modernized or retained?

Choose the strategy from business value, technical fit, dependency risk and remaining useful life. Rehosting can move a compatible workload quickly but preserves much of its operational burden. Replatforming or refactoring can improve managed-service fit at the cost of application change and testing. Retaining or retiring a workload can be the right decision when migration has little benefit or an unacceptable risk.

For a vendor-supported legacy application with a near-term replacement, a controlled rehost may be more sensible than a large rewrite. A growing customer-facing service with deployment and scaling constraints may justify modernization. Assess data movement, latency-sensitive integrations, licensing, support, identity and recovery before choosing either path.

Estimate both migration cost and the operating model afterward. Define measurable success, such as lower release lead time or a tested recovery target, rather than merely counting migrated VMs. Sequence work by dependencies, rehearse cutover, and retain an exit or rollback approach. Cloud placement alone does not modernize software or guarantee savings.

119. How would you evaluate the real cost of an Azure architecture?

Evaluate total cost over a defined period and workload range, not just the advertised compute price. Include compute, storage capacity and transactions, database throughput, networking and egress, security, backups, monitoring, support, licensing and required standby capacity. Add engineering effort, operations, migration, training and expected incident impact where the comparison needs a business view.

Use transparent assumptions and sensitivity analysis. For example, compare a baseline month with doubled traffic and a recovery exercise rather than producing one deceptively precise estimate. Discounts depend on eligibility, utilization and commitments, so model them separately from demand reduction. Unused committed capacity can erase an apparent saving.

A useful unit metric is cost per successful business outcome, such as a completed order, alongside total spend. A cheaper instance that doubles failures or operator effort may be a worse choice. Validate the model against measured usage after deployment, explain variance, and update the architecture or forecast. Prices, taxes and commercial terms must be checked for the actual purchasing context.

120. How would you explain and defend an Azure architecture decision in a design review?

Present the decision as a reasoned response to requirements, not as a list of Azure products. State the business flow, measurable targets and constraints, show the selected design, and compare credible alternatives. Explain why the chosen trade-offs are acceptable and what evidence supports the conclusion. Separate tested facts from assumptions and future work.

An architecture decision record can use a compact structure:

Plain-text example

Context: Orders must survive a worker restart.
Options: Synchronous processing or durable queued work.
Decision: Queue work after durable acceptance.
Consequences: Eventual completion and duplicate handling.
Evidence: Recovery and load-test results are required.
Revisit when: Latency or ordering requirements change

Context: Orders must survive a worker restart.
Options: Synchronous processing or durable queued work.
Decision: Queue work after durable acceptance.
Consequences: Eventual completion and duplicate handling.
Evidence: Recovery and load-test results are required.
Revisit when: Latency or ordering requirements change

Context: Orders must survive a worker restart.
Options: Synchronous processing or durable queued work.
Decision: Queue work after durable acceptance.
Consequences: Eventual completion and duplicate handling.
Evidence: Recovery and load-test results are required.
Revisit when: Latency or ordering requirements change

This illustrative record does not claim those tests have already run. In the review, walk through normal operation, failure, recovery, security and cost. Name the owners of unresolved risks and define the conditions that would invalidate the choice. A strong defense can acknowledge a simpler alternative and explain why it was rejected. Keeping the decision revisitable is more useful than asserting that the architecture is universally best.

Azure Documentation and Further Reading

Examples concern public Azure unless another cloud or deployment model is explicitly named. Service availability, defaults, limits, pricing, and retirement timelines can depend on the region, tier, subscription, resource creation date, API version, and current service documentation. Do not assume all regions are paired, every service supports availability zones, or a platform feature automatically provides application-level recovery. Microsoft Entra roles, Azure resource roles, and service data-plane permissions have different scopes. CLI examples use the stated shell; Bicep and configuration excerpts require compatible tooling and resource APIs. Review changes, permissions, potential charges, and rollback arrangements before any separately authorized deployment. This article does not require live cloud actions. Static parsing, source review, or synthetic calculations do not establish successful Azure deployment, connectivity, failover, security, performance, or cost outcomes.

Use these primary Microsoft references to verify Azure service behavior, supported configurations, reliability options, and management boundaries. Match the documentation to the actual cloud, region, tier, API version, and deployment model, and check current service notices before applying a design.

Team Sherlock.sh

Building fraud intelligence for live high-stake video interactions (financial discussions, hiring interviews, board meeting etc).

Catch candidate fraud before it costs you.

Sherlock AI helps you detect AI-assisted, proxy, and deepfake candidates, so every hiring decision is backed by evidence.

Ask AI about Sherlock.sh

Similar Posts