Microsoft AI-900 to AI-901 Azure AI Fundamentals Readiness Matrix: Diagnose Your Weakest Areas for the Current Exam

 

Microsoft retired AI-900 on June 30, 2026, so a current Azure AI Fundamentals readiness plan must target AI-901 rather than treat AI-900 as a schedulable exam. The good news for people who began with AI-900 material is that several fundamentals remain useful: responsible AI, recognizing AI workloads, text and speech concepts, computer vision, and generative AI. The important change is that the current AI-901 blueprint places much more emphasis on implementing lightweight AI solutions with Microsoft Foundry. Microsoft lists two top-level skill groups: identify AI concepts and capabilities at 40–45%, and implement AI solutions by using Microsoft Foundry at 55–60%.

That shift changes what “ready” means. Recognition-level knowledge is no longer enough. You should be able to move from a scenario to an appropriate AI workload or model, then demonstrate basic implementation judgment: prompts, model deployment, Foundry interactions, lightweight SDK applications, single-agent solutions, text and speech work, multimodal vision, image generation, and information extraction. Microsoft also expects foundational Python syntax and programming techniques plus familiarity with Azure resources.

Use this readiness matrix to diagnose gaps before spending more time on material you already know. Score each area by evidence, not confidence. If you can explain a topic but cannot perform the associated Foundry task, treat that as a real gap for the current exam.

The four-level readiness scale

Use four levels for every skill area.

Level 0 — unfamiliar. You cannot explain the concept or recognize the appropriate service, model, or workload without notes.

Level 1 — recognition. You can identify a term or choose the correct definition, but scenario changes make you uncertain. You may know that a capability exists without understanding when or how to use it.

Level 2 — applied understanding. You can explain why a solution fits a scenario, compare it with close alternatives, and complete a guided implementation with documentation or prompts.

Level 3 — exam ready. You can handle a new scenario, choose the right concept or Foundry workflow, complete a small implementation without step-by-step instructions, explain responsible-AI considerations, and troubleshoot a simple failure.

For AI-901, most blueprint items should reach Level 2 or Level 3. A candidate with many Level 1 items may feel familiar with the vocabulary while still being vulnerable to scenario and implementation questions.

Matrix area 1: responsible AI principles

The current blueprint explicitly includes fairness, reliability and safety, privacy and security, inclusiveness, transparency, and accountability. Do not memorize these as six disconnected definitions. Practice mapping each principle to a design decision.

A fairness scenario may involve a model that performs differently across demographic groups. Reliability and safety may involve failure modes, unsafe outputs, or a need for testing and guardrails. Privacy and security can involve sensitive training or prompt data, access control, and exposure of confidential information. Inclusiveness asks whether a system works for people with different abilities and contexts. Transparency concerns communicating limitations, model behavior, or AI involvement. Accountability concerns ownership, governance, review, and responsibility for outcomes.

Level 3 evidence: given a short AI scenario, you can identify the primary responsible-AI concern, explain why it matters, and name a practical mitigation without claiming that one principle makes all others irrelevant.

A useful self-test is to take one application—such as an AI recruiting assistant—and analyze it under all six principles. This prevents keyword matching. The same system can have fairness, privacy, transparency, and accountability risks at the same time.

Matrix area 2: how generative models work

You should understand generative AI at a conceptual level well enough to explain model input, tokens or representations at a high level, probabilistic generation, context, prompts, and why outputs can be fluent without being guaranteed facts. You do not need to become a machine-learning researcher, but you should not treat a model as a deterministic database.

Level 1 knowledge recognizes that generative models create new content. Level 2 distinguishes generation from retrieval and explains why prompt context influences output. Level 3 can reason about hallucination risk, grounding, evaluation, model capability, and why changing prompt structure or system instructions can change behavior.

Self-test: explain why a model can produce an incorrect answer even when its language sounds confident, and describe two ways an application designer can reduce the operational risk.

Matrix area 3: choosing an appropriate model

The blueprint asks candidates to identify an appropriate AI model based on capabilities. Readiness therefore requires more than knowing model names. Compare models by task fit, modality, capability, latency, cost, deployment availability, context needs, and operational constraints.

A text-only classification or summarization task may not require the same model as an application that must reason over images and text. An image-generation request requires a generative visual capability, while speech recognition converts spoken audio to text. Agentic workflows add tool use, state, or action-oriented behavior beyond a simple one-shot prompt.

