Microsoft AI Fundamentals for Non-Technical Pros (AI-900)

AI-900 measures foundational understanding across five outcome areas you’ll see throughout this course: describing AI workloads and responsible AI; understanding fundamental machine learning concepts on Azure; identifying computer vision workloads; identifying natural language processing (NLP) workloads; and describing generative AI workloads (including Azure OpenAI and prompt concepts). If you are a non-technical professional—product manager, business analyst, sales engineer, program lead, or educator—AI-900 validates that you can collaborate with technical teams and make sound AI decisions without hand-waving.

What the exam is really testing is your ability to translate a business need into an AI workload category. You should be able to tell when a rules-based solution is sufficient (for example, deterministic validation logic) versus when AI adds value (for example, language understanding, image recognition, anomaly detection). You should also be able to recognize responsible AI concerns—fairness, reliability, privacy, transparency, and accountability—and how they affect solution selection.

• Common scenario patterns: “classify,” “predict,” “extract,” “summarize,” “converse,” “generate,” “detect,” “recognize.” These verbs often map directly to a workload.
• Service-family recognition: Vision, Language, Speech, Azure Machine Learning, Azure OpenAI (conceptual, not implementation-heavy).

Common Trap: Confusing “machine learning” as the answer for every scenario. Some questions want a simpler decision: rules-based logic, search, or a prebuilt AI service (for example, OCR) rather than custom model training. Your best answer is the one that meets requirements with the least complexity.

Registering correctly prevents last-minute problems that have nothing to do with your knowledge. AI-900 is scheduled through Microsoft’s certification dashboard and delivered via an exam provider (often Pearson VUE). You typically choose between an online proctored exam (taken at home/office) and a test center. Your choice should depend on stability and risk: online is convenient but less forgiving of environmental issues; test centers reduce technical variables but require travel.

Before you book, confirm the exam language, time zone, and name on your profile. A mismatch between your registration name and your ID is one of the most preventable reasons for being turned away. Plan for a valid, government-issued ID that meets the provider’s requirements (often photo ID; sometimes a second ID depending on region).

• Online delivery readiness: Stable internet, a quiet room, and compliance with proctor rules (clear desk, no additional screens, no notes).
• Test center readiness: Arrive early, know locker rules, and bring required IDs.

Exam Tip: Treat your exam environment like a dependency. If your environment fails, your score doesn’t matter. Do a full check: webcam, microphone, room lighting, and system test (if offered) at least 24 hours in advance.

Common Trap: Scheduling an online exam during a high-interruption time. Unexpected pop-ups, notifications, or people entering the room can trigger a proctor warning. Choose a time slot when you can fully control your space.

AI-900 uses Microsoft’s typical question styles: multiple choice, multiple response (“choose all that apply”), scenario-based items, and occasionally drag-and-drop or matching formats. The exam is designed to test understanding, not memorization of obscure facts, but you must be precise with terminology (for example, the difference between classification vs regression; OCR vs image analysis; entity recognition vs key phrase extraction; generative AI vs traditional NLP).

Microsoft does not always disclose exact scoring mechanics per item, and some exams may include unscored items for quality evaluation. Your pass strategy should assume that every question counts and focus on consistency. Read carefully for requirement words like “best,” “most cost-effective,” “least administrative effort,” “requires training data,” or “near real-time.” Those words are the scoring hinge.

• Approach for scenario questions: First identify the workload category (vision/NLP/speech/ML/generative AI). Then identify constraints (data privacy, latency, cost, skill level). Finally select the Azure capability that fits the category and constraints.
• Approach for multi-select: Verify each option independently against the scenario. Don’t “bundle” choices based on a guess.

Exam Tip: When two answers both look plausible, choose the one that requires the least custom work. AI-900 often rewards “use a prebuilt service” over “build a custom model” unless the prompt explicitly requires custom training or specialized outputs.

Common Trap: Over-reading the scenario and inventing requirements. Only solve the problem stated. If the question doesn’t mention multilingual needs, don’t pick an option solely because it supports multiple languages.

A realistic beginner plan for AI-900 is 2–4 weeks, depending on how many hours you can commit. The exam domains map cleanly to weekly themes. Your objective is not to become an engineer; it is to develop a “workload selection reflex” and a responsible AI lens. Build repetition by cycling: learn concepts, review terminology, then apply to mini-scenarios (without turning your prep into heavy labs).

2-week plan (accelerated, ~45–60 minutes/day): Week 1 covers AI workloads, responsible AI, and ML fundamentals (training vs inference, features/labels, evaluation metrics at a high level). Week 2 covers vision, NLP/speech, and generative AI concepts and use cases, with daily review of scenario mapping.

4-week plan (steady, ~30–45 minutes/day):

• Week 1: AI workloads + responsible AI. Focus on when to use AI vs rules and what makes an AI system “responsible.”
• Week 2: ML on Azure: core concepts, model training/evaluation, and when to choose Azure Machine Learning vs a prebuilt service.
• Week 3: Vision + OCR + solution selection. Learn to differentiate image classification, object detection, and text extraction.
• Week 4: NLP + speech + generative AI workloads, including prompt fundamentals and common Azure OpenAI use cases.

Exam Tip: Each week, create a one-page “decision map” (workload → typical tasks → common Azure service family). The exam rewards quick categorization more than deep implementation knowledge.

Common Trap: Spending too long on model math. AI-900 may reference metrics conceptually, but you rarely need formulas. Prioritize understanding what a metric implies (for example, when accuracy is misleading) over calculation.

Microsoft Learn is your primary study resource for AI-900 because it matches Microsoft’s vocabulary and scenario framing. Use it strategically: skim for structure, then re-read sections that map to exam outcomes (workloads, service selection, responsible AI, and generative AI). Your goal is to adopt Microsoft’s terms so you can recognize them in questions.

You may also explore the Azure portal to become familiar with how services are presented, but do so safely. Many Azure services can be used within free tiers or limited trials, yet it’s still possible to create billable resources accidentally. Build “no-cost habits” now: always check pricing pages, watch for paid SKUs, and delete resources immediately after experimentation.

• Safe portal workflow: Use a dedicated resource group for study, tag it (for example, “ai900-practice”), and delete the entire group when done.
• Limit exposure: Avoid leaving deployments running. If you test anything compute-related, double-check it is stopped/deallocated when you finish.
• Track what you create: Keep a simple log: date, service name, region, and whether you deleted it.

