How to Prepare & Pass Microsoft AI-200

AI-200 - Microsoft Certified: Azure AI Cloud Developer Associate

 

Basic Info: 

Official Link: MicrosoftCertified: Azure AI Cloud Developer Associate - Certifications | MicrosoftLearn

Here you can check syllabus, all important things related to AI-200 & schedule the exam. 

 

Idea about Exam Syllabus: 

1. Develop containerized solutions on Azure

20–25% · Images, containers, deployment, scaling, networking, AKS.

Think: Where does my application run, and how does it scale?

 

2. Develop AI solutions using Azure data management services

25–30% · Cosmos DB, PostgreSQL + pgvector, Managed Redis.

Think: Where do I store, retrieve, search, and cache AI data?

 

3. Connect to and consume Azure services

20–25% · Service Bus, Event Grid, Azure Functions.

Think: How do applications communicate and trigger work?

 

4. Secure, monitor, and troubleshoot Azure solutions

20–25% · Identity, Key Vault, App Configuration, Open Telemetry, Azure Monitor, KQL.

Think: How do I protect, observe, and diagnose the application?

 

Concept Notes about Syllabus:

Domain 1 — Develop containerized solutions on Azure

1.1 Container fundamentals

Concept	Short description	Exam trick
Container	Runs an application with its required dependencies in an isolated environment.	Same image can run in development, testing, and production.
Container image	Packaged, versioned blueprint used to create containers.	Image is the package; container is the running instance.
Dockerfile	Instructions for building an image.	Build instructions are not the same as a running container.
Container registry	Stores and distributes images.	ACR stores images; it does not run your application.
Repository and tag	Organize images and identify versions.	latest is just a tag; it is not guaranteed to mean the newest or safest image.
Image digest	Content-based identifier for a specific image artifact.	Prefer digest-based references when immutable image identification matters.
ACR Tasks	Builds or automates image workflows in Azure Container Registry.	Useful when builds should run in Azure without managing your own build machine.
Registry authentication	Grants a workload access to pull or push images.	For pulling private ACR images, check the correct identity and registry permissions.

 

1.2 Azure Container Apps

Concept	Short description	Exam trick
Container Apps environment	Shared boundary for related Container Apps and their networking/observability configuration.	Think of it as the environment hosting related apps.
Container App	Managed platform for containerized APIs, web apps, and workers.	Choose it when you want containers without managing Kubernetes directly.
Revision	Immutable snapshot of an app configuration and template.	Configuration change or new image can create a new revision.
Replica	Running instance of a revision.	Revision = version; replica = running copy.
Single revision mode	Traffic transitions between revisions as the new revision becomes ready.	Best when you don't need to operate multiple revisions concurrently.
Multiple revision mode	Lets you keep revisions active and control traffic between them.	Use for canary testing, gradual rollout, and rollback strategies.
Traffic splitting	Distributes requests across active revisions.	Example: 90% old version, 10% new version.
Ingress	Controls how requests reach the application.	External = public entry point; internal = private entry point within the supported network scope.
Target port	Port on which the application listens inside its container.	A mismatch can make a deployed app unreachable.
Environment variables	Provide runtime configuration to the application.	Different environments can use the same image with different settings.
Secrets	Store sensitive configuration for app consumption.	Do not hardcode secrets into source code or Docker images.
Managed identity	Lets a workload authenticate to supported Azure services without storing its own credentials.	Identity provides authentication; permissions still need to be granted.
KEDA scaling	Event-driven scaling based on supported external or internal signals.	Queue backlog → KEDA-based worker scaling.
HTTP scaling	Scales based on incoming HTTP workload and configured rules.	Web/API traffic → HTTP scaling may be appropriate.
Scale to zero	Allows replicas to reduce to zero when configured conditions permit.	Saves resources, but a new request/event may incur startup latency.
Container Apps Jobs	Runs finite tasks to completion.	Scheduled report or one-time batch → Job; continuously serving requests → app.
Dapr	Adds distributed-application capabilities through APIs and components.	Service invocation, pub/sub, state management, bindings; it is not a replacement for all Azure services.
Monitoring and logs	Help inspect runtime behavior, failures, and events.	A running container does not automatically mean the application is healthy.

Container Apps: high-value exam traps