Level 3 evidence: when shown three workload descriptions, you can choose a suitable capability class and explain why an alternative model type is unnecessary or incapable of meeting the requirement.

Matrix area 4: deployment options and model configuration

AI-901 includes model deployment and configuration judgment. You should understand that deploying a model makes it available to applications under a chosen deployment configuration and that parameters can influence response behavior. Avoid reducing preparation to memorizing a portal sequence.

Practice the questions an implementer asks: which model capability is required, where can it be deployed, what resource and access are needed, how will the application authenticate, and which generation settings affect output behavior? Understand that configuration choices involve trade-offs rather than universally “best” values.

Level 3 evidence: you can deploy a supported model in Microsoft Foundry in a practice environment, interact with it, change a relevant configuration parameter, observe the effect, and explain the result.

Matrix area 5: common AI workload identification

Microsoft currently expects recognition of generative and agentic AI, text analysis, speech, computer vision, and information extraction. Build a workload-classification table in your own words.

Generative AI creates or transforms content. Agentic AI can pursue goals by combining model reasoning with tools or actions. Text analysis includes tasks such as keyword extraction, entity detection, sentiment analysis, and summarization. Speech workloads include recognizing spoken language and synthesizing speech. Computer vision includes understanding visual input; image-generation models create new visuals. Information extraction pulls structured meaning from documents, forms, images, audio, or video.

Level 3 evidence: you can read a business request and classify the dominant workload without being distracted by industry context. “Extract invoice number, supplier, and total from scanned invoices” is fundamentally information extraction even though the input contains images and text.

Matrix area 6: text analysis techniques

Keyword extraction, entity detection, sentiment analysis, and summarization appear explicitly in the current skills list. Be able to separate them by output.

Keyword extraction identifies salient terms or phrases. Entity detection identifies people, organizations, locations, products, or other entity types. Sentiment analysis estimates opinion or emotional polarity. Summarization condenses content while preserving important information.

Level 3 evidence: given a customer-feedback workflow, you can decide whether it needs sentiment, key phrases, entities, summarization, or a combination, and explain what each output contributes.

A good implementation exercise is to run several different text samples through a lightweight text-analysis workflow and inspect how wording changes the output. Do not treat the exercise as proof that the model is always correct; use it to understand task behavior and limitations.

Matrix area 7: speech recognition and speech synthesis

Speech recognition converts spoken input into text or machine-usable representations. Speech synthesis produces spoken output from text or generated content. The exam may frame these capabilities inside a larger multimodal or conversational solution.

Level 2 readiness means you can distinguish input and output direction and identify appropriate use cases. Level 3 means you can build or exercise a small Foundry-related speech workflow, recognize where microphone/audio format or service configuration can fail, and explain how speech fits into an end-to-end application.

Self-test: design a kiosk that receives a spoken question and returns a spoken answer. Identify the speech-to-text step, the model interaction, and the text-to-speech step rather than calling the entire system “speech AI.”

Matrix area 8: computer vision and image generation

Computer vision can interpret visual inputs; image-generation models create visual outputs. AI-901 also includes multimodal models, so a scenario may combine visual understanding with text prompts.

Level 3 evidence: you can submit an image to a capable deployed model, ask a meaningful question about it, evaluate the response, and separately create a new visual output with an appropriate image-generation capability. You should understand that “analyze this image” and “generate an image” are different workload directions.

Practice describing risk as well as capability. Images can contain sensitive data, misleading context, or ambiguous content. Responsible use requires appropriate privacy, safety, and human-review decisions.

Matrix area 9: information extraction across document, image, audio, and video

The current blueprint explicitly includes extracting information from documents and forms, images, audio, and video by using Azure Content Understanding in Foundry Tools. This is a major signal for candidates transitioning from older AI-900 material: current readiness includes hands-on awareness of how unstructured multimodal content becomes structured information.

Level 1 recognizes the term. Level 2 can identify a scenario where structured extraction is preferable to free-form generation. Level 3 can run a small extraction workflow, inspect the output schema or fields, and explain how the extracted data could be validated before entering a business process.

Self-test: compare “summarize this contract” with “extract contract date, parties, renewal term, and governing law into fields.” Both use document content, but the second is an information-extraction requirement with structured output expectations.

