Track B — Hands-On Without an Azure Subscription

Why this track exists

Creating an Azure account requires a credit or debit card for identity verification. Prepaid and virtual cards are refused, and Microsoft retired its free Learn sandboxes, so there is no way around that requirement.

Plenty of capable people do not have a card. That is a banking problem, not a talent problem, and it has nothing to do with whether you can pass AI-901. So Track B gives you two things in place of a subscription: a free model endpoint you own outright, and a simulator for the portal work.

This is not the lesser track. Here is the thing most single-vendor students never learn: the pattern you are taught — Import → Connect → Send → Use — is identical no matter whose model you call. Only two values change: the base URL and the key. By the end of this course you will have pointed the same four steps at more than one provider. That makes the pattern portable in your hands, and portability is the actual skill. The vendor is a detail.

Be accurate about what you did. When an assignment asks what you built, say you used the simulator or a free provider. Never imply you deployed to live Azure. Describing your own work precisely — including its limits — is graded on this course, and it is a habit worth more than the marks.

Set up once — about ten minutes

1 · Your free model endpoint

Go to Google AI Studio and create an API key. It is free, it needs no credit card, and it does not expire. The free tier allows roughly 1,500 requests a day, which is far more than this course will use.

Read this before you use it. On a free tier, what you send may be used to improve the provider's models. Never send personal data, client data, medical details or anything confidential. Use invented examples. This is not a footnote — it is the Privacy and Security principle from Session 8 landing on your own desk in week one.

2 · Store the key properly, from the very first day

In Colab, open the key icon in the left sidebar and add two secrets:

Name	Value
`endpoint`	`https://generativelanguage.googleapis.com/v1beta/openai/`
`api_key`	your key from AI Studio

Then never type the key into a cell again. Not once. Not "just to test it."

3 · Your connect cell — this is the only thing that differs from Track A

# Import from google.colab import userdata from openai import OpenAI # Connect — endpoint and key are needed HERE, not at Send client = OpenAI( base_url = userdata.get('endpoint'), api_key = userdata.get('api_key') ) MODEL = "gemini-2.5-flash" # Track A students put their deployment name here

Everything after this line — every Send, every Use, every assignment in the course — is written exactly as Track A writes it.

4 · The simulator

Open simulated-foundry-portal.html and set your resource group name to rg-yourname-ai901. Use the same name all the way through the course.

SESSION 2

Getting into your environment — and the security model

Track A signs into the Azure portal. You will work through the simulator's Portal tour, which reproduces the same access model.

Confirm which resource groups you can see. There will be exactly one — yours.
Use the three Try to reach what you should not buttons: billing, another student's resource group, and assigning a role. Read each denial message properly and write down what it tells you.
Everything else in the assignment is unchanged, including the Microsoft Learn profile screenshot. That part is identical on both tracks — your Learn profile is free, it needs no card, and it is where your actual Microsoft certification will land, in your own name.

The concept being graded is identical. A role says what you may do. A scope says where. You could hold a powerful role and still see almost nothing, because scope decides reach. This is the single most-tested idea in Domain 2 and it is worth more marks than anything else in Session 2.

SESSIONS 5 · 14 · 17 · 23

The coding sessions

These need no change at all beyond your connect cell. Write the code exactly as the session teaches it.

Session	What you build	Any difference?
5	List, loop, function; the four-step pattern	None — no model call yet
14	A chat client that sends a system and user prompt	Connect cell only
17	A text-analysis program over several texts	Connect cell only
23	An information-extraction program	Connect cell only

Read the reply the same way Track A does:

reply = client.chat.completions.create( model = MODEL, messages = [ {"role": "system", "content": instructions}, {"role": "user", "content": question}, ] ) print(reply.choices[0].message.content)

Type it, do not paste it. This rule matters more on Track B, not less. Later in the course you will meet a question offering response.messages[0] — a line that does not exist. Students who typed response.choices[0] with their own hands spot the fake instantly. Students who pasted it do not.

