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: Container Apps Revision Strategy

A company hosts an AI inference API in Azure Container Apps.

The current production revision is v17. A new revision, v18, contains a significant change to the inference pipeline.

The development team wants to:

deploy v18 without immediately sending all users to it,
send 5% of production traffic to v18,
monitor the new revision,
increase traffic gradually,
immediately return traffic to v17 if errors increase.

No changes should be made to the container image itself.

Which approach should you use?

A. Configure a KEDA scaler to maintain 5% of replicas on v18.

B. Create a new Container Apps revision and use revision traffic splitting.

C. Create a new ACR repository for v18 and configure both repositories as application replicas.

D. Deploy v18 as an AKS Deployment and use a Service to distribute traffic.

Answer: B

Explanation

Container Apps revisions are designed for versioned application deployments. Multiple revisions can coexist, and traffic can be assigned between revisions.

KEDA controls scaling, not deployment traffic percentages. ACR repositories store images, while moving the workload to AKS would introduce an unnecessary architecture change.

A particularly important distinction for AI-200 is:

Revision management controls application versions and traffic; KEDA controls scaling.

The current study guide explicitly calls out Container Apps environments, revision management, and KEDA event-driven scaling.

Question 2 — Scenario: ACR Image Lifecycle

A company has an ACR repository containing:

			
ai-api:1.0
ai-api:1.1
ai-api:1.2
ai-api:latest

Production deployments must always use an immutable version rather than a mutable tag such as latest.

The deployment pipeline should also be able to identify exactly which image version was deployed.

Which approach is best?

A. Deploy ai-api:latest and record the deployment timestamp.

B. Deploy ai-api:1.2 and use immutable image identification such as its digest for deployment traceability.

C. Rebuild the image every time the application starts.

D. Store the Dockerfile in Azure Key Vault and rebuild the image during deployment.

Answer: B

Explanation

A versioned tag is preferable to latest for predictable deployments, and an image digest provides stronger immutability because it identifies the exact image content.

Using latest makes it possible for the same deployment configuration to resolve to different image content later.

The question tests the distinction between image versioning and mutable deployment references, both relevant to the ACR portion of AI-200. The study guide explicitly includes generating, storing, versioning, and managing container images in ACR.

Question 3 — Scenario: KEDA Scaling

An AI document-processing application runs in Azure Container Apps.

The application consumes messages from a queue.

During peak periods:

			
Queue messages:      18,000
CPU utilization:       22%
Memory utilization:    31%
Application replicas:    2

Messages are waiting several minutes before being processed.

The application currently scales based only on CPU utilization.

What should you change?

A. Increase the CPU limit for each replica.

B. Configure KEDA-based event-driven scaling using the queue workload.

C. Configure a Container Apps revision with 100% traffic.

D. Move the queue data into ACR.

Answer: B

Explanation

CPU is not the appropriate workload signal here. The actual bottleneck is the growing queue.

KEDA allows Container Apps to scale according to an external event source, making it appropriate for queue-driven workloads.

This is exactly the type of diagnostic reasoning that AI-200 expects: identify the workload signal rather than automatically scaling based on CPU.

The current Microsoft objectives explicitly identify KEDA event-driven scaling in Container Apps.

Question 4 — Matching: Container Deployment Concepts

Match each requirement to the most appropriate capability.

Requirement	Capability
1. Automatically build an image from source code changes	A. Container Apps revision
2. Run multiple versions of an application simultaneously	B. KEDA
3. Scale based on an external event source	C. ACR Task
4. Define Kubernetes resources declaratively	D. Kubernetes manifest

Answers

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

Explanation

ACR Tasks → automated image building.
Container Apps revisions → versioned application deployments.
KEDA → event-driven scaling.
Kubernetes manifests → declarative AKS resource configuration.

These distinctions are explicitly reflected in the current AI-200 containerization objectives.

Question 5 — Scenario: AKS Connectivity

An AI service is deployed to AKS.

The following observations have been made:

The Deployment reports the expected number of replicas.
Pods are in Running state.
Application logs show successful startup.
Requests through the application’s public endpoint fail.
Direct requests from within the pod to the application port succeed.

