Implementation Guide: Generate proposals, sows, project status reports, and deliverable documentation

Hardware Procurement

Network Switch Upgrade (if needed)

Software Procurement

Prerequisites

• Active Microsoft 365 tenant (Business Premium, E3, or E5) with Azure AD/Entra ID configured and all target users licensed
• Global Administrator or at least SharePoint Administrator and Teams Administrator roles available for the MSP during deployment
• CRM system active and in use (Salesforce, HubSpot, or Dynamics 365) with API access enabled and an integration user/service account created
• Existing document templates: minimum 5 proposals, 3 SOWs, 3 status report templates, and 2 deliverable document templates in Word or PDF format. These will be converted to AI-ready templates.
• Content repository: at minimum 20 past proposals, 10 completed SOWs, and representative status reports. These form the knowledge base for RAG-based generation.
• Stable internet connectivity: minimum 50 Mbps symmetric with under 50ms latency to cloud services
• Client stakeholder identified as Document Owner/Champion who can make decisions about template standards, approval workflows, and brand guidelines
• Service descriptions, case studies, team bios, and standard terms and conditions compiled in a single accessible location (SharePoint site or shared drive)
• If using PSA integration: ConnectWise PSA, Autotask/Datto PSA, HaloPSA, or Kantata with API credentials and webhook capability confirmed
• OpenAI API account created at platform.openai.com with billing configured and API key generated (or Azure OpenAI resource provisioned if using Azure path)
• Data Processing Agreements (DPAs) signed with OpenAI/Microsoft for AI services — confirm with client legal that sending project metadata to cloud AI services is permitted
• E-signature solution confirmed: PandaDoc built-in (included) or existing DocuSign/Adobe Sign integration requirements documented

Installation Steps

Step 1: Environment Assessment and Site Survey

Before any deployment, conduct a thorough assessment of the client's current document creation processes, technology stack, and pain points. This information directly shapes the configuration. Interview 3–5 key proposal creators, document the current workflow from opportunity identification to signed proposal, identify bottlenecks, and catalog existing templates and content assets.

Step 2: Configure SharePoint Document Library Structure

Create a dedicated SharePoint site for the AI content generation system. This serves as the template library, content repository, and output document store. Proper information architecture here is critical for RAG performance and document retrieval.

# Connect to SharePoint Online via PowerShell
Install-Module -Name PnP.PowerShell -Scope CurrentUser
Connect-PnPOnline -Url https://[tenant].sharepoint.com/sites/admin -Interactive

# Create dedicated site
New-PnPSite -Type TeamSite -Title 'ProposalAI Hub' -Alias 'proposalai' -Description 'AI Document Generation Hub'

# Connect to the new site
Connect-PnPOnline -Url https://[tenant].sharepoint.com/sites/proposalai -Interactive

# Create document libraries with metadata columns
New-PnPList -Title 'Templates' -Template DocumentLibrary
New-PnPList -Title 'Generated Documents' -Template DocumentLibrary
New-PnPList -Title 'Content Library' -Template DocumentLibrary
New-PnPList -Title 'Past Proposals' -Template DocumentLibrary

# Add metadata columns to Generated Documents
Add-PnPField -List 'Generated Documents' -DisplayName 'Document Type' -InternalName 'DocType' -Type Choice -Choices 'Proposal','SOW','Status Report','Deliverable'
Add-PnPField -List 'Generated Documents' -DisplayName 'Client Name' -InternalName 'ClientName' -Type Text
Add-PnPField -List 'Generated Documents' -DisplayName 'Project Name' -InternalName 'ProjectName' -Type Text
Add-PnPField -List 'Generated Documents' -DisplayName 'AI Generated' -InternalName 'AIGenerated' -Type Boolean
Add-PnPField -List 'Generated Documents' -DisplayName 'Reviewed By' -InternalName 'ReviewedBy' -Type User
Add-PnPField -List 'Generated Documents' -DisplayName 'Status' -InternalName 'DocStatus' -Type Choice -Choices 'Draft','In Review','Approved','Sent','Signed'

# Add metadata to Content Library
Add-PnPField -List 'Content Library' -DisplayName 'Content Type' -InternalName 'ContentCategory' -Type Choice -Choices 'Service Description','Case Study','Team Bio','Terms and Conditions','Methodology','Pricing Template','Boilerplate'
Add-PnPField -List 'Content Library' -DisplayName 'Last Verified' -InternalName 'LastVerified' -Type DateTime

Step 3: Upload and Organize Content Repository

Populate the SharePoint libraries with the client's existing content assets. This forms the knowledge base that the AI will draw from when generating documents. Quality of input directly determines quality of output — spend time curating this content.

# Bulk upload templates (from local folder)
$files = Get-ChildItem -Path 'C:\ClientAssets\Templates' -Recurse
foreach ($file in $files) {
    Add-PnPFile -Path $file.FullName -Folder 'Templates'
}

# Bulk upload past proposals
$proposals = Get-ChildItem -Path 'C:\ClientAssets\PastProposals' -Recurse
foreach ($file in $proposals) {
    Add-PnPFile -Path $file.FullName -Folder 'Past Proposals'
}

# Upload content library items
$content = Get-ChildItem -Path 'C:\ClientAssets\ContentLibrary' -Recurse
foreach ($file in $content) {
    Add-PnPFile -Path $file.FullName -Folder 'Content Library'
}

Step 4: Deploy Microsoft 365 Copilot Licenses

Assign Microsoft 365 Copilot licenses to target users through the Microsoft 365 Admin Center or PowerShell. Start with power users who create the most documents (typically partners, engagement managers, business development leads).

# Connect to Microsoft Graph PowerShell
Connect-MgGraph -Scopes 'User.ReadWrite.All','Organization.Read.All'

# Get the Copilot SKU ID
Get-MgSubscribedSku | Where-Object {$_.SkuPartNumber -like '*Copilot*'} | Select-Object SkuId, SkuPartNumber, ConsumedUnits

# Assign Copilot license to specific users (replace SKU ID and UPN)
$copilotSku = Get-MgSubscribedSku | Where-Object {$_.SkuPartNumber -eq 'Microsoft_365_Copilot'}
$users = @('user1@domain.com','user2@domain.com','user3@domain.com')