Matrix area 10: effective system and user prompts

Prompt design is implementation work in AI-901. Understand the different purposes of system-level instructions and user prompts. A system instruction can establish role, behavior, constraints, or response policy; a user prompt supplies the immediate task or content.

Level 3 evidence: you can take a vague prompt, identify why its output is inconsistent, improve instructions and context, specify useful output structure, and test the result. You should also recognize that prompting is not a substitute for authorization, data governance, or deterministic validation when those are required.

Practice with controlled changes. Modify one prompt element at a time—role, context, examples, constraints, output format—and compare results. That teaches cause and effect rather than encouraging superstitious “magic prompt” memorization.

Matrix area 11: deploy and interact with a model in Foundry

This is one of the clearest implementation expectations in the current exam. You should be comfortable navigating from a Foundry project or relevant environment to a model deployment, testing interaction, and understanding the basic relationship among resource, deployment, endpoint or SDK use, and application.

Level 3 does not mean production-platform mastery. It means you can perform a basic deployment and interaction without following a screenshot-by-screenshot tutorial, and you can diagnose simple issues such as missing access, wrong deployment reference, unsupported model choice, or configuration mismatch.

If you only watched videos, score yourself no higher than Level 1. Hands-on evidence matters here.

Matrix area 12: build a lightweight chat client with the Foundry SDK

The blueprint explicitly calls for a lightweight chat client. That means foundational coding readiness matters. You should understand Python syntax well enough to initialize a client using the supported approach, provide authentication or endpoint configuration appropriately, send input, receive output, and handle the response.

Level 3 evidence: you can build a very small working client from a clean file, explain each major step, and make a simple change such as adding system instructions or processing a different user input. You do not need a large web application.

If basic Python variables, functions, imports, environment configuration, or response handling still feel unfamiliar, record that as a technical prerequisite gap rather than hiding it inside “AI study.”

Matrix area 13: create and test a single-agent solution

Agentic AI is part of the current workload scope, and the implementation domain includes creating and testing a single-agent solution in the Foundry portal plus creating a lightweight client application for an agent.

Understand the conceptual difference between a direct model call and an agent that can operate with instructions, tools or knowledge, and a task-oriented interaction pattern. Avoid assuming that every chatbot needs an agent. The architecture should fit the requirement.

Level 3 evidence: you can create a simple single agent, give it a narrow role, test how instructions influence behavior, and connect to it from a lightweight client. You should also be able to explain basic governance concerns when an agent can take actions or access tools.

Matrix area 14: text and speech implementations in Foundry

The current study guide asks for a lightweight application that includes text analysis, responding to spoken prompts using a deployed multimodal model, and building a lightweight application using Azure Speech in Foundry Tools.

Treat these as workflows, not isolated definitions. An application has input, service/model interaction, output, authentication, and error behavior. Level 3 readiness means you have exercised each workflow at least once and can recognize where the task belongs if the scenario changes.

A useful combined lab accepts a short text for analysis, then separately accepts spoken input and produces a response. Keep it small enough that networking or UI code does not become the learning objective.

Matrix area 15: multimodal visual implementation

AI-901 expects candidates to interpret visual input in prompts using a deployed multimodal model, create visual outputs using generative models, and build a lightweight application that includes vision capabilities.

Level 3 evidence: you can distinguish these three tasks and implement a minimal example of each. For visual interpretation, supply an image plus a question. For image generation, create a controlled prompt and evaluate whether the output fits the request. For an application, pass visual data through a simple client and handle the model response.

Your readiness check should include limitations. A model can misidentify ambiguous objects or infer unsupported details. An exam-ready candidate understands both capability and the need to evaluate outputs.

Matrix area 16: Content Understanding implementation

Information extraction is not only conceptual. The current guide expects using Content Understanding in Foundry Tools for documents/forms, images, audio, and video, plus building a lightweight application with information-extraction capabilities.

Level 3 evidence: you can take a small unstructured sample, define or use an extraction approach, run it, inspect structured results, and explain how an application would consume them. Then deliberately use a difficult sample—poor scan, missing field, noisy audio—and observe the need for validation.

The point is to understand the pipeline from unstructured input to structured output, not merely remember a product name.

Matrix area 17: Python and Azure foundations

