AI-200 Study Guide 2026: Build One Project Across All 4 Domains

The Direct Answer: Prepare by Building a Back-End System, Not Memorizing an AI Glossary

The most efficient way to prepare for AI-200 is to build one small Azure back-end application, then deliberately modify it until you have exercised every bullet in Microsoft's four-domain outline. AI-200 is the exam for the Microsoft Certified: Azure AI Cloud Developer Associate credential. The official certification page gives candidates 120 minutes and lists four assessed areas. Microsoft does not publish a fixed AI-200 question count. The official AI-200 study guide says a scaled score of 700 or greater is required to pass.

Those facts matter because several third-party guides still quote 100 minutes, invent a 40–60-question range, or present extra study categories as though they were official domains. Build your plan from Microsoft's current four domains:

AI-200 practice questionsPractice questions with detailed explanations

The Capstone: A Semantic Support Knowledge API

Build a Python back end that accepts support documents, stores their text and embeddings, retrieves semantically similar material, and returns ranked results. Ingestion runs asynchronously. Configuration and secrets stay outside the image. Every request and background operation emits trace data that you can query.

The first version can be intentionally small:

1. A containerized API accepts a query vector and metadata filters.
2. A data layer stores documents and vectors and performs similarity search.
3. A Service Bus queue carries ingestion work to a background processor.
4. Event Grid publishes a document-updated event to another handler.
5. Key Vault stores secrets; App Configuration stores non-secret settings.
6. OpenTelemetry traces the API, queue processing, data query, and response.
7. Logs and metrics are investigated with KQL.

You do not need production volume or a polished user interface. The value is in producing evidence: deployment commands, configuration files, query plans, trace IDs, failed-message handling, and short decision notes. Microsoft describes the target candidate as a developer working across requirements, design, development, deployment, security, and monitoring, with an emphasis on back-end components. A capstone that crosses those boundaries is closer to the official role than isolated flashcard memorization.

Phase 1: Containerize and Deploy the Same API Three Ways

The container domain is not simply "know Docker." Microsoft's blueprint names Azure Container Registry (ACR), ACR Tasks, App Service, Azure Container Apps, KEDA, and Azure Kubernetes Service (AKS). Your lab should force you to compare them.

Build and version the image in ACR

Create a minimal Python API, containerize it, and push versioned images to ACR. Then use ACR Tasks to build and run images. Keep a short record of image tags, the source revision that produced each tag, and how you would prevent a deployment from silently pulling an unintended image. The objective is to understand image lifecycle, not merely complete one successful push.

Deploy to App Service

Deploy the container to Azure App Service and configure environment variables and secret references through the hosting configuration rather than baking them into the image. Prove that the same image behaves differently when configuration changes. Deliberately remove one required setting, observe the failure, and document where you found the evidence.

Deploy to Azure Container Apps

Move the image to Azure Container Apps, configure the environment and app settings, and create a new revision after changing a response field. Split or move traffic between revisions, and then roll back. Add event-driven scaling with KEDA using a queue signal. Test scale-to-zero and a burst of queued work. Record the relationship among the Container Apps environment, app, revision, replica, and scaling rule.

Deploy a variant to AKS

Use manifest files to deploy the same API or worker to AKS. The official outline expects deployment and management by manifests, plus troubleshooting through logs, events, and end-to-end connectivity. Break one image reference, configuration value, or service connection on purpose. Use pod status, events, logs, and network checks to isolate the fault.

Your completion evidence for this phase is not three screenshots. It is a comparison table: where configuration lives, how revisions or rollouts work, what triggers scale, and which diagnostic evidence reveals a bad image, unhealthy replica, or connection failure.

Phase 2: Implement All Three Official AI Data Paths

Data management is the largest published domain at 25–30%. Do not choose only your favorite database. Microsoft's outline explicitly covers Azure Cosmos DB for NoSQL, Azure Database for PostgreSQL, and Azure Managed Redis. Build a thin working path in all three, then compare their controls.