SESSIONS 11 · 13 · 15

The portal sessions

Work through the simulator in order. Each screen carries the observation your assignment asks for.

Session	Simulator screens	What to record
11	Portal tour → Model catalog	Which resource groups are visible, the region, where a project is created, and one model card: its name, whether it is text-only or multimodal, and one fact about context or cost
13	Create a project → Deploy → Endpoint & keys → Playground	Project name and scope, deployment name and status, a system prompt plus two user prompts, and the temperature comparison
15	Agents	Agent name, your full instructions, and all three tests — on-task, edge case, off-topic

Session 13 — the temperature comparison is real work

The simulator playground responds differently at low and high temperature, so do the comparison there. Better still, do it twice: once in the simulator, then again against your live free endpoint by passing temperature=0 and temperature=1 to chat.completions.create. Compare what you saw in both. That is a stronger answer than Track A typically produces.

Session 15 — an agent without an agent service

Design and test your agent in the simulator, then prove the same behaviour against your real endpoint: put your agent instructions in the system message and run all three tests through code. An agent is a model given a role, standing instructions and tools. You have the first two for real, and the simulator shows you what the third adds.

The one thing to carry out of Session 13: a deployment does what its model does. A chat deployment cannot generate an image. A text-only deployment cannot see one. When code fails later in the course, check the kind of model you pointed at before you check your syntax.

SESSIONS 19 · 20

Vision and image generation

Session 19 — vision

You can do this one for real. Free-tier Flash models accept images, so send a photograph and a question in a single message, exactly as the session teaches:

messages = [{"role": "user", "content": [ {"type": "text", "text": "What is in this image? Read any text you see."}, {"type": "image_url", "image_url": {"url": "https://.../receipt.jpg"}} ]}]

Photograph a real receipt and run it. Then state plainly in your assignment that you ran it, and on what.

Session 20 — image generation

Free tiers rarely include image generation, so treat this as a code sketch and say so explicitly. Write the images.generate call correctly, name the image-generation deployment you would need, and explain why your chat deployment cannot serve it.

This is the most-failed detail in the whole course. Both of the first two students wrote a perfectly correct images.generate call and passed it a chat model. One of them even defined the right image-model variable and then forgot to use it in the call. Correct syntax pointed at the wrong kind of deployment is still broken code. Check the model argument, every time.

You may test your prompts in any consumer image tool to prove they work, and paste the result — just label clearly what produced it.

SESSIONS 21 · 22

Content Understanding

Use the simulator's Content Understanding screen. Run a document, then an image, then an audio clip, and record the extracted fields with their confidence scores.

Then do it for real as well. Photograph a genuine receipt and send it to your free multimodal endpoint with this instruction:

instructions = """Extract these fields from the receipt and return JSON: merchant, date, line_items, total. For each field add a confidence between 0 and 1. If a field is unreadable, say so rather than guessing."""

Compare the two. You will usually find the general model guesses where the specialist analyzer would have flagged low confidence — which is exactly the lesson.

The confidence score is the point. A model that is unsure and says so is far more useful than one that is confidently wrong. That is Reliability and Safety expressed as a number, and it is what tells you where to put a human.

What is genuinely different — stated plainly

You will not	You will
Provision resources in a live Azure subscription	Write and run real code against a real model, every session that calls for it
See a real Azure billing or quota screen	Work inside a correct least-privilege model and hit its edges deliberately
Use the Azure AI Foundry portal itself	Complete the same workflow, in the same order, with the same vocabulary

AI-901 is a fundamentals examination. It is conceptual, it contains no labs, and a great many people pass it having never deployed a resource in their lives. Track B prepares you fully for the exam. What it does not do is put live-Azure experience on your CV — so do not claim it. If you get a card later, Session 13 in the live portal takes about twenty minutes, and everything you have written will run there after you change two lines.

ERW CommandPMO · Predict. Prioritize. Perform.
Training material. Not affiliated with or endorsed by Microsoft.