top of page
hero-bg-1.png

Search Content

Search this site

201 results found with an empty search

  • How to Build Dynamic Power Apps Dashboards Without Power BI

    Turn the records people already work with into on-demand dashboards by adding one focused AI capability to a familiar Canvas app. TL;DR A prompt-backed AI step can turn selected records in an existing Power Apps Canvas app into a fresh HTML dashboard. Learn how the selection becomes JSON, how a prompt shapes the output, and when this flexible approach belongs beside Power BI. A dashboard does not have to be the same collection of charts every time. When people select different records, they often need a different view of the data, not another fixed report they have to navigate around. Not to mention, they like shiny and sometimes the traditional reporting tools are less than pretty. A practical option is to keep the Canvas app, its data, and the familiar filtering experience, then add one AI-powered capability: ask a prompt to turn the selected records into an on-demand dashboard. This is a useful way to start using AI in an existing solution without rebuilding the app around AI. For the complete walkthrough, watch Build Dynamic Power Apps Dashboards Without Power BI. What makes a Power Apps dashboard dynamic? A dynamic dashboard changes its summaries and visuals based on the records a person chooses. In the demo, the user selects opportunities in a Sales Opportunity Explorer Canvas app and asks for a dashboard. A small selection produces a focused summary. A larger selection can support different views, such as revenue by quarter or opportunity status. The important distinction is that the app is not rendering a single, prebuilt report layout. It sends the chosen data to an AI prompt and displays the returned dashboard. That makes the experience flexible, but it also means the prompt and the returned content need clear boundaries and testing. How can you add AI without replacing the app you already have? The demo keeps the familiar parts of a Canvas app: a data source, search and filters, a gallery, and selection controls. The new behavior is a focused addition to that experience, not a new app architecture. The pattern is useful when your existing app already gets users to the right records but cannot easily answer every follow-up question with one fixed screen. The same idea can inform small additions to existing flows, such as sending data already available in a flow through an approved AI prompt step. This video demonstrates a Canvas app, not a Power Automate flow, so treat a flow version as an adaptation that needs its own design and testing. How does the app turn selected records into a dashboard? How does Power Apps prepare the selected data? When a user checks opportunity rows, the app places those records in a collection. The dashboard action uses the Power Apps JSON function to serialize the relevant columns into structured JSON, then passes that JSON as the input to an AI prompt. Selecting only the fields the prompt needs keeps the request focused and makes the data shape easier to explain. What does the AI prompt control? The prompt tells the model what the incoming fields mean, what kinds of summaries and visuals to consider, and what not to do. In the walkthrough, it asks for HTML only, uses inline CSS, applies a visual theme, and tells the model not to invent business data and to check its calculations. It also accounts for the HTML Text control by specifying compatible markup conventions, including single quotes for HTML attributes. The app calls the prompt, stores the returned text, and displays it on a dashboard screen with an HTML Text control. The layout is generated from the response rather than recreated as a collection of fixed Power Apps charts. What changes when the user selects different records? The data changes the dashboard. The video shows one result for two selected opportunities and another result after selecting twelve records. The larger set supports different summaries and visualizations, which is the main benefit of asking a prompt to respond to the current selection instead of forcing every user through one static report. That flexibility does not make the result a source of record. A model can produce a polished layout and still misunderstand a field or calculate something incorrectly. Keep the prompt specific, test it with small and large selections, and compare its summaries with the underlying data before people rely on them. When is this a better fit than Power BI? Use an AI-generated dashboard when people need quick, ad hoc exploration of the records in front of them. It can help a user get a useful summary without asking you to anticipate every possible question and build a separate chart for each one. Use Power BI or another governed reporting approach when the organization needs stable definitions, consistent visuals, and repeatable reporting for leadership, finance, or board decisions. The video makes this distinction directly: a flexible, AI-generated view is not meant to replace a carefully structured executive report. Think of the two approaches as serving different jobs. A dynamic Power Apps dashboard can help someone explore a changing selection. A governed report remains the better place for official numbers that must be consistent across users and meetings. What should you plan for before using the pattern with real users? AI generation takes time. In the prompt test shown in the video, a response took about twenty-four seconds, so users need feedback while they wait. The demo uses a playful loading indicator; in a business app, use a clear progress message and explain that the dashboard is being generated. Also plan around the data you send, the models available in your environment, and how the output is checked. Keep the prompt grounded in the selected records, avoid sending information that should not be processed by the configured AI service, and verify calculations and HTML rendering across realistic inputs. A clean-looking dashboard should not be treated as proof that its analysis is correct. You can let users add a little direction, too. A short text box could let someone ask the prompt to focus on margin or prefer a certain chart type. That extra instruction should guide the result without overriding the rules that protect the data and keep the output usable. The video also explores turning the HTML into a PDF or email body. A quick PDF test clipped part of an image, so treat export as a separate feature to validate rather than assuming a dashboard that looks good in the app will paginate correctly. Frequently asked questions Can a Power Apps Canvas app generate a different dashboard for each selection? Yes. A Canvas app can send the selected records as JSON to an AI prompt and render the returned HTML. The result can vary with the data, but it must be tested for accuracy and consistency. Does this replace Power BI? No. This pattern is for flexible, on-demand exploration inside an app. Use Power BI or another governed reporting tool for official reports that need stable calculations and consistent presentation. Do I need to rebuild my Canvas app to add this? Usually not. The example keeps the existing data source, filters, gallery, and selection pattern, then adds a prompt call and a screen to render its HTML response. Your app still needs changes and testing, but the whole experience does not have to be replaced. Can the user influence what the generated dashboard emphasizes? Yes. You can add an optional instruction field and pass the user’s preference to the prompt, such as emphasizing margin or preferring a particular chart style. Keep system rules and data constraints in the prompt as well. Can this same idea be used in a Power Automate flow? The pattern can be adapted, but the video does not demonstrate a flow. A flow could use an available AI prompt action with its existing data, but that implementation needs to be designed and tested for the flow’s trigger, inputs, and environment. How long does AI dashboard generation take? It can take long enough to require a progress message. One prompt test in the video took about twenty-four seconds. Actual response time varies with the model, prompt, and data, so set expectations based on your own tests. Key takeaways A prompt can turn selected records in a Power Apps Canvas app into an on-demand HTML dashboard. You can add a focused AI capability while keeping the app’s existing data, filters, and gallery experience. Serialize only the relevant fields to JSON and explain those fields clearly in the prompt. Constrain the output format and verify the returned calculations and HTML before relying on the result. Dynamic dashboards are useful for ad hoc exploration, while Power BI remains a stronger fit for governed, repeatable reporting. AI generation has latency, so show users clear progress and test with realistic data selections. Treat a Power Automate version as an adaptation, because this walkthrough demonstrates a Canvas app only. If you want help bringing AI into apps and flows you already use, the team at PowerApps911 can help you choose a useful first step and build it with the right guardrails. Just click the Contact button and let us know what we can do for you!

  • Power Platform Development Changed: Why Professional Makers Need to Start with a Prompt

    A practical look at building a Power Platform solution with a prompt, and what it means for professional makers. TL;DR I gave GitHub Copilot a 480-word prompt and, in one run, it built a working Power Platform request solution with Dataverse tables, security, a model-driven app, a canvas app, and three Power Automate flows. The first build took 44 minutes and used 661 credits, which I estimated at less than $7 in credits. If you build Power Platform solutions professionally, this is the part you should pay attention to: the starting point for development is moving from dragging and dropping to describing what you want. I have built Power Apps and Power Automate solutions for a long time, so I am not easily impressed by a demo that creates a pretty screen and an app that doesn't really work. What got my attention here was not one isolated AI trick. It was how much of a real solution I could build, how quickly I could build it, and how little of the traditional construction work I had to do myself. The big story is not the request-management app I built. The story is that professional makers need to start learning how to build with words. You still need your Power Platform skills. You still need to understand architecture, Dataverse, security, automation, UX, testing, and what a business actually needs. But the amount of implementation work you can hand to these tools has changed fast, and the results are getting really good. If you would rather watch the full walkthrough, check out the video here: Power Apps Development Will Never Be the Same How did this solution start? My design was not some giant specification. I had a simple workflow in mind: a requester submits something, it gets routed to the right manager, the manager breaks it into tasks and assigns those tasks, the doer completes the work, and the original requester gets notified when everything is finished. I also wanted files, overdue reminders, and enough variety to make it useful for teaching. That was basically the brainstorming. The interesting part is what happened next. When I wanted to build this solution, I did not start in Power Apps Maker Studio. I started with Copilot, talked through the business process, and used that conversation to produce the prompt I could hand to the GitHub Copilot app. Inside the GitHub Copilot app, I used the Power Apps, Power Automate, Copilot Studio, and model-driven app plugins to build across the solution. That is a fundamental workflow change. Instead of opening Maker Studio and beginning with controls, screens, and drag-and-drop authoring, I began with a conversation and a description of the outcome. I mainly went into Maker Studio afterward to verify the generated work and make small tweaks. What did the first prompt build? The initial solution was intentionally broad because I wanted to demonstrate several parts of the Power Platform working together. From that prompt, the build included: Three Dataverse tables for request types, work requests, and work tasks, including the supporting security. A model-driven app for requesters to submit work. A canvas app for managers to triage requests, create tasks, assign people, upload files, and for doers to update their work. A Power Automate flow that routes a new request to the appropriate manager based on request type. A flow that notifies the original requester after all related tasks are complete. A daily overdue reminder flow, otherwise known around here as a nag flow. Deep links in notifications so people can jump back into the work. For the demo, I submitted a marketing request to “Get Buddy ready for Christmas,” created tasks to give Buddy a bath and buy him a Santa suit, attached a file, assigned the work, and moved the tasks through the process. Silly scenario, real architecture. How fast did the GitHub Copilot app build the solution? Here is the part that made me stop and really think about where this is going. The main prompt was about 480 words. The build ran for 44 minutes and used 661 credits, which I estimated at less than $7. I did not go in afterward and quietly rebuild half of it. The apps, flows, Dataverse tables, security, and solution you see in the video came from that run. That is one demo run, not a universal benchmark. Your solution, environment, complexity, and iteration will change the numbers. I also spent more later when I had Copilot do hardening and testing. But even with that caveat, think about the amount of functioning Power Platform work that came out of a relatively small amount of natural-language instruction. This is why I keep telling professional makers that your first step should increasingly be a tool where you describe the outcome before you start dragging controls around. Do you need to be a prompt expert? There is another important detail. I did not magically know the perfect 480 words to type. I started with my rough notes and talked the idea through with Copilot. I gave it the workshop context and the pieces I wanted students to learn, including the model-driven app, canvas app, Dataverse, and flows. We went back and forth for roughly ten minutes. Once it understood what I wanted, I asked it to give me the prompt I should use for the build. That workflow matters. The skill is not memorizing some giant magical prompt formula. The skill is being able to explain the business problem, recognize the important requirements, have a conversation about the design, and judge whether the result makes sense. Those are exactly the skills experienced makers already have. What else can you build from the same process? Once the core solution existed, the fun part was seeing how many different experiences I could put on top of the same business process. This is where the demo becomes more than “AI built an app.” It shows how quickly we can explore different ways to solve the same problem. What can a generative page add? I asked Copilot for a generative page to improve the requester experience inside the model-driven app. Instead of treating it as a completely separate solution, it became another front end over the same request process. The existing Dataverse and automation pieces could keep doing their jobs. Reminder: This generative page wasn't necessary or doing anything new. Just me showing off we could do the same stuff a different way. 😁 How does a Copilot Studio agent fit? Next I asked for a Copilot Studio agent that could work with the same solution. The agent could retrieve my submitted requests and interact with the underlying data and process. In my run, building that agent used 213 credits. Again, the interesting part is not merely that an agent exists. It is that I could add a completely different interaction model to the same business solution with another prompt. Also, because I am asked often, it is using the same tables. I am not replicating the data, just a different way to interact with the same data. This is laying the framework for a future concept. Also, the agent isn't just read. It fully supports adding requests, editing them, etc while also just being a way to chat about the work. The agent can basically do everything the apps can do. And since I made the logic for routing requests in a cloud flow, I didn't have to repeat that work here. What does a Copilot managed runtime app add? Then I went further and had it build a Copilot managed runtime app. Why? Because I could. I used that as a consolidated experience that could cover submitting requests, the manager queue, and a task board. In the demo I could drag a task such as “buy a Santa suit” into In Progress and update the underlying work. I estimated that build at about $2.50 in credits. Sometimes I am honestly at a loss for words when I look at what a short prompt can produce now. Also, notice they all kept the same styling, very handy and required no effort on my part. Does AI-assisted building replace professional makers? If this feels a little uncomfortable, I get it. We have spent years learning how to build with formulas, controls, actions, tables, flows, components, solutions, and all the other pieces. Now I am telling you that more of the starting experience can be a conversation. But this is not an either-or choice. I am not saying prompting replaces Power Platform expertise. I am saying prompting is becoming another part of that expertise. The GitHub Copilot app did not just take an order and disappear into the back room. It asked me questions and presented design choices that affected the outcome. I still had to understand what those choices meant, supply the business context it could not know on its own, and decide which direction made sense for the people and process I was building for. That judgment was part of the value I brought before the first app was generated, not just something I added during cleanup. A generated app can still need iteration. You still have to understand whether the data model is sensible. You have to validate security. You have to test the flows. You have to recognize a bad UX decision. You have to know when a business requirement is missing. In my own build I later spent roughly $20 in credits having Copilot do more hardening and testing. Fast first builds do not eliminate responsible engineering. What changes is where you spend your time. If AI can construct the first 80 or 90 percent of the mechanical pieces from a good conversation, you can spend more of your energy on requirements, architecture, validation, usability, and the weird edge cases that actually require experience. What should professional makers do now? Do not wait until these tools are perfect. Start getting repetitions now. Take a small app you already understand and try describing the complete outcome instead of manually building the first version. Use Copilot as a thinking partner before you build. Give it your rough notes, constraints, and goals, then ask it to help turn the conversation into the build prompt. Judge the generated architecture, not just the pretty screen. Look at the tables, relationships, security, formulas, flows, error handling, and lifecycle. Iterate in natural language, then drop into the traditional maker experience when direct editing is faster or more precise. Test and harden the result. “It built in 44 minutes” is exciting. “It is safe and maintainable in production” is still your responsibility. What is the fundamental change in Power Platform development? For years, the first question was usually, “Which app type do I open, and what do I start dragging onto the screen?” Increasingly, I think the first question is going to be, “Can I describe the solution well enough for the tools to build a useful first version for me?” This might (does) mean that we need to spend more time up front planning and requirements gathering. And these tools do not make professional makers less important. I think it makes our judgment more important. As more people gain the ability to create software with natural language, knowing what should be built, how the pieces should fit together, whether the result is secure and maintainable, and how to fix it when it is wrong becomes incredibly valuable. The tools are moving fast. The results are already better than a lot of people realize. If Power Platform is what you do for a living, you need to be using this stuff, not just reading announcements about it. FAQ Did Copilot really build the whole Power Platform solution from one prompt? For the initial build shown in the video, yes. I used a roughly 480-word prompt and the resulting run created the apps, flows, Dataverse tables, security, and solution structure I demonstrated. I later used additional prompts for other experiences and for hardening and testing. How long did the initial build take? My observed run took 44 minutes and used 661 credits. I estimated that at less than $7. Treat that as one measured demo run, not a guaranteed benchmark for every solution. Does this mean I do not need Power Apps or Power Automate skills anymore? No. You still need to understand requirements, data, security, automation, UX, testing, and maintainability. The difference is that more of the initial construction can now be delegated to an AI-assisted building experience. Do I have to be great at prompt engineering? No. I spent about ten minutes talking through my rough idea with Copilot, then asked it to help produce the prompt I would use for the build. Clear requirements and good judgment mattered more than memorizing a magic prompt format. Was the first generated version automatically production ready? I considered the core demo a real, functioning solution rather than a fake mockup, but production responsibility does not disappear. I later spent roughly $20 in credits on additional hardening and testing, and any real deployment still needs appropriate review and validation. But, if you told me I had to roll out the first version it built... I would have. It worked and was well built, I just spent some time fine tuning it to make sure it wasn't good, it was great. What should a professional maker try first? Pick a small business process you already know well. Describe the users, data, routing, automation, and expected outcome, let the tool build a first version, and then inspect the implementation like the professional maker you are. Key Takeaways A roughly 480-word prompt produced the first version of a broad Power Platform solution in 44 minutes using 661 credits in my demo. That first build included Dataverse tables and security, a model-driven app, a canvas app, and three Power Automate flows. You do not need to invent the perfect prompt alone. I used Copilot to talk through the idea and help write the final build prompt. The same underlying business process could then be surfaced through a generative page, a Copilot Studio agent, and a Copilot managed runtime app. AI-assisted building does not replace Power Platform expertise. It changes where that expertise provides the most value. Professional makers should start practicing a “words first, tweak second” workflow now, while still validating architecture, security, UX, and production readiness. Ready to build this way? If you want help getting your team comfortable with AI-assisted Power Platform development, or you want somebody to build alongside you while you figure out where these tools fit, the team at PowerApps911 can help. We do training, mentoring, and implementation across Power Platform, Copilot, Dynamics, Azure, SharePoint, and the surrounding Microsoft ecosystem. The tools are changing quickly. Let’s make sure you are learning how to use them, not watching them go by.

  • Copilot Studio Workflows vs. Power Automate: Where Should You Build Your Automation?

    A practical look at Microsoft’s new workflow experience, what carries over from cloud flows, and where the AI-native pieces change the decision. TL;DR Copilot Studio Workflows use the same trigger-and-action foundation Power Automate makers already understand, but put agent handoffs, native AI nodes, human review, and node-level testing directly on a redesigned canvas. Use Power Automate for broad, general-purpose automation and established operational management. Use Copilot Studio Workflows when the automation belongs beside an agent or needs the new AI-native building blocks. The Automation Decision Just Got More Interesting For years, when someone said “workflow” in the Microsoft ecosystem, most Power Platform makers immediately thought Power Automate. That was reasonable. Cloud flows have been the workhorse for event-driven, scheduled, and button-triggered automation across Microsoft 365, Dataverse, and hundreds of other services. Now Copilot Studio has a new Workflows experience. The first thing I wanted to know was not whether it could send an email or update a record. Of course it can. The real question was: if I can build this in Power Automate, why would I build it in Copilot Studio instead? After building an autonomous email-response example, my answer is that the fundamentals are very familiar, but the center of gravity is different. Power Automate is still the broader automation platform. Copilot Studio Workflows are where deterministic automation and agentic AI are being pulled together on the same canvas. If you would rather watch the full walkthrough, check out the video here: Build Your First Copilot Studio Workflow What Is a Copilot Studio Workflow? A Copilot Studio Workflow is an automation built on a visual canvas. It starts with a trigger and then runs one or more actions. That model should feel immediately comfortable if you already know Power Automate. Microsoft describes the new experience as part of the GitHub Copilot harness. It combines defined, rule-based execution with AI-driven actions. A workflow can start manually, on a schedule, when a connector event occurs, through an HTTP request, or when an agent calls it. Inside the workflow, you can use connectors, variables, loops, branches, data operations, agents, Copilot, classification, extraction, and human review. That last group is the reason this is more than a renamed cloud flow. The familiar automation engine is still there, but AI and agents are first-class workflow nodes rather than something you have to bolt on from the outside. What Feels the Same as Power Automate? A lot of it, and that is good news. If you have years of Power Automate experience, you are not starting over. Every workflow begins with a trigger and continues through actions. Manual, scheduled, connector-event, and HTTP-based patterns remain recognizable. The connector ecosystem is still how you reach Outlook, SharePoint, Teams, OneDrive, Dataverse, third-party services, and custom APIs. Dynamic content still passes values from the trigger and earlier actions into later steps. Variables, conditions, loops, functions, data operations, run history, and monitoring still matter. A fixed business process should still be modeled as explicit steps instead of asking an agent to reason through every action. In other words, your Power Automate brain still works here. The buttons moved, the canvas changed, and new nodes showed up, but the core automation patterns remain recognizable. What Copilot Studio Workflows Add 1. Agents are native workflow steps The most important difference is the Agent node. A workflow can call an existing published agent or define a smaller inline agent specifically for that workflow. In my demo, I created an inline agent that received an email subject and body, composed a friendly response, and used an Outlook tool to reply to the original message. This is a meaningful architecture shift. The workflow controls the predictable process, while the agent handles the part that benefits from language understanding or reasoning. You do not need to hand the entire process to an autonomous agent just because one step needs AI. 2. Native AI nodes replace some old prompt patterns The new designer includes AI-focused actions such as Agent, Copilot, Classify, and Extract. In the demo, the inline agent effectively replaced the AI prompt pattern I would previously have used inside Power Automate or an agent flow. Classify is especially useful when you want to route free-form content by meaning. Extract is designed for pulling structured information from content. These jobs were possible before, but the new workflow experience makes them explicit building blocks. 3. Copilot and Cowork can participate in the process A Copilot node can call Microsoft Copilot, Cowork, and agents such as Researcher and Analyst. One scenario I find interesting is not simply asking Copilot to return a quick answer, but using the workflow to seed a longer piece of work. For example, a workflow could notice an incoming email with an attachment and hand that material to Cowork so a person can continue refining the result later. That is a very different goal from classic robotic process automation. The workflow becomes the bridge between a business event and an AI work session. 4. Human review is part of the design Copilot Studio Workflows include human-in-the-loop actions, including requesting information or review. This matters whenever an AI step is uncertain, missing necessary context, or about to perform something consequential. In the email demo, I had the agent use Reply to Email and send the response automatically. In hindsight, I should have used the Draft Email tool instead. That would let the AI do the work of composing the response while still giving a human the chance to read it, make any necessary changes, and then hit Send. That is a much better pattern when the AI is communicating with someone on your behalf: let the agent do the heavy lifting, but keep a human in control of the final message. 5. Node-level testing makes iteration faster The workflow designer can test an individual action or the entire workflow without leaving the designer. That is a quality-of-life improvement for makers. You can validate the troublesome step instead of repeatedly firing the original trigger and waiting for the entire automation to reach it. Copilot Studio Workflows vs. Power Automate Decision area Copilot Studio Workflows Power Automate cloud flows Best fit Automation that belongs beside agents and benefits from native AI nodes or agent handoffs. General-purpose business automation across apps, services, and established operational processes. Core model Trigger plus actions on a redesigned canvas, with deterministic steps and AI-driven nodes. Automated, instant, or scheduled cloud flows built with Copilot, templates, or the designer. Agent integration Can define an inline agent or call a published GitHub Copilot harness agent from an Agent node. Also, can call Copilot Chat or Cowork. Can call standard-harness Copilot Studio agents through the Copilot Studio connector. It cannot call GitHub Copilot harness agents through that connector. AI building blocks Native Agent, Copilot, Classify, Extract, and human-review experiences, plus node-level testing. Copilot helps create and edit flows, and AI can be added through available connectors and actions. Capacity model Uses Copilot Studio capacity. Building, testing, and running GitHub Copilot harness experiences can consume Copilot Credits. Uses Power Automate licensing and capacity rules, which vary by flow, connector, owner, and plan. Reuse and migration No supported direct conversion from a Power Automate cloud flow into the new GitHub Copilot harness workflow format. Existing cloud flows remain managed in Power Automate. A cloud flow can be converted to a standard-harness agent flow, but that is a different format and the conversion is one-way. Collaboration maturity Choose carefully if your operating model depends on long-established Power Automate ownership, sharing, and run-only patterns. Cloud flows support co-owners, run-only users, ownership reassignment, environment roles, and mature administration patterns. How I Decide Which Tool to Use Choose Copilot Studio Workflows when: The automation is part of a Copilot Studio solution and should live beside the agents that use it. A workflow needs to call a GitHub Copilot harness agent. You want an inline agent for one reasoning-heavy step without turning the whole process into an autonomous agent. Classify, Extract, Copilot, Cowork, or human-review nodes are central to the design. Node-level testing will materially speed up development and troubleshooting. Your organization is prepared to govern and monitor Copilot Studio capacity and credit usage. Choose Power Automate when: The process is general business automation rather than an agent-centered solution. You already have a mature cloud-flow estate, support model, ALM process, and ownership strategy. Co-owners, run-only users, reassignment, and established flow-level permissions are important. You need Power Automate-specific capabilities or an existing cloud flow already solves the problem. The AI step can be handled by a standard-harness agent or another supported Power Automate action. Rebuilding a proven cloud flow in the new workflow format would add risk without adding meaningful AI value. You have and want to leverage existing Power Automate licensing The Practical Pattern: Deterministic Outside, Agentic Inside The most useful design pattern is not “workflow or agent.” It is workflow and agent, each doing the part it is good at. Let the workflow own the predictable sequence: detect the event, gather the inputs, call the right service, capture the result, route the exception, and log what happened. Then use an agent only where you need interpretation, language generation, flexible reasoning, or access to agent-specific tools. That reduces unnecessary reasoning. It also makes the solution easier to explain, test, and troubleshoot. If a four-step approval process should always execute the same four steps, encode those steps in the workflow. Do not pay an agent to rediscover the process every time. What I Built in the Video For the demo, I built a workflow that watched for a new Outlook email from Chewy. I intentionally filtered the trigger so the test would not start replying to every message in my inbox. That is a small detail, but it is exactly the kind of safety boundary you want while testing an autonomous scenario. The workflow passed the incoming subject, body, and message ID into an inline agent. I told the agent to draft a friendly, positive response, use HTML for a nicer email, include a dog joke or pun, and use the Reply to email tool. The silly dog instruction had a serious purpose: it made it obvious whether the agent was following the instructions. The response did not arrive instantly, and I almost gave up on it. Then it showed up with formatting and a usable reply. The activity view recorded the inputs, outputs, and the agent's response, which made it possible to inspect what happened after the run. The lesson was not that an agent can answer an email. The lesson was that the new workflow can combine an ordinary connector trigger, an inline agent, and a connector tool in one governed sequence. That is the story behind this feature. Licensing and Capacity: Do Not Skip This Part Power Automate and Copilot Studio Workflows do not use the same capacity model. Microsoft states that Copilot Studio Workflows use Copilot Studio capacity and do not require a separate Power Automate license. The Workflows page can show credit usage for the previous 30 days, and new runs can be blocked when the environment has exhausted its available Copilot Studio capacity. For agents powered by the GitHub Copilot harness, Microsoft also documents that building, testing, evaluating, and running consumes Copilot Credits. That usage is not included with your Microsoft 365 Copilot license. This does not mean one platform is always cheaper. It means you must compare the actual licensing and capacity model for the scenario. A simple cloud flow that already fits your existing Power Automate entitlements may be the economical choice. A workflow whose main value is native agent orchestration may justify Copilot Studio consumption. Monitor the real runs instead of guessing. A Migration Warning Do not assume you can build everything in Power Automate today and convert it into the new workflow format later. Microsoft currently says there is no supported conversion from a Power Automate cloud flow to a GitHub Copilot harness workflow. A Power Automate cloud flow can be converted into a standard-harness agent flow if it is in a solution and the environment has Copilot Studio capacity. That conversion changes the billing model and is one-way. It still does not turn the flow into the new Workflows experience shown in this video. That distinction matters. Power Automate cloud flows, standard-harness agent flows, and GitHub Copilot harness Workflows share plenty of DNA, but they are not interchangeable packaging options. FAQ Are Copilot Studio Workflows replacing Power Automate? No. Power Automate remains Microsoft’s general-purpose cloud automation platform. Copilot Studio Workflows are optimized for automation that combines predictable process steps with agents and native AI actions. Can I use the same connectors with Power Automate and Copilot Studio workflows? Yes, the workflow model supports Microsoft 365, third-party, and custom connectors. The exact trigger and action availability can vary, so verify the specific connector and operation you need before choosing the platform. Can a Copilot Studio workflow call an agent? Yes. A workflow can call an existing published agent or define a new inline agent in an Agent node. A workflow can also be exposed as a tool that an agent calls when it uses the appropriate agent trigger and response action. Can Power Automate call the same agents? It depends on the harness. Power Automate can call standard-harness agents through the Microsoft Copilot Studio connector. Microsoft states that GitHub Copilot harness agents must be called from an Agent node in a Copilot Studio Workflow. Can I convert an existing Power Automate flow? Not into the new GitHub Copilot harness Workflow format. You can convert an eligible solution cloud flow into a standard-harness agent flow, but the conversion is one-way and changes the capacity model. Do Workflows use Copilot Credits? Yes, they use Copilot Studio capacity, and Microsoft documents credit consumption for workflow actions and GitHub Copilot harness experiences. Capacity coverage depends on how the workflow is invoked and the harness involved, so review the current licensing guidance and monitor actual usage in the Power Platform admin center. Key Takeaways Copilot Studio Workflows preserve the trigger-and-action model Power Automate makers already know. The major differentiator is native AI orchestration: inline or published agents, Copilot and Cowork calls, classification, extraction, human review, and node-level testing. Power Automate remains the safer default for broad, established business automation and mature collaboration or ownership requirements, especially if you don't need AI. Use a workflow for repeatable, deterministic steps, and reserve agent reasoning for the steps that genuinely need it. Power Automate cloud flows cannot currently be converted directly into the new GitHub Copilot harness Workflow format. Copilot Studio capacity and Copilot Credit usage must be designed and monitored as part of the solution, not treated as an afterthought. The best architecture may use both platforms rather than forcing every automation into one tool. Ready to Build One? If you want help deciding whether a process belongs in Power Automate, Copilot Studio Workflows, an agent flow, or a combination of all three, the team at PowerApps911 can help. We build these solutions for customers, troubleshoot the weird parts, and teach teams how to own them after the project is done. Reach out and let’s build something awesome together.

  • Build a Reliable Power Apps Time Tracking App with SharePoint

    TL;DR The reliable way to track elapsed time in Power Apps is to save the start and finish timestamps, then calculate the difference. Use a timer only as a visual aid because it can stop when the app closes, the screen changes, or the device goes to sleep. Timers look like the obvious answer when you need to track time in Power Apps. The trouble is that an on-screen timer is only reliable while the app stays open and active. Phones time out, users close apps, screens change, and epic gaming sessions have a way of outliving the device battery. In this app, I used SharePoint to record when a session starts and when it ends. That makes the elapsed time durable, lets an active session survive an app restart, and gives you clean data for weekly totals, reporting, and future limits. If you would rather watch the full walkthrough, check out the video here: Power Apps Time Tracking App video Want the exact demo app? The downloadable app is available in the curated library with a paid training.powerapps911.com subscription. The article below also explains the architecture so you can understand the important decisions behind it. Why a Power Apps Timer Is Not Enough The timer control is useful for showing a running count on the screen, but I would not trust it as the system of record. If the user leaves the screen, closes the app, or the phone goes to sleep, the timer can stop. That is a bad foundation for tracking work time, service calls, assembly activities, meeting duration, or even how long the kids have been playing games. Instead, the app records Now() when the session begins and records Now() again when the session ends. DateDiff then calculates the number of minutes between those timestamps. The app can disappear for hours and the data still tells us exactly when the session started. The SharePoint List Behind the App The hardest part was not building the buttons. It was deciding what data to store and how to structure it. The SharePoint list holds the raw facts needed to reconstruct every session: User: the person associated with the session. The demo uses User().FullName, although an email address or another unique identifier may be a better fit for a production app. When Started: a date and time value captured when the user selects Start. When Finished: a date and time value captured when the user selects End. Session Active: a Yes/No value that identifies an unfinished session. Number of Minutes Used: a number calculated when the session ends. Make sure the SharePoint columns for the start and finish values are configured as date and time, not date only. That small setting matters when the entire calculation depends on the timestamp. How the App Restores an Active Session On app start, the app loads the current week of records for the signed-in user into a collection. It also looks for a record where Session Active is true and stores that record in a variable. That lookup is what makes the app resilient. If the user starts a session, closes the app, and returns later, the app can find the unfinished SharePoint record. The visual timer will not magically recover, but the session itself is still alive because the real start time is stored outside the app. This pattern is useful anywhere a process can outlast one app session. Think field service visits, machine setup, phone calls, work orders, inspections, or production steps. Calculating the Current Week The demo treats a week as Monday through Sunday. Power Apps date logic commonly assumes Sunday as the start, so the app calculates the Monday date for the current week and filters the SharePoint data to records that started on or after that timestamp. Loading the filtered records once into a collection keeps the later calculations simple and responsive. The weekly total is just the sum of Number of Minutes Used in that collection for the current user. What Happens When the User Selects Start The Start button creates a new SharePoint record with the current user, the current timestamp, and Session Active set to true. The newly created record is saved in a variable so the app can update that exact item later. The app also starts a hidden timer control. That timer drives the number the user sees counting upward, but it never becomes the authoritative duration. It is presentation, not persistence. That separation is the key design decision in the entire app. What Happens When the User Selects End The End button stops the visual timer and patches the existing SharePoint record. It writes the finish timestamp, calculates the elapsed minutes with DateDiff, and changes Session Active to false. After the patch, the app refreshes the collection for the current week so the total updates. You could optimize this by updating the local collection directly, but reloading the filtered records keeps the first version easier to understand. The result is a complete session record that can be summed, reported, filtered by user, or used in later business rules. Control the Experience with Variables and DisplayMode The app uses the current record variable to decide which controls should be available. If there is no current record, Start is enabled. If the record is active, End is enabled. After the session ends, a Start New Session action clears the variable and resets the screen. This is a clean way to keep users on the happy path. Instead of presenting every action all the time, the app makes the valid next step obvious and disables or hides the rest. Where This Pattern Fits in the Real World The kids and their game time make the demo more fun, but the design is broadly useful. The same start-and-finish pattern can support: Tracking how long a technician spends on a service call. Measuring assembly or production activities. Recording time against tasks, jobs, or work orders. Tracking calls, appointments, inspections, or meetings. Monitoring equipment usage or any process with a clear start and stop. The big idea is simple: store durable events first, then calculate from those events. Do not let a temporary user interface control become your only source of truth. Common Gotchas Do not calculate from the timer. Use the saved timestamps so the session survives an app closure or device timeout. Use date and time columns. A date-only SharePoint column removes the detail you need for minute-level calculations. Choose a dependable user key. Full name is quick for a demo, but email or another unique value is safer when names can collide or change. Plan for unfinished sessions. The active Boolean is what lets the app reopen an in-progress session. Decide what a week means. If your business week begins on Monday, calculate that boundary explicitly instead of assuming the platform default matches your requirement. Frequently Asked Questions Can I use the Power Apps Timer control to track elapsed time? You can use it as a visual counter, but you should not rely on it as the permanent record. Save start and finish timestamps and calculate the difference. What happens if the user closes the app during a session? The SharePoint record remains active. When the app opens again, it can look up the active record and allow the user to end the session. Why store a Session Active column? It gives the app a simple true or false value for finding unfinished work and controlling which buttons are enabled. How does the app calculate weekly totals? It loads the current user’s records from the start of the week into a collection and sums the Number of Minutes Used values. Can I download the app shown in the video? Yes. The demo app is available in the curated library with a training.powerapps911.com subscription. Do I have to use SharePoint? This video demonstrates the pattern with a SharePoint list. The important design principle is to store the start and finish events in a durable data source rather than depending on the on-screen timer. Key Takeaways Save start and finish timestamps, then use DateDiff to calculate elapsed time. Treat the timer control as a visual aid, not the source of truth. Store an active-session flag so unfinished sessions can be recovered after the app closes. Filter data by both the current user and the start of the reporting period before calculating totals. Use variables and DisplayMode logic to guide the user through Start, End, and Start New Session states. Spend time on the data model first because the list structure determines how reliable and reusable the app will be. Build Your Time Tracking App with PowerApps911 A time tracking app looks simple until you account for closed apps, interrupted sessions, weekly totals, multiple users, and the business rules that come next. If you want help building a solution like this for your team, the PowerApps911 team can help you design the data, build the Power Apps experience, and make the whole thing reliable. Whether the need is big or small, reach out and let’s build it together.

  • M365 Copilot Agent Builder Skills: Turn Your Repeatable Prompts into Reusable Agents

    TL;DR M365 Copilot Agent Builder can now use skills, which means you can package a repeatable AI process into a reusable recipe and run it inside a lightweight agent. In my test, it recreated a weekly blog-writing workflow with strong results and no incremental credit charge under the licensing available to me at the time, but it does not replace the persistence of Cowork or the mature tools and governance in Copilot Studio. For a long time, one of the clearest reasons to reach for a more advanced AI tool was simple: I needed a skill. I had a repeatable process, a lot of detailed guidance, and no desire to paste the same giant prompt every week. Cowork was my shining star to get work done. That line just moved. Agent Builder inside M365 Copilot now supports skills, and after testing it with a real process I use every week, I walked away much more impressed than I expected. This is not a replacement for every other Copilot tool. It is, however, a legitimate new option for the repeatable jobs that already work well in chat. If you would rather watch the full walkthrough, check out the video here: https://youtu.be/2CEKxAttNic What Is a Skill in M365 Copilot Agent Builder? A skill is a predetermined recipe for an AI agent. If you regularly type the same instructions, follow the same steps, and expect the same type of output, you can capture that process once and reuse it. My skills are not usually one clever sentence. They are often 180 to 250 lines of guidance that explain the tone, structure, rules, checks, and expected output. The point is consistency. Instead of hoping I remember every requirement each time, the agent gets the full recipe every time. I use Skills via Cowork for things like cleaning up my inbox after a bunch of out of office messages, creating branded assets, and even things like writing these blog posts. Once I come up with the inputs and the steps, turning those into a skill saves me repetitive work. Bonus point: Skills are not just a Copilot thing or some proprietary Microsoft invention. Skills are becoming a broader standard for giving AI agents repeatable recipes they can follow. That means the real value is not tied to one chat window or product. You can build a skill once and potentially move or adapt it across both Copilot tools and Claude or ChatGPT or any other tool that supports skills. Each platform may handle them a little differently, but the big idea is universal: stop retyping the monster prompt and give the agent a reusable recipe instead. Why Skills in Agent Builder Matter Before this change, if I wanted a skill-driven experience, I would typically use Cowork. Agent Builder was useful, but it did not have a clean way to bring in a detailed reusable recipe and Cowork was the default answer. Man, did this change. Now I can build a small agent in the Copilot interface, attach a skill, add a short set of agent instructions, and use it for a focused job. At the time of my testing, that experience was included with my M365 Copilot license and did not add an incremental credit charge. Licensing can change, especially while a feature is new, so treat that as my observed experience rather than a forever promise. But as of right now, my Cowork credit consumption is down. The Real Workflow I Used to Test It Every week, I publish a YouTube video and turn the content into a companion blog post. The blog is not supposed to invent a new story. It documents my explanation for people who prefer to read, makes the topic easier to find, and gives me a solid draft that I can edit into its final form. I already had a detailed YouTube-to-blog skill for this process. It covers the title, TL;DR, headings, image placeholders, FAQ, key takeaways, voice, and a long list of content rules. It also prevents the model from wandering off to do a bunch of unrelated research and producing generic AI slop. I want my information and my point of view, just organized into a useful article and without me having to start from a blank screen every week when writing it. The AI-generated draft is not the finish line. It gets me roughly 80 percent of the way there, and I still edit it. That is an important distinction. The value is not that AI replaces my judgment. The value is that I begin with a structured draft, from my literal own words, instead of a blank page. Let me say this again for the people in the cheap seats. I hate AI Slop, I would never just have AI write something and post it as me. I am using AI to take my words, from my video, and put them on paper for me so I can create what you are reading. Moving the Skill into Agent Builder The setup itself was refreshingly small. I created a new agent, skipped the conversational builder, opened the Skills section, and uploaded the existing skill file. Then I added instructions telling the agent what it was, requiring it to use the skill for every blog request, and reminding it to stay grounded in the supplied content. I gave the agent a name and description, created it, and started a chat. That was basically the whole configuration. The important work was already captured in the skill. I did run into two rough edges. First, the upload dialog initially appeared to accept only ZIP files, but switching the file picker to show all files allowed me to select the skill file directly. Second, the preview experience did not give me a way to attach the transcript, so I had to create the agent before I could properly test the workflow. These are exactly the kinds of early-feature details I expect to move around. The Result Was Better Than I Expected Once the agent was created, I attached a YouTube video transcript and asked it to create the blog post. It produced the expected title, TL;DR, introduction, sections, image placeholders, FAQ, key takeaways, and conclusion. The result took about a minute in that test. The visual formatting (font color for example) was not identical every time, but I did not care much about that. I copy the content into our blog platform and format it there anyway. The question was whether the agent could follow the recipe and produce a strong content foundation. Yes, it could. Previously, a comparable Cowork run used 355 credits, which is about $3.55. I was happy to pay it because the output was worth more than the cost. But if Agent Builder can handle this particular workflow well with no incremental credit charge, it makes sense to use the simpler option. I Ran a Blind Comparison, and Agent Builder Won I did not want to trust my first impression, so I ran the same transcript and prompt through roughly seven different tool and model combinations. Then I removed the identifying details, labeled the outputs, and asked ChatGPT to compare them using the same criteria. ChatGPT also had the blog transcript and a good idea of what my voice is and end goal. The Agent Builder version came out on top in that blind comparison. I for sure did not expect that. The evaluator did not know which tool produced which draft. That does not prove Agent Builder will win every writing test, but it gave me a much stronger reason to trust the result than simply saying, “This looks pretty good.” It also reinforced a practical lesson: test the outcome you care about. I cared about accurate, usable content in my established format. A blind review was more useful than arguing about which model should theoretically be best. Does This Replace Cowork? No. For this workflow, I expect to use Agent Builder. For every workflow, absolutely not. Agent Builder is still a chat-oriented experience. It does not have the same tenacity for long, multi-step work. It is not going to keep iterating through a complicated process, try many approaches, and persist the way a more autonomous tool can. It also does not support every file type and scenario that Cowork can handle. My rule of thumb is simple: if the job already works well in chat and the main reason you moved it elsewhere was to use a skill, bring it back and test it in Agent Builder. If the job depends on deeper persistence, broader file handling, or a long chain of operations, Cowork may still be the better home. Does This Replace Copilot Studio? Also no. Copilot Studio brings a much more mature toolbox to agent development. Agent Builder now has skills and knowledge, which is great, but it does not give you the same depth of tools, plugins, workflows, MCP server connections, management, and enterprise-grade design options. I think of Agent Builder as a fast way to create focused agents that help me or a small group of people. You can share them and potentially publish them more broadly, but that does not make them equivalent to a robust Copilot Studio solution. Use Agent Builder when the job is focused and the experience can stay lightweight. Use Copilot Studio when you need a mature agent that connects to systems, takes actions, follows enterprise processes, and needs stronger lifecycle management. The “Use Everywhere” Setting Is the Brain Breaker The most interesting discovery came after the agent was already working. In the skill menu, I found a setting that changed the skill from being limited to one agent to “use everywhere.” When I enabled it, regular Copilot chat could see and use the skill even when I was not chatting with the custom agent. Then I shared the agent with one of our architects. After he received access to the agent, his regular Copilot chat also reported that it could access the skill. That is a fascinating behavior, but I could not find documentation that explained the intended boundaries, long-term design, or licensing story. So this is a trust-but-verify moment. Test it, learn from it, and pay attention to what Microsoft documents next. I would not redesign a critical enterprise process around an undocumented behavior yet, but I am absolutely watching it. Where Agent Builder Skills Fit Best This feature looks strongest when all of the following are true: The task already works reliably in Copilot chat. You repeat the same detailed instructions often. The output has a predictable structure, tone, or checklist. The job does not require a long autonomous chain of actions. You want a lightweight agent without immediately building a full Copilot Studio solution. That makes it useful for standards-based writing, recurring reviews, document transformation, meeting follow-up formats, analysis recipes, and other repeatable knowledge-work patterns. Start with a process you already understand. Capture the recipe, test against real examples, and compare the output to your current method. Frequently Asked Questions What is a skill in M365 Copilot Agent Builder? A skill is a reusable set of instructions that tells an agent how to perform a repeatable task. It packages the process, structure, tone, rules, and checks so you do not have to recreate a large prompt every time. Do I need an M365 Copilot license? In my test, I used Agent Builder through my M365 Copilot experience, and the feature was available with that license. Product availability and licensing can change, so verify the current terms in your tenant before standardizing on it. Do Agent Builder skills use credits? My Agent Builder test did not create an incremental credit charge. That was one of the most compelling parts of the experiment. However, this was an early experience, and I would recheck the current licensing before making a financial comparison. Can Agent Builder replace Cowork? Not completely. It can replace Cowork for some simpler skill-driven jobs that already fit well in chat. Cowork remains better suited to work that needs persistence, iteration, broader file support, or many connected operations. Can Agent Builder replace Copilot Studio? No. Copilot Studio is the better fit for mature agents that need tools, workflows, plugins, system connections, governance, and stronger enterprise management. Agent Builder is excellent for small, focused agents without much complexity or the need for tenacity. Can one skill be used outside its original agent? I observed a “use everywhere” option that made the skill available in regular Copilot chat, and the behavior also appeared for a colleague after I shared the agent. Because I did not find clear documentation for the long-term behavior, test carefully before treating it as a durable architecture decision. Key Takeaways Agent Builder skills let you turn a long, repeatable prompt into a reusable recipe inside M365 Copilot. A good skill captures the process, constraints, voice, structure, and quality checks, not just a one-line instruction. In my blog-writing test, Agent Builder produced the strongest draft in a blind comparison of roughly seven outputs. The tested Agent Builder run had no incremental credit charge, while a comparable Cowork run had used 355 credits, about $3.55 in that environment. Agent Builder is a strong fit for focused tasks that already work in chat, but it does not replace Cowork for persistent multi-step work. Copilot Studio remains the right choice when an agent needs tools, workflows, plugins, system connections, governance, and mature management. The “use everywhere” behavior is promising and surprising, but it deserves careful testing until Microsoft explains the intended model more clearly. Skills Make Agent Builder a Legitimate Part of the Toolkit The big takeaway is not that Agent Builder kills another product. It does not. The takeaway is that Agent Builder can now handle a meaningful class of repeatable work that previously pushed me toward a more advanced tool just because I needed a skill. That gives us another practical option. Put the simple, focused skill-driven jobs in Agent Builder. Keep the persistent, multi-step work in Cowork. Build the mature, connected enterprise agents in Copilot Studio. The tools overlap, but they are not interchangeable. If you want help deciding where your Copilot scenarios belong, building the right skills, or getting your team comfortable using M365 Copilot and Copilot Studio, the team at PowerApps911 can help. Whether you need training, mentoring, or someone to build alongside you, reach out and let’s build something awesome together. Click that Contact Us button and tell us how we can help.

  • Stop Using Power Platform Plugins One at a Time: Let GitHub Copilot Orchestrate the Whole Solution

    TL;DR The real value of the Power Platform plugins is not using each one by itself. GitHub Copilot, or another capable coding assistant, can combine the Power Apps, Dataverse, and Power Automate plugins with one prompt to build an end-to-end solution. In my test, it created a document submission app, its data model, the cloud flow, and most of the connections in about 32 minutes of real time for roughly 1,200 credits, or about $12 in the environment I was using. That is kind of crazy! Most plugin demos are intentionally small. You ask the Power Apps plugin to build a screen. You ask the Dataverse plugin to create a table. You ask the Power Automate plugin to build a flow. That is useful when you are learning what each tool can do, but it is not how real business solutions work. Real solutions cross boundaries. The app needs data. The data needs automation. Files might belong in SharePoint while their metadata belongs in Dataverse. The user should not care which service is doing which part. They just need the whole thing to work. That was the goal of this test: give GitHub Copilot App one business outcome, make the right Power Platform plugins available, and see whether it could assemble the pieces into a working solution. Spoiler alert, it did. If you would rather watch the complete build and all the messy parts that came with it, check out the video here: One Prompt Built My Power App, Dataverse Table AND Cloud Flow The Big Idea: Plugins Are Building Blocks, Not Separate Destinations The Power Apps, Dataverse, and Power Automate plugins are impressive on their own, but thinking about them individually puts an artificial limit on what you can ask an AI coding tool to accomplish. The better question is not, “What can this plugin build?” It is, “Can the coding assistant choose and combine the right plugins to solve my problem?” In this example, GitHub Copilot acted as the orchestrator. It interpreted the request, divided the work across the available plugins, asked a few useful questions, generated the components, and then brought those components together. The individual plugins did specialized work, while Copilot kept the overall solution in view. The One Prompt That Defined the Whole Solution I started with a single prompt that described the business outcome and the important constraints. Cleaned up slightly for readability, it looked something like this: Build me a Power Apps canvas app for uploading files. Use the blank app I already created. The app should let a user enter a document title, category, notes, and upload a file. Create a Dataverse table called Doc Submission to store the information. Create a Power Automate flow that saves the file in the SharePoint document library I already built. Save the SharePoint file URL with the submission information in Dataverse. Show recent submissions in the app. Build and connect everything needed to make it work, but if you need anything done through the browser, ask me to do it. Do not use Playwright. The prompt names the user experience: a canvas app for document submissions. It defines the fields the user needs to enter. It says where the file should go: an existing SharePoint document library. It says where the submission metadata should go: a new Dataverse table. It explains that the SharePoint URL must be stored with the Dataverse record. It asks for recent submissions to appear in the app. It gives Copilot permission to build and connect the necessary pieces. It establishes a collaboration boundary by asking Copilot to hand browser-only steps back to me. That last instruction mattered. GitHub Copilot can use browser automation for some tasks, but it can be slower, more expensive, and more fragile than simply asking a human to make a connection in Power Apps Studio. The goal was not to prove that AI could click every button. The goal was to finish the solution efficiently! How Copilot Divided the Work Across the Plugins Once the objective was clear, Copilot worked through the solution in layers. Each plugin handled the part of the problem it was designed for, but the output of one plugin became the input for the next. 1. The Dataverse Plugin Built the Data Foundation The document submission process needed structured data, so Copilot used the Dataverse capabilities to create a Doc Submission table and its columns. That table became the source of truth for the document title, category, notes, SharePoint file URL, and other submission details. This is an important distinction. The uploaded file itself went to SharePoint, but the business record went to Dataverse. That split is common in real solutions. SharePoint is a natural place for documents, while Dataverse gives the app a structured data layer for filtering, relationships, security, and future expansion. About six minutes into the run, the Dataverse table was created and the existing SharePoint document library had been confirmed. Copilot also accounted for the 10 MB file-size choice it had asked about earlier. 2. The Power Automate Plugin Built the Integration Layer The app needed more than a Patch operation. It needed to accept a file from Power Apps, create that file in SharePoint, retrieve the resulting file information, create the matching Dataverse record, and report back to the app. That is where the Power Automate plugin came in. The generated cloud flow followed the basic pattern you would expect: Power Apps triggers the flow and sends the submission fields and file. The flow creates the file in the existing SharePoint document library. It gets the newly created file properties so it can capture the file URL. It creates the Dataverse row with the submission details and SharePoint link. It responds to Power Apps when processing is complete. When I inspected the flow, it was a little more complicated than I might have built by hand. I also questioned whether the success and failure responses were returning enough useful information. That did not invalidate the result, but it reinforced the same rule I use with any AI-generated solution: trust, but verify. 3. The Power Apps Plugin Built the User Experience With the table and flow available, Copilot moved on to the canvas app. It planned a document submission screen with a soft, approachable style, a warm cream background, fields for the submission details, an upload experience, and a list of the newest submissions. Copilot asked me to approve the screen plan before it built the interface. That checkpoint was useful because it let me validate the intended experience without watching every control get created. After approval, the canvas app work took the largest chunk of the run. One build step alone took a little over eight minutes. The finished app accepted a document title, category, notes, and file. Submitting the form called the cloud flow. The uploaded file appeared in SharePoint, the Dataverse row appeared with the submitted information, and the new submission showed up in the app gallery. The Connections Were the Hand-Off Points The most important parts of the build were not the isolated components. They were the hand-offs between them: The canvas app had to know about the Dataverse table. The canvas app had to call the generated Power Automate flow. The flow had to understand the payload coming from Power Apps. The flow had to connect the SharePoint file with the Dataverse record. The app had to refresh and display the resulting record. Copilot asked me to add the Dataverse table and flow to the existing app in Power Apps Studio. I initially questioned the instructions, then realized they were correct. I added both connections manually in roughly 30 seconds to a minute, even with a few wrong clicks along the way. This was way faster and cheaper than letting GitHub Copilot App use browser control via Playwright to do it for its self. That manual step was not a failure. It was efficient collaboration. In an earlier approach, browser automation spent seven or eight minutes trying to do work I could complete almost immediately. If your goal is a working solution, the best process may be AI-generated components plus a few quick human hand-offs. Testing the Complete Solution A multi-plugin build is only valuable if the complete chain works. Copilot asked permission to run an end-to-end backend test using a clearly labeled test file and an invalid submission. I appreciated that it asked before leaving test data behind. In an earlier run with a different model, the test data was created without the same warning. The backend test passed. I then tested the app in preview mode by entering a title, category, and notes, choosing a file, and submitting it. The resulting record appeared in the recent submissions gallery, and the file could be opened from the application. I also verified the individual systems: The Power Automate run completed successfully. The uploaded file existed in the SharePoint document library. The Dataverse table contained the matching submission record. The canvas app displayed the new submission and could open the file. That is the real proof of orchestration. Three plugins did not merely create three disconnected artifacts. Together, they produced one working business process. What Went Wrong, and Why It Matters The build was not perfectly smooth, and that is worth talking about because the rough edges are part of the real story. Browser Automation Was Not Always the Best Choice Some Power Apps Studio tasks are still awkward to perform programmatically. Letting browser automation do everything can consume more time, tokens, and credits. For known, simple steps, it can be smarter to have Copilot pause and let you complete the action. The Generated Flow Deserved Inspection The flow worked, but parts of it felt more complicated than necessary, and the response handling deserved another look before production use. AI can get you to a working first version quickly, but “it ran once” is not the same as “it is production ready.” Keep in mind, you can ask GitHub Copilot to help or tell it your concerns, you don' have to edit by hand BUT if editing by hand is easy or quicker then step away from the agent and do it yourself. Saving the App Blew Up at the Finish Line After the solution was working, Power Apps Studio returned a network error during save and told me to refresh. When the browser came back, the app appeared blank. Yikes. Fortunately, Copilot still had a local copy of the generated YAML. I re-added the Dataverse source and flow, explained the save failure, and asked it to rescue the app. It verified the blank state and pushed the app content back. The controls reappeared, the second save succeeded, and I was able to publish the application. That recovery was one of the strongest moments in the demo. The AI was not only useful for initial generation. It could also use its local working files to recover from a platform failure. How Long Did It Take and What Did It Cost? The complete run took about 32 minutes of real time, excluding the extra time spent reacting to the save failure. That was faster than the approximately 45 to 55 minutes I had seen with an earlier approach. The run used about 1,200 credits, which was roughly $12 in the environment I was using. An earlier test showed around 1,900 credits, although that run included additional work, so it was not a clean comparison. I tested this run with the higher-end Astra 6 model. The earlier working example had been created with Sonnet 5, so the expensive model was not required. My result suggested that a stronger model might complete the work faster and with fewer detours, but that is anecdotal. Do not make a model or budget decision from one run. Also, do not spend the whole run staring at the screen. Copilot can notify you when it needs a decision. The productivity gain comes from letting it work while you do something else, then stepping in at the checkpoints that actually require your judgment. How to Write Better Multi-Plugin Prompts You do not need to tell Copilot which plugin to call at every moment, but you do need to describe the outcome clearly. A strong orchestration prompt usually includes: The business problem and the person who will use the solution. The required user inputs and outputs. Where different types of data or files should be stored. The automation that should happen after the user acts. What should be visible in the finished app. Existing assets that should be reused instead of recreated. Constraints such as file size, naming, or browser automation preferences. The situations where Copilot should stop and ask you to take over. The prompt should describe the finished system, not merely the first component. If you ask only for a form, you may get a form. If you describe the complete document submission process, Copilot can reason across the app, data, automation, and file storage layers. What This Means for Power Platform Development The lesson is bigger than this one document submission app. As plugin ecosystems improve, the unit of work changes. You are no longer limited to asking AI for a control, a formula, a table, or a flow. You can ask for a business capability and let the coding assistant assemble the necessary services. That does not remove the need for Power Platform expertise. In fact, experience becomes more valuable in different ways. You need to recognize good architecture, spot unnecessary complexity, validate security and error handling, understand where the AI is likely to struggle, and decide when a 30-second manual step is better than eight minutes of automation. This is why I think of Copilot as a teammate. It can do a lot of the building, but you still provide direction, judgment, testing, and the occasional rescue mission. When that partnership works, complete solutions become faster and less expensive to prototype. FAQ Can GitHub Copilot use more than one Power Platform plugin in the same request? Yes. In this test, one prompt led GitHub Copilot to use Power Apps, Dataverse, and Power Automate capabilities to build different parts of the same solution. What did each plugin do? The Dataverse plugin created the data foundation, the Power Automate plugin created the file and record-processing flow, and the Power Apps plugin built the canvas app experience. Copilot coordinated the work between them. Did Copilot build everything without human help? No. I manually added the Dataverse table and generated flow to the existing canvas app, adjusted display settings, tested the app, and completed save and publish steps. Those interventions were faster than forcing browser automation to do everything. Did the generated solution work? Yes. The app uploaded a file, the flow stored it in SharePoint, Dataverse received the submission record and file URL, and the new record appeared in the app. The components were also checked individually. Is an AI-generated solution ready for production? Not automatically. You still need to inspect the app, flow, data model, responses, error handling, security, connections, and test data. The generated flow in this example worked, but parts of its structure and response handling deserved further review. Do I have to let Copilot control the browser? No. For simple browser-only steps, asking Copilot to pause can be faster and cheaper. Use browser automation where it adds value, not merely to prove that it can click the buttons. Key Takeaways The biggest opportunity is not using Power Platform plugins individually. It is letting a coding assistant orchestrate them around a complete business outcome. One prompt produced a canvas app, Dataverse table, Power Automate flow, SharePoint integration, and recent-submissions experience. The hand-offs between Power Apps, Dataverse, Power Automate, and SharePoint were more important than any one generated component. Human intervention was valuable when a browser-only connection could be completed faster manually. The complete run took about 32 minutes and used roughly 1,200 credits in the tested environment. The save failure demonstrated that local generated files can also help recover work after a platform problem. AI-generated solutions still require inspection, testing, and production hardening. Trust, but verify. Final Thoughts Stop asking what each plugin can do by itself, they don't have to exist in a vacuum. Start asking what problem GitHub Copilot can solve when those plugins work together. The Power Apps plugin can build the experience. The Dataverse plugin can create the data model or security roles or even a model-driven app. The Power Automate plugin can connect the process. Copilot can keep the full outcome in view and coordinate the work. That is where these tools become much more interesting than a collection of isolated demos. If you want help building solutions like this, training your team to work with AI-assisted Power Platform development, or figuring out where this approach fits in your organization, the team at PowerApps911 can help. Whether you need training, mentoring, or someone to build it with you, reach out and let’s build something awesome together. Click the Contact button and tell us how to help!

  • Copilot Studio Efficiency: Stop Paying Your Agent to Rediscover What You Already Know

    TL;DR Copilot Studio can discover SharePoint sites, lists, and columns on its own, but every discovery step takes time and consumes tokens. Give the agent stable values such as the Site ID, List ID, and internal column names so it can go straight to the work that matters. You know the old saying: time is money. With Copilot Studio, that is not just a motivational poster. Time, reasoning, tool calls, and tokens are all connected. Copilot Studio does an awesome job figuring things out. Point it toward SharePoint through the SharePoint MCP server and it can find the right site, inspect the available lists, identify the list you meant, and retrieve the data. That is genuinely useful. But here is the question: if the agent found the same SharePoint site yesterday, and that Site ID is not going to change today or ever, why are we paying it to find the site again? That is the big lesson from this post, your agent should not have to solve the same mystery every time a user asks a question. By simply fixing that, you can make everything faster and that means cheaper. If you would rather watch the full walkthrough, check out the video here: Make Copilot Studio Faster and Cheaper It has more details, a deeper look at filtering, and my face. How could you go wrong? The Agent Setup I built a new Copilot Studio agent using the new harness, gave it the SharePoint MCP server, one instruction on what SharePoint Site to use, and started asking questions. Then I could ask it "When is the next payroll?" and it would give the right answer. What could possibly be wrong? The Hidden Cost of Letting Copilot Figure Out Everything The agent in my test answered a basic payroll question correctly. The answer was not the problem. The route it took to get there was the problem. To answer the question, the agent had to: Find the SharePoint site. List the lists available on that site. Identify the payroll list. Retrieve the list items. Read the results and produce the answer. That is impressive the first time. It is wasteful the 50th time. Every extra tool call introduces more processing, more reasoning, and more opportunities for latency. It can also increase consumption. The agent is being smart, but it is doing work that your solution already knows how to avoid. Which costs you credits! Side note: I hope you see the irony that I named the agent Speed. Probably should have named it Turtle. 🤣 Anyway. Three Steps, Then Two, Then One I started with instructions telling the agent to use the Box Checked HR site and the SharePoint MCP tool for payroll questions. That guidance helped it choose the general direction, but it still had to find the exact site. So to see if I could help, I expanded listLists to see what it was passing and found my first fix. The agent was using findSite to get the siteId of the HR Site. That Id will NEVER change, so why make it work so hard. We can copy that info in green and turn it into an instruction. Also, if we expand out listListItems, we can see the listID. Let's grab that info also and go update the instructions. Better Instructions With the siteID and listID in hand, lets update the instructions to: No more guessing! Now when we ask the same question, look at how much cleaner it is. One call, not three. Saving you time and money while still getting the exact right answer. Time Is Money, and So Are Tokens This is not only a speed optimization. It is an economics lesson for agent design. When an agent performs unnecessary discovery, you potentially pay twice: Users wait longer for the response. The agent consumes additional processing and tokens to rediscover information your solution already knows. That makes stable identifiers valuable configuration. If a SharePoint Site ID, List ID, or internal column name is known and unlikely to change, give it to the agent. Do not turn a constant into a scavenger hunt. The smartest agent is not the one that performs the most steps. It is the one that performs the fewest steps necessary to produce a trustworthy answer. Give the Agent Stable Facts, Not Every Possible Answer There is an important balance here. I am not suggesting that you hard-code every possible path or remove the agent’s ability to reason. In the test, adding payroll-specific details did not break the broader SharePoint experience. When I asked about December holidays, the agent still explored the available data, found the holidays list, and returned the answer. That is exactly what you want. Give the agent shortcuts for the routes you know, while preserving its ability to navigate when the request is new. Good candidates for stable guidance include: SharePoint Site or List IDs Dataverse Environments and Tables Internal SharePoint column names Known tool routing for common business questions Also, while in the video I used the SharePoint MCP this same guidance could be applied to any tool or MCP where it is having to do a lot of discover. Dataverse MCP and SharePoint Get Items are prime examples. The goal is not to make the agent rigid. The goal is to stop charging it rent for information it already learned. Filtering the Data Saves Even More Work The holiday example exposed another efficiency problem. The agent retrieved the entire holidays list, including dates from other months, and then reasoned through all of those rows to answer a question about December. It worked, but working is not the same as working efficiently. I will skip this part here but if you want to see the filter portion then jump over to the video. https://youtu.be/0FfQoM8iHNA Do Not Dump Detailed Execution Logic into Global Instructions There is one architectural warning worth calling out. All of this ID config most likely should NOT be in your instructions, they should be a skill. Global instructions should contain the things the agent should always know, plus clear routing guidance, like what skill or tool to use when. Detailed execution behavior that only applies to a specific scenario belongs in a skill. A cleaner pattern looks like this: Instructions: If the user asks about payroll, use the payroll skill. Payroll skill: Use the known Site ID, List ID, and any other payroll specific logic to get the answer. That keeps the base agent focused while still giving each scenario the precision it needs. It also prevents a giant wall of instructions from becoming its own source of confusion and wasted reasoning. I need to make a video and post about turning complicated instructions into skills, but that is for another day. A Practical Optimization Checklist When an agent feels slow or consumes more credits than expected, inspect the activity map and ask these questions: Is the agent repeatedly searching for the same site or data source? Is it listing resources just to find an ID that never changes? Is it retrieving an entire list when a filter could return only the relevant records? Does it know the internal column names required to create that filter? Are unused MCP tools enabled and adding noise to the available toolset? Does scenario-specific execution logic belong in a skill instead of the global instructions? You do not need to optimize everything on day one. Start with high-volume requests and obvious repeated discovery. Those are the places where a small amount of guidance can create a meaningful cumulative return. Trust, but Verify One test run is not a scientific benchmark. Network conditions vary, service response times vary, and in my final one-step test the elapsed time was not automatically lower than every previous run. It was raining, so obviously we can blame the weather. That is how networking works, right? The important result was the path, not one stopwatch reading. The agent went from three tool calls to two and then to one while producing the same answer. Fewer required operations give you a better foundation for consistent performance and lower consumption, even when individual response times bounce around. Test each change several times, inspect the activity map, and verify that your shortcut does not prevent the agent from handling related questions. Trust, but verify. FAQ Why should I provide a SharePoint Site ID to Copilot Studio? Providing a known Site ID lets the agent skip the find-site operation. That can reduce tool calls, reasoning, response time, and consumption for repeated requests. Should I also provide the SharePoint List ID? Yes, when the agent consistently uses the same list. A known List ID can let it skip enumerating every list on the site and go directly to the target data. Will hard-coding IDs stop the agent from answering other SharePoint questions? Not necessarily. In this test, payroll-specific guidance did not prevent the agent from finding and using a separate holidays list. Keep the guidance scoped to the relevant request. Why provide internal SharePoint column names? Internal column names help the agent create precise filters without first inspecting list metadata. That can reduce both metadata calls and the amount of list data returned. Should all of this information go into the agent instructions? No. Global instructions should hold always-relevant knowledge and routing guidance. Detailed scenario-specific execution logic is better placed in a skill. Does fewer tool calls always mean a faster response? Not on every individual run because network and service latency vary. Fewer required steps still remove avoidable work and provide a better path toward faster, more efficient responses at scale. Key Takeaways Copilot Studio can discover SharePoint resources, but repeated discovery of stable resources wastes time and tokens. Providing the known Site ID reduced the demonstrated path from three tool calls to two and cut one observed run from about 15 seconds to about 7 seconds. Providing both the Site ID and List ID allowed the agent to jump directly to retrieving the list items. Scenario-specific execution details should move into skills, while global instructions should focus on always-relevant knowledge and routing. Optimize the agent’s path, then verify the result across multiple runs instead of trusting a single timing measurement. Build Agents That Value Everyone’s Time Copilot Studio is good at figuring things out. Let it use that intelligence on the parts of the problem that actually require intelligence. If you already know the Site ID, give it the Site ID. If you already know the List ID, give it the List ID. If the agent needs a particular internal column name every time it builds a filter, give it that too. Stop paying the agent to rediscover facts that are never going to change. Your users get a faster experience, and you build a solution that uses its resources more responsibly. Time is money, especially when tokens are involved. If you want help optimizing your Copilot Studio agents, designing reusable skills, or getting your team comfortable building agents this way, PowerApps911 can help. Whether you need training, mentoring, or someone to build it with you, reach out and let’s build something awesome together.

  • The Power Automate Plugin Explained: An AI Agent That Builds, Fixes, and Documents Your Flows

    TL;DR: Microsoft ships a free Power Automate plugin that connects GitHub Copilot CLI or Claude Code to your real Power Automate environments. Once it is installed, you can ask an AI agent in plain English to list your flows, build new ones, make surgical edits to existing ones, diagnose failed runs, and clean up the stuff you never got around to, all without opening the flow designer. You know that flow. The one that runs in production, that everybody depends on, and that has exactly zero error handling in it. You have been meaning to fix it for about eight months. Adding proper try and catch scopes, failure notifications, and a bit of documentation is not hard, it is just tedious, and tedious work always loses to the next urgent request. That is the gap the Power Automate plugin fills. It is an official Microsoft plugin that plugs an AI coding agent directly into the Power Automate service, so the agent can read your flows, change them, publish them, and troubleshoot their run history. You describe what you want in a sentence, and it goes and does the work against your actual environment. In this post you will learn what the plugin is, what it can genuinely do, why it is worth your time, how to install it, what it costs to run, and the gotchas worth knowing before you point it at a production environment. If you would rather watch the whole thing in action, the full walkthrough is here: https://youtu.be/6OlQ3ioxoNA What Is the Power Automate Plugin? The Power Automate plugin is a Microsoft-published package that lets you build, edit, run, and debug Power Automate cloud flows from a Claude Code or GitHub Copilot CLI session. It lives in the microsoft/power-platform-skills repository on GitHub, alongside the canvas app and model driven app plugins you may have already installed. Under the hood it is powered by something called the FlowAgent MCP server. MCP stands for Model Context Protocol, and the short version is that MCP is the plumbing that lets an AI agent call real systems instead of just talking about them. The plugin bundles that server as a self-contained engine with more than fifty tools inside it, so the agent has a proper API surface for Power Automate rather than a guess. Two practical nerd notes from the documentation. First, it runs offline: there is no npm install and no remote host to stand up, it just needs Node.js 18 or newer. Second, authentication uses your local Azure CLI login, so the agent acts as you, with your permissions, in your environments. It cannot see anything you could not already see. Why Would You Use It Instead of the Flow Designer? The designer is great when you know exactly what you want and you are building one thing. The plugin shines somewhere else entirely: the work that is conceptually simple but painfully repetitive, and the work that requires expertise you have not built yet. Retrofitting Error Handling You Never Got Around To This is the headline use case, and it is the one the senior architects and developers already using it keep coming back to. Point the agent at an existing flow URL, tell it to add error handling and a failure notification, and it reads the flow, works out what could break, wraps the risky actions in scopes with run-after conditions, and publishes the result. In the video that took about five and a half minutes of agent time from a single sentence prompt. Think about how many flows in your tenant have no error handling at all. Now think about how long it would take you to add it by hand to every one of them. Building a Working Flow From a Description You can describe the flow you want in a sentence or two and let the agent build it. A daily reminder that checks Planner for tasks due today and emails you a list is the kind of request it handles end to end, including asking you a clarifying question like which time zone the recurrence should use. It built the trigger, the filter, the condition, the HTML table, and the email, and the flow worked on the first test run. This is not the same thing as the simple natural language flow builder you may have tried before. The agent iterates. It reads documentation, tries an approach, checks the result, and corrects itself, which is why it can get through genuinely complicated flows instead of only the demo-friendly ones. Troubleshooting Runs That Failed at 2am This is the capability people underrate. The plugin can pull run history, open a specific run, inspect the individual actions, and even drill down into a single loop iteration to find the one record that blew up. It can resubmit a run, cancel a run, cancel all running instances, and do an autonomous deep diagnosis of a failure. If you have ever scrolled through a two hundred iteration Apply to each looking for the bad row, you already know why that matters. Documenting the Flows Nobody Documented Descriptions and notes are one of those things everybody agrees are important and nobody writes. They matter more than ever now, because Dataverse table and column descriptions are exactly what your agents read when they try to understand your data. The same logic applies to flow action names and notes. Let the agent write the first draft, then go read it. Reviewing words on a screen and saying yes that is right, or no let me adjust that, is a hugely easier job than staring at a blank description box. Fair warning from the video: a notes-only edit was the one request that did not work cleanly, so be specific about what you want changed. What Can the Power Automate Plugin Actually Do? The documentation groups the capabilities into a handful of areas. Here is the honest inventory, because the scope is wider than most people expect. Area What you get Flows List, get, create, edit with surgical action-level changes, copy within or across environments, update, publish or disable, and delete Runs Run history, run details, action details, loop iteration drill-down, cancel, cancel all, resubmit, and diagnose Connections Full lifecycle create, read, update, delete and fix, plus auto-discovery and dynamic value resolution Authoring Templates and scaffolding, batch deploy, preflight checks and validation, and expression help Beyond cloud flows Desktop flow support for your RPA work, plus environment routing Which Skills Come With the Plugin? A plugin is more than a pile of tools. It also ships skills, which are the instructions that teach the agent how to use those tools properly for a specific job. You do not have to call them by name, the agent picks the right one, but knowing they exist tells you what the plugin was designed to be good at. Skill What it is for setup First-time prerequisite setup. Run this one first if anything feels off browse-flows Browse environments and flows interactively create-flow Guided flow creation where it asks you questions along the way build-flow Autonomously generate a complete flow from a description debug-flow Interactive debug of a failed run diagnose-flow Autonomous deep diagnosis of a failed run manage-flows Lifecycle work: publish, test, batch operations, inventory manage-desktop-flows List and run desktop RPA flows route-environments Environment resolution and routing when it lands in the wrong place How Do You Install It? Easier than you are expecting. The official route is two commands inside a Claude Code or GitHub Copilot CLI session: add the marketplace with /plugin marketplace add microsoft/power-platform-skills Then install with /plugin install power-automate@power-platform-skills There is an even lazier route that works surprisingly well. Copy the documentation page and ask the agent to install the Power Automate plugin for you using that documentation. It reads the instructions, runs the pieces, and reports back. In the video that took about a minute. You also need Node.js 18 or newer and an Azure CLI login, since the plugin authenticates with az login plus MSAL for the connectivity endpoints. If you have already installed the canvas app or model driven app plugins from the same repository, most of that groundwork is already done. What Does It Cost to Run? The plugin itself is free and open on GitHub. What you spend is agent time in whatever tool you are driving it from. In the video, a full working session that listed flows, reviewed a flow, edited a flow, created a brand new flow from scratch, and attempted a documentation pass came to 191 GitHub Copilot credits. That is roughly two dollars for a chunk of work that would have eaten a good part of an afternoon by hand. Model choice is yours, and it does affect both speed and cost. Any current frontier model will do the job. If you are not sure, leaving it on auto is a reasonable default. What Should You Watch Out For? A few practical things, learned the way these things are usually learned. Pick a small environment to start. A default environment with 600 flows in it can take a very long time to enumerate. Point the agent at a smaller environment while you are kicking the tires, and use the route-environments skill if it keeps landing in the wrong one. Trust but verify, every single time. The agent publishes real changes to real flows. Refresh the designer and look at what it did. In the video the edits held up, but checking takes ten seconds and it is the difference between a tool you can rely on and a tool you are nervous about. Be specific with your prompts. The one request that stumbled in the video was a vague ask to add documentation to every action, which the agent could not handle as a notes-only edit. Tell it exactly what you want changed and it does much better. Expect to wait, and be okay with that. Real work takes real time. Four to six minutes of agent runtime for a full flow build or a serious edit is normal. Go get a coffee. It is still faster than doing it yourself. Run setup first if things feel wrong. The setup skill handles prerequisites, and skipping it is the most likely reason a first session misbehaves. Who Gets the Most Out of This? If you are new to Power Automate, this is the closest thing to having an architect sitting next to you. You can ask the questions you feel silly asking, like why this expression works, what this filter query is actually doing, or how error handling is supposed to be structured, and get a real answer against your own flow instead of a generic article. If you are experienced, the value is leverage. The flows you would have built anyway get built while you work on something else, and the maintenance backlog you keep deferring becomes a prompt instead of a project. Teams already using it in production lean on it hardest for retrofitting error handling and chasing down failed runs. And this is still early. There are sibling plugins for canvas apps and model driven apps in the same repository, which means the interesting future is pointing several of them at one problem and letting an agent build the app and the flow together as a single solution. Frequently Asked Questions What is the Power Automate plugin? The Power Automate plugin is a Microsoft-published package in the microsoft/power-platform-skills GitHub repository that lets you build, edit, run, and debug Power Automate cloud flows from a Claude Code or GitHub Copilot CLI session. It is powered by the FlowAgent MCP server, which bundles more than fifty tools for working with flows, runs, and connections. Do I need to know how to code to use it? No. You talk to it in plain English. Requests like review this flow and add error handling, or create a flow that emails me my Planner tasks every morning at 8am, are the actual level of detail required. The only technical prerequisites are Node.js 18 or newer and an Azure CLI login, and the agent can walk you through installing the plugin itself. Can it edit flows that already exist, or only create new ones? It edits existing flows, and that is arguably its best trick. The documentation calls these surgical action-level edits, meaning it changes the specific action you asked about rather than rewriting the whole flow. Give it a flow URL or a flow name, describe the change, and it makes the edit and publishes it. It can also copy flows within an environment or across environments. Is it safe to point at a production environment? It authenticates as you, through your own Azure CLI login, so it can only touch what you could already touch. That said, it makes real changes to real flows, so treat it like any other change to production: start in a development or personal environment, review what it did in the designer before you rely on it, and test the flow afterward. How is this different from Copilot inside the Power Automate designer? The in-product Copilot helps you inside one flow you already have open. The plugin gives an agent tool-level access to the Power Automate service itself, so it can work across environments, iterate on its own, read run history, drill into loop iterations, manage connections, and take multiple minutes to reason through a hard problem before acting. It is a different class of task, not a different button. Does it work with desktop flows too? Partly. The plugin includes a manage-desktop-flows skill for listing and running desktop RPA flows. The deep authoring and debugging capability is aimed at cloud flows, so treat desktop flow support as useful but lighter. Key Takeaways The Power Automate plugin is a free, Microsoft-published plugin that connects GitHub Copilot CLI or Claude Code to your real Power Automate environments through the FlowAgent MCP server. It does far more than create flows: it lists, edits, copies, publishes, disables, and deletes them, and it manages connections, run history, and desktop flows. Retrofitting error handling into existing flows is the single highest value use case, and it takes one sentence and a few minutes instead of an afternoon. Loop iteration drill-down, run diagnosis, resubmit, and cancel all make troubleshooting failed runs dramatically less painful than scrolling run history by hand. Installation is two commands, or you can simply hand the agent the documentation link and ask it to install the plugin for you. It runs offline with no npm install or remote host, needs only Node.js 18 or newer, and authenticates with your own Azure CLI login, so it operates with your permissions. A full working session of listing, reviewing, editing, and building flows cost about 191 GitHub Copilot credits, roughly two dollars, which is excellent value for the work involved. Give It a Try Install the plugin, point it at a test environment, and give it the ugliest flow you own. Ask it to explain what the flow does, then ask it to add error handling. Ten minutes of that will tell you more than any article can, including this one. And if you want help building solutions like this, fixing the flows that keep you up at night, or getting your team enabled to work this way, the team at PowerApps911 can help. Whether it is training, mentoring, or building it for you, reach out and let us build something awesome together. Just click the Contact Us button to get started.

  • Microsoft Planner and Copilot: What You Can Actually Do Today

    TL;DR: Copilot Chat can now look at your Planner tasks, create simple ones, and mark things complete. The built in Planner agent goes further and can create a whole plan for you, including turning a meeting into a full Planner board with buckets, tasks, and dates. Here is what each one does and when to reach for which. Where does Copilot fit into your Planner workflow? You already know your way around Planner. The boards are set up, the buckets make sense, and the tasks are where they belong. The friction is not the tool, it is the upkeep: checking what is due today, closing out what is finished, and building a fresh plan by hand every time a new project kicks off. That is where Copilot earns its keep. Instead of clicking through a board, you can ask questions and give instructions in plain English, and Copilot does the board work for you. There are two ways to do this, and knowing the difference will save you a lot of frustration: the Planner connection inside regular Copilot Chat, and the separate Planner agent. In this post you will learn what each one can do, what neither one can do yet, and the one that saves the most time: turning a meeting into a fully built Planner board. If you would rather watch the full walkthrough, check out the video here: Microsoft Copilot + Planner: What Actually Works? What do you need before you start? You need a Microsoft 365 Copilot license. That is the one that gives you Work IQ, which is the part that lets Copilot see your Microsoft 365 content, including your Planner tasks. You do not need a special Planner license or any extra add on beyond that. If you can already ask Copilot about your email and files, you can ask it about your tasks. What can Copilot Chat do with Planner today? Think of the Planner connection in Copilot Chat as your quick daily check in. It is built for the small stuff you would otherwise click through a board to handle. Three things work really well: Ask what is on your plate. A prompt like "Look at my Planner board, anything I have to get done today?" pulls back the tasks assigned to you, what is due today, what is coming up, and what has quietly slipped past its due date. Mark tasks complete. "Mark the lunch and dinner tasks from last week as completed" cleans both of them up in one go. Copilot is forgiving about wording, so you do not have to phrase it perfectly. Create a simple task. "Add a task for me on Friday for meeting Chewy and Buddy for happy hour" creates the task and sets the due date to Friday for you. That combination covers a surprising amount of daily task management. You get a clear read on your day, you close out what is done, and you capture the new thing before you forget it, all without leaving the chat window. What can Copilot Chat not do with Planner? This is where a few people get tripped up, because the Planner connection in Copilot Chat is deliberately narrow. It is built around create task, update task, and search task. Anything bigger than that gets a polite "sorry, I cannot do that." Right now that includes: Deleting tasks Creating a brand new plan or board Assigning or reassigning a task to another person Microsoft has signaled that more of this is on the way, so it is worth trying again every few weeks. In the meantime, this is not a dead end, because there is a second option that already handles the bigger jobs. What is the Planner agent, and how is it different? The Planner agent is a built-in agent inside Copilot Chat, and it has been available for a while. Plenty of project management teams have never heard of it, which is a shame, because it does the next level work that the basic connection turns down. To find it, click the plus button in Copilot Chat, choose to chat with an agent, and start typing Planner. Pick the Planner agent and you are in. Same chat window, same plain English prompts, more capability. Give the agent a prompt like "Create a new plan named Copilot Training Class in Planner" and instead of declining, it proposes the plan, waits for you to save it, and then gives you a link straight into Planner. That one difference, being able to create the plan itself, opens the door to the good stuff. Can Copilot turn a meeting into a Planner board? Yes, and this is the part worth telling your team about. You have the meeting, you talk through who is doing what, and then somebody has to sit down afterward and turn all of that into a plan. The Planner agent can do that step for you. In the agent chat, type your prompt and use a forward slash to point at the meeting you want, then ask for what you need. For example: "Review my meeting /Webinar Planning and create a Planner board from that meeting. Create the tasks and assign them to the proper person." From there the agent reads the meeting, pulls out what was discussed and decided, and proposes a board. In the webinar planning example from the video, one conversation between two people turned into a plan with four buckets, three goals, and seven tasks, organized into delivery, content, promotion, and setup, with workback dates already filled in. You hit save, and the agent creates the board and hands you a link to open it. The value here is not that it saves clicks. It is that all the rich context from the conversation, the things people casually agreed to do, makes it onto the board instead of evaporating the moment the meeting ends. To see the whole thing happen start to finish, watch the walkthrough in the video. What still needs a human touch? Two things, and both are easy to plan around. First, the Planner connection cannot assign people. The agent works around it nicely by writing the recommended owner into the notes field of each task, so you still have to open each task and set the real assignment. Annoying, but it is a couple of minutes of clicking rather than an hour of planning. Second, the dates are assumptions. The agent builds a sensible workback schedule, but it is guessing at your timeline. Trust but verify is the rule here. Copilot is a very fast assistant, not the person in charge, so have someone walk the board once and confirm the dates and the scope line up with reality. Which one should you use? Use regular Copilot Chat for the quick one hitters during your day: what is due, mark it done, add a task. Use the Planner agent when you are actually building something: a new plan, a project board, or anything that starts from a meeting. Most people will end up using both, and it costs nothing to try the agent since it is already sitting in your Copilot Chat. Frequently Asked Questions Do I need a special license to use Planner with Copilot? You need a Microsoft 365 Copilot license, which includes Work IQ and gives Copilot access to your Planner tasks. No extra Planner license or add on is required. Can Copilot Chat create a new Planner plan? Not in regular Copilot Chat, which is limited to creating, updating, and searching tasks. The built in Planner agent can create a new plan, propose its structure, and give you a link to open it in Planner. Can Copilot assign Planner tasks to other people? No. Neither Copilot Chat nor the Planner agent can set or change assignments today. The Planner agent puts the recommended owner in each task's notes field so you can apply the assignments yourself in a few clicks. How do I find the Planner agent in Copilot Chat? Click the plus button in Copilot Chat, choose to chat with an agent, type Planner, and select the Planner agent. It is a built in agent, so there is nothing to install. Can Copilot build a Planner board from a meeting? Yes, using the Planner agent. Point it at a meeting with a forward slash and ask it to create a Planner board from that meeting. It reviews the meeting, proposes buckets, goals, tasks, and workback dates, and creates the board once you approve it. Can Copilot delete Planner tasks? No. Deleting is not supported today, so you will need to remove tasks in Planner yourself. Copilot can mark them complete, which handles most cleanup situations. Key Takeaways A Microsoft 365 Copilot license is all you need to use Planner with Copilot, because it includes the Work IQ access that connects Copilot to your tasks. Regular Copilot Chat handles day to day Planner work: reading your tasks, creating simple ones, and marking things complete. Copilot Chat cannot delete tasks, create new plans, or assign work to other people, and Microsoft has said more capability is coming. The built in Planner agent, found under the plus button in Copilot Chat, can create full plans and boards that regular chat cannot. The Planner agent can turn a meeting into a complete board, with buckets, goals, tasks, and workback dates pulled from what was actually discussed. Assignments still have to be applied by a person, and the agent helps by writing the recommended owner into each task's notes field. Always review the dates and scope a Copilot generated board proposes, because the timeline is an educated guess, not a decision. Need a Hand? If all the Copilot news feels like a lot to keep up with, you are not alone, and you do not have to figure it out by yourself. The team at PowerApps911 does training, consulting, and mentoring, including private sessions built to get an entire internal team excited and productive with tools like this. Reach out at by clicking the Contact Us button and let's build something awesome together.

  • The AI Expense Receipt App: How a Simple Power App Kills Expense Report Busywork

    TL;DR: Turning in travel receipts is a small, annoying task that quietly eats hours and frustrates your accounting team. This post walks through a simple Power Apps solution that lets you snap a photo of a receipt, uses an AI prompt to extract the vendor, date, amount, and category, and then sends accounting one clean, organized email per trip. Nobody has ever returned from a business trip excited to tackle their expense report. You come home with a wad of crumpled receipts stuffed in a laptop bag, a Chick-fil-A napkin with a total scribbled on it, and a very patient person in accounting who will email you three times before you finally deal with it. That is exactly the pain that led to this app. After joining TMC Global and getting a corporate credit card, receipts suddenly became a real requirement. So, on the flight out to see Microsoft, we built a small, focused Power App that captures receipts on the phone, uses AI to read them, and provides accounting with exactly what they need. In this post, you will learn what the app does, how AI takes the data entry out of the equation, why keeping a human in the loop matters, and how a tiny internal app like this can pay for itself almost immediately. If you’d rather watch the full walkthrough, check out the video here: https://youtu.be/rHBWxmqXnFg What Problem Does This AI Expense Report App Actually Solve? The real issue isn't "I cannot store a receipt." Phones already do that. The problem lies in everything surrounding it: Receipts pile up loose in a bag, an inbox, or a camera roll, and some never make it back. Someone has to type the vendor, date, amount, and category into a form or a spreadsheet, usually days later. Accounting receives a dump of files named IMG_4821.jpg and has to guess which Uber ride corresponds to which charge. The whole process gets delayed, which in turn delays reimbursement, closing the books, and makes everyone a little grumpy. This app tackles the friction at the exact moment it happens: when you are standing there holding the receipt. Capture it right then, let AI read it, and move on with your day. How Does the App Work from the User Side? The entire experience consists of three screens, and it is deliberately simple. The flow looks like this: 1. Create the Trip Before (or during) a trip, you add a trip with a name and a date. This serves as the container for everything else, ensuring a receipt is never floating without context. When you return to the app later, trips are sorted by date, because the oldest unsubmitted trip is usually the one accounting is asking about. 2. Snap the Receipt When you receive a receipt, you open the app and add a picture. On a phone, this means the camera opens right there at the table, allowing you to capture the receipt before it has a chance to get lost. You can also select a photo you took earlier if you are catching up later. 3. Let AI Read It Press scan, and an AI prompt reads the receipt image and extracts the four key pieces of information: the vendor, the date, the total amount, and a category. No typing is required. The fields come back filled in and ready for review. 4. Review, Tag, and Save The extracted values are added to the correct input fields. These fields are editable, so if you need to make any changes while reviewing the details, just click the field and type. If everything looks good, hit Save. That’s the entire effort per receipt: a photo, a glance, and a tap. 5. Send the Whole Trip to Accounting in One Click When the trip is complete, one button generates a single email to accounting with a clean table of every receipt from that trip, plus all the receipt images attached and automatically named so each attachment corresponds to the correct row. No more "which Uber receipt is this?" emails. Just one message that contains everything they need. Why Use AI for Reading the Receipts Instead of Typing Them In? Because reading a receipt is precisely the kind of boring, structured, high-volume task that AI excels at, while humans struggle to perform consistently. The app uses an AI prompt that analyzes the receipt photo and returns the fields in a consistent, structured format every time. That consistency is crucial. It means the data flows straight into the app and into the email without anyone having to massage it. The prompt is also designed to be honest about uncertainty. If it cannot confidently read a text field, it states so instead of making something up. If it cannot confidently read the amount, it does not guess a number. An AI that admits it is unsure is far more useful than one that confidently fabricates information on a document your finance team will rely on. Does the AI Cost a Fortune to Run? It does not, and that is a lesson worth learning. Extracting four fields from a receipt is a basic task, so a small, inexpensive model handles it perfectly well. Swapping in a top-tier premium model for the same job produced essentially the same answer, took roughly four times longer, and cost around 100 times more in credits. The takeaway: pick the smallest, cheapest model that does the job consistently. Save the expensive models for problems that genuinely need them. On a task you run dozens of times per trip, that decision is the difference between a scalable solution and one your finance team quietly kills. Should AI Be Trusted to Submit Expenses on Its Own? No, and the app is intentionally built so that it does not. Every field the AI extracts lands in an editable input, not a locked label. Before you save, you get a two-second sanity check: does nine dollars for that Chick-fil-A run sound right? Yes? Move on. If the receipt was smudged, faded, or covered in barbecue sauce, you can fix it right there. That is the human-in-the-loop principle, and it matters most in this scenario. When those numbers reach accounting, you are the one who is accountable, not the AI. Good AI solutions do not remove the human from decisions that carry responsibility; they remove the typing. What Is the Business Case for an App This Small? It is tempting to look at a three-screen receipt app and think it is too small to matter. But let’s do the math the other way. Say handling receipts manually costs you 30 minutes per trip in typing, hunting for files, and back-and-forth with accounting. Ten trips a year equals five hours. Multiply that across a team of travelers, and it becomes real money, plus faster closes, cleaner records, and fewer awkward reminders from finance. The bigger win is behavioral. The app makes the right thing the easy thing. Because capturing a receipt takes seconds and happens at the table, receipts stop going missing, which is where most expense pain actually originates. Where Else Does This Pattern Apply? Snap a photo, let AI extract structured data, keep a human review step, then push a clean summary to whoever needs it. This pattern shows up everywhere: Field service technicians capturing parts, serial numbers, or equipment nameplates Warehouse teams pulling data off packing slips and delivery paperwork Sales teams capturing business cards and event badges into the CRM Facilities teams logging inspection forms and safety checklists Accounts payable processing vendor invoices that show up as PDFs and photos If your team currently retypes something a camera and AI could read, this pattern probably fits. Why Should You Build Apps for Yourself, Not Just for Other People? Here’s the part that often gets overlooked. Most makers build apps for other departments and never turn that skill on their own daily annoyances. This app is not glamorous. It has no edit screen and no fancy reporting because those weren’t needed. It was built to solve one specific irritation for one specific person, and it does that perfectly. That is a completely legitimate reason to build something. The best internal apps are usually small, ugly, and used every single week. Look at your own workflow, find the thing you grumble about every month, and build the two-screen version of the fix. You will use it more than anything else you have created. And if everyone shows up jealous, then you could enhance this app. If Accounting shows up and asks, you could add all kinds of quick updates that take this from a Shane-only app to one that serves the entire company. That is the life of a Power Apps app—quick iterations to be exactly what your business needs. Frequently Asked Questions What Does the AI Receipt Scanning App Do? It is a Power Apps solution that allows you to photograph a travel receipt with your phone, uses an AI prompt to automatically extract the vendor, date, total amount, and expense category from the image, stores the receipt against a specific trip, and then generates a single email to accounting containing a summary table of all receipts for that trip with the images attached and clearly named. Can AI Accurately Read Receipts from a Photo? Yes, for standard printed receipts, it is very reliable because extracting a few structured fields from a document is a well-established AI task. Accuracy still depends on image quality, so a faded, torn, or stained receipt can produce an incorrect value. That is why the app presents every extracted field as an editable input for a quick human review before saving. Also, it doesn't have to be printed; I have tested it on handwritten receipts with great results as well. Do You Need an Expensive AI Model to Extract Receipt Data? No. A small, low-cost model handles receipt extraction accurately. In testing, a premium high-end model returned essentially the same result while taking about four times longer and consuming roughly 100 times more credits. Always choose the smallest model that does the job consistently and reserve premium models for genuinely complex reasoning tasks. Why Keep a Human Review Step if AI Does the Extraction? Because accountability stays with the person submitting the expense. AI removes the data entry, not the responsibility. A quick human glance at the extracted amount and vendor catches the rare misread before it reaches finance, and it costs about two seconds per receipt. Does the App Work on a Phone? Yes, and the phone is where it matters most. The picture control behaves differently on mobile than on a desktop: on a phone, it offers to open the camera and take a new photo, so you can capture a receipt the moment you get it instead of dealing with a pile of paper days later. Can I Get a Copy of This App? Yes. The app was packaged as a solution, and subscribers to any PowerApps911 training plan at training.powerapps911.com get access to the YouTube library, which includes this app plus a long list of other downloadable apps built on the channel over the years. Key Takeaways Expense reporting pain isn’t about storing receipts; it’s about the data entry, the naming, and the back-and-forth with accounting, which is exactly what this app removes. An AI prompt reads the receipt photo and extracts the vendor, date, total, and category automatically, so the maker never types receipt data again. Capturing the receipt on your phone at the moment you receive it is what actually prevents receipts from going missing. One button sends accounting a single email per trip with a summary table and clearly named attachments, so nobody has to match images to line items. Choose the smallest AI model that does the job consistently: a premium model produced the same receipt result for roughly 100 times the cost. Keep a human in the loop on anything you are accountable for by leaving AI-extracted values in editable fields for a quick review. The photo, extract, review, send pattern transfers directly to invoices, packing slips, inspection forms, business cards, and equipment tags. Small internal apps that fix your own daily annoyances are often the highest value apps you will ever build. Ready to Put AI to Work on Your Own Busywork? If you want help building solutions like this or taking your Power Platform skills to the next level, the team at PowerApps911 can help. We do consulting, coaching, and training for organizations that want to stop doing things the slow way. Reach out and let us build something awesome together. Just click that Contact button and tell us how we can help.

  • The New Copilot Studio: What Changed, and Why Your Agents Suddenly Got a Lot Smarter

    TL;DR: Copilot Studio has a brand-new build experience running on a new agent harness. One simplified screen, better models, reusable skills, memory, and an orchestrator with real tenacity. It is powerful enough that a working inventory management agent can be built with one sentence of instructions and one MCP tool. Here is what is different, what to watch out for on billing, and how to get results fast. If you have built agents in Copilot Studio before, you know the drill. Lots of tabs. Lots of screens. Topics, nodes, triggers, and a whole lot of clicking to get from idea to working agent. And then, after all that work, you ask your agent to do something slightly ambitious and it shrugs at you and says it could not do it. That is over. Microsoft has shipped a completely new way to build in Copilot Studio, and it is not a coat of paint. It is a different engine under the hood. In this post you will learn what the new experience actually changes, how skills and tools and memory fit together, what the billing change means for your budget, and then you will see a real example where one sentence of instructions produced a working inventory agent. If you would rather watch the full walkthrough, check out the video here: The New Copilot Studio walkthrough Or, if you want to see a fully functional agent built in 60 seconds check out this video: Build a Working Inventory Agent in 60 Seconds with Dataverse MCP What is the new Copilot Studio experience? It is a rebuild of the agent building experience at copilotstudio.microsoft.com. When you land on the familiar home page, you get a Try now option. Click it, the page reloads, and everything looks different. That is the new experience, and it runs on what Microsoft calls a new harness, which is their fancy way of saying this thing is fundamentally different under the hood, not just visually. The good news for the nervous among you: it is a toggle, not a one way door. There is a new experience badge in the corner, and if you need to go back to work on one of your older agents, you click it, tell it why you are leaving, hit submit, and you are back in the classic builder. For now, you make a conscious choice about which side you are working on. Why does the new build screen look so empty? Because it is one screen. That is the whole build studio. In the old experience you had screens and tabs and places to jump around. Now you name the agent, set the icon (it is hiding behind the image itself, so click it, you are welcome), and everything else lives in one panel: model, skills, tools, knowledge, connected agents, memory, and instructions. Here is the important part. Simpler does not mean it does less. It actually does more. The complexity moved from you to the orchestrator. How is the new harness different from the old one? Model choice is now yours The first thing you will notice on the right is a model picker, and the list is different from the old agent tooling. You will see frontier class models in there. Opus 5 is the default at the moment. Your list may differ depending on the date and what your company has enabled, which is completely normal. Choose deliberately, because the bigger the model, the more credits it burns. The most capable reasoning models are also the most expensive ones to run. The orchestrator finally has tenacity This is the real story. If you have used Copilot and then used Cowork, you have felt the difference. You ask Copilot to do something hard it tries hard and if it fails it says sorry, I could not. You ask Cowork and it just goes like a dog with a bone. That tenacity is what Microsoft brought to the new Copilot Studio harness. Practically, that means your agents keep working the problem instead of giving up and asking you to try a different question. The old builder had a habit of saying I tried, it did not work, ask me something else. These new agents are far more robust than that. Can you reuse your Cowork skills inside Copilot Studio? Yes, and this might be the biggest quality of life win in the whole release. Skills are now first class citizens in Copilot Studio. If skills are new to you, think of a skill as a recipe. It is a set of steps you want to be repeatable. Say every time you build a PowerPoint deck you want your brand colors, your fonts, your logos, and your standard intro slide applied. Instead of typing that into a prompt every single time, you package it once as a skill and call it forever. Skills can get far more complicated than that, but that is the right mental model to start with. The reason this matters so much: skills use the skill.md format, which has become a universal standard. The same skill works in Cowork, in Copilot, and in other AI tools. Build it once, use it everywhere. Sidenote: Skills are worth investing in. Lots of AI stuff comes and go but they seem to be core to a lot of platforms, learning them better is a good use of your time. The packaging gotcha nobody warns you about In Cowork you can find your skills under Customize. Open one and you will see the instructions plus any supporting files, like logo images. If you use the ellipses and click download, you only get the skill.md recipe file. Your logos and supporting files do not come along. So package it yourself. Go to your OneDrive, into Documents, then Cowork, then Skills, and open the skill folder. Select everything in there, including skill.md and every supporting file, right click, and compress to a zip. Name it something sensible like brand-guide.zip. Then in Copilot Studio, go to skills, click upload (the upload button, not the tempting area next to it), pick your zip, and a few seconds later the skill is live in your agent. No skill yet? Hit plus and create from blank. You give it a name, a description of when to use it, and the instructions. Pro tip: do not hand write the instructions. A real skill can run hundreds of lines. Ask an AI tool to build it for you. Tell it what you are trying to accomplish, let it interview you about your colors, fonts, and standards, and let it write the file. You can absolutely write it yourself, but why would you. Do tools work the same way as before? Mostly yes, with a slightly different interface. Hit plus on tools and you will find the same connectors you have been using in Power Apps and Power Automate for years, plus MCP servers like the SharePoint MCP server. Add a tool, click into it, and configure it. The part people get wrong: name and description are not decoration, they are how the orchestrator decides when to call the tool. Do not leave a tool named Get items. Rename it to something obvious like Get inventory data. When your agent is misbehaving and not calling the tool you expected, nine times out of ten your name and description are the problem. The rest is familiar. You choose whether the tool authenticates as the person using the agent or as the maker who built it. Inputs can be hardcoded values or left to AI, though the UI now makes you click into the field and choose New before the dropdown appears. If you leave an input set to AI, write a solid description of what you want generated, otherwise the agent will just ask the user for it at runtime. Outputs default to returning everything, and different tools expose different options, so poke around. One more thing worth knowing: for something like sending email you often have a choice between a prescriptive connector action and an MCP server that just knows how to send email. Both work. Which one you want depends on how much control you need. What changed with knowledge? By default your new agent can search the whole web through Bing. A lot of the time that is not what you want, so turn it off. Then add the knowledge you actually trust: specific public websites, SharePoint, OneDrive for Business, or a file uploaded directly to the agent. Here is the security detail to burn into your brain. If you upload a file directly to the agent, security is not honored. Anyone with access to the agent has access to that document. If you point at SharePoint or OneDrive instead, the agent uses the credentials of the person asking, so users only get results from data they already have rights to see. That difference will save you an awkward conversation someday. What are connected agents and agent memory? Connected agents let you bring other agents in as helpers. Your main agent can hand work to a child agent when it needs that specialty. This is how you build bigger solutions without cramming everything into one giant agent. Memory is genuinely new here, and it is still in preview. The idea is your agent develops a sense of what you have done with it before, and that memory is tied to that specific agent. Imagine a reporting agent that asks what region you are in the first time and never has to ask again. If you have used memory in Copilot or ChatGPT, the concept is familiar. Early testing works well, but it is preview, so do not bet the business on it just yet. What goes in the instructions? Instructions are where you tell the agent its purpose in life. Your job is building PowerPoint decks or helping to manage inventory. When you get asked for a deck, call the brand guide skill. That kind of thing. It is also where personality lives, so if you want every response to include a dog joke, this is your moment. (I love a good dog joke or pun) Aim for clear guidance rather than hyper specific micromanagement of every possible path. Tell it what it does, which tools and skills to use for what, and how to behave. How do you test, evaluate, and ship it? Preview lets you use the agent while you build. There is a great toggle up top that flips between the maker view, full of nerdy detail about which tool got called and what it was thinking, and end user preview, which shows what your users will actually see without the technical noise. Use the first one to debug and the second one to sanity check the experience. Evaluate lets you set up test sets and run standardized tests against your agent. It is in preview, but it is there today. Monitor shows sessions, billing, and what is actually happening in production. And do not forget to hit save. There is no autosave. Then use the publish dropdown to push to a demo website, embed in a web app, or (most likely) publish to Teams and Microsoft 365. Publishing takes a minute or two, then your channels light up and your agent shows up right inside M365 Copilot where your users already live. What does this change about billing? This one deserves your full attention. The new harness runs on Copilot credits, all the time. Building and previewing now costs credits. The old builder did not bill you while you were testing during the build phase. This one does. Every time the agent runs and thinks, that is credits. Your M365 Copilot license does not cover it. In the old model, depending on your licensing and scenario, some usage could be covered. On the new harness it is credits all the time. Model choice is a budget decision. The most capable reasoning models cost the most to run. Match the model to the job. None of that is a reason to avoid the new experience. It is a reason to plan for it and to be intentional about which agents get the expensive model. How much can it really do with so little? A one minute inventory agent Here is the demo that makes the point better than any feature list. The goal was an agent to manage order items and vendors sitting in Dataverse. The build took about a minute, start to finish. The entire build was two steps: One sentence of instructions: "You are an agent for managing order items and vendors for the Aug301 project using the Dataverse MCP tool." One tool: the Microsoft Dataverse MCP server. Connect, click add, done. That is it. Ask it for the list of vendors and it comes back with the right four vendors: Amazon, Costco, Dell, and Target. Ask it to update Amazon to be valid through the end of 2027 and it writes the change back, because the Dataverse MCP reads and writes. Ask it to add a new webcam to the items table and it goes and finds the right table, pulls the schema, asks you for the cost and the vendor, and creates the record. The kicker: the vendor column is a lookup. Nobody told the agent that it was a relational lookup or how to connect it. It figured that out on its own. Should you ship a one sentence agent to production? Please do not. It makes a spectacular demo, and it genuinely works, but one sentence leaves a lot to chance. Some things it will figure out. Some things it will not, and you will not know which until a user finds the weird path. The production version of that same inventory agent took about five minutes. The difference was the instructions. Instead of one sentence, it listed the five specific tables the agent is allowed to touch (with the word only, so it never wanders into one of those other vendor tables), what to consider when creating orders, what to do when deleting orders, how to handle the status choice column, and general behavior rules. Golden rule of agent building: you want the agent to think as little as possible. The more prescriptive you are, the less it improvises, and the less you have to worry. Frequently Asked Questions What is the new Copilot Studio harness? The harness is the new engine underneath Copilot Studio agents. It replaces the old orchestration model with one that picks from newer frontier models, keeps working a problem instead of giving up, and supports skills, connected agents, and memory. You opt into it with the Try now button at copilotstudio.microsoft.com, and you can switch back to the classic builder at any time. Does the new Copilot Studio cost more? It changes how you are billed. Everything on the new harness runs on Copilot credits, including the time you spend building and previewing your agent, which the old builder did not charge for. M365 Copilot license coverage does not apply the way it sometimes did before. Bigger models consume more credits, so model choice is a budget decision. Can I use my Cowork skills in Copilot Studio? Yes. Skills use the universal skill.md format, so the same skill works across Cowork, Copilot, and Copilot Studio. To move one over, open the skill folder in your OneDrive under Documents, Cowork, Skills, zip the entire folder contents, and upload the zip in Copilot Studio. Downloading a skill from Cowork only gives you the skill.md file, so supporting files like logos have to be packaged manually. Why does my agent ignore a tool I added? Almost always because the tool name and description are too generic. The orchestrator reads the name and description to decide when a tool is relevant, so a tool called Get items tells it nothing. Rename it to something specific like Get inventory data and write a description that states exactly when to use it. Is it safe to upload files directly as agent knowledge? Only if everyone with access to the agent should also have access to that file, because directly uploaded files do not honor per-user security. If you point the agent at SharePoint or OneDrive for Business instead, it uses the credentials of the person asking, so each user only sees results from data they already have permission to view. Key Takeaways The new Copilot Studio experience is opt-in through the Try now button, and you can switch back to the classic builder whenever you need to. The entire agent builder is now one screen, but it does more than the old multi-tab experience, not less. The new harness brings Cowork style tenacity, so agents keep working the problem instead of giving up and asking you to rephrase. Everything on the new harness is billed in Copilot credits, including build and preview time, and bigger models cost more. Skills built for Cowork work in Copilot Studio, but you have to zip the full skill folder yourself because downloading only gets you the skill.md file. Tool names and descriptions drive orchestration, so a vague tool name is the most common reason an agent ignores a tool. A working Dataverse agent can be built in about one minute with one sentence of instructions and one MCP tool, but a production agent needs prescriptive instructions and a human review. Filling in Dataverse and SharePoint description fields is the single highest value prep work you can do today for the agentic era. Need a Hand? Everything above comes out of real client work, whether that is training teams to build this stuff, building it for them, or co-building it alongside them. If you want help building agents like these, sorting out the difference between Copilot, Cowork, the old Copilot Studio, the new Copilot Studio, and Foundry, or just getting your team up to speed, the team at PowerApps911 can help. Reach out by clicking the Contact button or check out the upcoming live Copilot Studio class over at training.powerapps911.com. Let's build something awesome together.

  • PowerApps911 Has a Bigger Family

    POWERAPPS911 · A TMC GLOBAL COMPANY Same team, same Power Platform expertise, a much bigger family behind us. Here is what is changing, and everything that is not. TL;DR PowerApps911 is now part of TMC Global, a unified family that brings together PowerApps911, Technology Management Concepts (TMC), and The TM Group (TMG). We are still the same Power Platform team you know for consulting, mentoring, projects, training, and real-world expertise. What is new is how far we can take you beyond the Power Platform, with a larger team supporting Dynamics 365, Business Central, Microsoft 365, Azure, data, and AI, all through the partner you already trust. In This Article → What TMC Global means for PowerApps911 customers → Why Power Platform is still at the center of what we do → What you can now access beyond PowerApps911 → Where this leaves you and us → Quick answers about what is changing If you have been around PowerApps911 for a while, you know what we are about: helping people actually get things done with the Microsoft Power Platform. Sometimes that means teaching you to build it yourself. Sometimes it means working alongside you when you are stuck. And sometimes it means building the whole thing for you. That is not changing. What is changing is the size of the team behind us and how far we can now go with you. Earlier this year, PowerApps911 joined Technology Management Concepts, bringing our Power Platform and AI expertise into a larger Microsoft organization. Today, we are introducing the unified brand for that growing family: TMC Global. TMC Global brings together PowerApps911, TMC, and The TM Group under one connected organization, combining decades of Microsoft experience across business applications, cloud, data, AI, and the Power Platform. We are now PowerApps911, a TMC Global company, and everything you love about us is still right here. What Does TMC Global Mean for PowerApps911 Customers? For most of you, the first thing to know is simple: PowerApps911 is not going anywhere. You will still find the training, mentoring, projects, and Power Platform consulting you come to us for. You will still work with the experts you know across Power Apps, Power Automate, Power BI, Power Pages, Copilot Studio, Dataverse, Fabric, and the rest of the stack we live in every day. But now, when your needs reach beyond the Power Platform, the conversation does not have to end there. Maybe the app you are building needs to connect more deeply with Dynamics 365. Perhaps you have outgrown your current ERP and need to look at Business Central. Maybe your organization is trying to make sense of Microsoft 365 licensing, Azure, or its broader AI strategy. Those needs used to mean bringing another partner into the room. Now they are part of the same one. So what does that bigger team actually bring to the table? Real depth, earned over decades. TMC has spent nearly forty years on Dynamics ERP and CRM, with more than 3,000 implementations and a 98% client retention rate. The TM Group adds serious migration muscle, the kind that moves organizations off aging systems onto the modern Microsoft stack without breaking what already works. Put that next to our Power Platform, Copilot, and AI expertise, and you have coverage across just about every layer of a Microsoft environment you are likely to touch. It also opens doors you could not reach through a Power Platform practice alone, like AI at the Core, TMC’s approach to building AI readiness into a solution from the first design decision instead of bolting it on at the end. "I have spent almost forty years building toward one idea: a partner you can bring your entire Microsoft world to, and never outgrow. TMC Global is that idea, finally whole. PowerApps911 is a big part of why it works, because they have always believed what we believe, that the best partner makes you smarter, not more dependent." — Jennifer Harris, Founder and CEO, TMC Global One partner. Every product. No gaps. Power Platform Is Still Our Thing We should probably make this part especially clear. Joining a larger Microsoft organization does not turn PowerApps911 into a generalist. Our team stays focused on the thing that made PowerApps911 what it is: helping people build better solutions and become better makers. We have trained more than 15,000 students worldwide and worked one-on-one with hundreds of organizations. Our education runs through Power Platform University, a world-class program with students across six continents, alongside live and on-demand training, mentoring, quick consulting, and full solution builds. Here is something we are quietly proud of. Microsoft itself brings us in to help train its own people on its own products. When the company that builds the platform trusts you to teach it, that is not a credential you pick up by accident, and it is not going anywhere. That expertise does not get diluted by TMC Global. It gets connected to more expertise around it. Your Power App Doesn’t Live on an Island This is where we get especially excited about what comes next. The solutions we help you build rarely live by themselves. A Power App connects to Dataverse, automates a process through Power Automate, pulls data from another business system, and eventually becomes part of a much larger technology strategy. As those solutions grow, so do the questions. How does this connect to our ERP? What about our CRM? Where should our data live? How do we govern all of it? Where does Copilot fit? Do we have the right Microsoft licensing? Those are bigger questions than any single practice can answer alone. Through TMC Global, PowerApps911 customers now have access to deep expertise across Dynamics 365, Business Central, Microsoft 365, Azure, data, and AI, right alongside the Power Platform capabilities you already know us for. Take Microsoft licensing, one of the quietest places organizations lose money. As a TMC Global company, we can now handle your Microsoft 365, Dynamics, and Azure licensing directly, as your trusted Microsoft partner. That means the people who understand your solutions are the same people right-sizing what you pay for, trimming the licenses you are not using, and giving you a single source of truth for everything Microsoft, instead of piecing it together from a stack of renewal emails. Less time, less spend, one place to go. You do not have to outgrow PowerApps911 when your technology needs are outgrowing the Power Platform. Now we are growing with you. The Microsoft Partner You’ll Never Outgrow PowerApps911 has always been about meeting people where they are. If you want to learn, we will teach you. If you want help building, we will build with you. If you want us to take the project and run with it, we can do that too. TMC Global takes that same philosophy and extends it across the whole Microsoft ecosystem. For our customers and community, that means you can still come to PowerApps911 for exactly what you have always expected from us, with a much larger team standing behind us the moment you need something more. We are still PowerApps911. We just have a lot more people to call when things get complicated. And honestly, we think that (in Shane’s words) “It is pretty awesome”. Welcome to TMC Global. The Microsoft partner you’ll never outgrow. Common Questions, Answered Is the PowerApps911 name going away? No. PowerApps911 continues as a TMC Global company, serving customers with the same Power Platform consulting, mentoring, and training you know us for. Will I still work with the PowerApps911 team? Yes. Your existing relationships with the PowerApps911 team stay exactly as they are. Is Power Platform University changing? No. Power Platform University keeps running, with the same teaching-first approach and the same instructors. The only difference is the depth of expertise now standing behind it. Can I still buy PowerApps911 training and mentoring? Yes. We continue to offer live and self-paced training, Power Platform University, mentoring, and consulting. What new services can I access? Through the broader TMC Global organization, you can now tap expertise across Dynamics 365, Business Central, Microsoft 365, Azure, data, AI, and licensing. Can TMC Global help with our Microsoft licensing? Yes. As a TMC Global company, we can now manage and optimize your Microsoft 365, Dynamics, and Azure licensing directly, which often means real savings and one trusted source for everything Microsoft. Who should I contact if I need help? Keep reaching out to your existing PowerApps911 contacts. If your needs extend into another part of the Microsoft ecosystem, we will connect you with the right experts inside TMC Global. Have questions about what this means for you? PowerApps911 is still here, and we’re still the same team you know. If you’re curious about the bigger TMC Global family, or you want to talk through your next Microsoft project, we’d love to hear from you.

bottom of page