Exam Tip: The portal helps you recognize service names and categories, which is valuable for multiple-choice elimination. However, AI-900 does not require you to memorize portal clicks. Focus on what the service does and when to use it.

Common Trap: Confusing “Azure Machine Learning” (a platform for building ML solutions) with “Azure AI services” (prebuilt APIs for vision/language/speech). On the exam, the correct choice often hinges on whether you need custom training and model management versus consuming a prebuilt capability.

Exam-day success is mostly discipline: eliminate preventable friction, manage your pace, and avoid mental errors. If taking the exam online, start early to complete check-in steps and room validation. If at a test center, plan arrival time with a buffer for traffic and check-in. Either way, ensure you are rested; AI-900 is not conceptually hard, but it is detail-sensitive.

Time management is about avoiding stalls. Don’t spend too long on one question because the exam is designed to test breadth. Use a two-pass method: answer what you know quickly, mark items you’re uncertain about (if the interface allows), and return later. When you revisit, apply elimination: remove answers that solve a different workload, require unnecessary complexity, or ignore the scenario constraints.

• Pace rule: If you can’t justify an answer within a reasonable time, make your best choice, flag it, and move on.
• Read the last line first: Often the last sentence contains the actual ask (for example, “Which solution should you recommend?”).

Exam Tip: Watch for “keyword traps.” Words like “predict,” “forecast,” and “estimate” often indicate regression; “categorize” indicates classification; “extract text” points to OCR; “chat” indicates conversational AI; “generate” and “summarize” may indicate generative AI. Use these cues to orient fast.

Common Trap: Second-guessing correct answers after noticing unfamiliar terms. If your selected answer matches the workload and constraints cleanly, keep it unless you can articulate a stronger fit. Confidence comes from a repeatable method, not from recognizing every term.

Section 2.1: The domain objective—Describe AI workloads

The AI-900 objective “Describe AI workloads” is about matching business problems to the right AI capability. The exam frequently uses everyday workplace examples—support tickets, invoice processing, product recommendations, defect detection, forecasting demand, summarizing meetings—and asks what kind of AI is being described. Your job is to name the workload and often the Azure approach (prebuilt service vs custom model) at a high level.

In plain language: AI is the umbrella term for systems that perform tasks requiring human-like intelligence. Machine learning (ML) is a subset where the system learns patterns from data instead of being explicitly programmed with rules. Deep learning is a subset of ML that uses multi-layer neural networks and is especially common for images, speech, and large language models. The exam trap is thinking these are competing choices; in reality, deep learning is one technique used within ML, and ML is one approach within AI.

Exam Tip: When a question mentions “trained on historical examples,” “model,” “features,” “evaluation,” or “improves with data,” that’s ML. When it mentions “neural network,” “transformer,” “embeddings,” “computer vision,” “speech recognition,” or “large language model,” that often implies deep learning—still ML, still AI.

Another common test angle is capability vs workload. “Optical character recognition” is a capability; the workload is typically “document processing” or “text extraction from images.” Focus on the task being performed and the input/output, not buzzwords.

Section 2.2: Workload patterns: prediction, classification, detection, generation

Most AI-900 scenarios collapse into a few repeatable workload patterns. Learning these patterns makes multiple-choice questions much easier because distractors often swap similar terms (classification vs prediction, detection vs recognition). Start by identifying the output type.

• Prediction (regression/forecasting): output is a number. Examples: forecasting sales next month, estimating delivery time, predicting energy usage. If the scenario asks “how much” or “how many,” think prediction.
• Classification: output is a category/label. Examples: spam vs not spam, positive/neutral/negative sentiment, churn yes/no, product category. If the scenario asks “which class,” “what type,” or “is it A or B,” think classification.
• Detection (including anomaly detection and object detection): output is “something happened” or “where it is.” Anomaly detection finds unusual patterns (fraud spikes, sensor failures). Object detection identifies and locates objects in an image (bounding boxes). If the scenario says “unusual,” “outlier,” “suspicious,” think anomaly detection; if it says “locate,” “count items,” “bounding box,” think object detection.
• Generation: output is new content. Examples: drafting emails, summarizing text, generating code, creating marketing copy. If the scenario says “create,” “draft,” “summarize,” “rewrite,” “chat,” think generative AI.

Exam Tip: “OCR” is not classification; OCR is extraction of text from images. A common trap is choosing “text analytics” when the input is a scanned document. If the input is an image/PDF scan and the task is reading text, it’s a vision/document intelligence/OCR workload first, then NLP can be applied after the text is extracted.

Also watch for “recommendations.” Many learners assume recommendations are always generative AI. In exam framing, recommendations are typically prediction/ranking (ML) rather than generation—unless the system is asked to write a personalized message or explanation, which leans generative.

Section 2.3: AI vs rule-based automation: choosing the right approach

A high-value AI-900 skill is knowing when not to use AI. Rule-based automation (traditional programming, if/then logic, deterministic workflows) is often cheaper, easier to audit, and more reliable when the business logic is stable and can be expressed explicitly. AI becomes valuable when rules are hard to define, patterns are complex, or the environment changes.

Use a simple decision test the exam loves: if you can write a clear rule list that covers edge cases (“if X then Y”) and the inputs are structured and consistent, rules may be best. If you need to learn from examples (emails vary wildly, images differ by lighting, language is ambiguous), AI/ML is more appropriate.

• Good for rules: routing tickets by known product code, checking if a number exceeds a threshold, validating a form field, applying a fixed discount policy.
• Good for AI: detecting fraud patterns that evolve, interpreting customer intent in free-form text, recognizing objects in photos, forecasting demand with many interacting factors.

Exam Tip: Questions often include the phrase “cannot be easily defined with explicit rules” as a clue to choose AI. Conversely, when the scenario says “business rules are well-defined” or “must be fully explainable and deterministic,” consider rule-based automation.

Common trap: assuming AI always improves accuracy. AI introduces model drift, bias risk, and probabilistic outputs. For compliance-heavy decisions (loan approvals, hiring), the exam expects you to think about human oversight, transparency, and responsible AI—even if an AI approach is technically possible.

Section 2.4: Responsible AI: fairness, reliability, privacy, transparency, accountability

AI-900 regularly tests responsible AI principles using short workplace scenarios. You’re expected to know the principles and match them to the risk described. Microsoft commonly frames these as: fairness, reliability & safety, privacy & security, transparency, and accountability.

