Skip to content

Azure Cloud Interview Questions: Private Networking, DNS, and Hybrid Connectivity

Prepare for Azure networking interviews with 12 questions on private endpoints, hub-and-spoke design, hybrid connectivity, DNS, routing, and production operations.

Ekanatha Reddy Urivakili16 min3,391 words

Azure networking interviews often test more than whether you can name a service. Interviewers want to know whether you can trace a packet, explain how DNS affects the path, and recognize where a seemingly reasonable design breaks when networks, teams, or failure domains multiply.

This guide focuses on a specific, frequently consequential sub-area: private networking, DNS, and hybrid connectivity in Azure. It progresses from fundamentals to system design. For each question, look for the underlying decision: what traffic is allowed, what name resolves to which address, and how the design behaves when a dependency fails.

Fundamentals

1. What is an Azure virtual network, and what should you consider when choosing its address space?

What the interviewer is testing: Whether you understand the VNet as an address and routing boundary, and whether you plan for connections beyond the initial deployment.

Model answer:

An Azure virtual network (VNet) provides private IP connectivity for Azure resources and participates in routing. Its address space is divided into subnets, which let you organize resources and apply network controls.

Choose address ranges that do not overlap with networks the VNet may need to connect to: other VNets, on-premises networks, partner networks, and planned cloud environments. Overlap can prevent peering or make routes ambiguous. Treat address planning as a platform decision, not a value to choose independently for each application team.

Subnets are useful boundaries, but they are not a complete security model by themselves. Use controls such as network security groups (NSGs), route tables, and Azure Firewall where the required policy calls for them.

Follow-up: What would you do if an acquired company’s on-premises network overlaps with your Azure address space?
Hint: Explain why route preferences alone do not solve overlapping private address space.

2. How do an NSG and Azure Firewall differ?

What the interviewer is testing: Whether you can distinguish distributed subnet or interface filtering from centralized network inspection.

Model answer:

An NSG is a stateful traffic filter associated with a subnet or network interface. Its rules allow or deny traffic based on properties such as source, destination, port, and protocol. NSGs are useful for applying focused controls close to workloads.

Azure Firewall is a managed, centrally deployed network firewall. Depending on its configuration, it can enforce network and application rules, provide centralized egress control, and support logging and inspection. It is often used as a shared control point in a hub network.

They are not mutually exclusive. A design may use NSGs for workload-level restrictions and a firewall for shared egress or inspection. The trade-off is between distributed control and centralized policy, operations, and traffic flow.

Follow-up: If a subnet NSG allows a flow but the firewall denies it, does the traffic pass?
Hint: Identify every enforcement point on the actual route.

3. Compare a private endpoint with a service endpoint.

What the interviewer is testing: Whether you understand the difference between private IP connectivity and restricting access to a service’s public endpoint.

Model answer:

A private endpoint creates a network interface with a private IP in your VNet for an Azure service exposed through Private Link. Applications typically resolve the service’s expected hostname to that private IP, then connect over the private path. The service’s public endpoint may still exist; disable or restrict public access separately if the security requirement calls for it.

A service endpoint extends a VNet subnet’s identity to a supported Azure service. Traffic still targets the service’s public endpoint, while the service can restrict access to selected VNets or subnets. It does not give the service a private IP in the VNet.

Choose based on the connectivity and exposure requirements. Private endpoints support private-IP access and are commonly used when private reachability is required. Service endpoints can be simpler when subnet-based access control to a public service endpoint is sufficient.

ChoiceService address seen by clientTypical reason to choose itImportant consideration
Private endpointPrivate IP in the VNetPrivate connectivity to a servicePlan private DNS and endpoint approval or access
Service endpointService public endpointRestrict supported service access by subnetIt does not make the service endpoint a private IP
Public endpointPublicly addressed endpointPublic access is requiredRestrict and authenticate access appropriately

Follow-up: Does creating a private endpoint automatically block the service’s public endpoint?
Hint: Separate private connectivity from the target service’s public network access setting.

4. Why is DNS central to private endpoint connectivity?

What the interviewer is testing: Whether you know that a reachable private IP is not enough if clients resolve the service name incorrectly.

Model answer:

Applications generally keep using the service’s normal hostname. For private connectivity, DNS must return the private endpoint’s address from the client’s network. Azure Private DNS zones are commonly used to provide those private records, and the relevant VNets must be linked to the zone or otherwise able to resolve it.