Microsoft’s current audience profile explicitly expects knowledge of Python coding syntax and programming techniques and familiarity with Azure resources. These prerequisites can quietly become the largest readiness gap for someone who prepared for the older, more conceptual AI-900 experience.

Check whether you can read and modify basic Python code, work with imports, variables, functions, dictionaries or JSON-like structures, loops and conditions, exceptions at a basic level, environment variables, and SDK client patterns. On the Azure side, be comfortable with the idea of resources, resource groups, regions, access permissions, endpoints, and credentials.

Level 3 for a fundamentals exam is not advanced software engineering. It is enough practical fluency that basic code and resource interactions do not obscure the AI concept being tested.

Build your weighted readiness score

Do not average every row equally. The blueprint gives 55–60% to Foundry implementation and 40–45% to concepts/capabilities. Weight your diagnostic accordingly.

One simple method is to give concept rows 45 points total and implementation rows 55 points total, then distribute points within each group. Convert Level 0 to 0%, Level 1 to 35%, Level 2 to 70%, and Level 3 to 100% of the row’s points. The exact percentages are not official; they are a study tool that prevents a strong conceptual score from hiding a weak implementation score.

More important than the final number is the shape of the gaps. A candidate at Level 3 on responsible AI and workload identification but Level 0–1 on Foundry deployment, SDK work, agents, and Content Understanding is not ready for the current blueprint despite strong legacy AI-900 knowledge.

Diagnose by evidence type

For every low row, record the missing evidence:

• Definition gap: you cannot explain what the concept means.
• Selection gap: you know the concept but cannot choose it in a scenario.
• Implementation gap: you can select the right approach but have not built it.
• Troubleshooting gap: you can follow a happy-path lab but cannot diagnose a basic failure.
• Responsible-use gap: you can make the solution work but cannot identify fairness, safety, privacy, transparency, or accountability concerns.

This classification tells you what study activity to choose. Rereading a definition does little for an implementation gap. Another lab does not fix a misunderstood responsible-AI principle if you never analyze the principle explicitly.

A seven-session remediation sequence

Session one should repair Python and Azure basics if needed. Session two should cover responsible AI, model behavior, model selection, and deployment concepts. Session three should classify workloads and implement text/speech examples. Session four should focus on deploying and interacting with a model plus building a small chat client. Session five should build and test a single-agent solution and a lightweight agent client. Session six should cover multimodal vision and image generation. Session seven should focus on Content Understanding and structured information extraction.

After that sequence, take a mixed diagnostic rather than immediately rereading everything. Use Azure AI Fundamentals practice questions only as a legacy-to-current diagnostic resource: questions based on older AI-900 scope can reinforce transferable fundamentals, but they are not a complete representation of AI-901. For current readiness, every practice session must also test Foundry implementation skills that the retired exam did not emphasize in the same way.

Transition mistakes to avoid

Do not schedule or describe AI-900 as the current exam; it retired June 30, 2026. Do not assume an old AI-900 course is a complete AI-901 preparation path. Do not treat responsible AI and workload identification as obsolete—they remain directly relevant. Do not ignore Python because the credential is called “Fundamentals.” Do not confuse watching a Foundry demonstration with being able to perform the workflow. And do not study product labels without understanding the input, output, and business requirement of each workload.

The AI-901 practical preparation guide turns the implementation rows in this matrix into small exercises. Use it after scoring yourself, not before. A diagnostic is most useful when it tells you which labs deserve your time.

Final readiness gate

Before considering yourself ready, you should be able to do five things consistently. First, classify an unfamiliar AI scenario and identify the responsible-AI concerns. Second, choose a model or capability class based on task and modality. Third, deploy and interact with a model in Microsoft Foundry and build a minimal client. Fourth, implement at least one agent, one multimodal/vision workflow, and one information-extraction workflow. Fifth, explain what can go wrong and how you would validate the output.

If those skills are supported by real evidence rather than familiarity, the transition from retired AI-900 material to current AI-901 preparation is complete. The purpose of the matrix is not to generate a comforting score. It is to expose the exact difference between knowing Azure AI vocabulary and being able to reason about and implement the lightweight AI solutions the current exam now expects.

Scenario diagnostic 1: a support assistant that answers from internal policy