• Fairness: avoids unequal outcomes across groups (for example, a model rejecting qualified applicants from a demographic group). Look for hints about bias, underrepresentation, or disparate impact.
• Reliability & safety: performs consistently and safely under expected conditions (for example, a vision system failing at night or a chatbot giving harmful instructions).
• Privacy & security: protects personal or sensitive data (for example, storing voice recordings improperly or leaking customer information in model outputs).
• Transparency: users understand that AI is being used and can interpret outcomes at an appropriate level (for example, needing explanations for a prediction or disclosing AI-generated content).
• Accountability: humans remain responsible; there are governance processes, auditability, and escalation paths (for example, who approves model deployment and handles incidents).

Exam Tip: When a scenario includes “customers must be informed,” that’s transparency. When it includes “who is responsible if it fails,” that’s accountability. When it mentions “personal data,” jump to privacy & security. Many wrong answers swap transparency and accountability—anchor on “disclosure/explanation” (transparency) vs “ownership/oversight” (accountability).

Practical application matters: responsible AI is not an afterthought. It influences data collection (representative datasets), evaluation (performance across groups), deployment (monitoring drift), and user experience (clear disclosures and feedback loops). Even as a non-technical professional, the exam expects you to recognize that risk controls are part of the workload design.

Section 2.5: Azure AI services overview: when prebuilt vs custom is best

AI-900 does not require you to implement solutions, but it does test whether you can choose between prebuilt AI services and custom ML. The key tradeoff is speed and simplicity vs specialization and control.

Prebuilt services (Azure AI services) are ideal when the task is common and you want fast time-to-value: image tagging, OCR, face blurring, speech-to-text, translation, sentiment analysis, key phrase extraction, and basic chatbots. These are typically consumed via simple APIs and require minimal ML expertise.

Custom ML (Azure Machine Learning) is best when your data is unique, labels are specific to your business, or you need higher accuracy for a narrow domain (for example, classifying internal ticket types, predicting equipment failure based on proprietary sensor patterns). Custom also supports more control over training, evaluation, and deployment.

Generative AI workloads often use foundation models via Azure OpenAI (for summarization, drafting, Q&A over enterprise content, copilots). You may still combine this with custom components like retrieval (search over your documents) or safety filters. The exam frequently tests that “prompting a foundation model” is not the same as “training a custom ML model.”

Exam Tip: If the prompt says “no labeled data available” and the task is standard (OCR, translation, speech recognition), prebuilt is usually correct. If the prompt emphasizes “company-specific categories,” “custom labels,” or “trained on our historical records,” expect Azure Machine Learning/custom training. If it emphasizes “summarize,” “draft,” “generate,” “copilot,” expect Azure OpenAI/foundation model usage.

Section 2.6: Exam skills lab: scenario reading and keyword spotting

AI-900 questions reward disciplined reading. Many candidates miss points by picking the first familiar term (like “AI”) instead of the best-fitting workload. Use a two-pass method: (1) identify the input modality, (2) identify the output/goal, then map to a workload pattern.

• Input keywords: “emails,” “reviews,” “documents,” “chat logs” → NLP; “photos,” “camera,” “video,” “scanned forms” → computer vision/OCR; “microphone,” “call center,” “transcribe” → speech; “transactions,” “sensor readings,” “historical records” → tabular ML.
• Output keywords: “forecast,” “estimate,” “predict a number” → prediction; “assign category,” “detect sentiment” → classification; “unusual,” “fraud,” “outlier” → anomaly detection; “generate,” “summarize,” “draft,” “chat” → generative.
• Governance keywords: “explain,” “disclose,” “audit,” “consent,” “personal data,” “harmful outputs” → responsible AI principles (match the correct one).

Exam Tip: Watch for multi-step scenarios. Example structure: “extract text from invoices and then classify the request type.” The correct approach is often a pipeline: OCR (vision/document intelligence) first, then NLP/classification. The exam may ask for the best first step or primary workload—answer the step the question actually asks for.

Common traps include confusing “translation” (NLP prebuilt) with “summarization” (generative), confusing “object detection” (locating items in images) with “image classification” (one label for the whole image), and assuming all chat experiences require generative AI (many are intent-based bots). Your advantage as a non-technical pro is to focus on business intent and choose the simplest tool that satisfies it, while recognizing where responsible AI must be addressed.

On AI-900, “fundamental principles of ML on Azure” means you can explain what a model is, how it learns from data, how you check if it generalizes, and which Azure components help manage that lifecycle. The exam does not expect algorithm math; it expects correct identification of the workload and correct evaluation/implementation choices.

Most scenario questions hint at ML when the solution must learn patterns from historical examples (for example, predicting churn, classifying emails, forecasting sales). In contrast, if the decision can be expressed as fixed logic (for example, “if customer age < 18, deny loan”), rules may be better. When the data changes or the patterns are complex, ML often wins because it adapts through retraining.

Exam Tip: Watch for language that implies learning from examples (“based on past outcomes,” “predict,” “classify,” “forecast,” “probability”). That’s your signal to think ML rather than rules.

The chapter lessons connect directly to test objectives: (1) define supervised/unsupervised/reinforcement learning, (2) explain training/validation/testing and overfitting, (3) choose metrics for classification vs regression, and (4) recognize Azure ML building blocks. Your practice set should reinforce interpreting prompts and discarding distractors that use the wrong learning type or wrong metric.

AI-900 frequently tests vocabulary. A feature is an input variable used to make a prediction (for example, customer tenure, monthly spend). A label is the known correct output in your historical training data (for example, “churned: yes/no” or “next month revenue: 1250”). A model learns a mapping from features to labels during training.

Inference is the act of using a trained model to generate a prediction on new data. Many exam questions disguise inference as “scoring,” “predicting,” or “running the model in production.” If the scenario says “new customers arrive daily and you must assign a risk score,” that’s inference.

The model lifecycle (in simple exam terms) is: collect/prepare data → train → evaluate → deploy → monitor → retrain. Azure ML exists to make that lifecycle manageable with tracked experiments, repeatable pipelines, and deployable endpoints.

Exam Tip: If the question mentions “known outcomes” or “historical labeled data,” you’re in supervised learning territory. If it mentions “no labels available” but wants grouping or structure discovery, you’re in unsupervised learning territory.

Common traps: mixing up features vs labels (labels are not inputs), and confusing training with inference (training uses many examples to learn; inference uses the trained model to predict on new records).

Supervised learning uses labeled data (features + known label) to learn to predict the label for new cases. On AI-900, supervised learning splits into two high-frequency workloads: classification (predict a category like fraud/not fraud) and regression (predict a number like price or demand). The exam will often give you the target column; if it’s categorical, think classification; if it’s numeric and continuous, think regression.

