This post/practice exam is a part of the AI-200: Developing AI Cloud Solutions on Azure  Exam Prep Hub.

Section 1 — Develop Containerized Solutions on Azure

Question 1 — Scenario-Based: Container Apps Revisions

A company operates an AI summarization API in Azure Container Apps.

Revision 12 is currently serving all production traffic. The development team deploys revision 13, which contains a new model-integration implementation.

The team wants to:

1. Send a small percentage of traffic to revision 13.
2. Compare its behavior with revision 12.
3. Increase traffic to revision 13 if testing is successful.
4. Roll back quickly if problems occur.

Which Azure Container Apps capability should be used?

A. KEDA scaling rules

B. Container Apps revisions and traffic splitting

C. Azure Container Registry Tasks

D. AKS Horizontal Pod Autoscaler

Answer: B

Explanation

Azure Container Apps revisions allow multiple versions of an application to coexist. Traffic can be distributed between revisions, making revisions appropriate for controlled rollouts, testing, and rollback scenarios.

KEDA addresses event-driven scaling, not deployment traffic management. ACR Tasks builds container images, while AKS-specific autoscaling mechanisms aren’t required for a Container Apps deployment.

Microsoft specifically includes Container Apps environment configuration and revision management in the AI-200 objectives.

Question 2 — Scenario-Based: ACR Tasks

A development team has the following workflow:

Git repository
      ↓
Dockerfile
      ↓
Container image
      ↓
Azure Container Registry
      ↓
Azure Container Apps

Every time a change is committed to the application’s source repository, the team wants Azure to automatically build the image and publish it to ACR.

The team does not want to maintain a build VM.

Which solution should you implement?

A. Azure Container Registry Tasks

B. Azure Functions with a timer trigger

C. Azure App Service deployment slots

D. Azure Managed Redis

Answer: A

Explanation

Azure Container Registry Tasks provide cloud-based automation for building container images and can be triggered by source-code changes.

This is preferable to creating a custom VM-based build process when the requirement is specifically automated container-image building.

ACR Tasks are explicitly included in the AI-200 containerization objectives.

Question 3 — AKS Manifest Troubleshooting

An AI application is deployed to AKS using a Kubernetes manifest.

The deployment contains:

• a Deployment
• a Service
• an Ingress

The pods are running successfully and the container logs show that the application started correctly.

However, requests sent through the public endpoint return connection errors.

Which investigation is the most appropriate next step?

A. Change the Cosmos DB consistency level.

B. Rebuild the container image using ACR Tasks.

C. Inspect the Service, Ingress, port mappings, selectors, and end-to-end network path.

D. Increase the Redis cache expiration interval.

Answer: C

Explanation

The successful pod startup and application logs indicate that the problem is probably beyond the container’s basic startup process.

The next logical layer is the connectivity path:

Internet
   ↓
Ingress
   ↓
Service
   ↓
Pod
   ↓
Container port

Incorrect selectors, ports, ingress configuration, or networking can prevent an otherwise healthy pod from receiving external requests.

Microsoft specifically includes troubleshooting AKS and Container Apps by examining logs, events, and end-to-end connectivity.

Question 4 — Multiple Answers

A company deploys an AI API to Azure Container Apps.

The application experiences sudden bursts of requests generated by a backend messaging workload. CPU utilization isn’t a reliable indicator of pending work.

Which two capabilities are relevant to designing the scaling solution?

A. KEDA event-driven scaling

B. Container Apps revision management

C. An event-based scaler that responds to the workload source

D. Azure Container Registry image versioning

Answers: A, C

Explanation

KEDA provides event-driven autoscaling and can scale applications based on external event sources.

Revision management handles versions of the application but doesn’t determine how replicas are added based on workload.

ACR image versioning manages images rather than application replica counts.

The AI-200 study guide explicitly identifies KEDA event-driven scaling in Container Apps.

Question 5 — Scenario-Based: App Service Container Configuration

