# Creating and Managing Topics in Copilot Studio

> Chapter 14 of the Courseiva PL-900 curriculum — https://courseiva.com/learn/pl-900/copilot-studio-topics

**Official objective:** 5.2 — Describe how to create topics in Copilot Studio

## Introduction

Creating and managing topics in Copilot Studio. Why does this matter? Because without topics, your AI assistant would be a blank slate — unable to answer even the simplest question. For the PL-900 exam, you need to know how topics are the building blocks of any helpful chatbot, just like chapters are the building blocks of a book. Mastering this concept is the difference between a useless bot and one that actually helps people.

## The Restaurant Menu Analogy

You just walked into a busy restaurant and the host sits you down at a table. What happens next? You don’t start by cooking your own meal. You look at the menu. That menu is a list of all the dishes the restaurant is ready to make — each dish described in detail, with ingredients, cooking instructions, and even notes for dietary needs. When you order a dish, the kitchen follows that exact recipe to serve you.

In Copilot Studio, a topic is like that restaurant menu item. It’s a predefined conversation path that your AI assistant can follow when a customer asks a specific question. For example, if a customer types "I want a refund", that's like saying "I'd like the spaghetti carbonara". The Copilot Studio topic for refunds is the recipe that tells the AI exactly what to say, what questions to ask next ("What’s your order number?"), and how to resolve the request. Without topics, the AI would be like a chef with no recipes — just staring at ingredients, not knowing what to cook. By creating and managing topics, you design the menu so your AI can serve customers consistently, politely, and quickly.

But here's the clever part: a restaurant doesn't just have one menu. It has breakfast, lunch, and specials. You can trigger different topics based on the time of day or the customer's history. That's called branching and triggering conditions. So, just like a restaurant manager updates the menu, you — as a topic creator — decide which conversation paths exist, when they appear, and how they flow. That's the core of creating and managing topics in Copilot Studio.

## Core explanation

In Copilot Studio, a topic is a complete conversation pathway designed to handle one specific user intent. An intent is the goal or purpose behind what a user types — for example, the intent behind "I forgot my password" is to reset access. Topics are triggered when the AI recognises that intent from the user’s message. Topics are made of three main parts: trigger phrases, conversation nodes, and outputs.

Trigger phrases are the words or sentences that tell Copilot Studio, "Hey, this user is asking about this topic." You can list many trigger phrases for one topic. For a password reset topic, you might use: "I can't log in", "forgot password", "reset my account", "locked out". The more accurate trigger phrases you add, the better the AI gets at guessing the right topic.

Conversation nodes are the individual steps inside a topic. Each node is like a single step in a recipe. There are several types of nodes: 
- Question node: asks the user for information (e.g., "What’s your email address?").
- Message node: sends a reply to the user (e.g., "We’ve sent a reset link to your inbox.").
- Condition node: checks something and branches the conversation (e.g., if the user is a VIP member, send them to a premium support team; otherwise, send to standard support).
- Variable operation node: saves or changes data during the conversation (e.g., store the user’s email in a variable called `UserEmail`).
- Topic management node: ends or redirects the conversation to another topic.

You connect these nodes in a flowchart-like editor inside Copilot Studio. You drag and drop nodes to build the conversation logic. For instance, a refund topic might start with a question node asking for the order number, then a condition node to check if the order is within 30 days, then a message node to confirm the refund or deny it. This replaces the old way of building chatbots by hand with complex code. Instead of writing thousands of lines of script, you click blocks together.

Why do topics exist? Before platforms like Copilot Studio, developers had to write every possible conversation path in code using if-then statements and regular expressions. It was slow, error-prone, and impossible to update quickly. Topics solve this by giving non-technical people — business analysts, support managers, even you — the power to create sophisticated conversations without writing a single line of code.

Topics also support system topics. Those are pre-built topics that Microsoft includes in every Copilot Studio chatbot. Examples include:
- Greeting: handles "hello" and "hi".
- Escalate: sends the conversation to a human agent when the AI can't help.
- Goodbye: ends the conversation politely.
- Confirmation: asks "Are you sure?" before performing an action.

You can edit system topics, but you cannot delete them. They are mandatory to ensure the chatbot always has fallback behaviour. If a user says something your custom topics don't cover, the system's Escalate topic kicks in.

Managing topics means organising, testing, and updating them over time. Copilot Studio gives you a dashboard where you can see:
- What topics are published and live.
- Which topics are most used (analytics).
- Where conversations are failing (drop-off rates).
- How long each topic takes to complete.

You can duplicate topics to save time, delete obsolete ones, and publish changes instantly. The platform also lets you import and export topics as files, which helps when moving your bot between different environments (like from testing to production).

