u/oartconsult

Most Copilot Studio tutorials show you one happy-path demo in isolation. You see the agent work once, cleanly, with perfect input. What you don't see is what happens when the input is incomplete, the data is missing, or the file has 50,000 rows.

I built five agents across five completely different business problems and put every single one in one video — with live demos showing real input, the process running, and the actual output. Including what happens when things go wrong.

Here's what's in it:

1. Email invoice processor with OCR Emails arrive with invoice attachments — PDFs, PNGs, multi-page documents. The agent reads them, extracts the fields, validates completeness, registers clean invoices to an Excel table, and routes anything with missing data to an error folder. Zero manual input.

2. Hybrid knowledge assistant One question that needs two different sources to answer — a descriptive catalogue and a live data table. The agent decides which source to query, loops through both if needed, and compiles one complete answer. Falls back to web search for questions outside both sources.

3. Logistics assistant with external API Incomplete delivery request — no address, no dimensions, nothing. The agent figures out what's missing, searches the web for what it can find itself, builds a JSON payload, and calls an external shipping API via HTTP. Returns real carrier options with prices and delivery times.

4. SharePoint folder structure monitor Runs on a schedule every morning. Reads a SharePoint library, detects misplaced files and subfolders in the wrong location, and emails a structured report with a prioritised to-do list. No manual checks needed.

5. Large Excel data handler — 50,000+ rows Natural language query against an Excel file with 50,000+ rows. Uses OData filters to pull only the exact rows needed — no loading the whole file. Tested on a comparison between a row near the beginning and one near the very end of a 50,000-row dataset.

Five different architectures, five different trigger types, five different real-world outcomes.

Full walkthrough in the comments.

Which of these would solve something your team is still doing manually? Or what would a sixth agent on this list look like?

One of the most common questions I see in Power Platform: how do you call a third-party system that doesn't have a native connector — and how do you handle the case where the user hasn't given you all the required parameters upfront?

Most setups either hardcode the missing values, ask the user for everything at once, or just fail. None of those work in practice.

So I built a Copilot Studio agent that solves both problems in one architecture.

Here's what it actually does:

• Takes an incomplete natural language request and figures out what's missing before making any API call
• Runs a reasoning loop driven by a single prompt action that decides the next step every iteration: ask the user, search the web, build the payload, deliver the answer, or stop
• Fills missing parameters automatically using web search — if the user gives vague input, the agent finds the data itself instead of asking
• Builds a structured JSON payload from everything collected and sends it via HTTP request to an external API — with auth headers, content type, and body configured correctly
• Handles empty or error responses from the API gracefully and routes accordingly

The architecture — one controlling topic, one prompt driving all decisions, one accumulating variable — is the reusable pattern here. The logistics use case is just the demo. The same setup works for any external system: pricing APIs, ERP endpoints, custom internal services, anything with an HTTP interface.

Three live demos in the video showing the full loop from a vague input to a real API response with carrier options, prices, and delivery times.

Full walkthrough in the comments.

What external APIs or third-party endpoints have you needed to connect to from Power Platform without a native connector? Curious what others are building.

Most Copilot Studio agents only use Microsoft tools — query Excel, read SharePoint, send an email. The moment you need to call an external third-party system via HTTP, most setups fall apart fast.

So I built a logistics assistant that shows exactly how to do it — including the messiest part: the user never gives you all the data upfront.

Here's what it actually does:

• Takes an incomplete request — "get me a delivery price from Chicago to New York" — and figures out what's missing before making any API call
• Runs a decision loop driven by a single prompt action that decides the next step every iteration: ask the user, search the web, call the API, answer, or stop
• Searches the web automatically for missing details — if the user says "it's just a shoebox," the agent finds the dimensions itself instead of asking
• Builds a structured JSON payload and sends it via HTTP request to an external shipping API with proper auth headers
• Returns real carrier options with prices and delivery times

The architecture is one topic acting as a controller, one prompt making every routing decision, one variable accumulating everything — original request, follow-up answers, web results — so the agent gets smarter with every loop.

The main point of this build is the HTTP pattern: once you can call one external API this way, you can call any of them. The logistics use case is the demo — the same architecture applies to any third-party system your business connects to.

Three live demos in the video showing the full loop from vague input to real API response.

The full flow is in my flospect library — same link as always, this build has been added. Every node, prompt, variable, and HTTP setup. Ready to view and rebuild in your own environment.

Video walkthrough + library link in the comments.

What external APIs or third-party systems have you needed to connect to from Copilot Studio? Curious what others are trying to integrate.

Every time I finish a Copilot Studio build, I hit the same uncomfortable moment: how do I properly validate this works across all the scenarios it's going to face in production?

The happy path is easy. But edge cases, ambiguous inputs, error handling, boundary conditions — those are the things that break at the worst possible moment.

Most approaches I've seen fall into one of three buckets:

• A spreadsheet with test cases that nobody keeps updated
• Clicking around in the test chat and hoping for the best
• No structured testing at all — just shipping and monitoring what breaks

None of those feel right for anything running in a real environment.

Curious what others are doing — do you have a systematic approach to testing before go-live, or is it still mostly informal?

I've been building Copilot Studio flows for clients for a while, and one thing keeps coming up: once a flow is built, handing it over cleanly is harder than building it.

There's no native way to share a complete picture of an agent with a client or internal team — what topics are inside, how the logic is structured, what flows are connected — without giving them access to your environment or spending hours writing it up manually. And inside organisations, cataloguing what's been built across projects and teams has the same problem.

I built two videos about this earlier, video links in the comments.

So I built a Copilot Studio solution zip importer for flospect. Here's what it would do:

You export your agent from Microsoft 365 as a zip and drop it into flospect. It reads the contents — topics, agent flows, Power Automate flows — and lets you select what to import. AI then generates a visual canvas from the structure: nodes grouped, logic labelled, everything readable. You can configure the audience, layout direction, and verbosity level before generating. From there you can share it with clients or stakeholders, build test protocols, and generate documentation — all without exposing your environment or credentials.

The feature is technically ready. But before I release it, I genuinely want to know: would you use a zip importer like this? What would you use it for — client handover, internal cataloguing, something else? And is there anything you'd want it to do that isn't described above?

Most invoice processing setups I've seen rely on someone opening each email, reading the attachment, and typing the data manually into a system. At volume that becomes a part-time job.

So I built a flow that handles all of it automatically — from the moment an email lands in a dedicated folder to the moment the structured data is extracted and registered.

Here's what it actually does:

• Triggers when a new email arrives in a "To Process" folder — only processes emails with attachments, ignores everything else
• Loops through all attachments in a single email — one email can contain multiple invoices
• Saves each attachment to SharePoint, runs OCR text recognition, and stores the output as a structured text file including bounding box coordinates so the AI understands where data sits on the page
• Passes only the file path to the Copilot Studio agent — not the full OCR text — to avoid overloading the prompt
• AI extracts the fields: invoice number, vendor, customer, invoice date, due date, amount, currency
• Validates completeness — if any required field is missing, the attachment routes to an error folder instead of passing silently
• Registers the extracted data to a data table — in my example an online Excel file, but the same logic applies to any structured data target you connect to
• Moves the original email to a processed folder when done

Five attachments in the live demo: one PNG, one JPEG, a 2-page PDF, a 5-page PDF, and one file with a missing field on purpose to show the error routing. Four clean rows registered, one file in the error folder.

One licence note: the "Recognize text in image or document" action in Power Automate requires a Power Automate Premium licence. Worth checking before you build.

The full flow is in my flospect library — same link as always, this build has been added. Every node, prompt, variable, and formula. Ready to view and rebuild in your own environment.

Video walkthrough + library link in the comments.

What's the most repetitive document process your team is still handling manually? Curious what others are dealing with.

One thing I've learned delivering Copilot Studio agents: if the underlying SharePoint folder structure is inconsistent, the agent inherits the problem. Files in the wrong folder, subfolders under the wrong parent, naming that doesn't follow any convention — it causes misrouting, wrong data retrieval, and hard-to-debug failures.

The root cause is simple: colleagues move fast, nobody monitors the structure, and the mess compounds quietly over time.

So I built a Copilot Studio agent that checks the folder structure daily and sends a report. It's a straightforward build — one of the simpler ones I've done — but it solves a real operational problem.

Here's what it does:

• Recurrence trigger runs every morning at 8 AM automatically
• Get Files Properties tool pulls file and folder metadata from a SharePoint library
• AI prompt analyses the structure and detects misplaced files, wrong subfolder placement, and naming inconsistencies
• Generates a structured report with a prioritised to-do list — file path, issue type, created by, where it needs to move
• Flags items that need manual review where metadata alone isn't enough to decide
• Sends the full report by email before the working day starts

Full flow is in my flospect library — same link as always, this build has been added. Video walkthrough + library link in the comments.

What does your current folder governance look like — manual checks, nothing, or something automated?

Copilot Studio has a zip export, but it's essentially a deployment package. You can move it between environments, but you can't read it, present it, or hand it to someone who wasn't involved in building it.

Which means every time I need to show a client or a manager how an agent actually works — the logic, the decision branches, the prompts, the variables — I'm either recording a screen walkthrough, taking screenshots, or rebuilding the explanation from scratch in a separate document.

None of those scale.

Curious what others do here. If you could export a Copilot Studio agent into a genuinely useful format — not just a deployment package — what would that look like for you?

A visual flow diagram? A structured document with the prompt logic included? Something you could hand to a non-technical stakeholder and have them understand it? Or is this a problem most people just accept and work around?