• New version with controlled rollout: revisions and traffic splitting.
• Variable queue workload: KEDA scaling.
• Run a task at a specific time: scheduled Container Apps Job.
• Public frontend with private backend: configure ingress appropriately for each app.
• Application listens on port 8080 but ingress targets 80: check target-port configuration and the actual listening port.
• Secret retrieval returns 403: check identity permissions and networking, not just whether the identity exists.
• New revision fails: inspect the new revision's logs, configuration, image, port, and dependencies.

 

1.3 Azure App Service and AKS

Concept	Short description	Exam trick
App Service	Managed platform for web apps and APIs, including supported custom containers.	Conventional web app/API with minimal infrastructure management → consider App Service.
App Service configuration	Runtime settings, environment variables, and deployment configuration.	Keep environment-specific settings outside the image.
AKS	Azure Kubernetes Service for Kubernetes-based orchestration.	Choose when Kubernetes control, advanced orchestration, or ecosystem compatibility is required.
Cluster / node	Cluster is the Kubernetes environment; nodes provide compute capacity.	If Pods cannot schedule, check available node capacity and resource requests.
Pod	Smallest Kubernetes deployable unit; contains one or more containers.	Troubleshoot the Pod before assuming the entire cluster is broken.
Deployment	Manages desired Pod replicas and rolling updates.	Wrong replica count or rollout state → inspect Deployment.
Service	Provides stable networking to selected Pods.	Pods change; Service provides a stable endpoint.
Ingress	Routes incoming HTTP/HTTPS traffic to Services.	App runs but URL is unreachable → inspect Ingress, Service, selectors, and ports.
ConfigMap	Stores non-sensitive Kubernetes configuration.	Ordinary configuration → ConfigMap; sensitive values require appropriate secret handling.
Kubernetes Secret	Holds sensitive configuration such as credentials.	Do not assume stored Secrets are automatically encrypted or securely accessible in every setup.
ImagePullBackOff	Kubernetes repeatedly fails to pull an image.	Check image name/tag, registry authentication, ACR permissions, and network.
CrashLoopBackOff	Container repeatedly starts and crashes.	Check application logs, startup command, configuration, and dependencies.
Pending Pod	Pod cannot yet be scheduled or started.	Check resource requests, node capacity, constraints, and scheduling events.
Liveness probe	Checks whether the container should be restarted.	Persistent liveness failure can trigger restart.
Readiness probe	Checks whether the Pod should receive normal traffic.	Failed readiness removes the Pod from ready Service endpoints; it does not normally restart it.
Startup probe	Allows slow-starting applications time to initialize.	Use to protect slow startup from premature liveness failures.
CPU/memory requests	Declare resources used for scheduling decisions.	Requests influence placement and capacity calculations.
CPU/memory limits	Restrict resource usage.	CPU can be throttled; memory-limit exceedance can lead to OOM termination.
HPA	Horizontal Pod Autoscaler changes Pod replica count.	More application instances → HPA.
Cluster Autoscaler	Adjusts the number of cluster nodes when its conditions are met.	More compute nodes → Cluster Autoscaler.

Choose the right hosting service

• ACR: store container images.
• App Service: managed web app/API hosting.
• Container Apps: managed containers, event scaling, revisions, and jobs.
• AKS: Kubernetes orchestration and advanced control.

 

Domain 2 — Develop AI solutions using Azure data management services

This domain has the largest exam weighting: 25–30%. Focus especially on selecting the correct database, partitioning, vector search, consistency, and caching.

 

2.1 Azure Cosmos DB for NoSQL

