Power Platform Community Forum Thread Details

I’m trying to build a Copilot Studio agent for a POC that needs to extract structured fields from uploaded RFP/tender PDFs (e.g., Project Name, Bid Due Date, Client, Scope Summary, Submission Email/Portal, Mandatory Documents, etc.) and auto-fill a “Tender Information Form” Template PDF document (Word/Excel/JSON/SharePoint list). Documents vary widely in format and quality.

I’m exploring the best end-to-end approach in Microsoft 365/Power Platform + Copilot M365 to make this .

Target Outcome

User uploads an RFP/Tender document.

The agent extracts a consistent field set

The agent fills a template (e.g., a Word/PDF/SharePoint/Dataverse record) and returns a reviewable summary with an Approve/Edit step which can be added later on.

All within M365 boundaries (Copilot for M365 + Copilot Studio + Power Automate + SharePoint/Dataverse), and ideally reusable for different clients.

Options I’m Considering (and where I need advice)

Copilot Studio + Power Automate + AI Builder
- Questions:
  - Is AI Builder sufficient for unstructured, multi-section RFPs?
    
    Please guide on the best way to build this use case with the simplest approach as well.

Categories:

Building Copilot Studio chatbots in Microsoft Teams

Hey @MF-29100930-0

Here’s a practical way to think about this: you’re basically building a “document → structured record → template” pipeline. The simplest robust approach in M365/Power Platform right now is:

Use Copilot Studio as the front-end “agent”
Use Power Automate for orchestration
Store structured data in SharePoint/Dataverse
Use modern Copilot/LLM extraction, with AI Builder only where it’s a strong fit (tables / very regular layouts)

I’ll break it down by (A) architecture, (B) concrete implementation steps, and (C) answer your AI Builder question directly.

A. Recommended high-level architecture
1. Trigger: user uploads RFP PDF
You can do this in several ways, staying inside M365:

User talks to Copilot Studio bot (Teams/Web):
- Bot: “Upload the RFP document”
- User uploads file (or selects from SharePoint/OneDrive).
Or: user drops file into a SharePoint “RFP Intake” library and that kicks off a Power Automate flow; the bot then just shows status and results.

For a POC, the Copilot Studio upload → trigger Power Automate pattern is very clean.

2. Normalize document → text (and pages)
In Power Automate:

Get file content (from SharePoint / OneDrive).
Convert to text:
- Use “Extract text from PDF” (standard Power Automate action where available), or
- Use AI Builder “Extract information from documents” for general OCR + text, or
- If you have a “Get file content (preview)” that supports text, use that.
Optionally store:
- Raw PDF in SharePoint library (“RFP Documents”)
- Extracted text as a field (or separate file) for traceability/audit.

3. Extract the structured fields with LLM (Copilot / “Create text with Copilot” / Azure OpenAI)
This is the key piece.
Instead of designing complex AI Builder models for amorphous RFP layouts, use prompt-based extraction:
In Power Automate:

Add a “Create text with Copilot” (or “Azure OpenAI – Chat Completion” if using Azure) action.
Prompt pattern:
- System / Instruction (depending on connector):

You are a tender extraction engine. You receive the full text of a tender/RFP. Extract the following fields and return them in strict JSON. If a field is missing, return null. Do not hallucinate.
Fields:

- - project_name
  - bid_due_date (as ISO date if possible)
  - client_name
  - scope_summary (2–4 sentences)
  - submission_method (email / portal / physical / other + details)
  - submission_email
  - submission_portal_url
  - mandatory_documents (array of objects: {name, description})
  - questions_deadline (date if present)
  - site_visit_required (true/false + details)
- User content (or input variable):

Here is the full text of the RFP:
{RFP_TEXT}

Parse the JSON output using Power Automate – Parse JSON.

This gives you a consistent data model across wildly different RFP formats and languages.
You can improve reliability by:

If RFP is long:
- Chunk by sections (e.g., “Introduction”, “Instructions to Bidders”, “Scope”, etc.) and call the model with a “first summarize / then extract” pattern, or
- Use a 2-step flow:
  1. Ask Copilot to “rewrite the essential tender info in a short structured narrative”.
  2. Run the JSON extractor on that shorter narrative.

For a POC, a single LLM call on the whole text is usually good enough.

4. Write to structured storage (SharePoint/Dataverse)
Once you have the JSON fields:

Create a SharePoint list or Dataverse table:
- Columns: Project Name, Bid Due Date, Client, Scope Summary, etc.
- For lists like Mandatory Documents, either:
  - Store as JSON text in a single column, or
  - Create a child list/table (“RFP Mandatory Documents”) and relate via a lookup.

Power Automate:

“Create item” (SharePoint) / “Add new row” (Dataverse) using the parsed fields.

This becomes your Tender Information record, independent of any specific template.

5. Fill the Tender Information Form template
You have three common options inside M365:
Option 1 – Word template + Power Automate (quick POC)