A containerized AI application is deployed to Azure App Service.

The same image must be deployed to development, test, and production environments.

Each environment has a different value for:

AI_ENDPOINT
MODEL_NAME

The development team wants to use the same image in all three environments.

Which approach is most appropriate?

A. Build a different container image for every environment.

B. Store environment-specific values in the Dockerfile.

C. Supply environment-specific configuration through App Service application settings/environment variables.

D. Create a separate Azure Container Registry for each environment.

Answer: C

Explanation

Environment-specific configuration should generally be separated from the container image.

App Service can supply application settings to the container, allowing the same image to run in different environments with different configuration.

This approach improves portability and prevents configuration values from becoming embedded in the image.

Microsoft specifically identifies configuring App Service to supply environment variables and secrets as an AI-200 objective.

Question 6 — Matching: Container Technologies

Match each requirement to the best Azure capability.

Answers

• 1 → B
• 2 → A
• 3 → C
• 4 → D

Explanation

Each technology addresses a different part of the container lifecycle:

• ACR Tasks — automated container image builds.
• Container Apps revisions — versioned application deployments.
• KEDA — event-driven autoscaling.
• AKS manifests — declarative Kubernetes application configuration.

These capabilities correspond directly to the containerization objectives in the current AI-200 study guide.

Question 7 — Scenario-Based: Selecting AKS

A company has developed an AI inference platform consisting of multiple containerized components.

The architecture team requires:

• Kubernetes APIs and resource definitions
• Fine-grained Kubernetes workload configuration
• Direct control over Kubernetes networking and workloads
• The ability to manage Kubernetes resources through manifests

The team is willing to take on the additional operational responsibility associated with Kubernetes.

Which service should they select?

A. Azure Functions

B. Azure App Service

C. Azure Container Apps

D. Azure Kubernetes Service

Answer: D

Explanation

AKS is the appropriate choice when the architecture requires direct use of Kubernetes concepts, APIs, manifests, and Kubernetes workload management.

Container Apps provides a more managed abstraction over containerized application hosting and is preferable when the team doesn’t require direct Kubernetes control.

The AI-200 objectives explicitly include deploying and managing applications on AKS using manifest files.

Section 2 — Develop AI Solutions Using Azure Data Management Services

Question 8 — Cosmos DB Query Optimization

An application uses Azure Cosmos DB for NoSQL.

A query filters on:

customerId
status
createdDate

The query returns only a small number of documents, but its RU consumption is unexpectedly high.

The team discovers that the indexing policy was designed without considering the application’s actual query patterns.

What should the team investigate first?

A. The indexing policy and query execution characteristics

B. Azure Function trigger configuration

C. Event Grid retry settings

D. Container Apps revision traffic

Answer: A

Explanation

Cosmos DB indexing policies have a direct impact on query performance and RU consumption.

Rather than indiscriminately increasing provisioned throughput, developers should first examine query patterns and indexing configuration to determine whether the container is appropriately indexed.

The current AI-200 guide specifically includes optimizing Cosmos DB query performance and RU consumption using indexing policies and consistency levels.

Question 9 — Cosmos DB Change Feed

A document-ingestion application stores uploaded documents in Cosmos DB.

After each document is inserted or updated, a downstream process must:

1. Detect the change.
2. Extract information from the document.
3. Generate an embedding.
4. Store the embedding.

The downstream process should not continuously poll the entire container.

Which Cosmos DB capability is the best fit?

A. Strong consistency

B. Vector similarity search

C. Change feed processor

D. Composite indexing only

Answer: C

Explanation

The Cosmos DB change feed provides a mechanism for detecting changes to items in a container.

A change feed processor can consume those changes and invoke downstream processing without repeatedly scanning the entire container.

This is particularly useful in AI ingestion pipelines where document changes trigger embedding or enrichment operations.

The current AI-200 objectives explicitly include implementing a change feed processor.

Question 10 — Vector Search