Unsupervised learning uses data without labels to discover structure. The most common concept tested is clustering, where the model groups items based on similarity (for example, segmenting customers into groups with similar purchasing behavior). Unsupervised learning is not “less accurate”; it’s solving a different type of problem where no ground-truth labels exist.

Reinforcement learning (RL) is learning by trial and feedback—an agent takes actions and receives rewards or penalties. AI-900 treats RL as a conceptual category (you should recognize it), often described with phrases like “maximize reward,” “learn a policy,” “game/robot navigation,” or “dynamic decision-making.” It’s less about Azure-specific tooling and more about identifying that the learning happens through interaction rather than labeled examples.

Exam Tip: If the scenario includes “recommend the next best action” and mentions rewards over time (not just predicting a label), consider reinforcement learning. If it’s just choosing among products based on past clicks, that may still be supervised learning (predict click/no click) or ranking, not RL.

In your mini-case, practice translating business needs into one of these three learning types before thinking about Azure services. This avoids a classic mistake: jumping to “use clustering” when the problem actually provides labeled outcomes, or choosing classification when the output is a numeric forecast.

AI-900 expects you to match evaluation metrics to the ML task and to interpret “what good looks like” in business terms. For classification, you’ll see the confusion matrix: true positives (TP), true negatives (TN), false positives (FP), and false negatives (FN). These numbers drive metrics like accuracy, precision, and recall.

Accuracy is the percentage of correct predictions overall. It can be misleading when classes are imbalanced (for example, fraud is rare). Precision answers: “Of the items predicted positive, how many were actually positive?”—useful when false positives are costly (flagging legitimate transactions). Recall answers: “Of the actual positives, how many did we catch?”—useful when missing a positive is costly (missing a fraudulent transaction or a dangerous defect).

Exam Tip: When the scenario emphasizes “don’t miss any real cases,” prioritize recall. When it emphasizes “don’t overwhelm staff with false alarms,” prioritize precision.

For regression, accuracy/precision/recall don’t apply. Instead, you’ll see error-based metrics such as MAE (mean absolute error) and RMSE (root mean squared error). MAE is the average absolute difference between predicted and actual values, and it’s easier to explain in business terms (“on average, we’re off by $12”). RMSE penalizes larger errors more heavily, making it sensitive to outliers.

Training/validation/testing connects directly to evaluation. The training set teaches the model; the validation set helps tune choices (like model parameters); the test set provides an unbiased final check. Overfitting means the model performs well on training data but poorly on new data—usually because it learned noise rather than general patterns.

Azure Machine Learning (Azure ML) is the Azure service most associated with building and managing ML models end-to-end. AI-900 won’t test deep configuration, but it does test recognition of core pieces and what they’re for.

A dataset (or data asset) is how you register and manage training data references. Compute refers to the resources used to run training or inference (compute instances/clusters). Questions may describe “scaling training” or “running experiments” and expect you to choose compute rather than storage or deployment.

Pipelines are repeatable workflows that connect steps like data prep, training, and evaluation. If a scenario requires repeatability, auditing, or scheduled retraining, pipelines are a strong fit. Deployment is often described as hosting the model behind an endpoint for real-time or batch predictions. While AI-900 stays high-level, remember the big idea: training happens in an experiment; inference happens at a deployed endpoint.

Exam Tip: If the question says “make predictions for new data in an app,” think “deploy a model as an endpoint.” If it says “track runs and compare models,” think “experiments” and “registered models,” not deployment.

This is where your practice set helps: many distractors use Azure services that sound plausible but don’t match the ML lifecycle step. Your job is to map the requirement to the stage: data → train → evaluate → deploy → monitor.

Two of the most common AI-900 mistakes are (1) choosing a metric that doesn’t match the task, and (2) describing a process that accidentally leaks information from the future into training.

Metric mismatch: Using classification metrics (accuracy/precision/recall) for regression problems, or using MAE/RMSE for classification. The exam frequently hides the task type inside business wording. If the output is a number (price, demand, duration), it’s regression—use MAE/RMSE. If the output is a category (approve/deny, spam/not spam), it’s classification—use confusion-matrix metrics. If the output is grouping with no labels, it’s clustering—evaluation is different and usually described qualitatively or with clustering-specific measures (not a core AI-900 focus).

Exam Tip: Before reading answer options, identify the target output type (category vs number vs no label). This one step eliminates most wrong choices.

Data leakage occurs when information that wouldn’t be available at prediction time is used during training (for example, using “cancellation date” to predict churn, or using post-outcome fields to predict the outcome). Leakage inflates validation/test scores and leads to failure in production. The exam may describe overly “perfect” results or include a feature that is clearly derived from the label.

Another leakage variant is improper splitting: if you randomly split time-series data without respecting chronology, the model can “peek” at future patterns. For non-technical pros, remember the rule: training data must reflect what you would know at the moment you need to make the prediction.

Use your mini-case to practice a leakage check: list each feature and ask, “Would I know this at the time of inference?” If not, it’s a trap—and AI-900 loves this trap because it tests understanding, not memorization.

Section 4.1: The domain objective—Computer vision workloads on Azure

AI-900’s computer vision objective is about recognizing what kind of vision problem you have and which Azure service category can solve it. At a high level, the exam separates (1) understanding images (what’s in the picture), (2) locating things in images (where something is), and (3) reading text from images and documents (OCR and extraction). You should be able to map each to a business-friendly scenario.

Azure groups these capabilities primarily under Azure AI services. In exam language, you will commonly see references to “prebuilt models” versus “custom models.” Prebuilt models are ready-to-use for common tasks (for example, describing an image, detecting common objects, or extracting text). Custom models are used when you must recognize domain-specific categories (for example, types of defects on a circuit board) that a generic model is unlikely to cover.

Exam Tip: When a question emphasizes “no training data,” “quickly add vision,” or “out-of-the-box,” it’s steering you toward a prebuilt capability. When it emphasizes “your own categories,” “brand-specific products,” or “specialized objects,” it’s steering you toward custom vision/model training.

Common trap: confusing “image analysis” with “object detection.” Image analysis often returns tags, captions, categories, and general insights. Object detection implies bounding boxes (location) and is often used for counting or tracking items in a scene. If the scenario needs coordinates or “find all instances of X,” think detection.

Section 4.2: Vision workload types and typical business examples