foreach ($user in $users) {
    Set-MgUserLicense -UserId $user -AddLicenses @{SkuId = $copilotSku.SkuId} -RemoveLicenses @()
    Write-Host "Copilot license assigned to $user"
}

# Verify assignment
foreach ($user in $users) {
    $licenses = Get-MgUserLicenseDetail -UserId $user
    $hasCopilot = $licenses | Where-Object {$_.SkuPartNumber -like '*Copilot*'}
    Write-Host "$user - Copilot: $($hasCopilot -ne $null)"
}

Step 5: Configure Microsoft 365 Copilot for Document Generation

Set up Copilot policies, configure sensitivity labels, and create Copilot-optimized templates in Word. This ensures generated content follows brand guidelines and compliance requirements.

Connect-IPPSSession
New-RetentionCompliancePolicy -Name 'AI Generated Documents' -SharePointLocation 'https://[tenant].sharepoint.com/sites/proposalai'
New-RetentionComplianceRule -Name 'Retain AI Docs 7 Years' -Policy 'AI Generated Documents' -RetentionDuration 2555 -RetentionComplianceAction Keep

Step 6: Deploy and Configure PandaDoc

Set up PandaDoc Business as the dedicated proposal workflow platform. Configure the workspace, import templates, set up the content library, connect CRM, and configure approval workflows.

Step 7: Set Up OpenAI API Access and Test

Configure OpenAI API access for custom document generation workflows. This API powers the automated generation scenarios that go beyond M365 Copilot's capabilities — such as generating SOWs from structured project briefs or compiling status reports from time/billing data.

pip install openai

from openai import OpenAI
client = OpenAI(api_key='sk-...')
response = client.chat.completions.create(
    model='gpt-5.4',
    messages=[
        {'role': 'system', 'content': 'You are a professional services proposal writer.'},
        {'role': 'user', 'content': 'Write a 2-paragraph executive summary for an IT consulting proposal for a mid-size manufacturing company seeking ERP implementation.'}
    ],
    max_tokens=500
)
print(response.choices[0].message.content)
print(f'Tokens used: {response.usage.total_tokens}')
print(f'Estimated cost: ${response.usage.prompt_tokens * 2.5 / 1000000 + response.usage.completion_tokens * 10 / 1000000:.4f}')

Step 8: Deploy n8n Workflow Automation Platform

Install and configure n8n as the automation backbone connecting CRM/PSA triggers to AI APIs to document outputs. n8n orchestrates the entire document generation pipeline. Self-hosted deployment is recommended for MSPs managing multiple clients.

# Option A: Self-hosted on Docker (recommended for MSPs)
# Deploy on existing MSP infrastructure or client's server

# Create docker-compose.yml
cat > docker-compose.yml << 'EOF'
version: '3.8'
services:
  n8n:
    image: docker.n8n.io/n8nio/n8n
    restart: always
    ports:
      - '5678:5678'
    environment:
      - N8N_BASIC_AUTH_ACTIVE=true
      - N8N_BASIC_AUTH_USER=admin
      - N8N_BASIC_AUTH_PASSWORD=<STRONG_PASSWORD_HERE>
      - N8N_HOST=n8n.clientdomain.com
      - N8N_PORT=5678
      - N8N_PROTOCOL=https
      - WEBHOOK_URL=https://n8n.clientdomain.com/
      - GENERIC_TIMEZONE=America/New_York
      - N8N_ENCRYPTION_KEY=<RANDOM_32_CHAR_KEY>
    volumes:
      - n8n_data:/home/node/.n8n
      - ./local-files:/files
volumes:
  n8n_data:
EOF

# Start n8n
docker-compose up -d

# Verify running
docker-compose ps
curl -I https://localhost:5678

• Option B: n8n Cloud (simpler but less control) — Sign up at app.n8n.cloud — $20/month starter plan
• No installation needed; proceed to credential configuration

Step 9: Configure n8n Credentials and Connections

Set up all the service connections in n8n that the automation workflows will use. This includes CRM, OpenAI API, SharePoint, PandaDoc, and email services.

• Access n8n at https://n8n.clientdomain.com or localhost:5678
• Navigate to Settings > Credentials > Add Credential

1. OpenAI API Credential

• Type: OpenAI
• API Key: sk-... (from Step 7)
• Organization ID: (optional)

2. Microsoft OAuth2 (for SharePoint/OneDrive)

• Type: Microsoft OAuth2
• Go to portal.azure.com > Azure Active Directory > App Registrations
• New Registration: 'n8n-ProposalAI'
• Redirect URI: https://n8n.clientdomain.com/rest/oauth2-credential/callback
• API Permissions: Sites.ReadWrite.All, Files.ReadWrite.All
• Create Client Secret
• Copy Application (Client) ID and Client Secret to n8n

3. PandaDoc API Credential

• Type: HTTP Header Auth
• Name: Authorization
• Value: API-Key <PANDADOC_API_KEY>
• Get API key from PandaDoc Settings > Integrations > API

4. CRM Credential (HubSpot example)

• Type: HubSpot
• Create Private App in HubSpot: Settings > Integrations > Private Apps > Create
• Scopes: crm.objects.deals.read, crm.objects.contacts.read
• Copy Access Token to n8n

5. SMTP Credential (for notifications)

• Type: SMTP
• Host: smtp.office365.com
• Port: 587
• User: notifications@clientdomain.com
• Password: (app password or OAuth2)

• Test each credential by creating a simple workflow node and executing

Step 10: Build Core Automation Workflows in n8n

Create the four primary automation workflows that form the backbone of the AI document generation system: (1) Proposal Generation from CRM Deal, (2) SOW Generation from Project Brief, (3) Weekly Status Report Generation, (4) Deliverable Documentation Generation.