Cosmos DB for NoSQL

Use the SDK to create or read items and run queries. Store an embedding with document metadata and execute vector similarity search for semantic retrieval. Add a metadata filter so that a query can be restricted to a product, region, or access group.

Then measure Request Unit consumption. Change an indexing policy or consistency choice and record the effect on query behavior and cost. The study goal is not to memorize that indexes improve performance; it is to explain which fields and query shapes your policy supports, what the consistency setting changes, and why an apparently correct query may consume more RUs than expected.

Finally, implement a change feed processor that reacts to a new or updated document. Make the handler safe to retry, and record what happens when processing fails after the item change is visible.

Azure Database for PostgreSQL with pgvector

Create a schema for documents, embeddings, and metadata. Query it through a supported SDK or database driver, enable vector similarity search, and compare at least two index or query strategies. Use metadata filtering in a retrieval-augmented-generation-style lookup even if the lab stops at returning ranked context instead of calling a model.

Experiment with connection pooling or another connection-optimization control. Explain how schema types, index choice, compute, memory, storage, and connection behavior interact with latency and throughput. The official domain asks for both vector retrieval and operational optimization; a successful SELECT alone is not sufficient evidence.

Azure Managed Redis

Use Azure Managed Redis first as a cache. Implement a key, expiration policy, cache hit, cache miss, and invalidation path after a document update. Then create a small vector index and run similarity search. State when the cache may serve stale data and how the application repairs that state.

Finish the phase with a decision matrix. Compare Cosmos DB, PostgreSQL with pgvector, and Azure Managed Redis on data model, persistence role, vector indexing, metadata filters, performance controls, and invalidation or update behavior. AI-200 questions can describe requirements without naming the service; your preparation should make the service choice defensible from those requirements.

Phase 3: Make Ingestion Event-Driven

The official integration domain is narrower than a general Azure messaging survey. It names Azure Service Bus, Azure Event Grid, and Azure Functions. Build one workflow that makes their responsibilities visible.

Service Bus for durable back-end work

Send a document-ingestion command to a Service Bus queue. Process it with a worker and route repeatedly failing messages to the dead-letter queue. Then change the design to a topic with two subscriptions—for example, one subscription updates the search store while another records an audit event.

Document the difference between a message, queue, topic, subscription, retry, and dead-letter handling. Include a recovery exercise: inspect a failed message, correct the cause, and decide whether to resubmit it.

Event Grid for event notifications

Publish a custom document-updated event and subscribe a handler. Add a filter so only selected event types or subjects reach that handler. Create a temporary failure and observe retry behavior. Write down why this event is a notification about something that happened, while the Service Bus message represents work that must be processed.

Azure Functions for triggers, bindings, and serverless APIs

Implement one Function triggered by a message or event and another HTTP-triggered Function as a small serverless API. Configure and deploy the Function App, keeping environment-specific settings outside the code. Be able to trace which trigger starts execution, which bindings move data, and which settings are required at deployment and runtime.

A useful readiness test is to read a requirement and choose among a Service Bus queue, Service Bus topic, Event Grid subscription, and Function trigger before touching the portal. Then defend the choice in one sentence using delivery, routing, filtering, retry, and consumer requirements.

Phase 4: Secure Configuration and Trace the Entire Request

The fourth domain publishes four concrete skill groups: Key Vault, Azure App Configuration, OpenTelemetry, and KQL. Treat them as one operating workflow rather than a final security checklist.

Store a database secret or other sensitive value in Azure Key Vault and retrieve it at runtime. Exercise rotation by changing the value and confirming the application can use the updated secret without rebuilding its container. Put a non-secret feature flag, endpoint choice, or retrieval threshold in Azure App Configuration. Explain why configuration and secrets have different handling requirements.

Instrument the API and workers with OpenTelemetry. Carry trace context from the incoming request through queue or event processing and into the data call. Your goal is to find one trace that connects the user request, asynchronous handler, query, and final result—or to explain precisely where context propagation broke.

