AB-620, Agentic AI, AI, Microsoft Certification

Configure adaptive cards (AB-620 Exam Prep)

 
This post is a part of the AB-620: Designing and Building Integrated AI Agent Solutions in Copilot Studio Exam Prep Hub.
This topic falls under these sections:
Plan and configure agent solutions (30–35%)
   --> Configure topics
      --> Configure adaptive cards

Note that there are 10 practice questions (with answers) at the end of each section to help you solidify your knowledge of the material. Also, there are 4 practice tests with 30 questions each available from the hub's main page below the exam topics section.

What Are Adaptive Cards in Copilot Studio?

Adaptive Cards are a structured way to present rich, interactive UI elements inside a Copilot Studio agent conversation. Instead of plain text responses, they allow agents to display:

  • Forms
  • Tables
  • Images
  • Buttons
  • Structured data
  • Input controls

They are defined using JSON schema and rendered consistently across channels such as Microsoft Teams, web chat, and other supported interfaces.

In Copilot Studio, Adaptive Cards are commonly used when you need more than conversational text, especially when collecting structured input or displaying business data.

Why Adaptive Cards Are Used

Adaptive Cards help bridge the gap between conversation and application UI.

Key reasons they are used:

  • Improve user experience with structured layouts
  • Reduce conversational back-and-forth
  • Collect multiple inputs in a single interaction
  • Display data in a visually organized way
  • Enable guided actions (buttons, choices, forms)
  • Support enterprise-grade workflows inside chat

Core Structure of an Adaptive Card

An Adaptive Card is composed of three main layers:

1. Schema Version

Defines compatibility.

"version": "1.5"

2. Body

Contains visual and input elements.

Examples:

  • TextBlock
  • Image
  • Input.Text
  • Input.ChoiceSet
  • Container

3. Actions

Defines what the user can do.

Examples:

  • Submit
  • OpenUrl
  • Execute (in some advanced scenarios)

Common Adaptive Card Elements

TextBlock

Used to display text content.

  • Titles
  • Instructions
  • Labels

Input.Text

Captures free-text user input.

Example use:

  • Name
  • Email
  • Description

Input.ChoiceSet

Used for dropdowns, radio buttons, or multi-select.

Example:

  • Department selection
  • Product category
  • Priority level

Image

Displays visual content such as logos or product images.

Action.Submit

Sends user input back to the agent.

Adding Adaptive Cards in Copilot Studio Topics

In Copilot Studio, Adaptive Cards are typically added inside a topic node.

Basic Flow:

  1. User triggers topic
  2. Agent displays Adaptive Card
  3. User completes form/input
  4. Data is returned to variables
  5. Topic continues logic flow

Typical Configuration Steps

Step 1: Add a “Ask with Adaptive Card” node

This node renders the card inside the conversation.

Step 2: Define or paste Adaptive Card JSON

You either:

  • Paste a prebuilt JSON schema
  • Or build via Copilot Studio editor

Step 3: Map outputs to variables

Each input field is mapped to:

  • Topic variables
  • Conversation variables
  • Global variables (if needed)

Example mapping:

  • Input.Text → userEmail
  • ChoiceSet → departmentSelection

Step 4: Use collected data in workflow

Once captured, data can be used for:

  • Power Automate flows
  • API calls
  • Conditional branching
  • Database updates

Dynamic Adaptive Cards

Adaptive Cards in Copilot Studio can include dynamic values using variables.

Example:

{
  "type": "TextBlock",
  "text": "Hello {{userName}}"
}

This allows personalization such as:

  • Greeting users
  • Displaying previous answers
  • Showing context-aware content

Common Use Cases in Enterprise Scenarios

1. IT Service Desk

  • Ticket submission forms
  • Incident categorization
  • Priority selection

2. HR Assistants

  • Leave request forms
  • Benefits selection
  • Onboarding checklists

3. Customer Support

  • Case creation
  • Product selection
  • Feedback forms

4. Internal Tools

  • Approval requests
  • Data entry workflows
  • Status updates

Design Principles for Adaptive Cards

1. Keep It Simple

Avoid overly complex layouts. Cards should be easy to complete.

2. Minimize Inputs

Only ask for required data.

3. Group Related Fields

Use containers to logically organize inputs.

4. Provide Clear Labels

Ensure users understand what is being asked.

5. Use Defaults Where Possible

Pre-fill known values to reduce effort.

