Blog Post

Microsoft Mission Critical Blog
6 MIN READ

AI-Assisted Authoring: How Copilot, Canvas Apps Authoring MCP, and Playwright MCP Worked Together

ahmedshaalan's avatar
ahmedshaalan
Icon for Microsoft rankMicrosoft
Oct 29, 2026

I wanted to see how far an AI-assisted authoring workflow could go when the goal was not just to generate code, but to create a working Power Apps canvas app, connect it to Dataverse, validate it, and keep the maker in control of each important decision. The result was a three-screen Device Hub app built from Visual Studio Code with a coordinated flow across Copilot, Canvas Apps Authoring MCP, and Playwright MCP. 

The app scenario was intentionally simple: browse available devices, submit a purchase request, and review or cancel my own requests. That made it a useful test of the authoring workflow itself rather than a test of application complexity. 

 

The orchestration model 

The most important lesson was that each tool had a distinct role. The experience worked because the tools were not trying to do the same job. They handed work to each other at the right layer. 

 

 

 

GitHub Copilot in VS Code 

Interpreted my requirements, proposed the application plan and data model, coordinated the MCP tools, and guided the iterative implementation and troubleshooting process. 

 

Canvas Apps Coauthoring MCP 

Connected VS Code to the live canvas app, synchronized its source files, generated and updated YAML, compiled formulas, inspected data sources, and validated the app model. 

 

Playwright MCP 

Automated the authenticated browser experience in Power Apps Studio and the Power Apps Maker Portal. It handled interactions such as entering Copilot prompts, reviewing generated tables, wiring data sources through the user interface, and performing UI checks. 

 

Power Apps Copilot in the Maker Portal 

Provided a fast starting point for creating the Dataverse tables from a natural-language description, although the generated schema still required review and occasional correction. 

 

That separation mattered. Playwright MCP operated where an authenticated browser and user-interface interaction were required. Canvas Apps Coauthoring MCP operated where source code, schemas, formula compilation, diagnostics, and app-model validation were required. Power Apps Copilot accelerated Dataverse table creation, while GitHub Copilot served as the orchestration layer that connected my intent, the implementation plan, and the iterative fixes across all these surfaces. 

 

 

Starting from a real blank canvas app 

I began by enabling the canvas app coauthoring feature, opening a blank app in Power Apps Studio, and connecting Canvas Apps Authoring MCP from Visual Studio Code. The app stayed open in Studio, but the source became available locally as YAML. This created a practical split: I could reason and author in VS Code while still relying on the live Power Apps environment for authentication, metadata, data sources, and runtime validation. 

 

 

 

The initial app was the standard header, main, and footer template. From there, the AI-assisted workflow treated the app as an editable source project rather than a collection of manually inserted controls. 

Planning before generation 

Before generating screens, I used Canvas Apps Authoring MCP to drive the planning step. Instead of me hand-authoring every detail up front, the MCP helped translate the high-level idea - build a device purchase app - into a structured implementation plan. I then reviewed that plan, made a few tweaks, and approved it before generation started. 

 

 

 

That planning pass turned the request into a measurable target: the data model, screens, user actions, validation rules, and test scenarios. The approved Dataverse model included two tables: 

 

 

 

 

 

With that approved plan in place, Copilot and Canvas Apps Authoring MCP had a clear brief to work from. The workflow became less about guessing from a vague prompt and more about generating against a reviewed plan that could be compiled, validated, and adjusted. 

 

 

 

Using Playwright MCP for the browser-bound work 

Some parts of this build had to happen in the maker portal and Power Apps Studio. Because the browser session was already authenticated, Playwright MCP became the bridge into those experiences. It entered prompts into Power Apps Copilot, reviewed the generated table previews, corrected schema issues in the table designer, and added the Dataverse tables as data sources in the canvas app. 

This was not just UI automation for convenience. It let the AI-assisted workflow continue across surfaces that are normally difficult to drive from source alone: authenticated portal pages, embedded Studio frames, and generated Copilot previews. 

Where Copilot helped, and where it needed guardrails 

My first Copilot attempt asked for both Dataverse tables in one prompt, including fields, choices, lookup behavior, and autonumber requirements. Copilot produced a preview, but the operation stalled and the tables did not persist. 

 

 

 