What should you investigate next?

A. The container registry’s image retention policy.

B. The Kubernetes Service, Ingress, selectors, and port mappings.

C. The application’s vector index.

D. The PostgreSQL connection pool.

Answer: B

Explanation

The evidence isolates the problem:

			
Container starts       ✓
Application responds   ✓
External access        ✗

Therefore, the next layer to investigate is the connectivity path between the external endpoint and the pod.

Important areas include:

Service selectors
Service ports
target ports
Ingress configuration
ingress controller
routing/network configuration

The AI-200 study guide specifically calls for troubleshooting AKS and Container Apps by inspecting logs, events, and end-to-end connectivity.

Question 6 — Multiple Answers

A team wants to deploy the same containerized AI API to three environments:

			
Development
Test
Production

Which two practices are appropriate?

A. Build separate images solely because environment configuration differs.

B. Externalize environment-specific configuration.

C. Use environment variables/application settings where appropriate.

D. Embed production secrets in the Dockerfile.

Answers: B, C

Explanation

The same image should generally be reusable across environments.

Environment-specific configuration should be supplied externally, such as through application settings/environment variables or appropriate configuration services.

Production secrets should never be embedded in the image.

Microsoft explicitly includes configuring App Service to provide environment variables and secrets in the AI-200 objectives.

Question 7 — Scenario: AKS vs. Container Apps

A company is building an AI platform with these requirements:

Kubernetes manifests must be used.
The team needs direct access to Kubernetes resources.
Several specialized Kubernetes controllers will be installed.
The team already has substantial Kubernetes operational expertise.
Developers need Kubernetes-native workload configuration.

Which service should be selected?

A. Azure Container Apps

B. Azure App Service

C. Azure Functions

D. Azure Kubernetes Service

Answer: D

Explanation

The requirements explicitly depend on Kubernetes-native capabilities.

AKS is therefore the appropriate choice.

Container Apps provides a managed container application platform, but it intentionally abstracts away much of Kubernetes. When direct Kubernetes control is a requirement, AKS is the better fit.

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

Section 2 — Develop AI Solutions Using Azure Data Management Services

Question 8 — Cosmos DB Partitioning Scenario

An Azure Cosmos DB for NoSQL container stores documents for millions of customers.

The current partition key is:

/documentType

There are only a few document types, and one type contains approximately 80% of all documents.

The application experiences uneven request distribution and a heavily utilized partition.

What is the most likely underlying issue?

A. The partition key has poor cardinality and creates a hot partition.

B. The consistency level is necessarily too strong.

C. The vector embeddings are too large.

D. The container requires an Event Grid subscription.

Answer: A

Explanation

A good partition key should help distribute data and workload across logical partitions.

Using a low-cardinality property where one value dominates can result in uneven distribution and a hot partition.

This question is deliberately more architectural than simply asking which Cosmos DB query syntax to use.

Question 9 — Cosmos DB Query Optimization

A Cosmos DB query is:

			
SELECT *
FROM c
WHERE c.tenantId = @tenantId
  AND c.status = "Active"
  AND c.createdDate >= @date
ORDER BY c.createdDate DESC

		

The query executes frequently and consumes more RUs than expected.

The development team wants to investigate whether the indexing strategy matches the query workload.

What should they do?

A. Disable all indexing.

B. Examine the indexing policy and query characteristics, and optimize indexes for the actual query patterns.

C. Change the database to PostgreSQL.

D. Replace the query with an Event Grid event.

Answer: B

Explanation

Cosmos DB indexing is automatic by default, but indexing policies can be customized.

For performance-sensitive workloads, developers should understand which properties are being filtered/sorted and ensure that indexing aligns with query patterns rather than assuming that more indexing is always better.

Microsoft specifically identifies optimizing query performance and RU consumption through indexing policies and consistency levels.

Question 10 — Cosmos DB Change Feed Scenario

A document is inserted into Cosmos DB.

The application must automatically:

Detect the new document.
Generate an embedding.
Store the embedding.
Update a downstream search representation.

The application should not repeatedly query the entire container looking for new documents.

Which capability should be used?