Accessibility Considerations

Adaptive Cards should:

  • Use readable font sizes
  • Maintain high contrast
  • Avoid overly dense layouts
  • Provide clear instructions
  • Ensure keyboard navigation support (where applicable)

Adaptive Cards vs Regular Messages

FeatureAdaptive CardsText Messages
Structured inputYesNo
UI componentsYesNo
Data collectionHigh efficiencyManual parsing
Visual layoutRichLimited
Use caseForms, workflowsSimple responses

Common Mistakes

1. Overcomplicating cards

Too many fields reduce completion rates.

2. Not mapping variables correctly

Results in missing or unusable data.

3. Ignoring validation

Leads to bad or incomplete inputs.

4. Using cards for simple responses

Text is better for simple answers.

5. Forgetting fallback handling

If card fails, conversation should continue gracefully.

When NOT to Use Adaptive Cards

Avoid Adaptive Cards when:

  • Only a simple answer is needed
  • No user input is required
  • The response is purely informational
  • A generative answer is more appropriate

Exam Tips (AB-620)

For the exam, focus on these key ideas:

  • Adaptive Cards are JSON-based UI components
  • They are used for structured interaction
  • Inputs map to variables in Copilot Studio
  • They are commonly used in topics, not generative answers
  • They support buttons, inputs, and rich formatting
  • They reduce conversational complexity
  • They are best for business process interactions
  • They integrate with Power Automate and APIs
  • They improve user experience in enterprise workflows
  • They are not meant for free-form conversation

Advanced Adaptive Card Capabilities in Copilot Studio

Once you understand the basics of Adaptive Cards, the exam expects you to recognize how they behave in real enterprise-grade agent solutions, especially when combined with:

  • Variables
  • Power Automate flows
  • API calls
  • Topics
  • Generative answers (hybrid patterns)
  • Conditional logic

1. Using Variables Inside Adaptive Cards

Adaptive Cards in Copilot Studio support dynamic content through variables.

Example use cases:

  • Personalized greetings
  • Pre-filled form fields
  • Context-aware instructions

Example:

{
  "type": "TextBlock",
  "text": "Welcome {{userName}}, please confirm your request."
}

Key concept:

Variables are resolved at runtime and injected into the card before rendering.

2. Capturing and Returning Structured Input

Adaptive Cards are powerful because they return structured outputs, not just text.

Example mapping:

Card FieldCopilot Studio Variable
Input.Text (Email)userEmail
ChoiceSet (Department)selectedDepartment
Date InputrequestDate

Once submitted:

  • Values are stored in topic variables
  • Used in downstream logic (flows, APIs, conditions)

3. Adaptive Cards + Power Automate Integration

One of the most common enterprise patterns.

Flow:

  1. User completes Adaptive Card
  2. Data is stored in variables
  3. Topic calls Power Automate flow
  4. Flow processes data (e.g., create ticket, update record)
  5. Response returned to agent

Example use cases:

  • ServiceNow ticket creation
  • HR leave approval
  • CRM record updates
  • Order processing

4. Conditional Rendering (Dynamic Card Behavior)

Adaptive Cards can change based on:

  • User role
  • Prior answers
  • System state
  • Variables

Example pattern:

  • If user = “IT Admin” → show advanced options
  • If user = “Employee” → show simplified form

This is handled using:

  • Topic logic before rendering
  • Variable-based branching

5. Error Handling in Adaptive Cards

Adaptive Cards themselves do not “handle errors,” but Copilot Studio manages:

Common strategies:

  • Validation before submission
  • Required field enforcement
  • Re-prompting user on invalid input
  • Fallback to text input

Example:

If API fails after submission:

  • Show error message
  • Ask user to retry
  • Log failure in monitoring system

6. Adaptive Cards vs Power Fx Expressions

Adaptive Cards:

  • Define UI structure
  • Collect input
  • Render visuals

Power Fx:

  • Used for logic and expressions in Copilot Studio
  • Helps transform or validate values

Example:

  • Validate email format before submission
  • Compute derived values (e.g., priority level)

7. Security and Data Sensitivity

Adaptive Cards often collect sensitive data.

Important considerations:

  • Do not expose secrets in card JSON
  • Use secured variables
  • Avoid displaying sensitive backend values
  • Ensure compliance with organizational policies

8. Performance Considerations

Poorly designed cards can impact user experience.

