How many files can Copilot Cowork process in one task?

Dozens cleanly. In this demo, 22 files including Excel ticketing data and call transcripts. Hundreds becomes unreliable. For very large datasets, summarise or aggregate in SharePoint first (with a Skill, with Power Query, or with a separate Cowork task) then feed the aggregated data into the dashboard task.

Does Copilot Cowork actually check its own work?

Yes. After producing the dashboard, Cowork runs a self-verification pass. If it finds bugs (broken charts, missing sections, syntax errors in the HTML), it fixes them and runs again. The user sees a 'found a few little bugs, fixed them' note before the output is finalised. This is part of why Cowork tasks take a few minutes rather than seconds — the verification adds real reliability.

What's in a ticketing dashboard built this way?

In the demo: operational performance (SLA charts, resolution times, first call resolution), agent and team performance (per-agent tickets, calls, average resolution), customer and commercial metrics, demand mix by ticket type, sentiment analysis from transcripts, an agent-specialisation heat map, and after-hours load. All in one self-contained HTML file with sticky navigation.

Can the same workflow run for different brands or clients?

Yes. Swap the Design MD file and re-run with the same data. The dashboard layout, sections, and data stay the same; the colours, typography, and component styling change. This is the pattern for white-labelling or running the same workflow across multiple client tenants from one Skill.

Does the dashboard handle phone call transcripts as well as ticket data?

Yes. Cowork reads both structured exports (Excel ticket data) and unstructured transcripts (call transcripts in the same library) and synthesises across them. The sentiment scoring and transcript-driven insight sections of the dashboard come from the transcripts; the operational metrics come from the structured data. The synthesis happens inside the same task.

How long does the dashboard generation take?

About three to five minutes for the 22-file dataset in the demo, including the self-verification pass that catches and fixes bugs. Smaller datasets (5-10 files) take one to two minutes. The scheduled-task pattern means this happens overnight or at a defined time, so the team does not wait on it interactively.

Can this run on a schedule rather than on demand?

Yes. Wrap the workflow into a Cowork Skill. Schedule the Skill to run weekly or monthly. New files land in the SharePoint library during the period; the scheduled Skill picks them up, regenerates the dashboard, archives the source files. The team's monthly report becomes hands-off.

Is this Cowork specific or does it work in Copilot in SharePoint too?

Both can produce dashboards from SharePoint files. Cowork is the better fit for long-running multi-file synthesis with autonomous execution and self-verification. Copilot in SharePoint inside the site itself works for smaller dashboards built on-demand by team members. The /articles/copilot-sharepoint-dashboard article covers the same pattern with a different framing.

Build a ticketing dashboard from 22 SharePoint files with Copilot Cowork

A ticketing dashboard with 1,000 tickets, 500 call transcripts, SLA performance charts, agent heat maps, sentiment analysis, and on-brand styling produces itself in under five minutes when you point Copilot Cowork at the SharePoint library where the data lives. Then Cowork checks its own work and fixes the bugs it finds before handing the file over.

This is the worked example of the autonomous report generation pattern. It originated in a Cowork enablement day with Microsoft partners and MSPs. The team in the room came up with the scenario; the build ran live. The pattern transfers to any team that produces structured monthly reports from SharePoint files.

The scenario

A managed services provider (MSP) is the example. The team's ticketing system exports a month of data into a SharePoint library: ticket records, agent performance data, customer interactions, and phone call transcripts. By the end of the month, there are 22 files in the library covering roughly 1,000 tickets and 500 calls.

Manually, the monthly report takes a senior analyst a full day. Pulling data from each Excel sheet into the reporting template. Building charts. Reading enough call transcripts to identify themes. Writing the commentary. Designing the layout.

The Cowork task replaces that day with a five-minute autonomous build.

The prompt that sets the dashboard structure

The user types one detailed prompt that defines the full output:

"Create an interactive HTML report based on these files. Below are the KPI reports and areas we want to cover: operational performance, agent and team performance, customer and commercial section, demand and deflection, ticket type and demand mix, sentiment and quality, plus a section driven by the call transcripts. Brand it in our company brand using the attached Design MD file."

Two attachments alongside the prompt: the 22 SharePoint files (selected via the "attach cloud files" picker pointing at the SharePoint library) and the Design MD file for the brand.

Cowork plans the work. It loads the PowerPoint and HTML skills from its skill set. It reads the spreadsheets to understand the data shape. It reads the transcripts. It plans the dashboard structure. Then it generates.

What Cowork produces

The finished output is a self-contained HTML dashboard. The video shows the user opening it in the browser to walk through what got built.

Top of the dashboard. Title, summary stats (1,000 tickets, 500 calls), and a brand-aligned hero block.

Sticky left navigation. Sections accessible by click. The active section is highlighted as you scroll.