A RAG application stores 1 million document chunks in Cosmos DB for NoSQL.

Each chunk contains:

documentId
tenantId
content
embedding

A user query is converted into an embedding.

The application must retrieve semantically similar chunks while restricting results to the user’s tenant.

Which approach is most appropriate?

A. Search the content property using exact string matching.

B. Perform vector similarity search and apply a tenant metadata filter.

C. Use the Cosmos DB change feed to retrieve matching documents.

D. Increase the container’s consistency level to Strong.

Answer: B

Explanation

Vector similarity search provides semantic retrieval based on embeddings.

The tenant filter ensures that candidate documents are restricted to the appropriate security boundary.

Increasing consistency does not implement semantic retrieval, and the change feed is for detecting data changes rather than answering semantic queries.

The AI-200 objectives specifically include storing/retrieving embeddings, vector similarity search, semantic retrieval, and RAG patterns.

Question 11 — PostgreSQL Schema Design

An AI application stores customer information and document embeddings in Azure Database for PostgreSQL.

The application frequently performs:

WHERE tenant_id = ?
  AND document_type = ?

followed by vector similarity search over the resulting records.

Which design consideration is most important?

A. Put all values into a single unstructured text column.

B. Avoid indexes because vector search cannot use metadata.

C. Store metadata in appropriately typed relational columns and design indexes around the query pattern.

D. Store tenant IDs in Azure Key Vault.

Answer: C

Explanation

PostgreSQL provides relational modeling capabilities that should be used appropriately.

Metadata used for filtering should be stored in appropriately typed columns, and indexing strategies should reflect the actual query workload.

Vector search and metadata filtering can then be combined for RAG-style retrieval.

The current AI-200 guide specifically includes schema modeling, data types, indexing strategies, vector similarity search, and metadata filters.

Question 12 — PostgreSQL Vector Workload

A PostgreSQL-based AI application performs vector searches against a large embedding dataset.

Performance analysis shows that vector operations consume substantial CPU.

The development team wants to reduce pgvector compute overhead.

Which area should they investigate?

A. Vector indexing and query strategy

B. Event Grid event filtering

C. Key Vault secret rotation

D. Container Apps revision traffic

Answer: A

Explanation

Vector indexing and query strategy are key factors in the computational cost of pgvector workloads.

An appropriate indexing strategy can reduce the amount of vector computation required for searches.

The AI-200 study guide specifically calls out optimizing query latency and reducing pgvector compute overhead.

Question 13 — PostgreSQL Resource Configuration

A vector-search workload is consistently CPU-bound.

The database contains enough storage, but vector searches are slow under concurrent load.

Which resource should the development team investigate first?

A. Event Grid retry count

B. Container image size

C. PostgreSQL compute and memory resources

D. Azure Key Vault SKU

Answer: C

Explanation

Vector workloads can be computationally intensive. If the workload is CPU-bound, database compute resources should be evaluated.

The AI-200 objectives specifically include configuring compute, memory, and storage resources to support PostgreSQL vector workloads.

Question 14 — Azure Managed Redis

An AI application stores frequently requested retrieval results in Azure Managed Redis.

A cached result should no longer be used after 10 minutes.

Which mechanism should the application use?

A. Cosmos DB change feed

B. Redis key expiration/TTL

C. PostgreSQL vector index

D. Event Grid retry policy

Answer: B

Explanation

Redis supports expiration through TTL semantics.

An application can assign an expiration time to cached data so that stale entries are automatically removed or become unavailable after the specified period.

Caching, expiration, and invalidation are explicitly part of the AI-200 Azure Managed Redis objectives.

Question 15 — Multiple Answers: AI Data Services

A RAG application uses Azure data services.

Which two practices are appropriate?

A. Use vector similarity search for semantic retrieval.

B. Use metadata filtering to restrict candidate records.

C. Treat vector similarity as an authorization mechanism.

D. Store secrets directly in vector metadata.