Best practices:

  • Keep JSON lightweight
  • Avoid unnecessary images
  • Limit number of inputs per card
  • Reduce nested containers
  • Avoid overly large payloads

9. Multi-Step Adaptive Card Workflows

Instead of one large card:

Break into steps:

  1. Basic information card
  2. Detail collection card
  3. Confirmation card

Benefits:

  • Better usability
  • Lower abandonment rate
  • Cleaner logic flow

10. Common Enterprise Patterns

Pattern 1: Service Request Intake

  • Collect issue type
  • Collect urgency
  • Collect description
  • Submit to ticket system

Pattern 2: HR Onboarding

  • Employee details
  • Role selection
  • Equipment request
  • Manager approval trigger

Pattern 3: Customer Feedback

  • Rating selection
  • Comments input
  • Submit to CRM

Pattern 4: Approval Workflow

  • Request details
  • Approver selection
  • Approval action buttons

Common Pitfalls (Exam Focus)

  • Overusing Adaptive Cards for simple text responses
  • Missing variable mapping after submission
  • Not validating required fields
  • Ignoring fallback conversation design
  • Creating overly complex card layouts
  • Not considering user accessibility

Exam Tips (AB-620)

Key things to remember:

  • Adaptive Cards = structured UI in JSON format
  • Used inside Topics (not generative answers directly)
  • Inputs map to Copilot Studio variables
  • Frequently combined with Power Automate flows
  • Support dynamic content using variables
  • Better for structured workflows than free-form chat
  • Can be used for enterprise forms and approvals
  • Improve UX by reducing conversational steps
  • Should be simple, focused, and task-oriented
  • Often part of hybrid agent designs

Practice Exam Questions

Question 1

An agent needs to collect multiple fields (name, department, and request type) in a single interaction.

What should be used?

A. Generative Answers node
B. Topic variables only
C. Adaptive Card with input controls
D. Conversation summary node

Answer: C

Explanation: Adaptive Cards allow structured multi-field input in a single UI interaction.

Question 2

What is the primary format used to define Adaptive Cards?

A. YAML
B. XML
C. Markdown
D. JSON schema

Answer: D

Explanation: Adaptive Cards are defined using JSON.

Question 3

A developer wants to pass user input from an Adaptive Card into a Power Automate flow.

What is required?

A. Direct API call from card
B. Manual email parsing
C. Mapping card inputs to variables first
D. Using generative responses

Answer: C

Explanation: Inputs must be stored in variables before being passed to flows or connectors.

Question 4

Which component of an Adaptive Card defines user actions like Submit or Open URL?

A. Body
B. Schema
C. Variables
D. Actions

Answer: D

Explanation: Actions define what happens when a user interacts with the card.

Question 5

What is a best practice when designing Adaptive Cards?

A. Include as many fields as possible
B. Use nested loops in JSON
C. Avoid using variables
D. Keep the card simple and focused

Answer: D

Explanation: Simpler cards improve usability and completion rates.

Question 6

Which Copilot Studio feature is MOST commonly used with Adaptive Cards for automation?

A. Dataverse triggers
B. Azure DevOps pipelines
C. Power Automate flows
D. Azure Functions only

Answer: C

Explanation: Power Automate is commonly used to process data collected from Adaptive Cards.

Question 7

A developer wants to personalize an Adaptive Card with the user’s name.

What should be used?

A. Hardcoded values
B. Static JSON only
C. API gateway
D. Variables inside the card template

Answer: D

Explanation: Variables allow dynamic content insertion at runtime.

Question 8

What happens when a user submits an Adaptive Card in Copilot Studio?

A. The card is deleted permanently
B. A new topic is created automatically
C. The agent restarts
D. Input values are stored in mapped variables

Answer: D

Explanation: Submitted values are captured in Copilot Studio variables for use in the conversation flow.

Question 9

Which scenario is NOT suitable for Adaptive Cards?

A. Collecting structured form data
B. Displaying service request forms
C. Showing multiple input fields
D. Answering a simple factual question

Answer: D

Explanation: Simple questions are better handled by text or generative answers.

Question 10

What is the main advantage of Adaptive Cards over plain text responses?

A. Faster deployment pipelines
B. Reduced licensing cost
C. Structured data collection and richer UI interaction
D. Automatic AI training

Answer: C

Explanation: Adaptive Cards provide structured input and rich UI elements, improving interaction quality.

Go to the AB-620 Exam Prep Hub main page