• proposal-generation-workflow.json — Trigger: CRM webhook (deal moves to 'Proposal Requested' stage). Steps: Fetch deal data > Pull relevant past proposals > Generate draft > Create PandaDoc > Notify creator
• sow-generation-workflow.json — Trigger: Manual trigger or CRM webhook (deal won). Steps: Fetch project brief > Pull service descriptions > Generate SOW sections > Assemble document > Save to SharePoint
• status-report-workflow.json — Trigger: Cron schedule (every Friday 2pm). Steps: Pull active projects from PSA > Pull time entries > Pull milestones > Generate narrative > Email to PMs for review
• deliverable-doc-workflow.json — Trigger: Manual trigger with form input. Steps: Accept parameters > Pull project context > Generate document > Save to SharePoint > Notify stakeholders

Step 11: Build and Test Prompt Templates

Create the system prompts and prompt templates that drive high-quality document generation. These are the most critical component — the quality of prompts directly determines the quality of output. Each prompt template is stored in SharePoint and referenced by the n8n workflows.

python3 << 'PYEOF'
from openai import OpenAI
import json

client = OpenAI()

# Test proposal generation prompt
system_prompt = open('prompts/proposal_system.txt').read()
user_prompt = '''
Generate a proposal for the following opportunity:
Client: Acme Manufacturing
Project: ERP System Selection and Implementation Advisory
Budget Range: $150,000 - $250,000
Timeline: 6 months
Key Requirements: Replace legacy AS/400 system, integrate with existing CRM, train 50 users
Our Relevant Experience: 15 similar ERP projects in manufacturing vertical
'''

response = client.chat.completions.create(
    model='gpt-5.4',
    messages=[
        {'role': 'system', 'content': system_prompt},
        {'role': 'user', 'content': user_prompt}
    ],
    max_tokens=4000,
    temperature=0.7
)

print(response.choices[0].message.content)
PYEOF

Step 12: Configure PandaDoc API Integration for Automated Document Creation

Set up the PandaDoc API connection so n8n workflows can automatically create proposals in PandaDoc with AI-generated content, assign recipients, and trigger the approval workflow.

# Test PandaDoc API connectivity
curl -X GET 'https://api.pandadoc.com/public/v1/templates' \
  -H 'Authorization: API-Key <YOUR_API_KEY>' \
  -H 'Content-Type: application/json'

# List available templates (note the IDs for automation)
curl -X GET 'https://api.pandadoc.com/public/v1/templates' \
  -H 'Authorization: API-Key <YOUR_API_KEY>' | python3 -m json.tool

# Test document creation from template
curl -X POST 'https://api.pandadoc.com/public/v1/documents' \
  -H 'Authorization: API-Key <YOUR_API_KEY>' \
  -H 'Content-Type: application/json' \
  -d '{
    "name": "Test Proposal - Acme Corp",
    "template_uuid": "<TEMPLATE_ID>",
    "recipients": [
      {
        "email": "client@acme.com",
        "first_name": "John",
        "last_name": "Smith",
        "role": "Client"
      }
    ],
    "tokens": [
      {"name": "Client.Company", "value": "Acme Corporation"},
      {"name": "Project.Name", "value": "ERP Advisory"},
      {"name": "Proposal.ExecutiveSummary", "value": "<AI_GENERATED_TEXT>"}
    ],
    "fields": {
      "ProjectBudget": {"value": "$150,000 - $250,000"},
      "ProjectTimeline": {"value": "6 months"}
    },
    "metadata": {
      "ai_generated": "true",
      "generation_date": "2025-01-15",
      "model_used": "gpt-5.4"
    }
  }'

Step 13: Set Up Human Review and Approval Workflow

Configure the mandatory human-in-the-loop review process. No AI-generated document should reach a client without human review. This step sets up the approval gates in PandaDoc and notification workflows in n8n/Teams.

Step 14: Implement Audit Logging and Compliance Controls

Set up comprehensive audit logging for all AI-generated content. This satisfies SOC 2, GDPR, and SOX requirements and provides the documentation trail needed for regulated clients.

# Create an audit log SharePoint list
Connect-PnPOnline -Url https://[tenant].sharepoint.com/sites/proposalai -Interactive

# Create audit log list
New-PnPList -Title 'AI Generation Audit Log' -Template GenericList

# Add columns
Add-PnPField -List 'AI Generation Audit Log' -DisplayName 'Document Name' -InternalName 'DocumentName' -Type Text
Add-PnPField -List 'AI Generation Audit Log' -DisplayName 'Document Type' -InternalName 'AuditDocType' -Type Choice -Choices 'Proposal','SOW','Status Report','Deliverable'
Add-PnPField -List 'AI Generation Audit Log' -DisplayName 'AI Model' -InternalName 'AIModel' -Type Text
Add-PnPField -List 'AI Generation Audit Log' -DisplayName 'Tokens Used' -InternalName 'TokensUsed' -Type Number
Add-PnPField -List 'AI Generation Audit Log' -DisplayName 'Estimated Cost' -InternalName 'EstimatedCost' -Type Currency
Add-PnPField -List 'AI Generation Audit Log' -DisplayName 'Input Summary' -InternalName 'InputSummary' -Type Note
Add-PnPField -List 'AI Generation Audit Log' -DisplayName 'Generated By' -InternalName 'GeneratedBy' -Type User
Add-PnPField -List 'AI Generation Audit Log' -DisplayName 'Reviewed By' -InternalName 'AuditReviewedBy' -Type User
Add-PnPField -List 'AI Generation Audit Log' -DisplayName 'Review Date' -InternalName 'ReviewDate' -Type DateTime
Add-PnPField -List 'AI Generation Audit Log' -DisplayName 'Approved' -InternalName 'Approved' -Type Boolean
Add-PnPField -List 'AI Generation Audit Log' -DisplayName 'Generation Timestamp' -InternalName 'GenTimestamp' -Type DateTime
Add-PnPField -List 'AI Generation Audit Log' -DisplayName 'CRM Deal ID' -InternalName 'CRMDealID' -Type Text

• In n8n: Add audit logging node to every workflow
• After each AI generation call, add a 'SharePoint > Create List Item' node that writes to this audit log with all metadata

Step 15: End-to-End Testing and User Acceptance

Conduct comprehensive testing of all workflows with real client data (anonymized if needed) before going live. Test each document type, each trigger mechanism, error handling, and the complete approval flow.

Step 16: User Training and Go-Live

Conduct training sessions for all users, deploy to production, and transition from testing to active use. Training should cover both the tools and the new workflow process.