For PL-900, remember that topics are the core unit of conversation in Copilot Studio, and managing them effectively is how you keep your AI assistant working well over time. The exam focuses on the lifecycle: create a topic, define trigger phrases, add conversation nodes, test it in the test chat pane, and then publish it so users can interact with it.

## Real-world context

Consider a medium-sized online clothing retailer called "Fashioneer". They use a Copilot Studio chatbot on their website to handle customer queries. Their IT manager, Priya, needs to create a new topic for handling "lost package" enquiries because customers keep repeating themselves in chats.

Priya logs into Copilot Studio and clicks on the "Topics" tab. She creates a new topic and names it "Lost Package Inquiry". She then adds trigger phrases like "Where is my order?", "package lost", "I didn't receive my item", "tracking says delivered but not here", and "my shipment is missing". These phrases help the AI correctly route the conversation. She uses phrases she's actually seen in real support tickets.

Next, Priya builds the conversation flow using nodes:
- She starts with a message node: "I'm sorry your package hasn't arrived. Let me help you track it down."
- She adds a question node asking for the order number.
- She uses a variable to save that order number.
- Then a condition node checks if the order was placed more than 60 days ago. If yes, the chatbot sends a message: "This order is outside our carrier investigation window. Let me connect you to a human agent." If within 60 days, the chatbot asks for the delivery address.
- Another condition node checks the address against the order system (via a connection to their backend). If matched, the chatbot triggers a carrier trace request and sends a confirmation message. If not matched, it asks the customer to double-check the address.

Priya clicks "Save" and uses the test pane to type "I didn't get my jeans". The chatbot triggers the new topic correctly. She notices one issue: the chatbot asks for the order number before the delivery address, but customers often don't have the order number handy. She reorders the nodes to ask for the zip code and name first, then looks up the order number automatically. She tests again and it works smoothly.

Then she publishes the topic. Immediately, the live chatbot starts handling lost package enquiries correctly. Within a week, Priya checks the topic analytics and sees a 40% drop in escalations to human agents for this issue. The chatbot resolves the problem on its own. She then duplicates the topic and modifies it slightly for "damaged package" enquiries to save time.

This is exactly what an IT professional (or a business analyst using low-code tools) does with topics every day. They don't write code. They design conversation paths, test them, monitor performance, and iterate based on real user behaviour.

## Exam focus

The PL-900 exam tests your understanding of topics in Copilot Studio in a few specific ways. First, you need to know what a topic IS. A common exam question gives you a scenario: "A user types a message into a Copilot chatbot. How does the chatbot decide which topic to use?" The correct answer is: it matches trigger phrases from the user's message to the trigger phrases defined in topics.

Second, the exam tests the difference between custom topics and system topics. Remember: system topics are built-in and cannot be deleted (Greeting, Goodbye, Escalate, Confirmation). The exam might present a false statement like "All topics can be deleted" or "You can create unlimited custom topics but only delete some system topics". The truth is you cannot delete system topics, but you can edit them.

Third, the exam loves to ask about trigger phrases. Key traps:
- Trigger phrases are not case-sensitive — "HELLO" and "hello" both work.
- You can have multiple trigger phrases per topic, and Copilot uses machine learning to match variations even if not exact.
- The exam may confuse you by saying trigger phrases have to be exact matches — that's wrong. The AI is smart enough to understand synonyms.

Fourth, the exam might ask about topic management in the authoring canvas (the visual designer). Questions like "Which node would you use to ask the user for information?" Answer: Question node. "Which node would you use to send a message?" Message node. "Which node allows you to make decisions based on conditions?" Condition node.

Fifth, publishing and versioning. Topics must be published to go live. You can have unpublished versions that you test before making them available to users. The exam might present a scenario where someone edits a topic but users still see the old behaviour — that's because they didn't publish. The correct step is to publish after editing.

Key definitions to memorise:
- Topic: a conversation path for a specific user intent.
- Trigger phrase: phrases that tell the AI which topic to activate.
- Node: a single step in a topic (Question, Message, Condition, etc.).
- System topic: pre-built topics that handle essential bot behaviours.
- Publish: the action that makes your topic available to end users.

Common trap patterns on the exam:
- The exam might describe a scenario with a chatbot that can't handle a request and ask what to do. The answer is to either create a new custom topic or edit an existing one — not to delete the system topic.
- Another trap: they might say that trigger phrases must be perfect sentences. Actually, fragments like "order status" work fine.
- They might present a scenario where a chatbot responds incorrectly and ask why. The answer is often that the wrong topic was triggered because trigger phrases were too broad (e.g., "help" triggering a refund topic instead of a general help topic). So you need to narrow the trigger phrases or reorder topic priority.