A. Cosmos DB change feed processor

B. Cosmos DB strong consistency

C. Cosmos DB composite index

D. Redis expiration

Answer: A

Explanation

The change feed provides a mechanism for detecting changes to items.

A change feed processor can consume changes and drive downstream processing such as:

			
New document
     ↓
Change feed
     ↓
Embedding generation
     ↓
Vector storage

		

This is explicitly part of the AI-200 Cosmos DB objectives.

Question 11 — PostgreSQL Connection Optimization

An AI application creates a new PostgreSQL connection for every individual database operation.

Under heavy load, the application experiences:

high connection counts,
increased connection latency,
reduced throughput.

The database itself isn’t CPU-bound.

What should the developer investigate?

A. Connection pooling and connection reuse.

B. Increasing vector dimensionality.

C. Event Grid event filtering.

D. Cosmos DB consistency.

Answer: A

Explanation

Creating and tearing down database connections repeatedly introduces overhead.

Connection pooling and connection reuse can reduce connection establishment overhead and improve throughput and latency.

The current AI-200 study guide explicitly includes connection optimization to improve throughput and reduce latency for PostgreSQL.

Question 12 — PostgreSQL Vector Search

A RAG application stores:

			
document_id
tenant_id
document_type
content
embedding

		

Users should only retrieve documents belonging to their tenant.

The application needs semantic similarity retrieval.

Which approach should be implemented?

A. Search only on content.

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

C. Use PostgreSQL connection pooling as the security boundary.

D. Use vector similarity scores as authorization decisions.

Answer: B

Explanation

Vector similarity identifies semantically relevant content.

Metadata filtering constrains the candidate set:

			
Tenant filter
     ↓
Eligible documents
     ↓
Vector similarity
     ↓
Relevant chunks

		

The vector similarity score itself should not be treated as an authorization mechanism.

The AI-200 study guide explicitly includes vector similarity, semantic retrieval, RAG, and metadata filtering.

Question 13 — PostgreSQL Vector Performance

A PostgreSQL database contains millions of embeddings.

Vector searches are accurate but increasingly slow.

Telemetry shows that CPU usage is very high during vector searches, while storage I/O remains relatively low.

Which two areas should be investigated first?

A. Vector indexing strategy.

B. pgvector query strategy.

C. Event Grid retry policy.

D. Azure Key Vault secret expiration.

Answers: A, B

Explanation

High CPU during vector similarity operations points toward the computational cost of vector search.

The developer should investigate:

the vector indexing strategy,
the query plan,
pgvector configuration,
similarity-search approach,
filtering strategy.

Microsoft explicitly identifies optimizing vector-search latency and reducing pgvector compute overhead.

Question 14 — Azure Managed Redis

An AI application uses Azure Managed Redis to cache generated answers.

The application has this requirement:

If a cached answer becomes stale, the application must not continue serving it indefinitely.

Which Redis capability directly addresses this requirement?

A. Event Grid filtering

B. Key expiration/TTL

C. Cosmos DB change feed

D. PostgreSQL pgvector

Answer: B

Explanation

Redis key expiration allows a key to automatically expire after a specified interval.

For example:

			
Cache answer
     ↓
TTL = 10 minutes
     ↓
Entry expires
     ↓
Application regenerates/retrieves result

		

The AI-200 objectives explicitly include Redis caching, expiration, and invalidation.

Question 15 — Multiple Answers: Data-Service Architecture

An AI application must support:

semantic retrieval,
frequently accessed results,
relational metadata,
millions of vector embeddings.

Which two architectural choices are reasonable?

A. PostgreSQL with pgvector can provide relational data plus vector search.

B. Redis can be used for caching frequently accessed results.

C. Key Vault should be used as the primary vector database.

D. Event Grid should replace the relational database.

Answers: A, B

Explanation

PostgreSQL with pgvector can combine relational modeling and vector search.

Azure Managed Redis can provide low-latency caching and vector-related capabilities.

Key Vault is a secret-management service, not a general-purpose vector database, and Event Grid is an event-routing service.

The current AI-200 course explicitly identifies PostgreSQL with pgvector and Azure Managed Redis as AI-oriented data services.