Training Session Plan (2 sessions, 90 minutes each)

Session 1: Power Users (Proposal Creators, PMs)

• Microsoft 365 Copilot in Word: drafting proposals, referencing templates
• Microsoft 365 Copilot in PowerPoint: generating pitch decks
• PandaDoc: using AI Copilot, content library, template selection
• Workflow: how to trigger automated generation from CRM
• Review process: how to review/edit AI-generated content effectively
• Hands-on: each user creates one proposal using the new system

Session 2: All Staff

• Overview of AI document generation capability
• How to request a proposal/SOW (CRM process)
• Status report review process
• Compliance: what AI-generated means, review requirements
• Q&A

Go-Live Checklist

Custom AI Components

Proposal Generation System Prompt

Type: prompt

The master system prompt used by GPT-5.4 to generate professional services proposals. This prompt establishes the AI's persona, writing style, structure requirements, and quality standards. It is loaded into every proposal generation API call as the system message.

Implementation:

You are an expert proposal writer for [CLIENT_FIRM_NAME], a professional services firm specializing in [PRIMARY_SERVICES]. You create compelling, professional proposals that win business.

YOUR IDENTITY

• You write as [CLIENT_FIRM_NAME], using 'we' and 'our' language
• Your tone is confident, consultative, and client-focused
• You demonstrate deep expertise without being condescending
• You focus on client outcomes and business value, not just deliverables

PROPOSAL STRUCTURE

Every proposal you generate must follow this structure:

1. Cover Page Information

Provide as metadata:

• Proposal title
• Client name
• Date
• Prepared by
• Confidentiality notice

2. Executive Summary (250-400 words)

• Open with the client's challenge/opportunity (show you understand their situation)
• Briefly describe your proposed approach
• Highlight 2-3 key differentiators
• State expected outcomes with specifics
• Close with a confident call to action

3. Understanding of Your Needs (300-500 words)

• Restate the client's situation, challenges, and goals
• Demonstrate insight beyond what they told you
• Connect their challenges to industry trends

4. Proposed Approach (500-800 words)

• Describe the methodology in phases
• For each phase: name, duration, key activities, deliverables
• Explain WHY this approach (not just what)
• Include client responsibilities and collaboration points

5. Team & Qualifications (200-400 words)

• Highlight relevant team members and their expertise
• Reference similar projects completed
• Include relevant certifications or partnerships

6. Timeline & Milestones

Provide as structured data:

• Phase-by-phase timeline with key milestones
• Decision points and client review gates

7. Investment

• Fee structure (fixed, T&M, or blended)
• Phase-by-phase breakdown
• What's included and excluded
• Payment terms

8. Why [CLIENT_FIRM_NAME] (200-300 words)

• 3-4 compelling differentiators
• Relevant case study reference
• Client testimonial if available

9. Next Steps (100-150 words)

• Clear call to action
• Proposed timeline for decision
• Contact information

WRITING RULES

• Use active voice predominantly
• Keep sentences under 25 words on average
• Use bullet points for lists of 3+ items
• Bold key terms and deliverables on first mention
• Never use: 'leverage', 'synergy', 'best-in-class', 'cutting-edge', 'world-class'
• Use specific numbers and metrics wherever possible
• Every claim should be supported by evidence or example
• Write at a 10th-grade reading level (Flesch-Kincaid)

FORMATTING

• Output in clean Markdown format
• Use ## for section headers, ### for subsections
• Use | tables | for | timeline and pricing data
• Use > blockquotes for client testimonials or case study callouts

IMPORTANT CONSTRAINTS

• Never fabricate case studies, team members, or client names
• If you need specific information you don't have, insert [PLACEHOLDER: description of what's needed]
• Pricing placeholders: use [FEE: [varies] - $Y range based on scope] when exact pricing isn't provided
• Always err on the conservative side for timelines
• Include a disclaimer: 'This proposal is based on our current understanding of the project scope. Final pricing and timeline will be confirmed upon detailed requirements gathering.'

SOW Generation System Prompt

Type: prompt

System prompt for generating Statements of Work from project briefs. SOWs require more precision and legal awareness than proposals, so this prompt emphasizes structured output, clear scope boundaries, and standard contractual terms.

Implementation:

You are a Statement of Work (SOW) author for [CLIENT_FIRM_NAME]. You create precise, comprehensive SOWs that clearly define project scope, deliverables, timelines, and responsibilities.

SOW STRUCTURE

WRITING RULES FOR SOWs

• Use precise, unambiguous language
• Every deliverable must have measurable acceptance criteria
• Use 'shall' for obligations, 'will' for intentions, 'may' for options
• Number every section and subsection for easy reference
• Dates should use format: DD-MMM-YYYY
• Currency should be explicit: USD, EUR, etc.
• All acronyms defined on first use
• Never leave scope boundaries ambiguous — if in doubt, list it as out of scope

CONSTRAINTS

• Insert [PLACEHOLDER] for any specific details not provided
• Do not include legal terms (indemnification, liability, IP) — these are in the MSA
• Flag risks with [RISK: description] annotations
• Output in Markdown format

Status Report Generation System Prompt

Type: prompt

System prompt for generating weekly project status reports from structured data (time entries, milestones, budget data). This prompt transforms raw project data into narrative status updates suitable for client distribution.

Implementation:

You are a project status report writer for [CLIENT_FIRM_NAME]. You transform raw project data into clear, professional status reports for client stakeholders.

STATUS REPORT STRUCTURE

STATUS DETERMINATION RULES

• 🟢 Green: On track, no significant concerns
• 🟡 Yellow: Minor deviation, corrective action underway, manageable risk
• 🔴 Red: Significant deviation, requires escalation or client intervention

Budget status thresholds:

• 🟢: Actual spend within 5% of planned
• 🟡: Actual spend 5-15% over planned
• 🔴: Actual spend >15% over planned

Schedule status thresholds:

• 🟢: Within 1 week of plan
• 🟡: 1-3 weeks behind
• 🔴: >3 weeks behind

WRITING RULES

• Be factual and concise — no filler
• Lead with the most important information
• Quantify everything possible
• Use client-friendly language (no internal jargon)
• Highlight positive progress but don't hide issues
• Every issue must have a mitigation plan and owner
• Output in Markdown format

