AI-200 · Domain 1 of 4

AI-200 Domain 1: Develop containerized solutions on Azure

This domain covers packaging and running AI workloads in containers. It covers building and storing images in Azure Container Registry, hosting containers in App Service and Container Apps, event-driven scaling with KEDA, and deploying and troubleshooting on Azure Kubernetes Service.

Exam weight
20–25%
Official functional groups
2
Estimated questions estimate
9–14
Suggested study time estimate
15–25 hrs

About 10 min read Reviewed October 2026

Overview

Develop containerized solutions on Azure is the entry point of the AI Cloud Developer exam, and the area an experienced Azure developer finds most familiar. It has two objective groups. Implementing container application hosting covers building, storing, versioning and managing images in Azure Container Registry, building and running images with Container Registry Tasks, and deploying containers to Azure App Service with environment variables and secrets. Implementing container-orchestrated solutions covers deploying to Azure Container Apps with environment configuration and revision management, event-driven scaling with Kubernetes Event-driven Autoscaling (KEDA), deploying to Azure Kubernetes Service (AKS) with manifest files, and troubleshooting Container Apps and AKS through logs, events and connectivity.

At 20–25%, this group tests practical container development for AI back-end services. AI workloads are frequently packaged as containers, so the exam rewards choosing the right hosting option and scaling model, and diagnosing container problems.

How it's tested

AI-200 questions are scenario-based and often describe a requirement without naming the service, so you must choose the hosting or scaling option from the requirements. In this domain they describe a container workload and reward the right registry, hosting, scaling or troubleshooting approach. Read the requirement before choosing the service.

  • Right container hosting

    A workload is described, and you choose App Service, Container Apps or AKS for it.

  • Event-driven scaling

    A scaling-on-events need is described, and you choose KEDA in Container Apps.

  • Troubleshoot the container

    A container failure is described, and you choose the logs, events or connectivity check to diagnose it.

Reasoning it through

An AI processing service must scale up automatically when messages arrive on a queue and scale to zero when the queue is empty, without managing a Kubernetes cluster. AKS would require cluster management, and App Service does not scale on queue depth natively. Azure Container Apps with KEDA scales on queue length, including to zero, without managing Kubernetes, which matches the requirement, so Container Apps with KEDA is the answer.

Functional groups 2

Official functional groups from the Microsoft outline, in outline order.

1.1 Implement container application hostingContainer Registry, Registry Tasks, and deploying containers to App Service.
What it means
This covers building, storing, versioning and managing container images in Azure Container Registry, building and running images with Container Registry Tasks, and deploying containers to Azure App Service, including configuring environment variables and secrets for the container.
What to understand
Container Registry is the private image repository, and Registry Tasks build images in the cloud. App Service can host a container and inject configuration through app settings and secrets, often from Key Vault. Image versioning with tags lets you deploy and roll back specific versions.
How it shows up
A hosting or image-management need is described, and you must choose Container Registry, Registry Tasks or App Service container hosting with the right configuration.
Common confusion
Confusing Container Registry with a running container host; the registry stores images, while App Service, Container Apps or AKS run them.
1.2 Implement container-orchestrated solutionsContainer Apps, revisions, KEDA scaling, AKS manifests and troubleshooting.
What it means
This covers deploying applications to Azure Container Apps with environment configuration and revision management, implementing event-driven scaling with Kubernetes Event-driven Autoscaling (KEDA), deploying and managing applications on Azure Kubernetes Service with manifest files, and monitoring and troubleshooting Container Apps and AKS through logs, events and end-to-end connectivity.
What to understand
Container Apps is a managed, serverless container platform with revisions for versioned rollouts and KEDA for event-driven scaling, including scale to zero, without managing Kubernetes. AKS gives full Kubernetes control with manifest-based deployment but more operational overhead. Troubleshooting uses logs, events and connectivity checks.
How it shows up
An orchestration, scaling or troubleshooting need is described, and you must choose Container Apps with KEDA, AKS, or the right diagnostic.
Common confusion
Confusing Container Apps with AKS; Container Apps is managed and serverless with KEDA, while AKS gives full Kubernetes control with more management.

High-yield concepts