Operational performance. SLA chart showing tickets resolved within target versus out of target. Resolution time chart by category. First-call resolution percentage. Talk time versus full-resolution-time scatter. Customer effort score.

Team performance. Per-agent breakdown showing tickets handled, calls handled, total volume, average resolution times. Workload distribution chart. Agent specialisation heat map showing which ticket types each agent handles most.

Customer and commercial. Customer satisfaction trends. Top customer interactions. Demand-mix breakdown by category.

Sentiment. Baseline sentiment analysis pulled from the call transcripts. Sentiment trend by week. Comparison between ticket-based sentiment and call-based sentiment.

Transcripts-driven insights. Themes from the calls, common pain points raised by customers, escalation triggers. Generated by Cowork reading every transcript during the build.

Industry benchmarking. Comparison against typical MSP metrics in the same band.

After-hours load. Charts showing ticket and call volume outside business hours.

All in one HTML file. Every chart interactive (hover for details). Every section navigable from the sticky panel. The brand colours and fonts from the Design MD applied throughout.

Cowork verifies its own output

This is the moment in the video that surprises most viewers. After Cowork generates the dashboard, it does not just hand it over. It runs a self-verification pass.

"CoWork actually found some bugs in the report, and it went back and fixed it. So it did a verification after it had created and found a few little bugs."

The bugs in the demo were minor — a chart rendering issue, a section heading missing on one block. Cowork found them itself, fixed them, then declared the task done.

This self-check is part of why Cowork tasks take a few minutes rather than seconds. The verification adds real reliability. For autonomous tasks where you are not watching the output land, the self-check is what makes the pattern safe to schedule.

Same data, different brand: re-running with a new Design MD

The video shows a second pattern that demonstrates the leverage of the Design MD approach.

The user feeds the same 22 files into a new Cowork task but swaps the Design MD file. Same prompt, same content, same dashboard structure. The output looks completely different — different colours, different fonts, different component styling.

For MSPs running the same operational dashboard across multiple clients, this is the white-label pattern. One Skill, one set of data, one Design MD per client. The dashboard regenerates with the right brand for each client without rewriting the workflow.

The same idea works inside one organisation across teams or business units. The People and Culture team gets one Design MD. The Finance team gets another. Same workflow shape, different brand application.

Delegation, not chat

The video closes on the same mindset point as the Copilot Cowork PowerPoint walkthrough: this is delegation, not chat.

You give Cowork a task. The task is non-trivial — read 22 files, build a dashboard, apply branding, verify output. You walk away. You come back to the finished result.

That mental shift matters more than any specific feature. Most Copilot interactions treat the model as a chat partner. Cowork treats it as an autonomous colleague you hand work to.

For ticketing dashboards specifically, the implication is that monthly reporting stops being a thing somebody has to do and becomes a thing that happens. Schedule the Skill, file the dashboards in a SharePoint library, review them on Monday morning when they are already built.

The scheduled-task pattern

The natural follow-on from a working manual build is a scheduled execution.

Wrap the dashboard prompt into a Cowork Skill. Bundle the Design MD into the Skill. Schedule the Skill to run on the first of every month (or every Monday for weekly cadence).

During the period:

The ticketing system exports new files to the SharePoint library
Call transcripts accumulate in the same library
Nothing happens in Cowork yet

At the scheduled run time:

Cowork executes the Skill
Reads every new file in the library
Builds the dashboard with current-period data
Archives the source files into a dated folder
Saves the dashboard to a known location in SharePoint
Sends a Teams message announcing the new dashboard

The team opens the dashboard on Monday. The work has happened overnight.

Where this fits in the bigger picture

Three patterns this connects to.

SharePoint as the data layer. The files live in SharePoint. Cowork is the synthesis layer. The dashboard is the output. Each tool does the part it is best at. The SharePoint dashboard article covers the same pattern with a slightly different framing.

Design MD as the brand layer. One Design MD file, one workflow, multiple brand applications. The PowerPoint Design MD article covers Design MD for slide decks.

Skills wrap the workflow. Once the manual build works, wrap it in a Skill. The Skills deep-dive covers the SKILL.md format Cowork uses (same format as SharePoint Skills).

What to do this week

If your team produces structured monthly reports from SharePoint files, three actions.

Identify the dashboard that hurts most. Whichever monthly report consumes the most analyst time. Ticketing, sales pipeline, project status, finance, compliance.
Run the manual version in Cowork once. Open Cowork, attach the SharePoint library, dictate the prompt, see what comes out. Iterate the prompt over two or three runs until the output is what you want.
Wrap the working prompt into a Cowork Skill. Schedule the Skill. The next monthly cycle, the report builds itself.

For organisations running this pattern across multiple teams or clients (the white-label scenario), the Copilot in SharePoint Immersive is the one-day workshop format where we build the SharePoint side and the Cowork side together in your tenant.