CRM-to-Proposal Automation Workflow

Type: workflow

n8n workflow that triggers when a CRM deal moves to 'Proposal Requested' stage. It fetches deal data, retrieves relevant past proposals and service descriptions from SharePoint, calls GPT-5.4 to generate a proposal draft, creates a PandaDoc document from a template with the AI-generated content, logs the generation to the audit trail, and notifies the assigned user via Teams.

Implementation:

n8n Workflow: CRM-to-Proposal Generation

Workflow JSON (import into n8n)

CRM Webhook Configuration (HubSpot)

{ "dealId": "{{dealId}}", "triggerType": "proposalRequested" }

For Salesforce:

• Use Salesforce Flow to send outbound message when Opportunity Stage = 'Proposal Development'
• Configure n8n Salesforce node instead of HubSpot node.

Weekly Status Report Automation Workflow

Type: workflow

n8n workflow triggered on a cron schedule (every Friday at 2:00 PM) that pulls active project data from the PSA/project management tool, retrieves time entries and milestone status, generates narrative status reports via GPT-5.4, saves them to SharePoint, and emails them to project managers for review before client distribution.

Implementation:

n8n Workflow: Weekly Status Report Generation

Trigger

Cron schedule: Every Friday at 14:00 local time

Workflow Steps

Node 1: Cron Trigger

• Type: n8n-nodes-base.cron
• Schedule: Every Friday at 14:00

Node 2: Fetch Active Projects

• Type: HTTP Request to PSA API
• Method: GET
• URL: https://api.[psa-platform].com/v1/projects?status=active
• Returns: List of active projects with IDs, names, PMs, budgets

Node 3: Split Into Batches

• Type: n8n-nodes-base.splitInBatches
• Batch Size: 1 (process each project individually)

Node 4: Fetch Time Entries (This Week)

• Type: HTTP Request
• URL: https://api.[psa-platform].com/v1/projects/{{projectId}}/time-entries?from={{$today.minus(7,'days').format('yyyy-MM-dd')}}&to={{$today.format('yyyy-MM-dd')}}
• Returns: Hours logged by team member, task, date

Node 5: Fetch Milestones

• Type: HTTP Request
• URL: https://api.[psa-platform].com/v1/projects/{{projectId}}/milestones
• Returns: Milestone names, planned dates, actual dates, status

Node 6: Fetch Budget Data

• Type: HTTP Request
• URL: https://api.[psa-platform].com/v1/projects/{{projectId}}/budget
• Returns: Total budget, spent to date, forecast

Node 7: Build Status Report Prompt

• Type: Set node
• Assembles all project data into a structured prompt

Generate a weekly status report for this project:

Project: {{projectName}}
Client: {{clientName}}
Project Manager: {{pmName}}
Report Period: Week of {{weekStartDate}}

Budget:
- Total Budget: ${{totalBudget}}
- Spent to Date: ${{spentToDate}}
- Remaining: ${{remaining}}
- % Complete (estimated): {{percentComplete}}%