Generate a controlled slow request and a controlled failure. Write KQL queries that locate the relevant logs or metrics, narrow by operation or correlation identifier, and compare successful with failed executions. Keep the queries in your study repository. If you cannot move from a symptom to the responsible component, the lab is not finished.

A Six-Week Study Schedule Built Around Evidence

Microsoft's AI-200T00-A course is a five-day intermediate course, but Microsoft does not prescribe one universal self-study duration. The schedule below is an OpenExamPrep recommendation for a working developer with Azure fundamentals, not an official requirement. Increase the setup time if Python, containers, or Azure administration is new to you.

AI-200 practice bankPractice questions with detailed explanations

What Not to Put in Your AI-200 Blueprint

Microsoft says the bullets under each measured skill illustrate how that skill is assessed and that related topics may appear. That does not authorize a prep guide to replace the published outline with speculative domains. Keep these boundaries clear:

• There are four published domains, not six.
• Microsoft gives 120 minutes, not 100 minutes.
• Microsoft does not publish a fixed question count for AI-200. A third-party estimate is not an official exam fact.
• The four weights come from the current study guide; do not redistribute them according to the number of pages in a course or question bank.
• Related services in Microsoft documentation can support learning, but the detailed skills-measured bullets should control your coverage checklist.
• The official certification page currently says a Microsoft Practice Assessment is not yet available. Recheck that page because Microsoft says availability can change after an exam leaves beta and becomes generally available.

This discipline prevents two opposite mistakes: spending weeks on attractive Azure AI topics that are not in the measured bullets, and studying only the domain headings while missing the configuration and troubleshooting verbs beneath them.

AI-200 Readiness Checklist

You are ready to move from learning to final review when you can produce all of the following without a tutorial open:

• Build, run, and version images with ACR and ACR Tasks, and explain App Service, Container Apps, and AKS deployment differences.
• Manage Container Apps revisions, configure a KEDA scaling rule, and troubleshoot a failed container from logs, events, and connectivity evidence.
• Query Cosmos DB with the SDK, reason about RUs, indexing, and consistency, run vector search, and explain a change feed processor.
• Model and query vectors in PostgreSQL, choose an indexing approach, use metadata filters, and reason about resource and connection optimization.
• Implement Redis cache expiration and invalidation, then distinguish that operation from Redis vector indexing.
• Choose correctly among Service Bus queues, topics, subscriptions, dead-letter handling, Event Grid filters and retries, and Functions triggers and bindings.
• Rotate a Key Vault secret, change a non-secret value in App Configuration, follow an OpenTelemetry trace, and write a KQL investigation.
• Complete fresh mixed questions while explaining why every rejected option fails the stated requirement.

Do not convert a practice percentage into an official pass guarantee. Use stable performance plus complete lab evidence as your readiness bar. Microsoft uses scaled scoring and requires 700 or greater, but practice-question percentages are not an official conversion to that scale.

Exam-Day Facts to Verify

Before scheduling, return to the official certification page. It currently lists 120 minutes, English as the offered exam language, Pearson VUE scheduling, and regional pricing. It warns candidates that the proctored assessment may include interactive components and links to the exam sandbox for interface practice. Microsoft strongly recommends scheduling with a personal Microsoft account because records associated with an organizational account can be lost when a candidate leaves that organization.

Check the live page again near your date because exam delivery details and practice-assessment availability can change. For content coverage, use the official study guide as the source of truth, then use your capstone evidence and AI-200 flashcards to close specific recall gaps. Your final step should be a fresh mixed set, a review of every missed decision, and a quick walk through the Microsoft exam sandbox—not another unbounded tour of Azure services.

Official Sources

• Microsoft Certified: Azure AI Cloud Developer Associate
• Study guide for Exam AI-200
• Course AI-200T00-A: Develop AI cloud solutions on Azure