Concept	Short description	Exam trick
Account → Database → Container → Item	Logical hierarchy for NoSQL data.	Container holds JSON-like items.
Partition key	Determines how items are distributed across logical partitions.	Choose based on access patterns and data distribution; avoid hot partitions.
High-cardinality key	A key with many distinct values.	Often helps distribute load, but does not guarantee good partitioning.
Request Units (RUs)	Measure the resources consumed by database operations.	Expensive query or write → examine RU consumption.
Provisioned throughput	Reserves throughput capacity, commonly measured in RU/s.	Sustained demand beyond available throughput can cause throttling.
HTTP 429	Request throttling.	Check RU/s, query efficiency, and retry behavior; do not assume the database is unavailable.
Point read	Retrieves one item using its ID and partition key.	Known ID + partition key → point read is often the efficient choice.
Cross-partition query	Query that needs to search across partitions.	Missing partition-key filter can increase cost.
Indexing policy	Controls which JSON paths are indexed.	Indexes can improve query performance but add write and storage overhead.
Consistency levels	Control how recent and consistent reads are across replicas.	Select the weakest consistency level that satisfies the application's requirements.
Session consistency	Provides session-level read-your-writes guarantees.	Useful when a user should see their own recent changes.
Change Feed	Exposes changes to items for downstream processing.	React to data changes → Change Feed; retrieve current matching data → query.
Change Feed Processor	Coordinates change processing across workers, commonly using a lease container.	For distributed processing, consider checkpointing, leases, and idempotent handlers.
Vector search	Retrieves semantically similar items using embeddings.	RAG retrieval → embeddings + vector similarity + relevant context.
Metadata filtering	Restricts retrieval by attributes such as category or tenant.	Use filters when semantic similarity alone is insufficient.
Hybrid search	Combines vector similarity with keyword-based retrieval.	Useful when both semantic meaning and exact terms matter.

 

Cosmos DB consistency: memory trick

Think from strongest to weakest consistency guarantees:

• Strong: strongest consistency guarantee.
• Bounded staleness: reads may lag within configured bounds.
• Session: useful session-level guarantees, including read-your-writes.
• Consistent prefix: updates are observed in order, without guaranteeing the latest write.
• Eventual: replicas converge when updates stop, without a guarantee of immediate freshness.

Exam trap: Session consistency is not the same as globally strong consistency.

Exam trick: RAG supplies relevant external context to an LLM; it does not automatically retrain or change the model's weights.

 

2.2 Azure Database for PostgreSQL + pgvector

Concept	Short description	Exam trick
PostgreSQL	Managed relational database service.	Structured entities, transactions, joins, and relational constraints → PostgreSQL.
Table / row / column	Relational data organization.	Use SQL for relational queries.
Npgsql	Common .NET data provider for PostgreSQL.	.NET application connecting to PostgreSQL → Npgsql is a key name to recognize.
Connection pooling	Reuses database connections rather than creating one for every operation.	Helps connection overhead; it does not increase database CPU capacity.
pgvector	PostgreSQL extension for storing and searching vector embeddings.	Relational data + semantic similarity search → PostgreSQL + pgvector is a strong fit.
Embedding dimensions	Number of values in a vector.	Query and stored vectors must have compatible dimensions.
Cosine similarity	Compares vector direction/orientation.	Often used for semantic similarity; understand whether the implementation reports similarity or distance.
Euclidean distance	Measures straight-line distance between vectors.	Lower distance generally means closer vectors under this metric.
Inner product	Measures a vector dot product.	Interpretation depends on vector normalization and the search implementation.
ANN search	Approximate nearest-neighbor retrieval.	Can improve search speed at the cost of some retrieval accuracy.
Metadata filtering	Restricts vector results to eligible records.	Important for tenant boundaries, categories, and business constraints.

Exam trap: PostgreSQL + pgvector is not a separate Azure database product. pgvector adds vector capabilities to PostgreSQL.

 

2.3 Azure Managed Redis

Concept	Short description	Exam trick
In-memory cache	Stores frequently accessed data for low-latency retrieval.	Reduce repeated database reads and response time → consider Redis.
Cache hit	Requested value exists in cache.	Return the cached value when valid.
Cache miss	Requested value is absent.	Fetch from the source database and populate the cache.
Cache-aside	Application checks the cache first, then reads and updates it on a miss.	The application controls the cache flow.
TTL	Time to live; controls when cached data expires.	Helps limit how long old data remains cached.
Cache invalidation	Removes or refreshes stale cached values.	Data changes in the source → consider invalidation or refresh.
Redis vector search	Supported Redis capabilities can index and search vectors.	Redis may support vector retrieval, but choose based on persistence, query, and application needs.
Source of truth	The authoritative data store.	Do not treat an ordinary cache as the authoritative database by default.

 

Domain 3 — Connect to and consume Azure services

The central exam skill is distinguishing commands, events, and execution.

 

3.1 Azure Service Bus