Time Logged This Week:
{{#each timeEntries}}
- {{teamMember}}: {{hours}}hrs on {{task}}
{{/each}}
Total Hours This Week: {{totalHours}}

Milestone Status:
{{#each milestones}}
- {{name}}: Planned {{plannedDate}} | {{status}} {{#if actualDate}}| Completed {{actualDate}}{{/if}}
{{/each}}

Previous Week's Status: {{previousStatus}}
Known Issues from Last Report: {{previousIssues}}

Based on this data, generate a complete status report following the template structure.

Node 8: Generate Report via GPT-5.4

• Type: OpenAI node
• Model: gpt-5.4
• System prompt: [STATUS REPORT SYSTEM PROMPT FROM ABOVE]
• Temperature: 0.3 (precision over creativity)
• Max tokens: 2000

Node 9: Convert to Word Document

• Type: Code node (JavaScript)
• Uses markdown-to-docx conversion
• Applies client branding template

Node 10: Save to SharePoint

• Type: Microsoft SharePoint node
• Upload to: Generated Documents library
• Metadata: Document Type = 'Status Report', Project Name, AI Generated = true

Node 11: Email to Project Manager

• Type: Microsoft Outlook node
• To: {{pmEmail}}
• Subject: '[ACTION REQUIRED] AI-Generated Status Report - {{projectName}} - Week of {{date}}'
• Body: 'A status report has been generated for your review. Please review, edit as needed, and forward to the client by EOD. [Link to SharePoint document]'

Node 12: Audit Log Entry

• Type: SharePoint Create List Item
• Log generation metadata

Node 13: Loop Back

Return to Node 3 for next project

PSA-Specific Adapters

Replace Node 2, 4, 5, 6 API URLs based on PSA platform:

• ConnectWise PSA: https://api-na.myconnectwise.net/v4_6_release/apis/3.0/
• Autotask/Datto: https://webservices.autotask.net/ATServicesRest/V1.0/
• HaloPSA: https://[instance].halopsa.com/api/
• Kantata: https://api.mavenlink.com/api/v1/

Notes

• If no PSA, adapt to pull from project management tools (Monday.com, Asana, Jira) using their respective APIs
• The workflow handles multiple projects in sequence — expect 1-2 minutes per project for generation
• Previous week's status is pulled from the most recent status report in SharePoint for continuity

Content Library RAG Retrieval Agent

Type: agent

A retrieval-augmented generation (RAG) component that searches the client's SharePoint content library to find relevant past proposals, case studies, service descriptions, and boilerplate content. This ensures AI-generated documents are grounded in the firm's actual experience and offerings rather than generic content.

Implementation:

RAG Content Retrieval Agent

Architecture

This agent runs as a sub-workflow in n8n, called by the proposal and SOW generation workflows to retrieve relevant context before generating content.

Implementation Option A: Microsoft 365 Copilot Graph-Grounded (Simplest)

If using M365 Copilot, it automatically has access to SharePoint content through Microsoft Graph. No additional RAG setup needed — Copilot will reference documents the user has access to.

Implementation Option B: SharePoint Search API + Prompt Stuffing

For API-based generation (GPT-5.4), use SharePoint Search to find relevant documents and include them in the prompt context.

// n8n Code Node: RAG Retrieval
const projectDescription = $input.first().json.projectDescription;
const clientIndustry = $input.first().json.clientIndustry;
const serviceType = $input.first().json.serviceType;

// Build search queries
const queries = [
  `${serviceType} proposal ${clientIndustry}`,
  `case study ${clientIndustry}`,
  `service description ${serviceType}`,
  `${clientIndustry} SOW deliverables`
];

// This would be executed via SharePoint Search REST API
// Called from n8n HTTP Request nodes in parallel
const searchUrl = `https://[tenant].sharepoint.com/sites/proposalai/_api/search/query`;

// Search query for each topic
const results = [];
for (const query of queries) {
  const searchPayload = {
    Querytext: query,
    RowLimit: 3,
    SelectProperties: ['Title', 'Path', 'HitHighlightedSummary', 'ContentCategory'],
    SourceId: 'proposalai' // Limit to ProposalAI site
  };
  results.push(searchPayload);
}

return results.map(r => ({ json: r }));

Implementation Option C: Azure AI Search (Advanced)

For larger content libraries (500+ documents) or clients needing semantic search:

Query from n8n

POST https://[search-service].search.windows.net/indexes/proposals/docs/search?api-version=2024-07-01
{
  "search": "{{projectDescription}}",
  "searchMode": "all",
  "queryType": "semantic",
  "semanticConfiguration": "proposal-config",
  "top": 5,
  "select": "title,content,category,industry"
}

Feed results into GPT-5.4 prompt

Append retrieved content as context in the user prompt:

## Reference Material from Our Content Library:

### Past Proposal: {{result1.title}}
{{result1.content_snippet}}

### Case Study: {{result2.title}}
{{result2.content_snippet}}

### Service Description: {{result3.title}}
{{result3.content_snippet}}

Use the above reference material to inform your writing. Match our tone, terminology, and level of detail.

Recommended Path by Client Size

• 5-20 employees, <100 documents: Option B (SharePoint Search + prompt stuffing)
• 20-50 employees, 100-500 documents: Option B or C depending on search quality needs
• 50+ employees, 500+ documents: Option C (Azure AI Search)

Content Refresh Process

• SharePoint indexer runs automatically (daily for Azure AI Search)
• Prompt the client to add new case studies and update service descriptions quarterly
• Flag stale content (>12 months since last verified) for review

Deliverable Documentation Generator

Type: workflow

An n8n workflow triggered manually via a web form that generates project deliverable documentation (technical specifications, implementation plans, assessment reports, etc.) based on structured input from the project team. This handles the most variable document type in the system.

Implementation:

n8n Workflow: Deliverable Documentation Generator

Trigger: n8n Form Trigger (Web Form)

A simple web form that project team members fill out to request document generation.

Form Fields:

• Project Name (dropdown from active projects)
• Deliverable Name (text)
• Deliverable Type (dropdown: Technical Specification, Implementation Plan, Assessment Report, Design Document, Test Plan, Training Manual, Runbook, Other)
• Target Audience (dropdown: Technical, Executive, End User, Mixed)
• Key Points to Cover (multi-line text)
• Data/Inputs to Include (file upload — supporting documents, spreadsheets, etc.)
• Desired Length (dropdown: Brief 2-5 pages, Standard 5-15 pages, Comprehensive 15+ pages)
• Special Instructions (text)
• Requester Email (email)

Workflow Steps

Node 1: Form Trigger

• Captures all form inputs
• Validates required fields

Node 2: Fetch Project Context

• Pull project details from PSA/PM tool
• Retrieve project SOW for scope reference
• Get team roster and roles

Node 3: Retrieve Relevant Templates

• Search SharePoint Templates library for matching deliverable type
• Return template structure/outline to use as framework

Node 4: Process Uploaded Files

• Code node: Extract text from uploaded documents
• For spreadsheets: convert to structured text/tables
• For PDFs/docs: extract key content

// Code node to process uploaded files
const files = $input.first().json.files;
let extractedContent = '';

for (const file of files) {
  if (file.mimeType.includes('spreadsheet') || file.mimeType.includes('csv')) {
    extractedContent += `\n### Data from ${file.name}:\n`;
    extractedContent += file.textContent; // n8n extracts text automatically
  } else {
    extractedContent += `\n### Content from ${file.name}:\n`;
    extractedContent += file.textContent?.substring(0, 5000) || '[File content not extractable]';
  }
}

return [{ json: { extractedContent } }];

Node 5: Build Generation Prompt

• Assemble comprehensive prompt with:
• Deliverable type-specific system prompt
• Project context from SOW
• Template structure as format guide
• Uploaded file content as source data
• User's key points and special instructions
• Audience-appropriate tone guidance

Node 6: Generate Document via GPT-5.4

• Model: gpt-5.4 (128K context window handles large inputs)
• Temperature: 0.4 (balance of precision and readability)
• Max tokens: 8000 for Standard length, 16000 for Comprehensive

Node 7: Quality Check (Optional GPT-5.4 mini pass)

• Second AI call to review the generated document for:
• Completeness against the requested key points
• Consistency with project SOW scope
• Appropriate tone for target audience
• Any placeholder markers that need human attention
• Returns a quality score and list of items to verify

Node 8: Save to SharePoint

• Save as Word document in Generated Documents library
• Apply metadata: project name, deliverable type, AI generated flag
• Apply sensitivity label: 'AI Generated - Draft'

Node 9: Audit Log

• Record generation in audit log

Node 10: Notify Requester

• Email to requester with:
• Link to generated document in SharePoint
• Quality check results/notes
• Reminder to review before client delivery
• Estimated AI cost for this generation

Deliverable-Type Specific System Prompt Variants

Store these in SharePoint Prompts folder:

• prompts/deliverable_technical_spec.txt
• prompts/deliverable_implementation_plan.txt
• prompts/deliverable_assessment_report.txt
• prompts/deliverable_design_document.txt
• prompts/deliverable_test_plan.txt
• prompts/deliverable_training_manual.txt
• prompts/deliverable_runbook.txt

Each variant includes section structures and writing rules specific to that document type.

Prompt Version Manager

Type: integration

A SharePoint-based prompt version control system that stores all system prompts with versioning, tracks which version was used for each generated document, and enables A/B testing of prompt improvements. This ensures prompt engineering improvements are systematic and auditable.

Implementation:

Prompt Version Management System

SharePoint List: 'Prompt Registry'

Create a SharePoint list with the following columns:

n8n Sub-Workflow: Get Active Prompt

Every generation workflow calls this sub-workflow to retrieve the current active prompt:

// Code node in n8n: Fetch Active Prompt
// Input: promptType (e.g., 'Proposal')
// This is called after a SharePoint 'Get Items' node with filter:
// IsActive eq 1 AND PromptType eq '{{promptType}}'

const activePrompt = $input.first().json;

return [{
  json: {
    systemPrompt: activePrompt.SystemPromptText,
    temperature: activePrompt.Temperature,
    maxTokens: activePrompt.MaxTokens,
    model: activePrompt.Model,
    promptVersion: `${activePrompt.PromptName}_v${activePrompt.Version}`,
    promptId: activePrompt.Id
  }
}];

Prompt Update Process

Monthly Prompt Optimization Cadence

As part of managed service, MSP reviews:

• Documents with lowest review scores
• Common edits made by human reviewers (indicates prompt gaps)
• New content types or services that need prompt updates
• Model upgrades (e.g., new GPT version) that may benefit from prompt adjustments

Testing & Validation

• TEST 1 - M365 Copilot Activation: Open Microsoft Word on a licensed user's machine, click the Copilot icon in the ribbon, and prompt 'Draft a 3-paragraph executive summary for an IT consulting proposal for a healthcare company.' Verify that Copilot generates relevant content within 30 seconds and that the content references SharePoint documents when prompted with 'reference our past proposals.'
• TEST 2 - SharePoint Content Library: Navigate to the ProposalAI Hub site, verify all four document libraries exist (Templates, Generated Documents, Content Library, Past Proposals), confirm metadata columns are present and filterable, upload a test document to each library and verify metadata tagging works correctly.
• TEST 3 - OpenAI API Connectivity: Run the Python test script from Step 7 and verify a coherent proposal paragraph is returned. Check that token usage and cost are reported. Verify the API key budget limit is active by checking platform.openai.com/usage.
• TEST 4 - PandaDoc Template Population: Using the PandaDoc API, create a test document from the proposal template with sample token values. Verify all token placeholders are correctly replaced with the provided values. Open the document in PandaDoc and confirm formatting and branding are intact.
• TEST 5 - n8n Workflow Engine: Access the n8n interface, verify all five credential connections show green/connected status (OpenAI, Microsoft SharePoint, PandaDoc, HubSpot/Salesforce, Microsoft Teams). Create a simple test workflow that chains all five services and execute it.
• TEST 6 - End-to-End Proposal Generation: Create a test deal in the CRM with realistic data (company name, description, budget, contact). Move the deal to 'Proposal Requested' stage. Verify within 3 minutes: (a) n8n workflow triggers, (b) GPT-5.4 generates proposal content, (c) PandaDoc document is created with AI content, (d) Teams notification appears in the Document Review channel, (e) audit log entry is created in SharePoint.
• TEST 7 - Status Report Generation: Create a test project in the PSA with at least 20 hours of time entries and 3 milestones. Manually trigger the status report workflow in n8n. Verify: (a) all project data is correctly pulled, (b) status report is generated with appropriate RAG status indicators, (c) Word document is saved to SharePoint with correct metadata, (d) email notification is sent to the assigned PM.
• TEST 8 - Approval Workflow: Take the AI-generated proposal from Test 6, click 'Submit for Review' in PandaDoc. Verify: (a) reviewer receives notification, (b) reviewer can add comments and request changes, (c) final approver receives the document after reviewer approves, (d) document status updates through each stage correctly, (e) the document cannot be sent to the client without final approval.
• TEST 9 - Audit Trail Completeness: After running Tests 6 and 7, navigate to the AI Generation Audit Log in SharePoint. Verify entries exist for both generated documents with: document name, type, AI model used, tokens consumed, estimated cost, CRM deal ID, and generation timestamp. Verify no fields are blank.
• TEST 10 - Error Handling: Temporarily set an invalid OpenAI API key in n8n credentials. Trigger the proposal generation workflow. Verify: (a) the workflow fails gracefully without crashing, (b) an error notification is posted to the MSP alerts Teams channel with the error message, (c) restore the valid API key and verify the next execution succeeds.
• TEST 11 - Content Quality Assessment: Generate 5 proposals for different hypothetical clients across different industries. Have the client's Document Champion rate each on a 1-5 scale for: accuracy, brand voice consistency, completeness, and usefulness as a starting draft. Target: average score of 3.5+ across all dimensions. If below, iterate on prompts before go-live.
• TEST 12 - Security and Permissions: Log in as a non-admin user without Copilot license and verify they cannot access the ProposalAI SharePoint site's admin lists (audit log, prompt registry). Verify that generated documents inherit correct SharePoint permissions and that the PandaDoc API key is not visible to end users in any interface.

Client Handoff

Client Handoff Checklist

Training Sessions Delivered

• Using M365 Copilot in Word for proposal drafting (live demo + hands-on)
• Using M365 Copilot in PowerPoint for pitch deck generation
• PandaDoc: creating documents from templates, using AI Copilot, content library
• Triggering automated proposal generation from CRM
• Reviewing and editing AI-generated content (best practices for efficient editing)
• Submitting documents through the approval workflow
• Using the deliverable documentation web form

• What the AI system can and cannot do
• How to request a proposal or document (CRM process)
• Status report review workflow
• Compliance requirements: always review before sending, never send AI drafts directly to clients

Documentation Left Behind

• User Guide (PDF/SharePoint): Step-by-step instructions for each document type with screenshots
• Quick Reference Card (1-page laminated): Most common workflows at a glance per user role
• Prompt Library Guide: How to use and request updates to AI prompts
• Troubleshooting Guide: Common issues and self-service fixes (e.g., 'Copilot not appearing' → sign out/in)
• Template Catalog: Index of all available templates with descriptions and use cases
• Content Library Guidelines: How to add new case studies, service descriptions, and boilerplate content
• Compliance Policy Document: AI-generated content review requirements, data handling rules, audit log purpose
• Escalation Matrix: Who to contact for what — MSP help desk for technical issues, Document Champion for content/template changes

Success Criteria Review (with client stakeholders)

Transition to Managed Services

• Hypercare period: 2 weeks of daily MSP check-ins (15-min standup)
• Transition to standard managed service after hypercare: weekly check-in for first month, then monthly
• Support ticket process established: client submits via MSP ticketing system for technical issues
• Document Champion identified as internal first-line support for content/process questions

Maintenance

Ongoing Maintenance Responsibilities

Weekly Tasks (MSP)

• Monitor n8n workflow execution logs: Check for failed executions, error patterns, and performance degradation. Target: 99%+ workflow success rate.
• Review OpenAI API usage: Check platform.openai.com/usage or Azure portal for consumption trends. Alert if approaching monthly budget cap (set at $200/month initially).
• Check PandaDoc API health: Verify document creation success rates via PandaDoc analytics.
• Review Teams alert channel: Ensure no unresolved error notifications from the past week.

Monthly Tasks (MSP)

• Prompt quality review: Analyze audit log for documents with low review scores or high edit rates. Identify prompt improvement opportunities. Update prompts in the Prompt Registry with new versions.
• Content library freshness audit: Flag content items older than 12 months since last verification. Send report to Document Champion for review/update.
• Usage analytics report: Generate monthly report for client showing: documents generated by type, average generation time, API costs, approval cycle times, and adoption metrics per user.
• Software updates: Update n8n to latest stable version (if self-hosted). Review M365 Copilot feature updates and communicate relevant new capabilities to client.
• Security review: Verify API key rotation schedule (rotate every 90 days), check user access permissions, review audit log for anomalies.

Quarterly Tasks (MSP)

• Prompt optimization sprint: Dedicated 2–4 hour session to test and improve prompts based on accumulated feedback. A/B test new prompt versions against current production prompts.
• Template refresh: Work with client to update/add templates based on new service offerings, client feedback, or changing brand guidelines.
• Integration health check: Verify all CRM/PSA connections are functioning, test webhook triggers, validate data mapping accuracy.
• Client business review: Present quarterly metrics, ROI analysis, and recommendations for expanding AI document capabilities. Discuss new document types, workflow improvements, or additional user rollout.
• Compliance audit preparation: Ensure audit log completeness, verify DPAs are current, confirm data retention policies are being followed.

Annual Tasks (MSP)

• AI model evaluation: Assess whether newer models (e.g., GPT-5, Claude next-gen) offer quality or cost improvements. Test and migrate if beneficial.
• Full system review: End-to-end assessment of architecture, performance, costs, and client satisfaction. Recommend upgrades or optimizations.
• DPA and contract renewal: Ensure all vendor DPAs are renewed and terms remain compliant with current regulations.
• Disaster recovery test: Verify n8n backup/restore process, confirm SharePoint content recovery procedures, test API failover (e.g., switch from OpenAI direct to Azure OpenAI).

SLA Considerations

• Response time for workflow failures: 4-hour response during business hours, next business day for non-critical
• Document generation availability: Target 99.5% uptime during business hours (dependent on cloud service availability)
• Prompt update turnaround: 5 business days for standard prompt improvements, 2 business days for critical fixes
• Monthly reporting delivery: By 5th business day of following month

Escalation Paths

• Level 1 (Client Document Champion): Content questions, template requests, user how-to questions
• Level 2 (MSP Help Desk): Technical issues — workflow failures, API errors, permission problems, PandaDoc configuration
• Level 3 (MSP AI Specialist): Prompt engineering, RAG tuning, model selection, architecture changes
• Level 4 (Vendor Support): OpenAI API issues → OpenAI support; M365 Copilot issues → Microsoft support; PandaDoc issues → PandaDoc support

Cost Management

• Set OpenAI API budget alerts at 75% and 90% of monthly cap
• Review per-document cost monthly; if average exceeds $0.50/document, investigate prompt efficiency or consider switching to GPT-5.4 mini for routine documents
• Annual license true-up: adjust Copilot and PandaDoc seat counts based on actual usage (remove licenses from inactive users)

Alternatives

Microsoft-Only Stack (M365 Copilot + Power Automate + SharePoint)

Eliminates PandaDoc and OpenAI API entirely. Uses only Microsoft 365 Copilot for AI generation, Power Automate for workflow orchestration, SharePoint for document storage and templates, and Word/PowerPoint for output. Copilot Studio can be used to build custom agents for document generation. All workflows run through Power Automate instead of n8n.

Cost: ~$30/user/month for Copilot + Power Automate Premium ($15/user/month) = $45/user/month total.

Proposify-Centric Stack (Proposify + OpenAI API + Zapier)

Replaces PandaDoc with Proposify as the proposal platform. Proposify offers stronger proposal analytics, interactive pricing tables, and a more design-focused editor. Uses Zapier instead of n8n for simpler setup. OpenAI API still handles custom generation.

Budget-Friendly Stack (M365 Copilot + GPT-5.4 mini + Zapier Free)

Minimizes monthly costs by using M365 Copilot as the primary tool, GPT-5.4 mini API for automated workflows (instead of GPT-5.4), and Zapier free tier for basic automations. Documents are generated directly in Word/SharePoint without a dedicated proposal platform.

Self-Hosted Privacy-First Stack (Ollama + Open WebUI + n8n + SharePoint)

Replaces all cloud AI APIs with locally-hosted open-source LLMs running on an on-premises GPU workstation. Uses Ollama to run Llama 3.1 70B or Mistral models locally. Open WebUI provides a chat interface for interactive drafting. n8n handles automation. All AI processing stays within the client's network.

Enterprise-Scale Stack (Templafy + Azure OpenAI + Power Automate + Dynamics 365)

For larger professional services firms (200+ employees) already on Microsoft Dynamics 365. Templafy provides enterprise document generation with deep M365 integration. Azure OpenAI provides enterprise-grade AI with data residency. Power Automate Premium orchestrates workflows. Dynamics 365 serves as both CRM and PSA.