The fix was to simplify the orchestration. Instead of asking Copilot to create the complete schema in one step, I created one table at a time. The Device table succeeded on the next attempt, including generated columns and sample records. After a short metadata delay and refresh, it appeared in Dataverse. 

 

Connecting Dataverse back into the canvas app 

After both tables existed, Playwright MCP opened the embedded Power Apps Studio frame and added the data sources: Devices and Device Purchase Requests. Canvas Apps Authoring MCP then inspected those sources from the app model. It confirmed that the sources were writable and delegatable and returned the logical names, data types, lookup metadata, and choice values needed for reliable formula generation. 

This handoff was critical. The browser created and connected the sources. The authoring MCP used the actual app metadata to generate formulas against the correct names rather than guessing. 

Building the app as source 

Once the data sources were available, Canvas Apps Authoring MCP generated the implementation plan, shared design rules, and per-screen briefs. The app was built as source and compiled repeatedly, not manually assembled control by control. 

The generated app included three primary screens: 

Device Catalog 

The catalog reads active device records from Dataverse and supports search by device name, manufacturer, or model; device-type filtering; stock visibility; and a Request action for active, in-stock devices. 

 

Purchase Request 

The request screen supports create and edit modes. It carries forward the selected device, calculates totals from unit price and quantity, and captures the business justification and needed-by date. 

 

My Requests 

The My Requests screen filters records to the signed-in user and supports reviewing, editing, and cancelling existing requests. 
 

Compile, diagnostics, and accessibility 

The compile step did more than check syntax. The first full compile produced 180 delegation warnings. Because the app was available as source, the assistant could inspect the repeated diagnostic pattern, identify the formula issue, update the affected expressions, and compile again. 

After the formula issues were resolved, App Checker reported no formula problems. Accessibility validation then found missing keyboard tab stops on both galleries. Adding TabIndex: 0 cleared those errors. This reinforced the value of treating validation as part of the authoring loop rather than a final manual cleanup task. 

 

 

 

 

 

How the Tools Worked Together 

The key was orchestrating the tools as one connected workflow rather than using each tool separately. 

  • The plan established the intent first. The app requirements, data model, screens, actions, and validation scenarios were defined before generating controls. 

Playwright MCP handled the authenticated browser tasks. It worked within the existing Power Apps browser session to prompt Copilot to create the Dataverse tables, review and correct the generated schema, and add the completed tables to the canvas app. 

  • Canvas Apps Authoring MCP created and validated the app. It inspected the connected data-source schemas, generated the app source and screens, compiled the Power Fx, diagnosed delegation issues, and supported the App Checker and accessibility validation loop. 

The maker orchestrated the complete process. I remained responsible for reviewing decisions, correcting the schema, coordinating the tools, and confirming that the final app matched the intended business experience. 

Final takeaway 

The biggest shift was where the time went. I spent less time inserting controls and rewriting formulas, and more time defining the user journey, reviewing generated decisions, correcting the data model, and validating behavior. 

Copilot provided a fast starting point. Playwright MCP extended the workflow into the authenticated maker experience. Canvas Apps Authoring MCP turned the canvas app into a source-driven project that could be planned, generated, compiled, inspected, and fixed from VS Code. Together, they created an orchestrated AI-assisted authoring loop rather than a one-shot generation experience. 

The result was a real Device Hub canvas app connected to Dataverse, compiled without formula errors or delegation warnings, and checked for accessibility. The tools moved quickly, but the solution still depended on human review, clear requirements, and validation at every handoff. 

Official documentation and further reading 

- Create and edit canvas apps with AI code generation tools - Microsoft Learn - https://learn.microsoft.com/power-apps/maker/canvas-apps/create-canvas-external-tools 

- Playwright MCP server for Power Platform testing - Microsoft Learn - https://learn.microsoft.com/power-platform/developer/playwright-samples/ai-mcp 

- View source code files for canvas apps - Microsoft Learn - https://learn.microsoft.com/power-apps/maker/canvas-apps/power-apps-yaml 

- Microsoft Playwright MCP server - GitHub - https://github.com/microsoft/playwright-mcp 

 

Updated Oct 29, 2026
Version 1.0
No CommentsBe the first to comment