Concept	Short description	Exam trick
Message broker	Reliably mediates asynchronous communication between applications.	Decouple a producer from a worker.
Queue	Holds messages for consumers to process.	A work item is typically processed by one competing consumer, subject to delivery and settlement semantics.
Topic	Routes published messages to subscriptions.	Several independent systems need the same message → topic + subscriptions.
Subscription	Independent message stream associated with a topic.	Each eligible subscription can receive its own copy.
Message settlement	Marks a message completed, abandoned, or otherwise handled.	Complete after successful processing, not before.
Retry / redelivery	Makes failed or unsettled messages available for another attempt.	Design for duplicate delivery; processing should be idempotent where needed.
Dead-letter queue (DLQ)	Holds messages that cannot be processed normally.	Repeated failures or poison messages → inspect DLQ and failure reason.
Duplicate detection	Helps filter duplicate sends within configured conditions.	Do not assume it makes every business operation exactly-once.
Sessions	Group and order related messages under session semantics.	Ordered processing of related messages → consider sessions.

 

3.2 Azure Event Grid

Concept	Short description	Exam trick
Event	Notification that something happened.	“A blob was uploaded” is an event.
Event source	Resource or application that emits events.	Identify where the event originates.
Event subscription	Specifies which events go to which handler and under what filters.	Route selected event types to the correct consumer.
Event handler	Receives and processes events.	Azure Functions and supported webhooks are common handlers.
Event filtering	Limits delivery based on event type, subject, or supported properties.	Reduce unnecessary event processing.
Custom topic	Supports events emitted by your own application or domain.	Use when publishing custom business events.
Retry and dead-lettering	Handle delivery failures according to configured behavior.	Event delivery is not proof that business processing completed successfully.

 

3.3 Azure Functions

Concept	Short description	Exam trick
Function	A unit of code executed in response to a trigger.	Use for event-driven or serverless tasks.
Function App	Hosting and configuration boundary for functions.	A Function App can contain multiple functions.
Trigger	Starts a function execution.	HTTP request, timer, Service Bus message, or Event Grid event.
Input binding	Supplies data to a function.	Retrieves or exposes input using a supported binding.
Output binding	Sends data to a supported destination.	Can simplify integration; direct SDK code is also possible.
Durable Functions	Adds stateful orchestration patterns for supported function workloads.	Multi-step workflows, coordination, and durable waiting → consider Durable Functions.
Managed identity	Authenticates the function to supported Azure services without embedded credentials.	Identity alone does not grant the required permissions.

Exam traps

• Multiple independent consumers need copies of events → Event Grid subscriptions or Service Bus topic subscriptions, depending on the delivery and processing requirements.
• Reliable asynchronous business work → Service Bus is often the better fit.
• Run code on a timer → Azure Functions timer trigger or an appropriate scheduled job.
• Event notification does not itself guarantee that downstream business work has completed.
• A queue consumer may receive a message more than once; make critical operations safe to retry.

 

Domain 4 — Secure, monitor, and troubleshoot Azure solutions

This domain combines security, configuration, telemetry, monitoring, and root-cause troubleshooting. Exam questions often describe a failure and ask for the most appropriate next step.

 

4.1 Azure Key Vault

Concept	Short description	Exam trick
Secrets	Stores passwords, API keys, tokens, and connection strings.	Sensitive application value → Key Vault.
Keys	Cryptographic keys used for encryption, signing, and related operations.	Encryption/signing requirement → keys.
Certificates	Manages supported certificates and related lifecycle operations.	TLS certificate requirement → certificates.
Managed identity	Provides workload identity without embedding credentials.	Avoid storing service-principal passwords in code.
Authorization	Controls what an identity may do.	Identity exists ≠ permission to read secrets.
Secret versioning	Maintains versions of secret values.	New version may not automatically refresh a running app.
Rotation	Replaces credentials or cryptographic material under a planned process.	Update dependent systems and refresh consumers; changing Key Vault alone may be insufficient.
Access troubleshooting	Checks identity, role or access policy, network access, and secret status.	A 403 is a clue to investigate authorization or network restrictions.

Remember the flow: application → authenticate using identity → Key Vault authorizes access → application retrieves the secret.

 

4.2 Azure App Configuration

Concept	Short description	Exam trick
Centralized configuration	Stores shared, generally non-sensitive application settings.	Manage settings across environments without rebuilding the image.
Labels	Distinguish configuration values, often by environment or version.	A label does not automatically detect the environment or enforce security.
Feature flags	Control whether functionality is enabled.	Enable or disable a feature without a full redeployment when the app supports refreshing the flag.
Dynamic refresh	Updates configuration consumed by running applications.	Refresh is not necessarily instantaneous across all instances.
Key Vault references	Allow configuration to reference a secret stored in Key Vault.	The secret value belongs in Key Vault, not as a plain-text App Configuration setting.