The exact zone depends on the Azure service. Follow the service’s documented Private Link DNS configuration rather than guessing a zone name. A missing zone link, conflicting record, or custom DNS server that does not forward queries correctly can cause clients to resolve a public address even when the private endpoint exists.

For on-premises clients, plan the DNS path too. A common approach is forwarding the relevant private zones to an Azure DNS Private Resolver inbound endpoint or to a suitably configured DNS forwarder in Azure.

Follow-up: A VM can resolve the hostname to the private IP, but its connection times out. What do you inspect next?
Hint: Follow the packet after DNS: route, firewall, NSG, endpoint state, and target policy.

Intermediate

5. What does hub-and-spoke networking provide, and what does VNet peering not provide?

What the interviewer is testing: Whether you can describe the topology without claiming that peering automatically acts as a router.

Model answer:

A hub-and-spoke design places shared services—such as a firewall, DNS infrastructure, or VPN gateway—in a hub VNet and connects workload VNets as spokes. It can centralize shared controls while keeping workload address spaces and ownership separate.

VNet peering provides private connectivity between the peered VNets, but peering is not transitive. If spoke A is peered with the hub and the hub is peered with spoke B, that alone does not make A-to-B traffic flow through the hub. A design that requires transit needs routing and a forwarding path, such as a network virtual appliance or Azure Firewall, with appropriate route tables and settings.

The topology only works as intended when peering, routes, firewall policy, and DNS are designed together.

flowchart LR
    OnPrem["On-premises network"] --> Hub["Hub VNet"]
    Hub --> Firewall["Azure Firewall"]
    Hub --> SpokeA["Workload spoke A"]
    Hub --> SpokeB["Workload spoke B"]
    SpokeA --> PrivateEndpoint["Private endpoint"]
    PrivateEndpoint --> PaaS["Azure service"]

Caption: A hub-and-spoke layout centralizes shared connectivity, but routing and policy must explicitly support transit.

Follow-up: How would you make traffic from one spoke reach another through the hub firewall?
Hint: Cover peering settings, user-defined routes, and the firewall’s forwarding role.

6. How would you make private endpoint DNS work across multiple spokes?

What the interviewer is testing: Whether you can reason about DNS ownership, zone links, and resolution across network boundaries.

Model answer:

First decide who owns the private DNS zones and how records are maintained. A common approach is to use centrally managed Azure Private DNS zones, link them to the VNets that need to resolve the names, and configure private endpoint DNS integration for the target service. Central ownership reduces duplicated zones and inconsistent records, but it also makes change control important.

A VNet link is not a substitute for routing: it enables the linked VNet to use the zone for name resolution; it does not connect clients to the endpoint’s subnet. Likewise, peering alone does not guarantee that a custom DNS server will query the correct private zone.

For on-premises resolution, configure forwarding for the relevant zones to an Azure resolver or forwarder reachable over the hybrid connection. Verify the result from the client’s actual DNS path, not only from an Azure portal configuration page.

Follow-up: What risks come with linking one private DNS zone to many VNets?
Hint: Consider record ownership, accidental changes, and the impact of central DNS failures.

7. When would you use a VPN Gateway instead of ExpressRoute?

What the interviewer is testing: Whether you understand the different connectivity models and can make a requirements-based choice.

Model answer:

An Azure VPN Gateway provides encrypted connectivity over the internet using VPN protocols and supports site-to-site and other VPN scenarios. It is often a practical choice when encrypted connectivity over existing internet links meets the organization’s availability, performance, and operational requirements.

ExpressRoute provides private connectivity between an organization’s network and Microsoft’s network through an ExpressRoute connectivity provider. It is commonly considered when the design requires private connectivity, predictable network integration, or a specific connectivity arrangement that a public-internet VPN does not meet.

Neither name alone guarantees a particular end-to-end latency, availability, or performance result. Those depend on the selected configuration, provider, geography, routing, and application traffic. Some environments use both, with deliberate route preference and tested failover behavior.

OptionConnectivity modelDesign considerations
VPN GatewayEncrypted tunnels over the internetInternet path, gateway configuration, tunnel resilience, and routing
ExpressRoutePrivate connectivity through a providerProvider, circuit design, routing, redundancy, and operational ownership
BothSeparate paths with planned routingFailover behavior, route preference, and testing under failure