Start every vision question by identifying the workload type. Three appear repeatedly in AI-900: image classification, object detection, and OCR. The exam may also describe “image analysis” tasks like tagging and captioning, which are often prebuilt.

• Image classification: assign one label to an image (or multiple labels) such as “damaged” vs “undamaged,” or “cat” vs “dog.” Business examples: sorting product photos into categories; determining whether a manufacturing image passes inspection; categorizing social media content.
• Object detection: identify objects and their locations (bounding boxes). Business examples: counting items on a shelf; detecting cars/pedestrians for safety monitoring; locating defects on a surface; finding logos or parts in an image.
• OCR (Optical Character Recognition): extract printed/handwritten text from images or documents. Business examples: reading serial numbers from photos; extracting totals from receipts; digitizing scanned forms; capturing ID card details.

Exam Tip: If the prompt includes verbs like “count,” “locate,” “track,” “find all,” or “draw boxes,” it’s object detection. If it includes “classify as,” “categorize,” or “label,” it’s classification. If it includes “extract text,” “read,” “digitize,” or “scan,” it’s OCR/document processing.

Common trap: assuming OCR is enough for “invoice processing.” OCR extracts text, but invoice processing often requires structure (vendor name, invoice number, line items). That usually points to a document extraction capability designed for forms, not just raw text recognition.

Section 4.3: Image analysis vs custom vision: decision points

AI-900 frequently tests your ability to choose between prebuilt image analysis and custom model approaches. The simplest decision point is: do you need generic understanding of common things, or do you need to recognize your own domain-specific categories?

Image analysis (prebuilt): best when you want broad insights such as describing an image, generating tags, detecting common objects, or identifying scenes. It’s ideal for rapid prototyping and for scenarios where “good enough” general recognition is acceptable.

Custom vision (custom model): best when you need to classify or detect items that are specific to your organization or niche—such as a particular product packaging variant, a proprietary component, or a set of defect types that don’t exist in standard datasets. This approach requires labeled images and a training/evaluation cycle, even if the platform abstracts much of the ML complexity.

Exam Tip: Watch for constraints in the stem: “limited time,” “no ML expertise,” and “no labeled dataset” lean toward prebuilt analysis. “High accuracy on specific items,” “unique classes,” and “you can provide labeled images” lean toward custom.

Common trap: picking custom vision just because the scenario mentions “images.” The exam often rewards the simplest workable solution. If the task is “generate tags for photos” or “detect whether an image contains a dog,” prebuilt analysis is usually the intended answer—no need to train a custom model.

Another trap is conflating “classification” and “detection” when talking about custom models. Custom vision can support both, but if the scenario asks for the location of each instance, the correct workload is object detection, not classification.

Section 4.4: OCR and document extraction concepts (forms, receipts, IDs)

OCR questions on AI-900 range from simple “read text in an image” to more business-driven “process documents.” The exam expects you to understand the difference between raw text recognition and structured document extraction.

OCR basics: OCR converts text in images into machine-readable characters. Use cases include reading signs in photos, extracting text from screenshots, or digitizing paper documents. If the question only asks to “extract all text,” OCR alone is sufficient.

Document and form processing: Many business scenarios require you to extract fields (like invoice number, date, total) and sometimes tables (line items). This is more than OCR because you need to understand layout and map text to named fields. Azure provides capabilities for analyzing documents such as invoices, receipts, business cards, and IDs using prebuilt models, and can also support training for custom document types.

Exam Tip: When the prompt mentions “receipts,” “invoices,” “forms,” “contract fields,” “key-value pairs,” or “line items,” it’s usually testing whether you know that document extraction is a specialized workload—not just OCR. The best answer often references a document intelligence/form recognition capability rather than generic text extraction.

Common trap: choosing an image analysis service for document processing because it “handles images.” Document extraction is assessed on accuracy of field capture and structure, not on image tagging/captioning. Another trap is assuming you must build a custom model for every form; if the document type is common (receipt/invoice/ID), prebuilt models are frequently the intended choice.

Section 4.5: Ethical and privacy considerations in vision solutions

AI-900 includes Responsible AI concepts across all workloads, and computer vision is a frequent area for privacy and fairness concerns. The exam may embed ethical qualifiers in a scenario (for example, “public space,” “employees,” “children,” “medical images”) and expect you to identify risk and a safer approach.

Privacy and consent: Images can contain personally identifiable information (PII) such as faces, license plates, addresses, and ID numbers. A responsible solution minimizes data collection, uses access controls, retains data only as long as necessary, and obtains appropriate consent and legal basis for processing.

Bias and fairness: Vision models can perform differently across demographics or conditions (lighting, skin tones, cultural attire). If a scenario involves decisions that impact people (security screening, hiring, access control), the exam expects awareness that model evaluation must include diverse data and ongoing monitoring.

Transparency and accountability: Stakeholders should know when automated vision is being used, what it’s for, and how errors are handled. Human review is often appropriate for high-stakes outcomes.

Exam Tip: If a question asks “what should you do first” or “best practice,” look for answers about consent, data minimization, evaluating bias, and human oversight—not technical performance tweaks. Fundamentals exams often reward governance steps over implementation details.

Common trap: treating responsible AI as optional. On AI-900, responsible AI is part of the expected reasoning. If two services could work, the scenario’s privacy constraints may determine the best choice (for example, preferring to extract only needed fields rather than storing full images).

Section 4.6: Exam drill: picking the best service from a scenario

On the AI-900 exam, “select the right service” is often the real task. Use a repeatable approach: (1) identify the workload type, (2) decide prebuilt vs custom, (3) match to the Azure capability, and (4) validate against constraints like speed, data availability, and governance.

• Step 1—Workload keywording: “label/categorize” → classification; “locate/count” → object detection; “read/extract text” → OCR; “extract fields/line items” → document extraction.
• Step 2—Prebuilt vs custom: generic/common items with minimal setup → prebuilt; domain-specific categories with labeled data → custom.
• Step 3—Service family mapping: general image insights → Azure AI Vision image analysis; custom classification/detection → Custom Vision; text extraction from images → OCR capability; structured forms/receipts/invoices/IDs → document intelligence/form recognition capability.
• Step 4—Check traps: Does the scenario require bounding boxes (detection) or just a label (classification)? Does it require key-value pairs and tables (document extraction) rather than plain OCR?

Exam Tip: When multiple answers sound plausible, choose the one that most directly matches the deliverable in the scenario (tags, boxes, extracted fields) with the least additional work. AI-900 scenarios typically favor managed, prebuilt services unless the stem explicitly demands customization.