Key Vault vs App Configuration

• Password or API key → Key Vault.
• Feature flag or non-sensitive application setting → App Configuration.
• Runtime environment-specific value → environment configuration, often supplied through the hosting platform.
• Credential-free Azure service authentication → Managed Identity.

 

4.3 Identity, RBAC, and network security

Concept	Short description	Exam trick
Authentication	Establishes who or what is making a request.	“Who are you?”
Authorization	Determines what the identity can access or do.	“What are you allowed to do?”
Azure RBAC	Assigns roles to principals at defined scopes.	Apply least privilege at the appropriate scope.
Management-plane permissions	Control resource management operations.	Permission to manage a resource does not automatically mean permission to read its data.
Data-plane permissions	Control access to service data.	Reading Key Vault secrets requires the appropriate data access permission.
System-assigned identity	Identity associated with one Azure resource's lifecycle.	It is generally removed with its associated resource.
User-assigned identity	Separate identity resource that can be assigned to supported workloads.	Useful when identity lifecycle should be independent or shared.
Private Endpoint	Provides private connectivity to a supported service.	Private networking does not automatically grant authorization.
Network restrictions	Control permitted network paths to a resource.	Correct identity and role may still fail if network access is blocked.
Least privilege	Grants only the access needed for the task.	Avoid broad roles when a narrower role works.

Troubleshooting status codes: quick clues

Symptom	First things to investigate
401 Unauthorized	Missing, invalid, or expired credentials/token; authentication configuration.
403 Forbidden	Role or permission, wrong identity, access policy, or network restrictions.
Timeout	DNS, routing, firewall, private endpoint configuration, or service responsiveness.
404 Not Found	Wrong resource, endpoint, path, or resource state.
Key Vault access denied	Confirm the identity actually used by the workload, its data permissions, and network access.

These are diagnostic clues, not absolute rules: inspect the service's detailed error and logs.

4.4 OpenTelemetry distributed tracing

Concept	Short description	Exam trick
OpenTelemetry (OTel)	Vendor-neutral framework for generating, collecting, and exporting telemetry.	OTel is not itself a monitoring dashboard or database.
Trace	Represents a request's journey through one or more services.	Follow one slow request end-to-end.
Span	Represents one operation within a trace.	A database call or HTTP request can be a span.
Trace ID	Identifies the overall trace.	Related spans in the same trace share the trace ID.
Span ID	Identifies an individual span.	Different spans normally have different span IDs.
Parent-child relationship	Shows how operations relate within a trace.	Helps identify which operation called a slow dependency.
Context propagation	Carries trace context between services.	Disconnected traces across services → check propagation and instrumentation.
Attributes and events	Add contextual metadata or timestamped events to spans.	Useful for filtering and explaining a request's behavior.
Automatic instrumentation	Instruments supported libraries and frameworks with limited code changes.	Good starting point for common .NET HTTP and dependency telemetry.
Manual instrumentation	Adds spans around custom application operations.	Use for business steps that automatic instrumentation cannot describe adequately.
OpenTelemetry Collector	Receives, processes, and exports telemetry when included in the architecture.	Useful for centralized processing and routing.
Sampling	Controls which traces are retained or processed.	Missing traces may be due to sampling, not necessarily a broken app.

Trace vs logs vs metrics

• Trace: What happened during this specific request?
• Log: What event or error occurred?
• Metric: How much CPU, latency, or error rate is observed over time?

 

4.5 Azure Monitor, Application Insights, and Log Analytics

Concept	Short description	Exam trick
Azure Monitor	Broad Azure monitoring platform.	Think platform for collecting, analyzing, and acting on telemetry.
Application Insights	Application performance monitoring and application telemetry.	Investigate requests, dependencies, exceptions, and application behavior.
Log Analytics workspace	Stores and queries supported log data using KQL.	Run log queries here.
Azure Monitor Metrics	Numeric time-series measurements.	CPU percentage, request count, or latency trends → metrics.
Alerts	Evaluate conditions and trigger actions or notifications.	Select the alert type based on the signal and condition.
Metric alert	Evaluates a metric condition.	CPU above a threshold → metric alert.
Log alert	Evaluates a log query condition.	More than 20 failed requests within a window → query-based alert.
Diagnostic settings	Route supported resource logs and metrics to configured destinations.	Missing resource logs → verify diagnostic settings, destination, permissions, and ingestion.
Retention and ingestion	Affect how long data is available and may affect cost.	More telemetry is not always better; balance diagnostic value and cost.

 