Suppose a company wants an AI assistant that answers employee questions about internal policy, cites the relevant policy section, avoids exposing restricted information, and escalates uncertain cases. This single scenario can test several matrix rows.

First identify the workload: it is a generative conversational application, potentially enhanced with retrieval or grounding. Next identify the responsible-AI concerns. Privacy and security matter because policy repositories may contain restricted material. Reliability and safety matter because an authoritative-sounding but incorrect answer could affect employment or compliance decisions. Transparency matters because users should understand that the response is AI-generated and may need verification. Accountability matters because a business owner must define escalation and review.

Then move to implementation. Could you deploy an appropriate model in Foundry, write system instructions that constrain the assistant, create a lightweight client, test adversarial or ambiguous questions, and inspect whether output follows the required format? If you can describe all of that but have never built even a small version, score concept rows higher than implementation rows. The matrix should expose that difference.

Scenario diagnostic 2: extract structured fields from mixed media

A claims department receives scanned forms, damage photos, short voice notes, and occasional video clips. The goal is to extract claimant details, dates, identifiers, described damage, and other structured fields for downstream review.

A weak response says “use generative AI.” A stronger response identifies information extraction across documents, images, audio, and video and recognizes the relevance of Content Understanding in the current Foundry-oriented blueprint. You should be able to explain why structured extraction is different from simply summarizing the claim.

Level 3 evidence would include running at least two different media types through a small extraction exercise, inspecting missing or low-confidence fields, and explaining why human or rule-based validation may still be necessary. Responsible-AI considerations also apply: claims data is sensitive, incorrect extraction can create material consequences, and processing must respect privacy and security requirements.

Scenario diagnostic 3: multimodal field-service helper

A technician takes a photo of equipment and asks a question by voice. The application interprets the image and spoken prompt, returns troubleshooting guidance, and can speak the response back.

Break the solution into capabilities. Speech recognition captures the spoken question. A multimodal model interprets text plus visual input. A generative component produces guidance. Speech synthesis can return audio. If the application later gains permission to open a service ticket automatically, agentic behavior and tool governance become relevant.

This scenario tests whether you can compose capabilities rather than treating “multimodal AI” as one opaque feature. Level 3 means you can identify each stage, build a minimal version of at least the key multimodal interaction, and state the reliability and safety controls required before technicians rely on it for risky actions.

Scenario diagnostic 4: when an agent is unnecessary

A department wants to categorize incoming feedback as positive, neutral, or negative and extract common topics. An agent may sound modern, but the requirement does not inherently need goal pursuit, tool use, or multi-step autonomous action. Sentiment analysis plus text-processing capabilities can satisfy the need more directly.

Exam readiness includes knowing when *not* to use the newest capability. If you choose an agent for every AI problem, you are matching buzzwords rather than requirements. Compare complexity, determinism, governance, and operational overhead. The simplest capability that satisfies the stated requirement is often the stronger architecture.

Use this diagnostic whenever your answer is driven by excitement rather than necessity: what additional requirement does the more complex design actually satisfy?

How to turn the matrix into a two-column error log

After each practice set or lab, record two things only: the failed skill and the next evidence you need. For example, “agent client — can create agent in portal but cannot call it from Python; next evidence: build minimal client without copying full sample” is actionable. “Need to study agents more” is not.

Other useful entries are “responsible AI — confuse transparency with accountability; next evidence: explain both in three business scenarios,” “Content Understanding — definition known but no hands-on evidence; next evidence: extract fields from one form and one image,” or “multimodal models — can use portal but cannot explain model-selection trade-off; next evidence: compare two workload descriptions.”

This style of error log keeps preparation tied to proof. It also prevents repeatedly reviewing your strongest topics simply because they feel productive.

What a balanced final week should look like

In the final week, do not spend every session on theory because theory feels easier to review quickly. Alternate conceptual and implementation work. One session can review responsible AI and workload classification, the next can deploy a model and rebuild a minimal client, the next can test an agent, and the next can work through vision or information extraction. Finish with mixed scenario practice that forces you to decide which capability is appropriate before touching the portal or code.

A useful rule is that every major implementation objective should have at least one recent hands-on proof and every major conceptual objective should have at least one scenario-based explanation. That balance reflects the current 40–45% concepts versus 55–60% Foundry implementation split far better than a legacy preparation approach built mainly around definitions.