Section 3 — Connect to and Consume Azure Services

Question 16 — Service Bus Topic Architecture

An application publishes:

InvoiceProcessed

Three independent systems need to receive every event:

			
Billing Analytics
Notification Service
Audit Service

The publisher should publish the event once without knowing which consumers exist.

Which Service Bus configuration is most appropriate?

A. One queue with three consumers

B. One topic with a subscription for each consumer

C. Three queues populated manually by the publisher

D. One Redis key per consumer

Answer: B

Explanation

A Service Bus topic provides publish/subscribe semantics.

Each subscription receives its own copy of messages published to the topic.

Conceptually:

                  Topic
                    │
        ┌───────────┼───────────┐
        ▼           ▼           ▼
   Billing       Notify       Audit
 subscription  subscription subscription

Queues are more appropriate for competing consumers where a message should normally be processed by one consumer.

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

Question 17 — Service Bus Message Processing

A Service Bus worker receives a message and begins processing it.

The worker crashes before successfully completing the message operation.

What is the primary purpose of Service Bus message settlement/lock semantics in this situation?

A. To allow the message to be considered successfully processed without any acknowledgment.

B. To help prevent concurrent processing and allow unsuccessful processing to be retried according to the messaging semantics.

C. To convert the message into a vector embedding.

D. To permanently delete the message when the worker crashes.

Answer: B

Explanation

Service Bus supports message-lock and settlement concepts that help coordinate message processing.

A message isn’t simply considered successfully completed because a consumer received it.

If processing fails and the message isn’t successfully completed, it can become available for redelivery according to the applicable Service Bus behavior.

This is an important distinction between receiving and successfully completing a message.

Question 18 — Service Bus Dead-Letter Scenario

An AI processing service repeatedly receives a malformed message.

The message cannot be processed successfully.

The operations team wants failed messages separated from the normal processing path so that developers can inspect them later.

What should the application use?

A. Dead-letter queue

B. Redis cache

C. Event Grid custom event

D. Cosmos DB vector index

Answer: A

Explanation

The Service Bus dead-letter queue provides a dedicated location for messages that cannot be processed successfully or meet configured dead-lettering conditions.

It prevents a permanently problematic message from continuously interfering with normal processing.

Dead-letter queue management is explicitly included in AI-200.

Question 19 — Event Grid Filtering

A custom Event Grid topic receives:

			
DocumentUploaded
DocumentClassified
DocumentRejected
DocumentArchived

A subscriber is responsible only for rejected documents.

Which configuration minimizes unnecessary event delivery?

A. Increase the subscriber’s CPU.

B. Configure event subscription filtering.

C. Put all events into a Redis cache.

D. Use a Service Bus dead-letter queue.

Answer: B

Explanation

Event Grid subscription filters allow a subscriber to receive only events matching specified criteria.

Filtering is preferable to delivering every event and forcing the subscriber application to discard unwanted events.

Event filtering, custom events, and retries are explicitly listed in the current AI-200 objectives.

Question 20 — Event Grid Retry Scenario

An Event Grid subscriber is temporarily unavailable.

The publisher should not have to implement its own polling loop to repeatedly check whether the subscriber has recovered.

Which capability should be relied upon?

A. Event Grid retry behavior

B. Redis TTL

C. Cosmos DB consistency

D. AKS Horizontal Pod Autoscaler

Answer: A

Explanation

Event Grid provides delivery retry behavior for events that cannot initially be delivered successfully.

The purpose is to make event delivery more resilient to temporary endpoint failures.

Retry behavior is specifically included in the AI-200 Event Grid objectives.

Question 21 — Azure Functions Binding

A Function receives an HTTP request containing a document ID.

The Function must write a message to an Azure Service Bus queue.

The developer wants to use Azure Functions integration rather than manually implementing all of the Service Bus client code.

Which capability should be used?

A. HTTP trigger only

B. Service Bus output binding

C. Cosmos DB change feed

D. Event Grid event filter

Answer: B

Explanation

The HTTP trigger initiates function execution.

A Service Bus output binding can connect the function to the queue for output.