Finally, memorise the order of events: create a topic → add trigger phrases → build nodes in the canvas → test in test pane → publish → monitor analytics. This lifecycle is exam gold.

## Step by step

1. **Create a New Topic** — In Copilot Studio, go to the Topics page and click 'New Topic'. Give it a descriptive name that reflects the user's intent, like 'Order Cancellation'. This name is for your management only — users never see it. Naming it well helps you find it later.
2. **Define Trigger Phrases** — Add at least five to ten trigger phrases that users might type to indicate they want this topic. For 'Order Cancellation', you might add 'cancel my order', 'I want to cancel', 'stop shipment', 'remove item from order'. The more good phrases, the more accurate the AI will be. Avoid single-word phrases like 'cancel' because they are too broad and may trigger this topic for unrelated queries.
3. **Add Conversation Nodes in the Authoring Canvas** — Drag and drop nodes onto the canvas to build the conversation flow. Start with a Message node to acknowledge the user (e.g., 'I see you want to cancel an order.'). Then add a Question node to collect the order number. Use a Condition node to check if the order is eligible for cancellation (e.g., status is 'Pending'). Finally, use a Message node to either confirm the cancellation or explain why it can't be done. This step is where you design the actual user experience.
4. **Test the Topic Using the Test Pane** — Click 'Test' to open a chat pane on the right. Type a trigger phrase like 'I need to cancel' and see if the correct topic fires. Walk through each step of the conversation and check that nodes fire in the right order. If something goes wrong, edit the nodes and test again. This step catches errors before users do.
5. **Publish the Topic** — Once tested, click 'Publish' to make the topic available on your live chatbot. Without publishing, your edits remain as a draft and users will see the old version. Publishing is the final step that updates the bot for everyone. After publishing, you can still edit and republish later.
6. **Monitor and Improve Based on Analytics** — After the topic is live, check the analytics dashboard to see how often it's used, where users drop off, and how many conversations escalate to a human. Use this data to refine trigger phrases, adjust conversation paths, or add new nodes to handle edge cases. This is an ongoing process, not a one-time task.

## Comparisons

### Custom Topic vs System Topic

**Custom Topic:**
- Created by you for a specific business need like refunds.
- You can create unlimited custom topics.
- Can be deleted if no longer needed.

**System Topic:**
- Pre-built by Microsoft for general behaviours like greeting.
- Limited to a fixed set (Greeting, Goodbye, Escalate, Confirmation).
- Cannot be deleted, only edited.

### Trigger Phrase vs Conversation Node

**Trigger Phrase:**
- A word or phrase that activates a topic.
- Usually at the start of a topic definition.
- No logic; just matching input.

**Conversation Node:**
- A single step inside a topic, like asking a question.
- Form the structure of the conversation flow.
- Contains logic like conditions and variables.

### Question Node vs Message Node

**Question Node:**
- Asks user for information and stores the response.
- Creates a variable to hold user input.
- Can be followed by a condition node to check the answer.

**Message Node:**
- Sends a message to the user without expecting a reply.
- Used for confirmations, instructions, or closing remarks.
- Does not store user data.

### Publishing a Topic vs Saving a Topic

**Publishing a Topic:**
- Makes the topic live for all users.
- Requires publishing each time you change the topic.
- Can be undone by publishing an older version.

**Saving a Topic:**
- Stores your draft changes locally.
- Does not affect the live chatbot.
- Lets you work without disrupting users.

## Diagram

_This diagram shows the basic flow of a custom topic from user input through nodes to resolution._

```mermaid
flowchart TD
    A[User types message] --> B{Copilot AI matches trigger phrases}
    B --> C[Topic selected: e.g. Order Cancellation]
    C --> D[Message Node: Acknowledge user]
    D --> E[Question Node: Ask for order number]
    E --> F{Condition Node: Is order cancellable?}
    F -- Yes --> G[Message Node: Confirm cancellation]
    F -- No --> H[Message Node: Explain why not]
    G --> I[Topic Management: End or redirect]
    H --> I
```

## Common misconceptions