Create a Word template with content controls / placeholders:
- e.g., <<Project_Name>>, <<Bid_Due_Date>>, etc.
In Power Automate:
- Use “Populate Word template” (if using Word Template connector) or
- Use “Replace text in Word document” actions.
Save generated doc to a SharePoint library (“Tender Forms”).
Optionally convert to PDF via “Convert Word document to PDF”.

This gives you a very fast path: RFP → JSON → Word → PDF.

Option 2 – SharePoint list / Dataverse form as the “template”
If your “Tender Information Form” is essentially a set of fields:

Use the SharePoint/Dataverse record itself as the “form.”
Let the user review and fix values there.
Only then generate a Word/PDF using values from the confirmed record.

This is often better for review/approval flows.

Option 3 – Excel / JSON template
If clients want Excel:

Create a standard Excel template with named ranges or fixed cells.
Power Automate:
- “Add a row into a table” or
- “Write to specific cells” using the extracted fields.
Save resulting file in a “Client Tenders” library.

For JSON:

Simply write the extracted JSON directly to a file in SharePoint/Blob and treat that as the “template output.”

6. Add review/approve/edit step
You can bolt this on in multiple ways:

Power Automate approval:
- After creating the Tender record + Word/Excel document:
  - Send an approval to the bid manager (Teams/Outlook).
  - Include a link to the SharePoint item / document.
  - On “Approve”, mark as Approved; on “Reject”, either delete or create a revision task.
Copilot Studio conversational review:
- Copilot shows a summary:
  - “Here’s what I extracted. Would you like to correct anything?”
- User edits individual fields conversationally:
  - “Change the client name to ‘City of Toronto’”
- Bot updates the underlying SharePoint/Dataverse record via Power Automate or a connector.

B. Concrete build steps (simplest working POC)
You asked for the simplest approach, so here is a step-by-step “do this” path:

Create SharePoint intake library
- Library: RFP-Intake
- Columns: Client name (optional), Status, Processed (yes/no).
Create SharePoint list “Tender Info”
- Columns: Project Name (text), Bid Due Date (date), Client (text), Scope Summary (multiple lines), Submission Method (choice), Submission Portal URL (hyperlink), Submission Email (text), Mandatory Docs (multiple lines or separate list).
Power Automate flow: “RFP → Tender Info”
- Trigger: “When a file is created in folder” (RFP-Intake).
- Actions:
  1. Get file content (PDF).
  2. Extract text from PDF (standard or AI Builder action).
  3. Call “Create text with Copilot” / “Azure OpenAI – Chat completion” with extraction prompt returning JSON.
  4. Parse JSON.
  5. Create item in “Tender Info” list.
  6. Populate Word Tender Template and save to “Tender Forms” library.
  7. Optional: send email/Teams message to owner with links.
Copilot Studio bot
- Topic/flow:
  - User: “I want to register a new tender.”
  - Bot: “Upload the RFP document or pick one from SharePoint.”
  - Bot calls the Power Automate flow via Power Automate action.
  - After completion, bot:
    - Fetches the created SharePoint item
    - Presents the summary: “Here’s what I found…”
    - Offers: “Do you want to open the Tender Information Form?”

This gets you a fully M365-native, reusable pipeline.

C. Is AI Builder sufficient for unstructured multi-section RFPs?
Short answer: not by itself, no.
Longer explanation:

AI Builder “Document processing / form processing” shines when:
- Layouts are semi-structured (invoices, ID cards, consistently designed forms).
- The fields appear in predictable regions.
RFPs / tenders typically:
- Are long, unstructured documents.
- Use many different layouts across clients and jurisdictions.
- Have critical info buried in prose (“bids shall be submitted no later than 2:00 PM on 15 February 2026 via the City’s Bids& Tenders portal …”).

For these:

You’d spend a lot of time:
- Creating multiple AI Builder models.
- Maintaining them for new templates.
And you’d still struggle when a client completely changes template.

Therefore:

Use AI Builder for:
- OCR / base text extraction.
- Tables, if you need specific tabular info (e.g., price schedule, contact list).
Use LLM-style extraction (Copilot / Azure OpenAI / “Create text with Copilot”) as the primary engine for the tender metadata.

D. Making it reusable across clients
To keep it client-agnostic:

Define a standard schema for all tenders (the JSON you extract).
Keep client-specific fields or variations configurable:
- A “Client Config” list with:
  - Client Name
  - Required fields
  - Additional fields / custom mappings.
The Power Automate flow reads the client config and:
- Only populates the fields relevant to that client’s template.
- Uses different Word/Excel templates per client if needed.

This keeps your extraction logic generic while output formatting is client-specific but still parameterized.

Summary

Best approach:
- Copilot/LLM-based extraction in Power Automate → SharePoint/Dataverse → Word/Excel template → optional approval.
- Copilot Studio acts as the conversational shell around this pipeline.
AI Builder alone is not sufficient for arbitrary unstructured RFPs, but is still useful for OCR and structured/table extraction.
Start with a simple POC:
- RFP PDF in SharePoint → LLM JSON extraction → SharePoint list record → Word template → PDF → review.