Common trap: overfitting to brand names in the options. Some questions list several Azure services; focus on the capability described, not the most familiar name. Also watch for “document” wording: if the source is a scanned invoice or receipt, the exam is usually checking whether you can distinguish document extraction from generic OCR.

Section 5.1: The domain objective—NLP workloads on Azure

NLP workloads focus on understanding and working with human language in text (and sometimes speech transcribed into text). For AI-900, you should recognize the most common NLP scenarios: sentiment analysis on customer feedback, entity recognition in documents (names, organizations, locations), key phrase extraction to find themes, language detection and translation, and summarization for long content.

On Azure, these capabilities are commonly delivered through Azure AI services for language features (often referred to in study materials as “Language” capabilities). The exam expects you to connect a scenario to a capability, not to memorize every API name. Read the stem carefully: “classify” usually means assign labels (e.g., positive/negative or categories), “extract” means pull out structured bits from unstructured text, and “summarize” means reduce length while preserving meaning.

Also recognize the boundary between rules and AI. If the scenario is deterministic and easy to encode (e.g., “if the email contains ‘unsubscribe’ then label it opt-out”), a rule can be enough. If you need to interpret nuanced language (“I expected better, but support was kind”), AI is more appropriate.

Exam Tip: If the question mentions “structured output from unstructured text” (entities, key phrases), classic NLP is typically the most direct and cost-effective choice. Don’t over-select generative AI unless the scenario requires free-form output or creative rewriting.

Common trap: confusing document processing (OCR) with NLP. OCR converts images to text (a vision workload); NLP then analyzes that text. Many scenarios in business use both, but the exam will often focus on one step at a time.

Section 5.2: Text analytics concepts: classification, extraction, summarization

Text analytics is a bucket of classic NLP tasks that turn text into insights. The exam frequently frames these as “analytics” rather than “generation.” Three patterns appear repeatedly: classification, extraction, and summarization.

Classification assigns labels. Examples include sentiment (positive/negative/neutral), topic categories (billing issue vs product defect), or intent-like routing (sales lead vs support request). The key is that the output is one or more categories, not a rewritten paragraph.

Extraction pulls structured data from text. Entity recognition finds items like people, organizations, places, dates, and product names. Key phrase extraction identifies the main talking points. This is ideal when downstream systems need fields, tags, or highlights rather than prose.

Summarization condenses content. On AI-900, summarization can appear as an NLP scenario (produce a shorter version of the same content). Pay attention to constraints: if the question demands a specific tone (“executive summary in 3 bullet points”) or asks you to incorporate outside context, that leans toward generative AI. If it’s “summarize this article,” classic summarization fits.

• Sentiment: classification of opinion/attitude in text (commonly used for reviews and social media).
• Entities: extraction of names/places/organizations and other important terms.
• Translation: convert text between languages; look for “multi-lingual support” requirements.
• Language detection: identify which language text is written in—often a first step before translation or routing.

Exam Tip: When a question asks for “key information to index/search,” think extraction (entities/key phrases). When it asks for “overall mood,” think sentiment. When it asks for “convert Spanish to English,” think translation—don’t choose generative AI just because it can also translate.

Common trap: treating “summarization” as always generative. The exam may present summarization as a classic NLP capability. Your clue is whether the output must be tightly controlled (length only) or creatively adapted (style, persona, compliance formatting). Adaptation and style usually indicate GenAI.

Section 5.3: Speech and conversation basics: speech-to-text and chat experiences

Conversational AI combines language understanding with an interaction pattern: a user says or types something, the system responds, and context may carry across turns. For AI-900, you should recognize two core building blocks: speech scenarios (speech-to-text and text-to-speech) and chat experiences (bots and conversational interfaces).

Speech-to-text converts spoken audio into written text. This is used for call center transcription, meeting notes, and voice commands. Text-to-speech generates spoken audio from text, useful for accessibility and voice assistants. In many real solutions, speech-to-text feeds an NLP step (sentiment or entity extraction) to analyze calls, or feeds a GenAI step to summarize a meeting.

Chat experiences come in two major patterns you should be able to identify: (1) a scripted or guided bot that routes users through options, and (2) a more flexible assistant that handles open-ended questions. The exam often tests which approach is appropriate. If the business wants consistent, controlled answers (“store hours, return policy”), a structured conversational experience is a safer fit. If it wants broad help (“draft an email to a customer about…”) then a generative assistant is more suitable.

Exam Tip: If the prompt mentions audio input/output, your first mental model should be speech services (transcription or voice synthesis). If it mentions multi-turn interaction, remember that “conversation” is a pattern and can be implemented with classic NLP, GenAI, or both.

Common trap: assuming a chatbot must be generative. Many chatbots are retrieval/FAQ or decision-tree based. Look for wording like “predictable responses,” “approved answers,” or “compliance.” Those phrases signal you should avoid open-ended generation unless guardrails are explicitly included.

Section 5.4: The domain objective—Generative AI workloads on Azure

Generative AI workloads produce new content: text, summaries, drafts, explanations, or even code. On Azure, this commonly maps to Azure OpenAI, where large language models (LLMs) can be used to build assistants, copilots, and content generation features. For AI-900, you must distinguish GenAI from classic ML and classic NLP: GenAI is optimized for generating language, while classic NLP is optimized for extracting or classifying language.

Typical GenAI use cases tested on the exam include: drafting emails and marketing copy, summarizing long documents into a tailored format, generating FAQs from internal documentation, and building Q&A assistants over enterprise content. The exam often frames this as “foundation models” that can be adapted with prompting or augmented with your data.

Key concept: GenAI responses are probabilistic and can be incorrect. That’s why questions about enterprise assistants often include requirements like “use my company documents” or “cite sources.” Those phrases are signals to use grounding approaches (retrieval-augmented generation) rather than letting the model answer purely from its general training.

Exam Tip: If a scenario asks for “human-like response,” “drafting,” “rewriting,” “brainstorming,” or “natural language Q&A,” default to generative AI. If it asks for “extract fields,” “detect sentiment,” or “classify,” default to classic NLP. The correct answer is usually the simplest tool that meets the requirement.

Common trap: picking GenAI when the question wants deterministic results. For example, compliance tagging or extracting invoice numbers is better served by extraction and rules, not a model that might paraphrase or hallucinate numbers.

Section 5.5: Foundation models, copilots, and prompt techniques (zero/few-shot)