Follow-up: How would you prove that traffic fails over from ExpressRoute to VPN as intended?
Hint: Test route withdrawal and application reachability, not just gateway health.

8. How do user-defined routes, system routes, and BGP affect traffic paths?

What the interviewer is testing: Whether you can explain why a packet takes a particular route instead of just listing route types.

Model answer:

Azure applies system routes by default, while user-defined routes (UDRs) let you add or override routing behavior for a subnet. BGP can advertise routes from a VPN or ExpressRoute connection. The effective route depends on the destination prefix, route source and priority, and the relevant gateway or network configuration.

A UDR pointing to a virtual appliance can steer traffic through a firewall, but only if the route applies to the sending subnet and the appliance can forward the traffic. Check both directions: asymmetric paths can break stateful inspection or connections even when one direction looks correct. Also verify that routes do not send traffic toward a next hop that cannot reach the destination.

When troubleshooting, inspect the effective routes on the actual network interface and subnet involved, then verify the firewall and gateway route state.

Follow-up: A firewall sees outbound packets but responses do not return through it. What might be wrong?
Hint: Look for asymmetric routing and the return route.

Senior and system-design level

9. Design private connectivity for a hybrid application that uses Azure PaaS services.

What the interviewer is testing: Whether you can combine address planning, DNS, routing, security boundaries, and operational ownership into a coherent design.

Model answer:

Start with requirements: which application components need private access, whether on-premises clients need to reach them, whether internet egress must be inspected, and how availability and disaster recovery are defined. Reserve non-overlapping address space for the hub, spokes, gateway, and future growth before deploying endpoints.

A typical design places shared connectivity and DNS services in a hub, workload tiers in spokes, and private endpoints near the consuming workload or in a deliberately shared network segment. Use peering for the intended network links, and add explicit routes and a firewall forwarding path where inspection or transit is required. Do not rely on peering to create transitive connectivity.

For DNS, establish which zones are authoritative for private endpoint records, link or forward them to the right clients, and test resolution from Azure and on-premises. Apply NSGs and firewall rules according to least privilege. Finally, document who owns endpoint approval, zone changes, routes, and incident response; shared networking without clear ownership tends to become a deployment bottleneck.

Follow-up: How would you handle disaster recovery if the application is deployed in a second Azure region?
Hint: Include regional DNS, endpoint placement, routing, and the failover procedure.

10. A workload cannot connect to an Azure service through a private endpoint. How do you troubleshoot it?

What the interviewer is testing: Whether you use a layered diagnostic method and distinguish name resolution, routing, filtering, and service configuration.

Model answer:

Troubleshoot from the client outward:

  1. Confirm the client and target. Record the source subnet, destination hostname, port, region, and the private endpoint’s connection state.
  2. Check DNS from that client. Confirm the expected hostname resolves to the intended private IP. Check the DNS server in use, zone records, VNet links, and forwarding rules.
  3. Check the network path. Verify effective routes, peering, gateway or firewall routes, and any UDRs. Confirm that return traffic can follow a valid route.
  4. Check filtering. Review NSG rules, Azure Firewall policy and logs, appliance rules, and any target service network restrictions.
  5. Test in layers. Compare name resolution with a direct connectivity test, and compare from a known-good client in the same or a different network.
  6. Review recent changes. A newly linked zone, endpoint, route, or firewall rule may explain why only one client group is affected.

Avoid using a successful DNS lookup as proof that the connection should work. It proves only that a resolver returned an answer.

Follow-up: The problem affects on-premises clients but not Azure VMs. What is your first area of investigation?
Hint: Compare the DNS forwarding and hybrid route paths used by the two client groups.

11. How would you build resilience into hybrid connectivity?

What the interviewer is testing: Whether you design around failure domains and verify recovery rather than treating a redundant diagram as proof of availability.

Model answer:

Identify the failure domains that matter: gateway instances, circuits or tunnels, provider links, regions, power and facility dependencies, and DNS infrastructure. Select redundancy that addresses those risks, and ensure the paths are operationally independent where the requirements demand it.

Then define routing behavior for normal operation and failure. If VPN and ExpressRoute are both present, document expected route preference and test what happens when a route is withdrawn or a path becomes unavailable. Confirm that firewalls, route tables, and return paths support failover rather than pinning traffic to a failed path.