Answers: A, B

Explanation

Vector similarity is appropriate for semantic retrieval, while metadata filtering can constrain retrieval to relevant records such as a tenant, document type, or access scope.

Vector similarity alone should not be treated as an authorization mechanism. Secrets also shouldn’t be embedded into searchable metadata.

The current AI-200 objectives explicitly include vector similarity search, semantic retrieval, and RAG patterns with metadata filtering.

Section 3 — Connect to and Consume Azure Services

Question 16 — Service Bus Messaging Architecture

An AI application processes financial documents.

Each submitted document must be processed by exactly one available worker. The system may have several worker instances running simultaneously.

If a worker fails while processing a message, the system needs the message to become available for processing again according to Service Bus messaging semantics.

Which messaging pattern is most appropriate?

A. A Service Bus queue with competing consumers

B. An Event Grid topic with three identical subscriptions

C. A Redis cache

D. A Cosmos DB vector index

Answer: A

Explanation

A Service Bus queue can support competing consumers, allowing multiple worker instances to process messages from the same queue.

This differs from a topic with multiple subscriptions, where each subscription receives its own copy of published messages.

Service Bus queues, messages, and dead-letter handling are part of the AI-200 objectives.

Question 17 — Dead-Letter Handling

A Service Bus message has repeatedly failed processing.

The development team does not want the same malformed message to continue consuming normal processing resources.

What should happen to the message?

A. It should be placed in a dead-letter queue according to the configured dead-lettering behavior.

B. It should automatically become a Cosmos DB vector.

C. It should be moved to Azure App Configuration.

D. It should be converted into an Event Grid subscription.

Answer: A

Explanation

Service Bus provides dead-letter queues for messages that cannot be successfully processed or meet configured dead-letter conditions.

Dead-lettering separates problematic messages from normal processing so they can be inspected, repaired, or handled separately.

Dead-letter queue handling is explicitly identified in the AI-200 study guide.

Question 18 — Event Grid vs. Service Bus

An AI system publishes the event:

DocumentAnalysisCompleted

Multiple independent applications need to react to the event.

One application updates analytics, another sends notifications, and another updates a search index.

The publisher should not need to know which applications consume the event.

Which service is the best fit?

A. Azure Service Bus queue

B. Azure Key Vault

C. Azure Event Grid

D. Azure Managed Redis

Answer: C

Explanation

Event Grid is designed for event-driven architectures in which publishers emit events and independent subscribers react to them.

Custom events, filtering, and retries are among the Event Grid capabilities identified in the AI-200 objectives.

Question 19 — Event Grid Filtering

An Event Grid custom topic receives:

DocumentUploaded
DocumentAnalyzed
DocumentRejected

A subscriber should receive only:

DocumentRejected

What should you configure?

A. A Redis TTL

B. An Event Grid event subscription filter

C. A Service Bus dead-letter queue

D. A Cosmos DB indexing policy

Answer: B

Explanation

Event Grid event subscriptions can filter events so that subscribers receive only the events relevant to them.

This prevents every subscriber from having to receive and discard unrelated events.

Filtering is explicitly included in the AI-200 Event Grid objectives.

Question 20 — Azure Functions Binding Design

An HTTP-triggered Azure Function receives a document-processing request.

The function should place a message onto a Service Bus queue without requiring the developer to manually create and manage the Service Bus client in the function’s application logic.

Which capability should the developer consider?

A. A Service Bus output binding

B. An Event Grid retry policy

C. A Cosmos DB vector index

D. An AKS manifest

Answer: A

Explanation

Azure Functions bindings provide declarative integration with external services.

An output binding can allow a function to write to a Service Bus queue without requiring the application code to manually implement all of the messaging client plumbing.

The AI-200 objectives specifically include Functions triggers and bindings.

Question 21 — Functions Trigger Selection

A serverless AI backend must execute whenever a message arrives in a Service Bus queue.

Which trigger should be selected?