The terms, rules and formulas this domain turns into questions most often.

  • Azure Container Registry

    A private repository for container images.

    Remember
    It stores images; it does not run them.
    Tested as
    Image management questions.
    Trap
    Confusing it with a running host.

  • Container Registry Tasks

    Cloud-based building of container images.

    Remember
    Build images without a local Docker host.
    Tested as
    Image build questions.
    Trap
    Overlooking cloud builds.

  • App Service containers

    Hosting a single container with managed configuration.

    Remember
    Inject settings and secrets via app settings.
    Tested as
    Hosting questions.
    Trap
    Using it for complex orchestration.

  • Azure Container Apps

    Managed, serverless container platform with revisions and KEDA.

    Remember
    Serverless scaling, including to zero, without Kubernetes management.
    Tested as
    Orchestration questions.
    Trap
    Confusing it with AKS.

  • KEDA

    Kubernetes Event-driven Autoscaling for scaling on events.

    Remember
    It scales on queue depth and other event sources, including to zero.
    Tested as
    Scaling questions.
    Trap
    Expecting CPU-only scaling for event workloads.

  • Revisions in Container Apps

    Versioned snapshots of a container app for rollout and rollback.

    Remember
    They enable traffic splitting and rollback.
    Tested as
    Deployment questions.
    Trap
    Deploying without revision control.

  • Azure Kubernetes Service (AKS)

    Managed Kubernetes with full control via manifests.

    Remember
    More control, more operational overhead.
    Tested as
    Orchestration questions.
    Trap
    Using AKS where Container Apps suffices.

  • Manifest files

    YAML definitions that deploy and configure AKS resources.

    Remember
    They declare the desired Kubernetes state.
    Tested as
    AKS questions.
    Trap
    Deploying imperatively instead of declaratively.

  • Environment variables and secrets

    Configuration injected into containers, often from Key Vault.

    Remember
    Keep secrets out of images.
    Tested as
    Configuration questions.
    Trap
    Baking secrets into the image.

  • Container troubleshooting

    Diagnosing via logs, events and connectivity.

    Remember
    Check logs and events before rebuilding.
    Tested as
    Troubleshooting questions.
    Trap
    Rebuilding without diagnosing.

Side by side

Concepts candidates mix up, compared on the point that decides the answer.

App Service vs. Container Apps vs. AKS

ConceptMeaningKey differenceCommon trap
App Service container Hosts a single container Simplest, managed Using it for orchestration
Container Apps Managed serverless containers with KEDA Event-driven scaling, no Kubernetes management Confusing with AKS
AKS Full managed Kubernetes Most control, most overhead Using it where Container Apps fits

KEDA vs. CPU-based scaling

ConceptMeaningKey differenceCommon trap
KEDA Scales on event sources such as queue depth Event-driven, scale to zero Expecting CPU-only metrics
CPU-based scaling Scales on CPU or memory Resource-driven Using it for bursty event workloads

Registry vs. running host

ConceptMeaningKey differenceCommon trap
Container Registry Stores images Repository, not compute Expecting it to run containers
Running host App Service, Container Apps or AKS Executes the container Confusing with the registry

Exam traps

Each trap is an answer that looks right. Learn the clue that should change your mind.

  1. AKS for simple scaling

    What candidates pick
    Deploy to AKS for a workload that scales on a queue and needs no cluster management.
    Why it looks right
    AKS is powerful.
    Why it's wrong
    Container Apps with KEDA scales on queue depth, including to zero, without managing Kubernetes.

    Clue to watch for The requirement is event-driven scaling with no cluster management.

  2. CPU scaling for events

    What candidates pick
    Use CPU-based autoscaling for a queue-driven workload.
    Why it looks right
    CPU scaling is familiar.
    Why it's wrong
    KEDA scales on event sources such as queue length, which matches event-driven demand better than CPU.

    Clue to watch for Scaling must follow message or event volume.

  3. Secrets in the image

    What candidates pick
    Embed secrets in the container image for the app.
    Why it looks right
    It is simple.
    Why it's wrong
    Secrets belong in app settings or Key Vault injected at runtime, not baked into the image.

    Clue to watch for The container needs credentials or secrets.

  4. Registry runs containers

    What candidates pick
    Expect Azure Container Registry to run the container.
    Why it looks right
    Both involve containers.
    Why it's wrong
    The registry stores images; App Service, Container Apps or AKS run them.

    Clue to watch for The need is to execute a container versus store an image.

  5. Rebuild before diagnosing

    What candidates pick
    Rebuild and redeploy a failing container immediately.
    Why it looks right
    A fresh build might fix it.
    Why it's wrong
    Logs, events and connectivity checks usually reveal the cause faster than a blind rebuild.

    Clue to watch for A container is failing and the cause is unknown.