Resilience also involves application behavior. Define connection timeouts, retry limits, and recovery expectations; retries cannot compensate for a broken route indefinitely. Test failover in a controlled exercise and record the observed recovery steps and limitations.

Follow-up: What would make two apparently redundant links a single failure domain?
Hint: Consider shared providers, facilities, routing policy, and operational dependencies.

12. How would you govern and operate a shared Azure network platform?

What the interviewer is testing: Whether you think beyond provisioning to ownership, change safety, diagnostics, and service objectives.

Model answer:

Treat shared networking as a platform with explicit interfaces. Define who can allocate address space, create peerings, approve private endpoints, modify central DNS, and change firewall policy. Use reviewed infrastructure as code for repeatable changes, with policy and permissions that protect shared resources without blocking valid workload deployments.

Make operational state visible. Capture DNS resolution outcomes, connection failures, route or firewall changes, and relevant configuration identifiers in a way that can be correlated to the workload and time window. Use network diagnostic capabilities alongside application telemetry; neither replaces the other. Set service objectives for the user-visible outcome—successful connectivity to required dependencies—not just the health of a gateway resource.

Plan incident procedures for stale DNS, incorrect routes, blocked flows, and unhealthy hybrid paths. Include tested rollback steps and clear escalation ownership for the central platform and application teams.

Follow-up: How would you prevent one team’s private endpoint DNS change from disrupting unrelated workloads?
Hint: Discuss ownership boundaries, review, validation, and staged rollout.

Runnable examples

The first example creates a resource group, VNet, and subnet with Azure CLI. Set the shell variables, authenticate with az login, and run the commands:

RG="rg-network-interview"
LOCATION="eastus"
VNET="vnet-app"
SUBNET="snet-app"

az group create \
  --name "$RG" \
  --location "$LOCATION"

az network vnet create \
  --resource-group "$RG" \
  --name "$VNET" \
  --location "$LOCATION" \
  --address-prefixes 10.20.0.0/16 \
  --subnet-name "$SUBNET" \
  --subnet-prefixes 10.20.1.0/24

Notice that this establishes address space and a subnet; it does not create a firewall policy, private DNS path, or connectivity to another network.

This Bicep example is a more realistic starting point: a hub and spoke with bidirectional peering, plus a private DNS zone linked to the spoke. Save it as main.bicep, then deploy it to an existing resource group with the Azure CLI. It creates topology, not a complete transit design.

param location string = resourceGroup().location

resource hub 'Microsoft.Network/virtualNetworks@2024-05-01' = {
  name: 'vnet-hub'
  location: location
  properties: {
    addressSpace: {
      addressPrefixes: [
        '10.0.0.0/16'
      ]
    }
  }
}

resource spoke 'Microsoft.Network/virtualNetworks@2024-05-01' = {
  name: 'vnet-app'
  location: location
  properties: {
    addressSpace: {
      addressPrefixes: [
        '10.20.0.0/16'
      ]
    }
  }
}

resource hubToSpoke 'Microsoft.Network/virtualNetworks/virtualNetworkPeerings@2024-05-01' = {
  parent: hub
  name: 'hub-to-app'
  properties: {
    remoteVirtualNetwork: {
      id: spoke.id
    }
    allowVirtualNetworkAccess: true
    allowForwardedTraffic: true
    allowGatewayTransit: false
    useRemoteGateways: false
  }
}

resource spokeToHub 'Microsoft.Network/virtualNetworks/virtualNetworkPeerings@2024-05-01' = {
  parent: spoke
  name: 'app-to-hub'
  properties: {
    remoteVirtualNetwork: {
      id: hub.id
    }
    allowVirtualNetworkAccess: true
    allowForwardedTraffic: true
    allowGatewayTransit: false
    useRemoteGateways: false
  }
}

resource privateDns 'Microsoft.Network/privateDnsZones@2024-06-01' = {
  name: 'privatelink.database.windows.net'
  location: 'global'
}

resource spokeDnsLink 'Microsoft.Network/privateDnsZones/virtualNetworkLinks@2024-06-01' = {
  parent: privateDns
  name: 'app-vnet-link'
  location: 'global'
  properties: {
    registrationEnabled: false
    virtualNetwork: {
      id: spoke.id
    }
  }
}
az deployment group create \
  --resource-group "$RG" \
  --template-file main.bicep