A. HTTP trigger

B. Timer trigger

C. Service Bus trigger

D. Cosmos DB output binding

Answer: C

Explanation

A Service Bus trigger causes an Azure Function to execute when the associated Service Bus messaging event occurs.

The distinction is important:

• Trigger → initiates function execution.
• Binding → provides an input/output connection to another service.

Azure Functions triggers and bindings are explicitly part of the AI-200 objectives.

Question 22 — Multiple Answers

An application uses Azure Event Grid for an event-driven workflow.

Which two capabilities can be used to make the workflow more resilient and selective?

A. Event filtering

B. Event delivery retries

C. PostgreSQL pgvector indexes

D. Container Apps revisions

Answers: A, B

Explanation

Event filtering prevents irrelevant events from being delivered to a subscriber.

Retry behavior allows Event Grid to attempt delivery again when a subscriber endpoint temporarily fails.

Both are specifically included in the AI-200 Event Grid objectives.

Question 23 — Fill in the Blank

Complete the statement:

In Azure Functions, a __________ initiates function execution, while a binding provides a declarative connection to input or output data.

Answer: trigger

Explanation

A trigger defines the event that causes a function to execute.

For example, an HTTP trigger can execute a function when an HTTP request arrives, while a Service Bus trigger can execute a function when a message becomes available.

Bindings provide connections to external services and data.

This distinction is fundamental to the Functions portion of AI-200.

Section 4 — Secure, Monitor, and Troubleshoot Azure Solutions

Question 24 — Key Vault Security

An application retrieves an API key from Azure Key Vault.

The development team wants the application to access the secret without embedding a permanent credential for Key Vault inside the application source code.

Which approach is most appropriate?

A. Store the Key Vault credential in the container image.

B. Store the credential in the Git repository.

C. Use an appropriate Azure identity-based authentication mechanism and grant the application the required Key Vault permissions.

D. Put the credential in an Event Grid event.

Answer: C

Explanation

The goal is to avoid introducing another hard-coded secret while accessing Key Vault.

An Azure-hosted application can use an appropriate managed identity or other supported identity mechanism, with permissions scoped to the required Key Vault operations.

The AI-200 security objectives include secure secret storage, retrieval, and rotation using Key Vault.

Question 25 — Key Vault vs. App Configuration

A development team identifies the following values:

MaxRetries = 5
EnableNewRAGPipeline = true
ModelDeployment = "production"
DatabasePassword = "..."
ExternalApiKey = "..."

Which design is most appropriate?

A. Store all five values in Key Vault.

B. Store all five values in App Configuration.

C. Store non-sensitive configuration in App Configuration and sensitive values in Key Vault.

D. Store all five values in Redis.

Answer: C

Explanation

App Configuration is designed for application settings and configuration values.

Key Vault is designed for secrets such as passwords and API keys.

The distinction is important because configuration management and secret management serve different purposes.

Microsoft explicitly identifies both Key Vault and App Configuration in the AI-200 security objectives.

Question 26 — Secret Rotation

A security policy requires an AI service API key to be rotated periodically.

The application should always retrieve the current valid value rather than requiring a code deployment whenever the key changes.

Which architecture is most appropriate?

A. Hard-code the key in the application.

B. Store the key in Key Vault and retrieve it at runtime using an appropriate identity.

C. Put the key into an Event Grid event.

D. Bake the key into the Docker image during the build.

Answer: B

Explanation

Key Vault provides secure storage and retrieval of secrets and supports secret lifecycle management.

Separating the secret from the application binary/container image allows the secret to be rotated independently of application deployment.

Secret rotation and retrieval are explicitly listed in the AI-200 objectives.

Question 27 — OpenTelemetry Troubleshooting

A distributed AI application produces the following trace:

HTTP request                  4.8 seconds
 ├── API processing           150 ms
 ├── Cosmos DB query          120 ms
 ├── PostgreSQL query         210 ms
 └── AI inference service     4.1 seconds