This illustrates the important distinction:

			
Trigger  → causes execution
Binding  → connects execution to data/services

Microsoft explicitly includes Functions triggers and bindings in the AI-200 objectives.

Question 22 — Fill in the Blank

Complete the statement:

An Azure Functions __________ determines what event or condition causes a function to execute.

Answer: trigger

Explanation

Examples include:

HTTP trigger
Service Bus trigger
Timer trigger
Event-based triggers supported by Functions

A binding is different: it provides a declarative connection to input or output data.

Question 23 — Scenario: Choosing Between Service Bus and Event Grid

An AI platform has these two requirements:

Requirement A

A document-processing job must be placed into a durable work queue. Multiple worker instances should compete for available jobs.

Requirement B

When processing completes, multiple independent systems should be notified that the document is complete.

Which design is best?

A. Event Grid for A and Redis for B

B. Service Bus queue for A and Event Grid for B

C. Redis queue for A and Cosmos DB change feed for B

D. Event Grid for both A and B

Answer: B

Explanation

Requirement A is a work-queue scenario:

Jobs → Service Bus queue → competing workers

Requirement B is an event notification/pub-sub scenario:

Processing complete → Event Grid → multiple subscribers

The distinction between messaging and event notification is important.

Microsoft’s AI-200 course specifically teaches both message-based and event-driven architectures using Service Bus and Event Grid.

Section 4 — Secure, Monitor, and Troubleshoot Azure Solutions

Question 24 — Key Vault and Application Identity

An Azure-hosted Function needs to retrieve a database password from Key Vault.

The security team prohibits storing a Key Vault credential in source code, configuration files, or the container image.

Which solution is most appropriate?

A. Embed the Key Vault credential in the Function package.

B. Store the password in App Configuration as plaintext.

C. Use an appropriate managed identity for the Function and grant it the required Key Vault access.

D. Put the password in an Event Grid event.

Answer: C

Explanation

A managed identity allows an Azure resource to authenticate to supported Azure services without the application having to maintain a long-lived credential for that identity.

Key Vault then remains responsible for storing the actual secret.

This follows the principle:

			
Application identity
        ↓
Key Vault authorization
        ↓
Secret retrieval

		

The AI-200 objectives explicitly include securing, rotating, and retrieving secrets using Key Vault.

Question 25 — App Configuration vs. Key Vault

An application has the following settings:

			
Feature:EnableSemanticCache = true
Feature:UseNewModel = false
AI:DeploymentName = gpt-production
Database:ConnectionPassword = ********

The team wants centralized configuration management while keeping secrets securely managed.

Which design is most appropriate?

A. Put all values in Key Vault.

B. Put all values in App Configuration.

C. Put non-secret configuration in App Configuration and secrets in Key Vault.

D. Put all values in environment variables inside the Docker image.

Answer: C

Explanation

App Configuration is intended for centralized application configuration.

Key Vault is intended for sensitive secrets.

Therefore:

			
App Configuration
 ├── feature flags/settings
 ├── deployment names
 └── other non-secret configuration
Key Vault
 └── passwords/API keys/secrets

		

The AI-200 study guide explicitly distinguishes the two capabilities.

Question 26 — Secret Rotation

A production AI service uses an API key stored in Key Vault.

The security team rotates the key regularly.

The development team wants the application to obtain the current secret without rebuilding or redeploying the container every time the key changes.

What design best meets the requirement?

A. Store the secret in the Dockerfile.

B. Store the secret in source control.

C. Retrieve the secret from Key Vault at runtime.

D. Put the secret into the container image during every deployment.

Answer: C

Explanation

Runtime retrieval separates the secret lifecycle from the application deployment lifecycle.

The container image remains unchanged while the secret can be rotated independently.

This is exactly the type of secret-management pattern targeted by AI-200.

Question 27 — OpenTelemetry Trace Analysis

An application exposes an HTTP endpoint.

A trace shows:

			
HTTP request                         6,250 ms
│
├── Function execution                120 ms
├── Service Bus send                   35 ms
├── PostgreSQL query                   95 ms
├── Cosmos DB query                    80 ms
└── External AI service             5,820 ms

		