4.6 Kusto Query Language (KQL)

KQL is used to query supported log tables. The exam may test query reading, filtering, aggregation, and troubleshooting logic.

Operator / function	Meaning	Memory trick
where	Filters rows by a condition.	Which records do I want?
project	Selects columns.	Which fields do I want to see?
extend	Adds a calculated column.	Create a derived value.
summarize	Aggregates or groups records.	Count or calculate averages by category.
count	Counts rows.	How many records?
order by / sort by	Sorts results.	Newest or slowest first.
top / take	Limits the result set.	Return fewer rows.
join	Combines related tabular results.	Correlate data from multiple tables.
ago()	Calculates a time relative to the current time.	ago(1h) means one hour ago.
bin()	Buckets values, often timestamps, into intervals.	Trend errors or latency over time bins.

 

KQL exam patterns

Requirement	Think of
Filter errors	where
Display only a few fields	project
Count errors by code	summarize count() by ResultCode
Find average duration by operation	summarize avg(DurationMs) by Name
Show latest failures	order by TimeGenerated desc
Group errors into five-minute intervals	bin(TimeGenerated, 5m)
Investigate a specific request across services	Distributed trace and correlated telemetry
Investigate CPU growth	Metrics first; use logs and traces for supporting evidence

 

 

Final exam tricks — memorize these comparisons

These are the distinctions that are easy to confuse in scenario-based questions.

If the question says…	Think…
Store and distribute container images	Azure Container Registry (ACR)
Managed hosting for a conventional web app	Azure App Service
Managed containers, revisions, event scaling	Azure Container Apps
Kubernetes orchestration and advanced control	AKS
Run a finite scheduled or event-triggered container task	Container Apps Jobs
Scale container workers from a queue backlog	KEDA
Retrieve one Cosmos DB item using ID and partition key	Point read
Store NoSQL JSON items and distribute them by partition key	Cosmos DB for NoSQL
Relational data plus vector similarity search	PostgreSQL + pgvector
Cache frequently accessed data	Azure Managed Redis
Deliver asynchronous business work	Service Bus
Notify several subscribers that something happened	Event Grid
Execute code in response to an event or timer	Azure Functions
Store credentials, API keys, or certificates	Key Vault
Centralize non-sensitive settings and feature flags	App Configuration
Let an Azure workload authenticate without embedded credentials	Managed Identity
Control access to Azure resources or data	Appropriate RBAC role/permissions
Trace a request across multiple services	OpenTelemetry distributed tracing
Query and aggregate logs	KQL in a supported log workspace
Alert when CPU exceeds a threshold	Metric alert
Alert based on a query's result	Log alert
Find why a request is slow	Trace and dependency telemetry
Pod keeps restarting	Liveness status, container logs, startup configuration
Pod runs but is not receiving traffic	Readiness, Service selectors, endpoints, ports, and Ingress
Pod cannot pull an image	Image reference, registry permissions, network
Pod cannot be scheduled	Resource requests, node capacity, scheduling constraints

Exam MCQ Preparation: 

The videos below will help you prepare for real exam MCQ 

Video Playlist Link:

https://www.youtube.com/playlist?list=PLTDeuHAjikIw

https://www.youtube.com/playlist?list=PL_HS7IsXErLYwyDVfiU_dtWt2mldzPV-s

Exam Tricks: 

Watch for Extreme Words

Often wrong answers contain:

• Always
• Never
• Only
• Must

Example:

❌ "You must retrain the model every day."

Too absolute.

More likely:

✅ "Monitor performance and retrain when needed."

Exam Questions:

In 2 Sections = Practical + Case Study 

We have total 49 Practical + 5 Case studies MCQ questions. 

Toal Time:  1 hour 40 Min 

Pass Criteria:  Min 700 score required 

Note: Once you submit Practical MCQ section then you cannot review again its move to Case study section. 

Hope this material will help you to prepare Microsoft AI-200 Certification. First please schedule the exam before 1 month then start your preparation. 

Best Luck ... Share your valuable feedback in comments... 

Thank You!