- **Misconception:** Topics are just pre-written responses, like a FAQ list — the user clicks a button and gets a fixed answer. **Reality:** Topics are dynamic conversation flows with branching logic. They can ask questions, save user input, check conditions, and hand off to different topics or human agents. They are interactive, not static. (Beginners often confuse a chatbot topic with a simple auto-reply email. They see a smooth interaction and think the bot just had a canned response. They don't realise the topic is making decisions behind the scenes.)
- **Misconception:** Trigger phrases must be an exact match to what the user types, otherwise the topic won't activate. **Reality:** Copilot Studio uses natural language understanding (NLU) to match the user's intent. Even if the user types something not exactly in the trigger list, the AI can still select the right topic based on meaning. (People are used to old-school rule-based systems where you had to match keywords exactly. They don't yet trust that AI can understand paraphrasing.)
- **Misconception:** You can only have one topic active at a time; if a user talks about two things, only one is handled. **Reality:** A single conversation can move between multiple topics. For example, a user might ask about a refund and then ask about shipping — the chatbot can redirect to a different topic mid-conversation using topic redirect nodes. (Beginners think topics are siloed because they see them listed separately in the interface. They don't grasp that topics can link together like a web.)
- **Misconception:** Once you create a topic and publish it, you should never edit it because it will break the chatbot. **Reality:** You can and should edit topics based on analytics and feedback. Copilot Studio allows you to edit, test, and republish safely. It's part of normal maintenance. (Many beginners come from a mindset where changing a live system is risky (like changing a plane engine mid-flight). They overestimate the fragility of low-code platforms.)
- **Misconception:** System topics like Greeting and Goodbye are optional — you can delete them if you don't want them. **Reality:** System topics cannot be deleted. They are mandatory. You can edit their content, but you cannot remove them from the bot. (People assume everything in a menu can be removed. The exam specifically tests this misconception because it's a common error in user interviews.)

## Key takeaways

- A topic is a complete conversation pathway triggered by user phrases, designed to handle one specific intent like 'reset password' or 'check order status'.
- Trigger phrases are phrases you add to a topic so the AI recognises when a user wants that topic — they do not need to be exact matches, thanks to natural language understanding.
- The four main types of conversation nodes are Question (to ask for info), Message (to reply), Condition (to branch logic), and Topic Management (to redirect or end).
- System topics like Greeting, Goodbye, Escalate, and Confirmation come built into every bot and cannot be deleted, only edited.
- Topics must be published to go live for users — editing them without publishing only changes the draft version.
- The lifecycle of a topic is: create, define trigger phrases, build nodes, test in the test pane, publish, and then monitor analytics to improve it.
- You can connect multiple topics together so a single conversation can flow through different topics based on user input.

## FAQ

**Can I delete a system topic like Greeting in Copilot Studio?**

No. System topics are built-in and cannot be deleted. You can edit their content (like changing the greeting message), but the topic itself will always exist in your bot.

**How many trigger phrases should I add to a topic?**

Aim for at least five to ten varied trigger phrases for each topic. Include different phrasings, synonyms, and even common typos. The more relevant phrases you add, the better the AI will match user intent.

**Do trigger phrases have to be exact matches for the topic to activate?**

No. Copilot Studio uses natural language understanding to interpret meaning, not just exact keywords. Even if a user types something not in your trigger list, the AI can still select the correct topic based on similarity.

**What happens if a user's message doesn't match any topic?**

The system's Escalate topic is triggered by default. This topic usually sends a message like 'I'm sorry, I didn't understand' and can redirect the user to a human agent or prompt them to rephrase.

**Can a conversation move from one topic to another?**

Yes. You can use a Topic Management node to redirect the conversation to a different topic. For example, after a refund is processed, you could automatically redirect the user to a 'Feedback' topic.

**Do I need to know code to create topics in Copilot Studio?**

No. Copilot Studio is a low-code platform. The topic creation interface uses drag-and-drop nodes and a visual canvas. No programming knowledge is required, though you can add advanced logic using Power Fx formulas if you want.

## Check your understanding

1. **What is the purpose of trigger phrases in a Copilot Studio topic?**

   Answer: Trigger phrases let the AI recognise a user's intent and activate the correct topic. They are phrases the user might type, and the AI matches them (with natural language understanding) to bring up the right conversation path.

2. **Name two types of conversation nodes you can use in a topic and what each one does.**

   Answer: Question Node: asks the user for information and stores it in a variable. Condition Node: checks a condition (like a variable value) and branches the conversation into different paths.

3. **Can you delete the built-in Greeting topic in Copilot Studio?**

   Answer: No. The Greeting topic is a system topic and cannot be deleted. You can edit its content, but the topic itself will always exist in the bot.

4. **What happens if you edit a topic but do not publish it?**

   Answer: The changes remain as a draft and are not visible to end users. The live chatbot continues to use the last published version of the topic.

5. **How does a topic handle a situation where the user's request does not match any trigger phrases?**

   Answer: The system's Escalate topic is triggered by default. It usually sends a fallback message (like 'I'm sorry, I didn't understand') and can redirect the user to a human agent.

---

Interactive version with quiz and diagrams: https://courseiva.com/learn/pl-900/copilot-studio-topics