Foundation models are large pre-trained models that can be applied to many tasks without training from scratch. In exam language, this is why GenAI can perform summarization, translation, classification-like tasks, and question answering through prompting. A copilot is an application pattern: an assistant embedded into a workflow (CRM, HR portal, help desk) that helps users produce or find information.

Prompting is how you steer the model. Two prompt styles show up frequently in AI-900 prep: zero-shot and few-shot. Zero-shot means you give instructions with no examples (“Summarize this complaint in one sentence and tag sentiment.”). Few-shot means you include examples of input/output to teach the format and expectations (“Example 1… Example 2… Now do this one.”). Few-shot prompting often improves consistency, especially for structured outputs.

When reading scenario questions (including the chapter practice set you’ll encounter elsewhere in the course), identify whether the goal is format consistency or creativity. If the system must always output JSON-like fields, bullet lists, or specific labels, that’s a clue to use clear constraints, examples (few-shot), and explicit formatting instructions.

• Instruction: Tell the model what role to take and what to produce (e.g., “You are a support agent…”).
• Context: Provide the necessary background or retrieved passages.
• Constraints: Limit length, tone, allowed sources, and output format.
• Examples: Few-shot samples that demonstrate the desired style/structure.

Exam Tip: “Few-shot” is a favorite term because it sounds like training but it isn’t. It’s still prompting. If an option says “train a custom model” when the scenario only needs better formatting, that’s often the trap.

Common trap: confusing few-shot prompting with fine-tuning. Fine-tuning changes model behavior through additional training; few-shot adds examples in the prompt at runtime. AI-900 typically emphasizes the conceptual difference rather than deep implementation steps.

Section 5.6: Responsible GenAI: safety, grounding, and content moderation concepts

Responsible AI is tested across AI-900, but generative AI increases the importance because the system can produce unsafe, biased, or incorrect content. For exam purposes, focus on three practical concepts: safety controls, grounding, and content moderation.

Safety refers to preventing harmful outputs (hate, violence, self-harm instructions, sexual content, or disallowed advice). Safety also includes reducing prompt injection risks (users trying to override instructions) and limiting data exposure. Expect scenario phrasing like “must not generate offensive content” or “must comply with company policy.” Those are direct signals that safety and moderation features are required.

Grounding means anchoring responses in trusted data (your organization’s documents, databases, or approved knowledge base) instead of letting the model answer purely from its general knowledge. Grounding reduces hallucinations and helps with enterprise requirements like “answer only using our policy documents.” Some questions will hint at this with language like “must cite sources” or “must be based on internal manuals.”

Content moderation is the mechanism that detects and filters unsafe user inputs and model outputs. On Azure, moderation capabilities are commonly discussed as part of building safe GenAI apps. The exam cares that you know moderation exists and why you would apply it, not that you memorize threshold settings.

Exam Tip: In scenario workshops (choose between classic NLP and GenAI), a frequent deciding factor is risk. If the organization requires controlled, auditable outputs, prefer classic NLP or grounded GenAI with moderation over “open-ended” generation.

Common trap: assuming grounding eliminates the need for moderation. Even grounded systems can produce problematic wording or be attacked through prompts. Another trap is assuming GenAI is always the right choice for summarization—if the requirement is compliance-critical, classic summarization plus extraction may be safer and more consistent.

Treat each mock exam like a rehearsal for the real thing: one sitting, no notes, no searching, and no pausing for deep reading. Your goal is to build the skill the exam tests most: fast, accurate workload identification under time pressure. Set a timer and commit to a pacing plan that leaves review time at the end. Even though AI-900 is fundamentals, candidates often run out of time because they overthink “familiar” scenarios.

Use a three-pass approach. Pass 1: answer everything you can confidently and flag anything with uncertainty. Pass 2: return to flagged items and eliminate distractors using scenario keywords (data type, output, constraints, and whether training is required). Pass 3: final sweep for misreads—especially “best,” “most cost-effective,” “no-code,” “real-time,” “without training,” or “must explain.”

Exam Tip: On AI-900, “without training” often points to prebuilt AI services (e.g., Vision, Language, Speech) rather than Azure Machine Learning. “Must train a model” generally points to ML workflows and evaluation.

• Rule: Don’t change answers unless you can articulate a concrete reason (a missing requirement, a contradicting constraint, or a better service fit).
• Rule: Track why you flagged an item: unclear domain, unfamiliar service name, or tricky wording. That becomes your Weak Spot Analysis data.
• Rule: After finishing, review with a structured framework (Section 6.4) rather than “skim and nod.”

Finally, store your results by objective domain (AI workloads, ML, vision, NLP, GenAI). The exam blueprint is broad; your review must be targeted. A raw score alone doesn’t tell you what to fix—patterns do.

Mock Exam Part 1 (Set A) should feel like the early-to-mid portion of the real exam: straightforward scenarios with a few traps. Focus on quickly classifying the workload. Start by asking: What is the input (text, images, audio, tabular data)? What is the output (label, score, extracted text, generated content)? And do we need training, or can we use a prebuilt capability?

Common scenario families in Set A include: (1) “Choose AI vs rules.” If the logic is static and fully described, rules are fine; if it requires pattern recognition from data (fraud, churn, sentiment), AI/ML fits. (2) “Select the right service.” This is usually about the Azure AI service families: Vision for image analysis/OCR, Language for text analytics and conversational language, Speech for transcription and voice, and Azure OpenAI for generative tasks. (3) “Responsible AI.” Look for fairness, transparency, privacy, and reliability cues—especially when dealing with sensitive attributes or decisions that affect people.

Exam Tip: If the scenario says “extract key phrases,” “detect sentiment,” or “recognize entities,” that’s classic NLP text analytics (Azure AI Language). If it says “write,” “summarize creatively,” “draft,” or “generate,” it’s generative AI (Azure OpenAI). Extractive vs generative is a frequent separator on AI-900.

• Trap to avoid: Confusing OCR with image classification. OCR produces text; classification produces categories; object detection produces bounding boxes.
• Trap to avoid: Choosing “Azure Machine Learning” for tasks that can be done with a prebuilt model. ML is for training/custom models and experimentation; prebuilt services are for ready-to-use capabilities.
• How to identify correct answers: Match one key requirement to one key capability. If the answer adds unnecessary complexity (custom training, pipelines, endpoints) when the scenario asked for a simple capability, it’s likely a distractor.

After completing Set A, don’t just check correctness—note whether misses came from terminology (service names), concept confusion (training vs inference, classification vs regression), or reading error (skipped a constraint like “near real-time” or “no code”).

