AZ-104 Study Plan: Six Weeks to Azure Administrator Associate (+ Lab Checklist) · CloudEngineerHub
Azure9 min read8 views
AZ-104 Study Plan: Six Weeks to Azure Administrator Associate (+ Lab Checklist)
A six-week AZ-104 study plan matched to the live blueprint, with a hands-on lab checklist per skill area and the weekly cadence that makes exam tasks boring.
C
CloudEngineerHub Team
Published: August 29, 2026· Last Updated: October 3, 2026·9 min read
AZ-104 Study Plan: Six Weeks to Azure Administrator Associate (+ Lab Checklist)
Most AZ-104 candidates fail the schedule, not the exam. They collect videos for a month, sprint through practice questions in the final week, and walk into task-based scenarios they have never executed. This plan inverts that: the Microsoft skills-measured outline sets the weights, every week pairs reading with hands-on labs in a real subscription, and the final week is reserved for full-length practice assessments and gap repair. Six weeks, roughly ten hours per week, one lab checklist that mirrors the live exam tasks — and the administration tasks that once felt exotic become boring.
Visual Walkthrough
C
CloudEngineerHub Team
Author
The CloudEngineerHub editorial team — Microsoft endpoint management and cloud engineers writing hands-on guides on Intune, Azure, Entra ID, Autopilot, Defender and PowerShell. Every article is reviewed against current Microsoft documentation.
The study cadence behind every AZ-104/MD-102 pass on this site.
TimelineSix-Week Certification Loop5/5
weeks 1–2
1
Weeks 1–2 · Foundations
Learn paths + concept mapping; notes as flashcards.
weeks 3–4
2
Weeks 3–4 · Labs
Hands-on in a test tenant; break and fix deliberately.
week 5
3
Week 5 · Practice tests
Timed mocks; review EVERY wrong answer to source docs.
week 6
4
Week 6 · Weak domains
Score report → targeted revision of weakest domains.
exam
5
Exam day
Rest, ID check, time-boxed flags, review marked questions.
Six-Week Certification Loop. 1. Weeks 1–2 · Foundations: Learn paths + concept mapping; notes as flashcards. — 2. Weeks 3–4 · Labs: Hands-on in a test tenant; break and fix deliberately. — 3. Week 5 · Practice tests: Timed mocks; review EVERY wrong answer to source docs. — 4. Week 6 · Weak domains: Score report → targeted revision of weakest domains. — 5. Exam day: Rest, ID check, time-boxed flags, review marked questions.
Prerequisites
Baseline: familiarity with the Azure portal, basic networking (IP addressing, DNS), and command-line comfort. Total beginners should add a fortnight for fundamentals.
Time budget: 8-12 hours weekly — two evening sessions plus one longer lab block on the weekend.
Environment: a personal Azure subscription with a spending alert and budget configured, or Microsoft Learn sandbox modules where a subscription is impractical. Clean up resource groups after every lab.
Tooling: Azure CLI and the Az PowerShell module installed locally, VS Code for notes, and the official AZ-104 study guide bookmarked as the single source of scope truth.
How It Works
The exam scores against a published skills outline: identity and governance lead, storage and compute are mid-weight, monitoring and backup close the outline. The plan allocates study time in those proportions instead of alphabetical service order — that is the entire optimization.
Three mechanics make the schedule work:
Lab-first learning. For every topic, do the task before reading the deep reference. The exam presents scenarios — "make this VM reachable only through the load balancer" — and hands-on reps turn portal familiarity into task fluency.
Spaced repetition on the cheat layer. AZ-104 rewards recall of small facts: SKU limits, default behaviors, which CLI verb does what. Keep one page per service with defaults and limits, and review the stack for ten minutes at the start of each session.
Measurement. Official practice assessments sit at week 3 and week 6. A score is not a verdict; it is a map — every wrong answer becomes a lab.
Step-by-Step Implementation
Week 1 — Identity, Governance, and Management (heaviest section)
Cover Microsoft Entra ID users and groups, role-based access control, subscriptions and management groups, tags, and Azure Policy.
Labs: create users and group-based assignment; assign built-in roles at management-group scope; apply a read-only resource lock and watch it block a delete; attach a tag policy and see denial in action; deploy a storage account with a Bicep template and tag enforcement.
Week 2 — Storage
Cover storage accounts, blob types and tiers, SAS and Entra-backed authorization, Azure Files, and lifecycle management.
Labs: upload blobs and script tier transitions; generate a user-delegation SAS and verify least-privilege scope; join an Azure Files share from a VM with Entra ID authentication; write a lifecycle policy that cools blobs after 30 days; configure soft delete and a replication choice and justify both aloud.
Week 3 — Compute + first practice assessment
Cover VMs, availability sets and zones, scale sets, images, and App Service basics.
Labs: deploy a VM scale set across zones with a custom image from a gallery; attach data disks and test resizing; configure autoscale rules on CPU; build a VM from a marketplace image with cloud-init. Then sit the official practice assessment cold and log every miss into the gap list — week 3 misses are cheap.
Week 4 — Virtual Networking (the scenario magnet)
Cover VNets and subnets, NSGs, peering, DNS, load balancing, and Application Gateway.
Labs: peer two VNets and test transit through a firewall VM with UDRs; write NSG rules with service tags and verify with Test-NetConnection; configure custom DNS zones and a private endpoint; put a VM behind a load balancer with health probes and kill a backend on purpose.
Week 5 — Monitoring and Backup/DR
Cover Azure Monitor, Log Analytics, alerts, Azure Backup, and Azure Site Recovery.
Labs: deploy Log Analytics, enable VM insights, and write three KQL queries against collected counters; create a metric alert with an action group; back up a VM to a vault and restore a file; configure Site Recovery for one VM and run a test failover.
Week 6 — Full assessments and gap repair
Two full-length practice assessments under exam timing, spaced two days apart. Each miss becomes either a lab rerun or a one-page note. Reserve the last two days for the cheat-layer review and logistics.
Configuration Deep Dive
Mapping Learn to the outline. The AZ-104 learning paths on Microsoft Learn follow the exam sections; use them as the reading track. The study guide lists every skill measured — check items off only after a lab proves them.
Cost control as a habit. Labs eat budget through forgetfulness, not compute: orphaned public IPs, premium disks, Log Analytics ingestion. Set a budget with an alert at 50 percent and delete by resource group after every session.
The note system. One page per service, four fields: what it does, defaults that surprise people, SKU/limits worth memorizing, and the CLI/PowerShell verbs you keep forgetting. These pages are the week-6 review set and, later, your on-the-job cheat sheet.
Assessment timing. Take nothing full-length before week 3 — early scores teach despair, not gaps. Official practice assessments reflect the live item style, including the case-study format that eats time when read linearly instead of triaged.
Real-World Enterprise Scenario
A four-person infrastructure team at a logistics company budgeted one workday per week for certification — management funded the vouchers but wanted the skills to land in production. The team ran this plan as a cohort: shared lab subscription with per-person resource-group prefixes, a Friday lab hour where each member demoed one task, and the Policy and KQL labs run directly in their dev landing zone. Three of four passed on the first attempt; the fourth, who skipped week-4 networking labs, passed on the second — and rebuilt the peering lab into the production hub-spoke design. The reusable artifact was the checklist that new joiners now complete during onboarding.
Visual Walkthrough
Each layer multiplies the ones below — never skip foundations.
Layered StackThe Engineer's Skill Stack5/5
PerimeterCore asset
1
OS internals
Registry, services, event logs, boot flow — the bedrock.
foundation
2
Networking + identity
DNS, TLS, Kerberos, Entra mechanics explain most mysteries.
layer 2
3
Automation
PowerShell + Graph turn hours into seconds — and into guardrails.
layer 3
4
Cloud platform
Azure/Intune services as building blocks, not black boxes.
layer 4
5
Architecture + security
Trade-offs, governance and Zero Trust tie it into strategy.
summit
Each layer assumes the previous one failed — depth is the strategy.
The Engineer's Skill Stack. 1. OS internals: Registry, services, event logs, boot flow — the bedrock. — 2. Networking + identity: DNS, TLS, Kerberos, Entra mechanics explain most mysteries. — 3. Automation: PowerShell + Graph turn hours into seconds — and into guardrails. — 4. Cloud platform: Azure/Intune services as building blocks, not black boxes. — 5. Architecture + security: Trade-offs, governance and Zero Trust tie it into strategy.
PowerShell for Study Progress Tracking
Keep the checklist executable — readiness is data, not a feeling:
PowerShell
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# AZ-104 lab tracker: score skill areas and surface the gaps to study next$areas = [ordered]@{
'Identity & Governance' = @{ Lab = 'RBAC at MG scope + policy denial'; Done = $true }
'Storage' = @{ Lab = 'SAS scoping + lifecycle policy'; Done = $true }
'Compute' = @{ Lab = 'Scale set across zones + autoscale'; Done = $false }
'Networking' = @{ Lab = 'Peering + UDR transit + NSG tags'; Done = $false }
'Monitoring' = @{ Lab = 'Log Analytics + KQL + alert rule'; Done = $false }
'Backup & DR' = @{ Lab = 'Vault backup + ASR test failover'; Done = $false }
}
$done = ($areas.Values | Where-Object Done).Count
"AZ-104 readiness: $done of $($areas.Count) skill areas lab-verified"$areas.GetEnumerator() | Where-Object { -not$_.Value.Done } |
ForEach-Object { "Next lab: $($_.Key) -> $($_.Value.Lab)" }
# Expected output:# AZ-104 readiness: 2 of 6 skill areas lab-verified# Next lab: Compute -> Scale set across zones + autoscale# Next lab: Networking -> Peering + UDR transit + NSG tags# Next lab: Monitoring -> Log Analytics + KQL + alert rule# Next lab: Backup & DR -> Vault backup + ASR test failover
Troubleshooting
Symptom
Likely Cause
Fix
Practice scores plateau near 65%
Reading without labs; recognition instead of recall
Rerun every missed item as a hands-on task, not a re-read
Case studies blow the time budget
Reading linearly instead of triaging requirements
Skim the business requirements, answer from the tabs, flag and return
Lab spend creeps past budget
Orphaned disks, IPs, and ingestion after sessions
Delete by resource group after each lab; alert at 50% of budget
CLI syntax evaporates on exam day
Notes list concepts but not verbs
Keep the one-page verb cheat sheet; drill az completion in labs
Week slips, plan feels broken
Hours budgeted per week, not per session
Cut reading, never cut labs; carry the gap list forward
Exam-day screen navigation surprises
Only practiced in the portal
Use the practice-assessment UI at least twice to build navigation muscle
Common Errors
Studying to the video catalog instead of the skills outline. Weights decide scores; the outline is the contract.
Doing labs in a production-adjacent subscription. Use a dedicated subscription with a budget, always.
Memorizing dumps. Item pools rotate and the task-based format punishes pattern-matching without understanding.
Booking the exam before week 6 diagnostics. Schedule after the second full assessment says ready.
Best Practices
Pair every section with a lab the same day; the exam tests execution, and execution is perishable.
Keep one page per service with defaults and limits — it doubles as the final-week review and the on-the-job reference.
Run practice assessments under real timing with no notes; open-book practice builds false confidence.
Study in a cohort where each member demos one lab weekly; explaining a task is the cheapest mastery check.
Security Considerations
Guard the personal lab subscription: spending alerts, a budget, and no production credentials anywhere in it.
Practice least privilege during labs — assign roles at the narrowest scope that works and say why aloud; the habit is exam-relevant and job-relevant.
In storage labs, never commit SAS tokens or keys to notes repos; use user-delegation SAS with short expiry as the default posture.
For online proctoring, clear the workspace per policy and keep the ID ready; logistics failures are the most avoidable exam-day loss, and the exam NDA still applies to study-group chatter.
FAQ
Q: Is six weeks realistic without prior Azure experience?
A: With command-line comfort and networking basics, yes. From zero, plan eight weeks and insert a fundamentals fortnight before week 1.
Q: CLI or PowerShell for the exam?
A: Both appear; tasks are solvable with either. Pick one as primary, stay conversant in the other.
Q: Are Microsoft Learn sandboxes enough for labs?
A: They cover guided module labs well, but free-form tasks — peering, scale sets, ASR — deserve a personal subscription with a budget.
Q: How many practice assessments before the real one?
A: Two official full-length assessments minimum, with every miss converted into a lab between sittings.
Q: Does AZ-104 expire?
A: Microsoft role-based certifications renew annually via a free online renewal assessment; set the reminder the day you pass.
Conclusion
AZ-104 rewards candidates who trained execution, not recognition. Weight your weeks to the outline, make every topic a lab, measure honestly at weeks 3 and 6, and let the gap list — not anxiety — decide the final days. Drill the underlying services with AZ-104 practice tests on /mock, automate lab teardown with the scripts in /tools, and round out the prep with the study bundles in /store.
Comments
0No comments yet — be the first to share your thoughts.