Answer framework

For any Domain 1 container scenario, use these steps to find the answer AI-200 expects.

  1. Read the requirement for hosting, scaling and management needs, since the service is often not named.
  2. Choose the hosting option: App Service for a single container, Container Apps for managed serverless containers, or AKS when full Kubernetes control is required.
  3. For event-driven scaling, use KEDA in Container Apps to scale on queue depth or events, including to zero, rather than CPU-based scaling.
  4. Manage images in Container Registry with versioned tags and inject secrets as configuration rather than baking them into images.
  5. For failures, diagnose through logs, events and end-to-end connectivity before rebuilding, and document the fix. Where several options could fit, choose the one the requirements make defensible, and document the reasoning.

Practice question

An AI back-end service must automatically scale out when messages accumulate in an Azure Service Bus queue and scale in to zero when the queue is empty, without the team managing a Kubernetes cluster. Which hosting and scaling approach is MOST appropriate?

Want more like this? The AI-200 practice test has questions for every domain.

Checklist

0 of 10

Tick each one you can do without notes. Your ticks stay in this browser.

Study strategy

This is the most familiar domain for an experienced Azure developer, so use it to warm up before the AI-heavy data domain. Start with Container Registry and image management: build and tag images, use Registry Tasks, and practice deploying a container to App Service with secrets injected as configuration rather than baked in.

Next, master the orchestration choices, which the exam tests closely. Keep Container Apps (managed, serverless, KEDA) and AKS (full Kubernetes, manifests) distinct, and learn KEDA event-driven scaling, including scale to zero, since AI pipelines often scale on queue depth. Practice reading requirements and choosing the hosting option, because the exam often does not name the service.

Finally, practice troubleshooting through logs, events and connectivity. Deploy a small containerized service in a free subscription to make these concrete. Afterwards, move to Domain 2, developing AI solutions with Azure data management services, the largest and most distinctive domain. Review missed practice questions on hosting choice separately, since mixing up Container Apps and AKS is the error most worth catching early.

FAQ

How much of AI-200 is Domain 1?

Develop containerized solutions on Azure is 20–25% of the exam, and it is the most familiar area for developers coming from the retired AZ-204.

What is the difference between Container Apps and AKS?

Azure Container Apps is a managed, serverless container platform with revisions and KEDA scaling that requires no Kubernetes management. AKS gives full Kubernetes control through manifests but with more operational overhead.

What is KEDA?

Kubernetes Event-driven Autoscaling, which scales containers based on event sources such as queue length, including scaling to zero when there is no work, which suits event-driven AI pipelines.

Where should container secrets go?

In app settings or Azure Key Vault, injected into the container at runtime, rather than baked into the image where they could be exposed.

What does Azure Container Registry do?

It stores, versions and manages container images privately. Running the containers is done by App Service, Container Apps or AKS, not the registry itself.

Is AI-200 the same as AZ-204?

No. AI-200 replaced AZ-204, which retired on 31 July 2026. It keeps familiar development content such as containers but shifts the emphasis to building and securing AI cloud solutions.

How does Domain 1 connect to the rest of the exam?

The containerized services here consume the AI data services of Domain 2, connect through the messaging of Domain 3, and are secured and monitored in Domain 4.

Other Cloud Computing certifications

Where the same subject shows up in other exams. Cards marked "Same subject" open the matching domain.

Test your Domain 1 knowledge

You have covered Container Registry, App Service containers, Container Apps, KEDA and AKS. Test whether you can choose the right hosting and scaling approach under exam conditions.

Take the AI-200 practice test Check your AI-200 readiness

Keep going