The development team wants to reduce the endpoint’s response time.

What should they investigate first?

A. The external AI service call.

B. The Cosmos DB indexing policy.

C. The Service Bus queue’s dead-letter count.

D. The Docker image tag.

Answer: A

Explanation

The external AI service accounts for approximately 5.8 seconds of the 6.25-second request.

The trace therefore provides strong evidence that this dependency is the dominant contributor.

This is precisely why distributed tracing is valuable: it lets developers identify where time is being spent across service boundaries.

The AI-200 study guide specifically requires distributed tracing using OpenTelemetry SDKs.

Question 28 — KQL Interpretation

You have an AppRequests telemetry table containing:

			
TimeGenerated
DurationMs
Success

You need to identify the five-minute intervals during the last 30 minutes with the highest average request duration.

Which query is most appropriate?

			
AppRequests
| where TimeGenerated > ago(30m)
| summarize AvgDuration = avg(DurationMs)
    by bin(TimeGenerated, 5m)
| top 6 by AvgDuration desc

		

			
AppRequests
| top 6 by DurationMs

			
AppRequests
| summarize count() by Success

			
AppRequests
| project TimeGenerated, DurationMs

Answer: A

Explanation

The requirement is to:

Restrict data to the last 30 minutes.
Group records into five-minute buckets.
Calculate average duration for each bucket.
Return the highest averages.

The query accomplishes all four.

Key KQL operators:

where → filters records.
bin() → creates time intervals.
summarize → aggregates.
avg() → calculates the average.
top → returns the highest values.

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

Question 29 — Multiple Answers: Troubleshooting

An AI application intermittently experiences slow requests.

Which two forms of telemetry would provide complementary information when diagnosing the problem?

A. Distributed traces showing the path and timing of individual requests.

B. Aggregate metrics showing latency, throughput, and error trends.

C. ACR image tags alone.

D. Dockerfile comments.

Answers: A, B

Explanation

Distributed traces answer questions such as:

“Where did this individual request spend its time?”

Metrics answer questions such as:

“Is latency increasing across the application?”

Using both provides a much stronger diagnostic picture than either alone.

OpenTelemetry distributed tracing and KQL-based analysis of logs and metrics are explicit AI-200 objectives.

Question 30 — Comprehensive Final Scenario

You are troubleshooting an AI document-processing platform:

                   HTTP API
                      │
                      ▼
              Azure Service Bus
                      │
                      ▼
             Azure Container Apps
                      │
             ┌────────┴────────┐
             ▼                 ▼
        Cosmos DB          PostgreSQL

The operations team reports:

HTTP requests remain fast.
The Service Bus queue backlog increases dramatically during peak periods.
Container Apps CPU averages only 25%.
Container Apps memory averages 35%.
PostgreSQL latency remains normal.
Cosmos DB RU consumption remains normal.
Distributed traces show that once processing begins, each document is processed normally.
The application currently uses CPU-based scaling for Container Apps.

The company wants to minimize processing delay while avoiding unnecessary compute costs.

Which two actions should you take?

A. Configure KEDA event-driven scaling based on the queue workload.

B. Increase PostgreSQL compute capacity.

C. Investigate the queue backlog as the workload signal and tune scaling thresholds accordingly.

D. Increase Cosmos DB consistency to Strong.

Answers: A, C

Explanation

The evidence strongly indicates a scaling-signal problem.

The important observations are:

			
Queue backlog       HIGH
CPU                 LOW
Memory              LOW
Database latency    NORMAL
Processing time     NORMAL

		

The processor is healthy once it receives work, but insufficient replicas are being created while work is waiting in the queue.

Therefore:

Use KEDA event-driven scaling based on the queue.
Tune the scaling configuration around the actual workload signal.

Increasing PostgreSQL capacity or Cosmos DB consistency would not address the observed bottleneck.

This scenario combines several AI-200 competencies:

Container Apps
KEDA
Service Bus
scalability
telemetry
troubleshooting
architecture reasoning

The current study guide specifically identifies KEDA scaling and troubleshooting using logs, events, and end-to-end connectivity.

Go to the AI-200 Exam Prep Hub main page