Which Azure services have you used in your project, and how do they integrate with each other?

A Note First

I haven't worked on a project myself. I'm an AI, so I can't claim hands-on experience. But if you're preparing for an interview or documenting an architecture, here is a realistic reference project built from the services we've covered, with how each piece integrates. You can adapt it to your real experience, and you should only describe what you've actually done.

Example: an order-processing platform

Users ─► Front Door (WAF) ─► APIM ─► App Service (.NET Web API)
                                          │
              ┌───────────────────────────┼──────────────────────────┐
              ▼                           ▼                          ▼
         Azure SQL                  Redis (cache)             Service Bus (topic)
                                                                     │
                                          ┌──────────────────────────┼──────────────┐
                                          ▼                          ▼              ▼
                                  Function: billing        Function: shipping   Function: notifications
                                          │
                                  Durable Functions (multi-step workflow)

Cross-cutting: Entra ID, Managed Identity, Key Vault, VNet + Private Endpoints,
               Application Insights, GitHub Actions / Azure Pipelines + Bicep

How the pieces integrate

Edge and API layer

• Front Door provides global entry, WAF, and TLS, and forwards to APIM.
• APIM validates Entra ID JWTs, applies rate limits, and routes to the backend. The backend accepts traffic only from APIM.
• App Service hosts the .NET Web API, with deployment slots for zero-downtime releases.

Identity and secrets

• Entra ID issues tokens (auth code + PKCE for users, client credentials for services). The API validates the JWT and checks scopes or roles.
• Managed identity is how the app and functions reach SQL, Key Vault, Service Bus, and Storage, with RBAC roles and no connection strings.
• Key Vault holds the few remaining secrets, exposed through Key Vault references in app settings.

Data and messaging

• Azure SQL is the system of record, accessed through the app's managed identity.
• Redis caches hot reads to reduce database load.
• Service Bus decouples the API from downstream work. The API publishes an OrderPlaced event to a topic, and each subscription (billing, shipping, notifications) feeds its own consumer. Dead-letter queues, idempotent handlers, and duplicate detection handle failures.
• Azure Functions consume those subscriptions with Service Bus triggers.
• Durable Functions orchestrate multi-step flows such as reserve inventory, charge payment, and confirm, with compensation on failure.

Networking

• VNet integration on the app and functions, plus Private Endpoints with private DNS for SQL, Key Vault, Service Bus (Premium), and Storage. Public access is disabled on those services.

Observability

• Application Insights (workspace-based, via the OpenTelemetry distro) captures requests, dependencies, and logs across all services, correlated by operation ID. Alerts cover failure rate, p95 latency, queue depth, and DLQ count.

Delivery

• GitHub Actions with OIDC login builds, tests, and deploys to a staging slot, runs a smoke test, then swaps to production after approval.
• Bicep defines the infrastructure, and EF migrations run as a controlled pipeline step.

Scale and availability

• Autoscale with a minimum of two instances, zone-redundant compute and data, and an auto-failover group for SQL if cross-region DR is required.