Lesson 1: Exam Orientation; Fairness, Reliability, Privacy

Welcome: what you are preparing for

This course prepares you for Exam AI-901: Microsoft Azure AI Fundamentals, which leads to the Microsoft Certified: Azure AI Fundamentals certification. Before we write any code, here are the facts you need about the exam itself:

• The study guide belongs to Microsoft. The Study guide for Exam AI-901 is Microsoft's own document. It is free on Microsoft Learn (aka.ms/AI901-StudyGuide), and this course does not copy it. Read it yourself and come back to it often, because Microsoft updates it. This course follows the skills measured as of April 15, 2026.
• The two skill areas and their weights:
  • Identify AI concepts and capabilities: 40–45%
  • Implement AI solutions by using Microsoft Foundry: 55–60%
• The pass mark is 700. Scores run from 1 to 1000, and you need 700 or greater.
• Duration: look on Microsoft's official AI-901 exam page on Microsoft Learn, in the scheduling details, and treat the time shown there as the figure that counts. Exam details can change, so don't rely on numbers quoted on third-party sites.
• This course is independent of Microsoft. It is not endorsed by Microsoft, and it cannot promise that you will pass. What it does promise is to cover every bullet in the study guide in proportion to its weight.

You'll also find a free Practice Assessment through AI Skills Navigator (you have to be signed in) and an exam sandbox where you can try out the exam interface. Use both before exam day.

Gotcha: AI-901 expects you to know some Python and to be familiar with REST APIs, SDKs and CLIs. Most questions are about generally available (GA) features, but a Preview feature can come up if it's widely used.

Responsible AI: six principles, three today

Microsoft's responsible AI principles are fairness, reliability and safety, privacy and security, inclusiveness, transparency, and accountability. This level covers the first three. Level 2 covers the other three.

On the exam, the usual pattern is a short scenario followed by "which principle does this concern?" or "what should you do?" The skill is matching the problem you see to the right principle and then to the right mitigation.

Fairness: similar people, similar treatment

A fair AI system treats everyone fairly and doesn't affect similar groups of people differently. Here's the classic case. A bank's loan model approves 68% of applicants aged 30–50 but only 41% of applicants over 60 who have similar incomes and credit histories. The model learned from historical data, and the old bias in that data came along with it.

The mitigation is to measure results group by group before release and again in production. You can do this in plain Python:

# Each row: (age_group, model_decision) -- 1 = approved, 0 = rejected
decisions = [("30-50", 1), ("30-50", 1), ("30-50", 0),
             ("60+", 0), ("60+", 1), ("60+", 0)]

from collections import defaultdict
totals, approved = defaultdict(int), defaultdict(int)
for group, decision in decisions:
    totals[group] += 1          # count applicants per group
    approved[group] += decision # count approvals per group

for group in totals:
    print(group, f"approval rate = {approved[group] / totals[group]:.0%}")
# 30-50 approval rate = 67%
# 60+ approval rate = 33%   <-- a gap this large needs investigating

In practice you'd use a library such as Microsoft's open-source Fairlearn, which does the same calculation for you:

from fairlearn.metrics import MetricFrame, selection_rate

mf = MetricFrame(metrics=selection_rate,   # share of applicants approved
                 y_true=y_test, y_pred=y_pred,
                 sensitive_features=age_group)  # the column to compare across
print(mf.by_group)       # approval rate per group
print(mf.difference())   # the largest gap between groups

Trade-off: taking out a sensitive column such as age does not make a model fair by itself, because other columns (postcode, years employed) can stand in for it. Test the outcomes, not only the inputs.

Reliability and safety: works as designed, fails safely

A reliable and safe AI system behaves consistently, does what it was designed to do, responds safely when something unexpected happens, and resists people trying to manipulate it. Some problems you might see: a chatbot that gives a different dosage answer every time it's asked, a model that writes violent content when a user tricks it, or an app that crashes and shows a raw error when the model call fails.

There are two kinds of mitigation, and in Microsoft Foundry you usually need both:

1. Content filters (guardrails). By default, Foundry gives model deployments the Microsoft.DefaultV2 guardrail. It uses Azure AI Content Safety classifiers to check for hate, sexual, self-harm and violence at severity levels, and it can also detect prompt attacks (jailbreaks). You can create a custom guardrail in the portal and set how strictly each category is blocked.
2. Failure handling in your code. Never assume the model answered:

def safe_reply(call_model, prompt):
    try:
        response = call_model(prompt)                # your model call
        choice = response.choices[0]
        if choice.finish_reason == "content_filter":   # output was filtered
            return "Sorry, I can't help with that request."
        return choice.message.content
    except Exception:                                 # timeout, blocked prompt, outage
        return "The assistant is unavailable right now. Please try again."

Best practice: test with harmful and unusual inputs before launch (this is called red-teaming), not only with the happy path.

Privacy and security: collect less, protect the rest

An AI system should be secure and respect privacy. Typical problems: a support chatbot repeats another customer's address, training data includes unredacted medical records, or API keys sit in source code.

The mitigations are to limit personal data (collect and keep only what you need, and redact before you store or send it), to protect what you keep (encryption, access control, keyless authentication through Microsoft Entra ID), and to detect personal data (Foundry guardrails include a Personally identifiable information control, currently in Preview).

import re
# Redact obvious personal data before logging a prompt
def redact(text):
    text = re.sub(r"[\w.+-]+@[\w-]+\.[\w.]+", "[EMAIL]", text)
    return re.sub(r"\b\d{16}\b", "[CARD]", text)

print(redact("I'm jo@contoso.com, card 4111111111111111"))
# I'm [EMAIL], card [CARD]

Gotcha: privacy and transparency get mixed up. A system that leaks data is a privacy and security problem. A system that doesn't explain its decisions is a transparency problem, which is covered in Level 2.

What the exam asks about this

Expect short scenarios: "A hiring model favours one gender" means fairness. "A chatbot produces harmful content or behaves unpredictably" means reliability and safety. "Customer data is exposed" means privacy and security. You may also be asked which action fits a principle: test results across groups, add content filters and failure handling, or minimise and protect personal data.

Key takeaways

• AI-901 has two skill areas: AI concepts (40–45%) and implementing with Microsoft Foundry (55–60%). You need 700 to pass. Check the duration on Microsoft's AI-901 exam page.
• The study guide is Microsoft's own free document on Microsoft Learn. This course is independent of Microsoft and doesn't promise a pass.
• Fairness: compare outcomes across groups (for example with Fairlearn).
• Reliability and safety: guardrails and content filters, red-teaming, and code that fails gracefully.
• Privacy and security: collect less, redact, encrypt, control access.