Mock Exam Part 2 (Set B) should increase difficulty by combining requirements and introducing “best choice” trade-offs. Expect scenarios that mix multiple AI workloads, such as a customer support system that needs sentiment detection (NLP), speech-to-text (Speech), and a chatbot (conversational AI), or a document workflow that needs OCR (Vision) plus entity extraction (Language). The exam often tests whether you can separate a multi-step solution into the correct service components.

Set B also tends to probe fundamental ML concepts: training vs evaluation, overfitting vs generalization, and what metrics imply. While you won’t be doing math, you will be asked to reason: Is it classification or regression? Do we need labeled data? What indicates a model may be overfit (excellent training performance, poor test performance)?

Exam Tip: If a scenario requires predicting a numeric value (price, demand), it’s regression. If it’s choosing a category (approve/deny, churn/no churn), it’s classification. If it’s grouping without labels, it’s clustering. The exam frequently hides this behind business language.

• Difficulty ramp pattern: Two answers may both “work,” but only one aligns with the constraint (e.g., “no training,” “minimal code,” “must be explainable,” “data stays in region”). Use constraints as your tiebreaker.
• Generative AI nuance: When the scenario wants grounded answers from internal documents, look for retrieval-augmented generation concepts (use your data to ground prompts). If it emphasizes safe deployment, think about content filtering and responsible AI practices.
• Common trap: Treating chatbots as “just Q&A.” If the scenario needs a natural conversational interface, that points to a bot solution plus language understanding; if it needs document summarization or drafting, that points to generative AI.

Finish Set B with the same discipline: log misses by objective domain and label the reason. This will drive your Weak Spot Analysis rather than guessing what to study next.

Your review process determines your score improvement more than the number of mock questions you take. Use a consistent framework to explain (1) why the correct answer is correct, and (2) why each distractor is wrong. The exam’s distractors are designed to test surface familiarity—so your job is to attach each choice to a specific capability boundary.

Apply the “Four-Box Review” to every missed or flagged item:

• Workload: Identify the workload type (AI vs rules, ML, vision, NLP, speech, GenAI). If you can’t name it, you’re guessing.
• Inputs/Outputs: Write the input modality and expected output. Many distractors fail here (e.g., choosing translation when the output is sentiment).
• Training requirement: Decide whether a prebuilt model suffices or custom training is implied. This eliminates many options quickly.
• Constraints: Extract the “must” statements (latency, cost, explainability, privacy, no-code). Use them as final filters.

Exam Tip: When two answers seem plausible, ask: “Which option is the minimum solution that satisfies all constraints?” AI-900 typically favors the most direct service match, not the most configurable platform.

Common distractor patterns to call out in your notes: (1) “Wrong domain” (Vision vs Language). (2) “Wrong task within domain” (classification vs detection vs OCR). (3) “Overkill platform” (choosing Azure Machine Learning when a prebuilt service is explicitly enough). (4) “Wrong AI type” (generative vs extractive). (5) “Violates constraint” (requires training, requires labeled data, or doesn’t support real-time needs).

Finish review by converting each mistake into a one-sentence rule you can reuse. Example: “If the task is to read printed text in images, pick OCR; if it’s to identify what the image contains, pick image analysis/classification.” These rules become your last-day revision sheet.

Use this final checklist to ensure coverage of the course outcomes and the AI-900 objective style. You’re not memorizing product marketing—you’re building quick matching rules between scenario language and solution category.

• AI workloads & Responsible AI: Can you justify when rules beat AI (fully specified logic, low variability)? Can you name core responsible AI principles (fairness, reliability/safety, privacy/security, inclusiveness, transparency, accountability) and recognize scenarios involving bias, sensitive attributes, and human oversight?
• Machine Learning fundamentals: Can you distinguish training vs inference, features vs labels, and supervised vs unsupervised learning? Can you identify classification/regression/clustering from business phrasing? Do you recognize overfitting and the purpose of splitting data for evaluation?
• Computer Vision: Can you separate image classification, object detection, and OCR? Do you recognize when the scenario is about “extract text from receipts/forms” vs “find objects/people” vs “tag content”? Can you choose a vision solution based on output needs (text, labels, bounding boxes)?
• NLP & Speech: Can you map “sentiment, key phrases, entities” to text analytics? Can you identify translation and language detection scenarios? For speech, can you distinguish speech-to-text, text-to-speech, and speaker-related needs at a high level?
• Generative AI: Can you explain what foundation models do and where copilots fit? Can you identify prompt engineering basics (clear instructions, context, constraints) and know when generative is appropriate vs risky? Can you recognize Azure OpenAI use cases like drafting, summarization, Q&A with grounding, and content generation while keeping responsible AI in mind?

Exam Tip: If you’re shaky on a domain, don’t re-read everything. Rework your own “if-then” rules and test them against mixed scenarios. AI-900 performance comes from fast categorization.

This checklist aligns directly to the exam’s coverage: describe workloads, select the right Azure AI capability family, and reason about responsible use. Your Weak Spot Analysis should now point to one or two domains to polish, not five to re-learn.

Exam-day performance is a systems problem: environment, timing, and composure. Start with your setup. If remote, ensure a quiet room, clear desk, stable internet, and allowed identification ready. If in a test center, arrive early and expect check-in time. These are not “extras”—they protect your mental bandwidth for scenario interpretation.

Use a simple confidence routine: before starting, remind yourself of your decision tree—identify modality (text/image/audio/tabular), choose workload type, apply constraints, then eliminate distractors. This keeps you from drifting into overthinking.

Exam Tip: If you feel stuck, stop rereading and instead restate the requirement in your own words: “The business wants X output from Y input under Z constraint.” Then pick the service family that does exactly that. This breaks the loop of indecision.

• Time management: Don’t aim for perfection on the first pass. Answer, flag, move. Your score improves more from completing all items than from spending too long on a few.
• Reading traps: Watch for negatives (“not,” “except”), superlatives (“best,” “most appropriate”), and constraints (“without training,” “real-time,” “minimize cost”).
• Stress control: If you miss one question, you’re still on track. Reset immediately; don’t carry uncertainty forward.

Finally, run a last-minute “two-minute review” of your personal rules: classification vs regression, OCR vs detection, extractive vs generative, prebuilt services vs custom ML, and responsible AI principles. When you sit down, your goal is steady execution—not new learning. If you’ve completed both mock exam parts, performed a structured review, and addressed weak spots, you’re prepared to score consistently.