Notice that peering is configured in both directions, but this template still needs workload subnets, any required private endpoint, routes, firewall policy, and a DNS design validated for the intended clients.

Common mistakes candidates make

  • Treating peering as transit. Peering two spokes to a hub does not automatically route traffic between the spokes.
  • Treating a private endpoint as a complete security configuration. Private connectivity does not by itself disable public access to the service.
  • Ignoring DNS in network design. A private endpoint that clients cannot resolve correctly is not usable private connectivity.
  • Confusing a service endpoint with a private endpoint. One restricts access by subnet while still using a public endpoint; the other provides a private IP in a VNet.
  • Assuming a route implies a working connection. Filtering, return paths, name resolution, and target-side policy still matter.
  • Using overlapping address ranges. This can block connectivity or require translation and additional complexity.
  • Calling a topology highly available without testing failover. Redundant components are not enough if routes or operations fail with them.
  • Troubleshooting only from the portal. Test from the affected client’s DNS and network context.

Observability for private connectivity

Network monitoring should help answer an operational question: which part of the path failed, and which workload was affected? Combine application telemetry with Azure network diagnostics. Application traces show dependency calls and their outcomes; network and DNS diagnostics help explain why a connection did or did not reach its destination.

Log structured events with enough context to correlate an incident without exposing secrets or unnecessary payload data:

{
  "event": "dependency_connectivity_check",
  "service": "orders-api",
  "environment": "production",
  "dependency": "orders-db",
  "endpoint_type": "private",
  "result": "timeout",
  "duration_ms": 3000,
  "trace_id": "4bf92f3577b34da6a3ce929d0e0e4736",
  "region": "eastus"
}

For a .NET service, this OpenTelemetry setup exports supported application telemetry through Azure Monitor. Install the Azure.Monitor.OpenTelemetry.AspNetCore package and configure a connection string for the target Application Insights resource.

using Azure.Monitor.OpenTelemetry.AspNetCore;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddOpenTelemetry()
    .UseAzureMonitor();

var app = builder.Build();

app.MapGet("/health", () => Results.Ok(new { status = "healthy" }));

app.Run();

Use the service’s documented configuration for the Azure Monitor connection string. Add dependency instrumentation and application-level connectivity checks where needed; exporting traces does not, by itself, diagnose every network hop.

Track service-level RED signals—rate, errors, and duration—and resource-level USE signals—utilization, saturation, and errors. For shared network components, add relevant gateway, firewall, DNS, and connection-monitor signals. The exact metrics depend on the services and topology deployed.

SLIExample objectiveMeasurement
Dependency connectivity successIllustrative target: 99.9% of scheduled checks succeed over a rolling 30-day windowSuccessful checks divided by completed checks, excluding planned test runs
Dependency connection latencyIllustrative target: p95 below an agreed application-specific thresholdClient-observed connection duration, segmented by dependency and region
DNS resolution correctnessIllustrative target: 99.9% of checks return the expected private address where requiredResolver checks from representative Azure and on-premises clients

These targets are examples, not Azure guarantees. Set actual SLOs from application requirements, observed baselines, and the service contract your organization intends to meet.

Page on:

  • A sustained drop in successful dependency connections that threatens the agreed SLO.
  • A hybrid path or shared gateway failure with no healthy alternate route.
  • A sustained DNS failure or incorrect resolution affecting production workloads.
  • A firewall or route change that blocks a critical dependency and has broad impact.

Alert on user-impacting symptoms and critical shared-platform failures. Send lower-severity resource warnings to dashboards or tickets unless they indicate imminent impact.

Official references

Quick-revision checklist

  • Explain why address ranges must not overlap across connected networks.
  • Distinguish NSG filtering from centralized firewall control.
  • State how private endpoints differ from service endpoints.
  • Trace private endpoint resolution from Azure and on-premises clients.
  • Explain why VNet peering is not transitive.
  • Describe the route and return path through a firewall or gateway.
  • Compare VPN Gateway and ExpressRoute against requirements, not assumptions.
  • Troubleshoot in order: client, DNS, route, filtering, target configuration.
  • Describe how you would test hybrid failover.
  • Tie monitoring and alerts to user-visible connectivity objectives.

This article was generated with AI. #AIGenerated