Which conclusion is best supported by this telemetry?

A. The container image is too large.

B. Cosmos DB indexing is necessarily incorrect.

C. Service Bus dead-lettering is causing the latency.

D. The AI inference service is the dominant contributor to request latency.

Answer: D

Explanation

The trace shows approximately 4.1 seconds of the 4.8-second request duration being spent in the AI inference service.

Distributed traces are particularly valuable because they expose timing across service boundaries and help isolate latency contributors.

OpenTelemetry distributed tracing is explicitly part of the AI-200 monitoring objectives.

Question 28 — KQL

You are analyzing an application telemetry table called AppRequests.

You need to calculate the average request duration by five-minute interval during the last hour.

Which query is the most appropriate?

A.

AppRequests
| where TimeGenerated > ago(1h)
| summarize avg(DurationMs) by bin(TimeGenerated, 5m)

B.

AppRequests
| top 5 by DurationMs

C.

AppRequests
| project DurationMs

D.

AppRequests
| where DurationMs > 5000

Answer: A

Explanation

The query needs three operations:

1. Restrict the time range to one hour.
2. Group records into five-minute intervals.
3. Calculate the average duration within each interval.

bin(TimeGenerated, 5m) creates the required time buckets, and avg(DurationMs) calculates the average duration.

KQL analysis of logs and metrics is explicitly included in the AI-200 objectives.

Question 29 — Multiple Answers: Telemetry

A distributed AI application is experiencing intermittent latency.

Which two telemetry approaches would provide the most useful information for diagnosing the problem?

A. Distributed traces showing individual request paths

B. Metrics showing aggregate latency/request behavior

C. Container registry repository names

D. Docker image tags

Answers: A, B

Explanation

Distributed traces can show where individual requests spend time across service boundaries.

Metrics provide aggregate information about application behavior, such as latency, request rate, and error rates.

Image tags and registry repository names are useful deployment metadata but aren’t substitutes for runtime telemetry.

OpenTelemetry instrumentation and telemetry analysis are explicitly included in the current AI-200 study guide.

Question 30 — Comprehensive Scenario

A company operates an AI document-processing platform:

                ┌───────────────────────┐
                │   HTTP API            │
                │   Azure Functions     │
                └───────────┬───────────┘
                            │
                            ▼
                    Azure Service Bus
                            │
                            ▼
                Containerized processor
                            │
              ┌─────────────┴─────────────┐
              ▼                           ▼
       Cosmos DB                      PostgreSQL
       documents                     vector search
              │
              ▼
        Embedding data

The application has recently experienced intermittent failures.

The team observes:

• The HTTP API responds quickly.
• Service Bus message counts occasionally increase significantly.
• Container processor CPU usage is low.
• PostgreSQL latency remains normal.
• Distributed traces show that some messages wait several minutes before processing begins.
• The application currently scales the processor based primarily on CPU utilization.

What should the team implement to address the primary bottleneck?

A. Increase PostgreSQL compute.

B. Increase Cosmos DB consistency.

C. Implement event-driven scaling for the container processor based on the messaging workload.

D. Increase OpenTelemetry sampling.

Answer: C

Explanation

The most important clues are:

• Service Bus backlog increases.
• CPU remains low.
• Messages wait before processing.
• The current scaling strategy is CPU-oriented.

The processor therefore isn’t scaling in response to the actual workload.

For a containerized application running in Azure Container Apps, KEDA-based event-driven scaling can scale replicas according to an external event source or workload metric.

Increasing PostgreSQL resources would not address the observed queue backlog because PostgreSQL latency is normal.

OpenTelemetry has already provided useful diagnostic information, but increasing sampling would not resolve the scaling problem.

This question combines the AI-200 containerization, messaging, monitoring, and troubleshooting objectives and represents the type of cross-topic reasoning expected from an experienced Azure developer.

Go to the AI-200 Exam Prep Hub main page