Implementation Guide: Draft job descriptions, offer letters, and onboarding documentation

Hardware Procurement

Software Procurement

Prerequisites

• Active Microsoft 365 E3 or E5 tenant with Azure AD/Entra ID configured for all HR staff users
• Global Administrator or at least SharePoint Administrator and Teams Administrator roles available to the MSP for initial setup
• Existing ATS platform (Greenhouse, Workable, Bullhorn, Lever, or iCIMS) with API access enabled and API keys generated
• Existing HRIS platform (BambooHR, Gusto, Rippling, or ADP) with API access enabled for employee data retrieval
• Business broadband internet (25+ Mbps minimum) at all client office locations
• Client must provide: current job description templates (at least 20 examples), existing offer letter templates, current onboarding checklist/documentation, company brand guidelines, compensation band data, and organizational chart
• Azure subscription (Pay-As-You-Go or existing EA) linked to the M365 tenant for Copilot Studio agent deployment
• DNS and firewall rules allowing HTTPS (port 443) outbound to: *.openai.com, *.microsoft.com, *.copilot.microsoft.com, *.zapier.com, *.docusign.com
• Identified HR content stakeholders: at minimum one HR Manager (approval authority), one Recruiter (primary user), and one Legal/Compliance reviewer
• Client legal counsel has reviewed and approved the use of AI-generated content for employment documents in their jurisdiction(s)
• OpenAI API account created at platform.openai.com with billing configured and organization-level data settings reviewed (Zero Data Retention enabled if required by client policy)
• SharePoint Online site collection designated for HR document storage with appropriate permission groups (HR Team, Hiring Managers, Legal) already created

Installation Steps

...

Step 1: Environment Assessment & Discovery

Conduct a thorough audit of the client's current HR content workflows. Interview the HR Manager, lead Recruiter, and Legal/Compliance contact. Document the current process for creating job descriptions (who writes them, what templates exist, approval chain, where they are posted), offer letters (what fields are variable, who approves, how they are signed), and onboarding documents (what is included in the packet, how it is delivered to new hires). Catalog all existing templates and collect samples. Identify all software systems currently in use (ATS, HRIS, email, document storage, e-signature). Assess compliance requirements based on client jurisdiction(s).

Step 2: Provision Microsoft 365 Copilot Licenses

Through the Microsoft Partner Center (CSP), assign Microsoft 365 Copilot add-on licenses to the identified HR users. Typically 3–10 seats depending on client size: HR Manager, Recruiters, HR Generalists, and optionally Hiring Managers who review content. Verify each user has a qualifying base license (M365 E3, E5, Business Standard, or Business Premium).

• In Microsoft 365 Admin Center (admin.microsoft.com)
• Navigate to Billing > Purchase services > Search 'Microsoft 365 Copilot'
• Purchase required number of licenses via CSP
• Navigate to Users > Active users > Select user > Licenses and apps
• Enable 'Microsoft 365 Copilot' for each designated HR user

Get-MgUserLicenseDetail -UserId 'recruiter@clientdomain.com' | Select-Object -ExpandProperty ServicePlans | Where-Object {$_.ServicePlanName -like '*Copilot*'}

Step 3: Configure SharePoint HR Document Library

Create a dedicated SharePoint site collection for HR AI content. This serves as the centralized repository for: (1) Input templates and brand guidelines that ground the AI, (2) Generated documents awaiting review, (3) Approved and finalized documents. Set up document libraries with metadata columns for document type, status, department, and date. Configure retention policies aligned with HR record-keeping requirements.

# PowerShell: Connect to SharePoint Online
Install-Module -Name PnP.PowerShell -Force
Connect-PnPOnline -Url https://clientdomain-admin.sharepoint.com -Interactive

# Create HR AI Content site
New-PnPSite -Type TeamSite -Title 'HR AI Content Hub' -Alias 'hr-ai-content' -Description 'AI-generated HR documents and templates'

# Connect to the new site
Connect-PnPOnline -Url https://clientdomain.sharepoint.com/sites/hr-ai-content -Interactive

# Create document libraries
New-PnPList -Title 'Job Description Templates' -Template DocumentLibrary
New-PnPList -Title 'Offer Letter Templates' -Template DocumentLibrary
New-PnPList -Title 'Onboarding Templates' -Template DocumentLibrary
New-PnPList -Title 'Generated Documents' -Template DocumentLibrary
New-PnPList -Title 'Brand Guidelines' -Template DocumentLibrary

# Add metadata columns to Generated Documents
Add-PnPField -List 'Generated Documents' -DisplayName 'Document Type' -InternalName 'DocType' -Type Choice -Choices 'Job Description','Offer Letter','Onboarding Document'
Add-PnPField -List 'Generated Documents' -DisplayName 'Status' -InternalName 'DocStatus' -Type Choice -Choices 'Draft','Under Review','Approved','Published'
Add-PnPField -List 'Generated Documents' -DisplayName 'Department' -InternalName 'Department' -Type Text
Add-PnPField -List 'Generated Documents' -DisplayName 'Generated Date' -InternalName 'GeneratedDate' -Type DateTime

Step 4: Upload and Organize Training Corpus

Upload all collected client documents to the SharePoint libraries created in Step 3. This includes: existing job descriptions (minimum 20, ideally 50+), offer letter templates, onboarding checklists, employee handbooks, brand voice guidelines, compensation band documents, org charts, and any compliance policies. Tag each document with appropriate metadata. This corpus grounds the AI agents and ensures generated content matches the client's voice, structure, and policies.

# Bulk upload via PnP PowerShell
$files = Get-ChildItem -Path 'C:\ClientDocs\JobDescriptions\' -Filter '*.docx'
foreach ($file in $files) {
    Add-PnPFile -Path $file.FullName -Folder 'Job Description Templates'
}

$files = Get-ChildItem -Path 'C:\ClientDocs\OfferLetters\' -Filter '*.docx'
foreach ($file in $files) {
    Add-PnPFile -Path $file.FullName -Folder 'Offer Letter Templates'
}

$files = Get-ChildItem -Path 'C:\ClientDocs\Onboarding\' -Filter '*.docx'
foreach ($file in $files) {
    Add-PnPFile -Path $file.FullName -Folder 'Onboarding Templates'
}

$files = Get-ChildItem -Path 'C:\ClientDocs\BrandGuidelines\' -Filter '*.*'
foreach ($file in $files) {
    Add-PnPFile -Path $file.FullName -Folder 'Brand Guidelines'
}

Step 5: Create OpenAI API Project and Configure Security

Set up the OpenAI API project that will power custom prompt pipelines for batch generation and bias-checking workflows. Create an organization-specific project, generate API keys, configure usage limits, and enable Zero Data Retention if required by client policy.

curl https://api.openai.com/v1/chat/completions -H 'Content-Type: application/json' -H 'Authorization: Bearer sk-YOUR-KEY-HERE' -d '{"model":"gpt-4.1","messages":[{"role":"system","content":"You are an HR content assistant."},{"role":"user","content":"Write a one-sentence job description for a Software Engineer."}],"max_tokens":100}'

Step 6: Build Copilot Studio HR Agents

Create three custom agents in Microsoft Copilot Studio: (1) Job Description Generator Agent, (2) Offer Letter Generator Agent, and (3) Onboarding Document Generator Agent. Each agent is grounded on the client's SharePoint document libraries and uses custom instructions (system prompts) that enforce the client's brand voice, formatting standards, and compliance requirements. These agents are published to Microsoft Teams for easy access by HR staff.

Step 7: Configure Zapier Integration Workflows

Set up Zapier automations (Zaps) that connect the AI content generation pipeline to the client's ATS, HRIS, e-signature, and document storage systems. Three primary Zaps: (1) New Job Requisition → AI-Generated JD → SharePoint → Approval Notification, (2) Candidate Selected → AI-Generated Offer Letter → DocuSign → HRIS, (3) Offer Accepted → AI-Generated Onboarding Packet → SharePoint → New Hire Email.

# ZAP 1: Job Requisition to AI-Generated Job Description
# Trigger: Greenhouse > New Job Opening (or Workable > New Job Created)
# Action 1: Code by Zapier (JavaScript) — Call OpenAI API
#   Input Data: job_title = {{job_title}}, department = {{department}}, 
#              location = {{location}}, employment_type = {{employment_type}}
#   Code: (see custom_ai_components for full implementation)
# Action 2: Microsoft SharePoint > Create File
#   Site: hr-ai-content
#   Library: Generated Documents
#   File Name: JD-{{job_title}}-{{zap_meta_human_now}}.docx
#   File Content: {{output from Action 1}}
# Action 3: Microsoft Teams > Send Channel Message
#   Team: HR Team
#   Channel: Job Description Reviews
#   Message: '📝 New AI-generated JD ready for review: {{job_title}}. Review here: {{sharepoint_url}}'

# ZAP 2: Candidate Selected to AI-Generated Offer Letter
# Trigger: Greenhouse > Candidate Stage Changed (stage = 'Offer')
# Action 1: Greenhouse > Get Candidate Details
# Action 2: BambooHR > Get Compensation Data (via API lookup)
# Action 3: Code by Zapier (JavaScript) — Call OpenAI API for offer letter
# Action 4: DocuSign > Create and Send Envelope
#   Template: Offer Letter Template
#   Recipients: Hiring Manager (signer 1), Candidate (signer 2)
#   Document: {{generated_offer_letter}}
# Action 5: SharePoint > Create File (archive copy)

# ZAP 3: Offer Accepted to Onboarding Packet
# Trigger: DocuSign > Envelope Completed
# Action 1: BambooHR > Get Employee Details
# Action 2: Code by Zapier (JavaScript) — Call OpenAI API for onboarding packet
# Action 3: SharePoint > Create File
# Action 4: Microsoft Outlook > Send Email
#   To: {{new_hire_email}}
#   Subject: 'Welcome to {{company_name}}! Your Onboarding Information'
#   Body: {{onboarding_email_content}}
#   Attachment: {{onboarding_packet}}

Step 8: Configure DocuSign E-Signature Integration

Set up DocuSign for automated routing of AI-generated offer letters. Create offer letter envelope templates with signature and date fields pre-positioned. Configure the DocuSign-Zapier connection and test the full flow from AI generation through signature completion.

Step 9: Deploy Bias Detection and Compliance Layer

Implement automated bias detection on all AI-generated content before it reaches human reviewers. This layer uses a combination of the OpenAI API with a bias-checking prompt and (optionally) Textio for advanced inclusive language analysis. Configure compliance logging that documents the AI tools used, the prompts submitted, and the human review status—required for NYC Local Law 144, Illinois HB 3773, and Colorado AI Act compliance.

# Create a SharePoint list for compliance logging
Connect-PnPOnline -Url https://clientdomain.sharepoint.com/sites/hr-ai-content -Interactive

New-PnPList -Title 'AI Compliance Log' -Template GenericList

Add-PnPField -List 'AI Compliance Log' -DisplayName 'Document ID' -InternalName 'DocID' -Type Text
Add-PnPField -List 'AI Compliance Log' -DisplayName 'Document Type' -InternalName 'DocType' -Type Choice -Choices 'Job Description','Offer Letter','Onboarding Document'
Add-PnPField -List 'AI Compliance Log' -DisplayName 'AI Model Used' -InternalName 'AIModel' -Type Text
Add-PnPField -List 'AI Compliance Log' -DisplayName 'Prompt Hash' -InternalName 'PromptHash' -Type Text
Add-PnPField -List 'AI Compliance Log' -DisplayName 'Bias Score' -InternalName 'BiasScore' -Type Number
Add-PnPField -List 'AI Compliance Log' -DisplayName 'Bias Issues Found' -InternalName 'BiasIssues' -Type Note
Add-PnPField -List 'AI Compliance Log' -DisplayName 'Human Reviewer' -InternalName 'HumanReviewer' -Type Text
Add-PnPField -List 'AI Compliance Log' -DisplayName 'Review Status' -InternalName 'ReviewStatus' -Type Choice -Choices 'Pending Review','Approved','Rejected','Approved with Edits'
Add-PnPField -List 'AI Compliance Log' -DisplayName 'Review Date' -InternalName 'ReviewDate' -Type DateTime
Add-PnPField -List 'AI Compliance Log' -DisplayName 'Generation Timestamp' -InternalName 'GenTimestamp' -Type DateTime

Step 10: Build Power Automate Approval Workflows

Create Power Automate flows that enforce human-in-the-loop review for all AI-generated documents. When a new document lands in the SharePoint 'Generated Documents' library, an approval request is automatically sent to the designated reviewer (HR Manager for JDs, HR Manager + Legal for offer letters). Only approved documents proceed to publishing or sending.

Step 11: End-to-End Testing and Bias Audit

Execute comprehensive testing across all three document generation workflows. Test with realistic data covering diverse job types, departments, seniority levels, and locations. Perform a bias audit on generated job descriptions using both the automated bias detection prompt and manual review by HR and Legal stakeholders. Document all test results in the compliance log.

• JD Generation Tests (minimum 10): Entry-level role (e.g., Customer Service Representative), Mid-level role (e.g., Marketing Manager), Senior/Executive role (e.g., VP of Engineering), Technical role (e.g., Data Engineer), Non-technical role (e.g., Office Administrator), Remote position, Multi-location position, Contract/temporary position, Bilingual requirement position, Role with physical requirements (test ADA compliance)
• Offer Letter Tests (minimum 5): Standard full-time offer, Part-time offer with different benefits, Executive offer with equity/bonus, Contractor offer (1099), Remote worker in different state (verify state-specific language)
• Onboarding Packet Tests (minimum 3): Standard new hire, Rehire, Intern/temporary worker
• Bias Audit: Run all 10 JDs through the bias detection prompt
• Document results in the AI Compliance Log SharePoint list
• Flag any JDs scoring below 85/100 for manual revision

Step 12: User Training and Go-Live

Conduct hands-on training sessions for all HR staff who will use the system. Cover: accessing Copilot Studio agents via Teams, triggering automated workflows, reviewing and editing AI-generated content, using the approval workflow, understanding bias detection results, and the compliance logging process. Deploy to production with a 2-week supervised period where MSP monitors all generated content.

• Training Agenda (2-hour session, split across 2 days)
• Day 1 (1 hour): Demo: Generating a JD via Teams Copilot Studio agent (15 min) | Hands-on: Each user generates a JD for a real open role (20 min) | Demo: Reviewing and editing AI output, approval workflow (15 min) | Q&A (10 min)
• Day 2 (1 hour): Demo: Offer letter generation triggered from ATS (15 min) | Demo: Onboarding packet generation (10 min) | Hands-on: Users process a sample candidate through full pipeline (20 min) | Review: Compliance logging, bias detection, escalation procedures (10 min) | Go-live announcement and support contact info (5 min)
• Post-training: Share recorded sessions via SharePoint
• Create quick-reference cards (1-page PDFs) for each workflow
• Enable the Copilot Studio agents in the production Teams channels

Custom AI Components

Job Description Generator System Prompt

Type: prompt Master system prompt used in both the Copilot Studio JD Agent and the OpenAI API Zapier integration. This prompt enforces the client's brand voice, structural format, inclusivity requirements, and compliance guardrails. It generates complete, ATS-optimized job descriptions from minimal input (job title, department, level, location). Implementation:

Offer Letter Generator System Prompt

Type: prompt System prompt for generating personalized offer letters from candidate and compensation data. Enforces legal requirements for the specific state/jurisdiction, includes all mandatory disclosures, and follows the client's established offer letter format.

Implementation:

Onboarding Document Generator System Prompt

Type: prompt System prompt for generating personalized onboarding packets including welcome letters, first-week schedules, IT setup instructions, benefits enrollment guides, and policy acknowledgment checklists. Adapts based on role type, department, and location.

Implementation:

Bias Detection Analysis Prompt

Type: prompt A specialized prompt that analyzes AI-generated job descriptions for bias across gender, age, race, disability, and other protected classes. Returns a structured score and specific actionable recommendations. Used as a second-pass quality check in the Zapier workflow.

Implementation:

Called via OpenAI API after initial JD generation. Returns structured JSON for automated processing.

Zapier OpenAI JD Generation Code Step

Type: integration JavaScript code for the Zapier 'Code by Zapier' action that calls the OpenAI GPT-4.1 API to generate a job description and then runs it through bias detection. This is the core integration code that connects the ATS trigger to the AI content generation. Implementation:

// calls OpenAI GPT-4.1 to generate a job description and run bias detection

// Zapier Code Step: Generate Job Description via OpenAI API
// Trigger provides: inputData.job_title, inputData.department, 
// inputData.location, inputData.employment_type, inputData.level,
// inputData.reports_to, inputData.salary_range, inputData.special_requirements

const OPENAI_API_KEY = inputData.openai_api_key; // Stored as Zapier secret
const COMPANY_NAME = inputData.company_name || 'Acme Corp';

// Step 1: Generate the Job Description
const jdSystemPrompt = `You are an expert HR content writer for ${COMPANY_NAME}. Generate a complete, inclusive, ATS-optimized job description following this exact structure:

### [Job Title]
**Department:** [Department]
**Location:** [Location]
**Employment Type:** [Type]
**Reports To:** [Manager Title]
**Salary Range:** [Range]

#### About ${COMPANY_NAME}
[2-3 sentences]

#### About the Role
[3-4 sentences]

#### What You'll Do
[6-10 bullet points with action verbs]

#### What You Bring
**Required:**
[4-6 items]

**Preferred:**
[3-5 items]

#### What We Offer
[4-6 bullet points]

#### Equal Opportunity Statement
${COMPANY_NAME} is an equal opportunity employer. We celebrate diversity and are committed to creating an inclusive environment for all employees. We do not discriminate based on race, religion, color, national origin, gender, sexual orientation, age, marital status, veteran status, or disability status.

If you need assistance or a reasonable accommodation during the application process, please contact hr@${COMPANY_NAME.toLowerCase().replace(/\s+/g, '')}.com.

RULES: No gendered language. No age-coded words. Use experience ranges not minimums. Include salary if location requires pay transparency. Flesch-Kincaid 8th-10th grade level.`;

const jdUserPrompt = `Generate a job description for:
- Title: ${inputData.job_title}
- Department: ${inputData.department}
- Location: ${inputData.location}
- Employment Type: ${inputData.employment_type || 'Full-time'}
- Level: ${inputData.level || 'Mid-level'}
- Reports To: ${inputData.reports_to || '[Hiring Manager]'}
- Salary Range: ${inputData.salary_range || '[PLACEHOLDER: Add salary range]'}
- Special Requirements: ${inputData.special_requirements || 'None'}`;

const jdResponse = await fetch('https://api.openai.com/v1/chat/completions', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': `Bearer ${OPENAI_API_KEY}`
  },
  body: JSON.stringify({
    model: 'gpt-4.1',
    messages: [
      { role: 'system', content: jdSystemPrompt },
      { role: 'user', content: jdUserPrompt }
    ],
    max_tokens: 2000,
    temperature: 0.7,
    store: false
  })
});

const jdData = await jdResponse.json();
const generatedJD = jdData.choices[0].message.content;

// Step 2: Run Bias Detection
const biasSystemPrompt = `You are an employment bias detection expert. Analyze the following job description and return ONLY a JSON object with: overall_score (1-100, 100=no bias), issues (array of specific problems found), priority_fixes (top 3 changes), and pass (boolean, true if score >= 85).`;

const biasResponse = await fetch('https://api.openai.com/v1/chat/completions', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': `Bearer ${OPENAI_API_KEY}`
  },
  body: JSON.stringify({
    model: 'gpt-4.1',
    messages: [
      { role: 'system', content: biasSystemPrompt },
      { role: 'user', content: `Analyze this job description for bias:\n\n${generatedJD}` }
    ],
    max_tokens: 1000,
    temperature: 0.2,
    store: false
  })
});

const biasData = await biasResponse.json();
const biasAnalysis = biasData.choices[0].message.content;

let biasScore = 0;
let biasPass = false;
try {
  const parsed = JSON.parse(biasAnalysis);
  biasScore = parsed.overall_score || 0;
  biasPass = parsed.pass || (biasScore >= 85);
} catch(e) {
  biasScore = 0;
  biasPass = false;
}

output = {
  generated_jd: generatedJD,
  bias_analysis: biasAnalysis,
  bias_score: biasScore,
  bias_pass: biasPass,
  job_title: inputData.job_title,
  department: inputData.department,
  generation_timestamp: new Date().toISOString(),
  model_used: 'gpt-4.1',
  doc_type: 'Job Description'
};

Zapier Offer Letter Generation Code Step

Type: integration JavaScript code for the Zapier 'Code by Zapier' action that generates a personalized offer letter from candidate and compensation data pulled from the ATS and HRIS.

Implementation:

// Zapier Code Step: Generate Offer Letter via OpenAI API
// Input data from prior Zapier steps (Greenhouse candidate data + BambooHR compensation data)

const OPENAI_API_KEY = inputData.openai_api_key;
const COMPANY_NAME = inputData.company_name || 'Acme Corp';

const systemPrompt = `You are an HR document specialist for ${COMPANY_NAME}. Generate a professional, legally compliant offer letter.

FORMAT:
- Use formal business letter format
- Include all compensation details clearly
- Include at-will employment language (unless Montana)
- Include background check and I-9 contingencies
- Include acceptance signature block
- For CA employees: note non-competes are unenforceable
- For NY/CO/WA/CT employees: include pay range
- Add benefits summary referencing full plan documents
- End with: "⚠️ AI-GENERATED DRAFT - Must be reviewed by HR and Legal before sending."

NEVER fabricate compensation numbers. Use only the data provided.`;

const userPrompt = `Generate an offer letter with these details:
- Candidate Name: ${inputData.candidate_name}
- Position: ${inputData.position_title}
- Department: ${inputData.department}
- Start Date: ${inputData.start_date}
- Employment Type: ${inputData.employment_type || 'Full-time'}
- Base Salary: ${inputData.salary}
- Pay Frequency: ${inputData.pay_frequency || 'Semi-monthly'}
- Bonus: ${inputData.bonus || 'N/A'}
- Equity: ${inputData.equity || 'N/A'}
- Benefits Eligibility: ${inputData.benefits_date || 'First day of month following 30 days of employment'}
- Reports To: ${inputData.manager_name}, ${inputData.manager_title}
- Work Location: ${inputData.work_location}
- State/Jurisdiction: ${inputData.state}
- Response Deadline: ${inputData.deadline || '5 business days from receipt'}
- Additional Terms: ${inputData.additional_terms || 'None'}`;

const response = await fetch('https://api.openai.com/v1/chat/completions', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': `Bearer ${OPENAI_API_KEY}`
  },
  body: JSON.stringify({
    model: 'gpt-4.1',
    messages: [
      { role: 'system', content: systemPrompt },
      { role: 'user', content: userPrompt }
    ],
    max_tokens: 2500,
    temperature: 0.4,
    store: false
  })
});

const data = await response.json();
const generatedLetter = data.choices[0].message.content;

output = {
  offer_letter: generatedLetter,
  candidate_name: inputData.candidate_name,
  position_title: inputData.position_title,
  generation_timestamp: new Date().toISOString(),
  model_used: 'gpt-4.1',
  doc_type: 'Offer Letter',
  state: inputData.state
};

Onboarding Packet Generation Code Step

Type: integration JavaScript code for generating personalized onboarding packets triggered by DocuSign envelope completion (offer acceptance). Pulls new hire data from HRIS and generates a comprehensive onboarding packet.

Implementation

// Zapier Code Step: Generate Onboarding Packet via OpenAI API
// Triggered after DocuSign offer letter is completed (signed by candidate)

const OPENAI_API_KEY = inputData.openai_api_key;
const COMPANY_NAME = inputData.company_name || 'Acme Corp';

const systemPrompt = `You are an onboarding experience designer for ${COMPANY_NAME}. Create a warm, comprehensive onboarding packet.

GENERATE ALL OF THESE SECTIONS:

1. **Welcome Letter** - Warm, enthusiastic, mentions their team and manager
2. **First Week Schedule** - Day-by-day with times (Day 1-5)
3. **Pre-Start Checklist** - Items to complete before Day 1 with checkboxes
4. **Benefits Enrollment Guide** - Summary with enrollment deadline
5. **Policy Acknowledgment List** - Policies they must review and sign
6. **Key Contacts** - HR, Manager, IT Help Desk, Buddy/Mentor
7. **IT Setup Instructions** - Account access, required software, VPN if remote

ADAPTATION:
- Remote employees: virtual onboarding equivalents, equipment shipping info
- Contractors: simplified benefits, note contract end date
- Include [PLACEHOLDER] tags for any links, passwords, or specific details HR must fill in.
- Tone: warm, welcoming, use first name, light emoji usage
- End with: "⚠️ AI-GENERATED DRAFT - HR should verify all dates, links, contacts, and policy documents before sending."`;

const userPrompt = `Generate an onboarding packet for:
- New Hire Name: ${inputData.new_hire_name}
- Position: ${inputData.position_title}
- Department: ${inputData.department}
- Start Date: ${inputData.start_date}
- Manager: ${inputData.manager_name}
- Work Location: ${inputData.work_location}
- Employment Type: ${inputData.employment_type || 'Full-time'}
- Buddy/Mentor: ${inputData.buddy_name || '[To be assigned]'}
- IT Equipment: ${inputData.equipment_notes || 'Standard laptop and peripherals'}`;

const response = await fetch('https://api.openai.com/v1/chat/completions', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': `Bearer ${OPENAI_API_KEY}`
  },
  body: JSON.stringify({
    model: 'gpt-4.1',
    messages: [
      { role: 'system', content: systemPrompt },
      { role: 'user', content: userPrompt }
    ],
    max_tokens: 3500,
    temperature: 0.6,
    store: false
  })
});

const data = await response.json();
const onboardingPacket = data.choices[0].message.content;

// Also generate a short welcome email body
const emailResponse = await fetch('https://api.openai.com/v1/chat/completions', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': `Bearer ${OPENAI_API_KEY}`
  },
  body: JSON.stringify({
    model: 'gpt-4.1',
    messages: [
      { role: 'system', content: `Write a brief, warm welcome email (3-4 paragraphs) from HR at ${COMPANY_NAME} to a new hire. Let them know their onboarding packet is attached and highlight the most important pre-start tasks. Use their first name.` },
      { role: 'user', content: `New hire: ${inputData.new_hire_name}, starting ${inputData.start_date} as ${inputData.position_title}. Manager: ${inputData.manager_name}.` }
    ],
    max_tokens: 500,
    temperature: 0.7,
    store: false
  })
});

const emailData = await emailResponse.json();
const welcomeEmail = emailData.choices[0].message.content;

output = {
  onboarding_packet: onboardingPacket,
  welcome_email_body: welcomeEmail,
  new_hire_name: inputData.new_hire_name,
  position_title: inputData.position_title,
  start_date: inputData.start_date,
  generation_timestamp: new Date().toISOString(),
  model_used: 'gpt-4.1',
  doc_type: 'Onboarding Document'
};

Power Automate Compliance Logger

Type: workflow Power Automate cloud flow that automatically logs every AI-generated document to the SharePoint AI Compliance Log list. Triggered whenever a new file is added to the Generated Documents library. Captures the document type, AI model used, bias score, generation timestamp, and sets the initial review status to 'Pending Review'. Required for regulatory compliance in NYC, Illinois, and Colorado jurisdictions.

Implementation:

# Power Automate Flow: AI Compliance Auto-Logger
# Type: Automated Cloud Flow

## Trigger
- **When a file is created (properties only)** - SharePoint
  - Site Address: https://clientdomain.sharepoint.com/sites/hr-ai-content
  - Library Name: Generated Documents

## Actions

### 1. Get file properties
- **Get file properties** - SharePoint
  - Site: hr-ai-content
  - Library: Generated Documents  
  - Id: triggerOutputs()?['body/ID']

### 2. Create compliance log entry
- **Create item** - SharePoint
  - Site: hr-ai-content
  - List: AI Compliance Log
  - Fields:
    - DocID: concat('DOC-', formatDateTime(utcNow(), 'yyyyMMdd-HHmmss'))
    - DocType: outputs('Get_file_properties')?['body/DocType/Value']
    - AIModel: 'gpt-4.1'
    - PromptHash: '' (populated by Zapier metadata if available)
    - BiasScore: outputs('Get_file_properties')?['body/BiasScore'] (if available from Zapier)
    - BiasIssues: '' (populated after bias review)
    - HumanReviewer: '' (populated after approval workflow)
    - ReviewStatus: 'Pending Review'
    - ReviewDate: null
    - GeneratedDate: utcNow()

### 3. Send notification
- **Post message in a chat or channel** - Microsoft Teams
  - Post in: Channel
  - Team: HR Team
  - Channel: AI Content Reviews
  - Message: 
        📋 **New AI-Generated Document Logged**
    - Type: @{outputs('Get_file_properties')?['body/DocType/Value']}
    - File: @{outputs('Get_file_properties')?['body/{FilenameWithExtension}']}
    - Compliance ID: @{outputs('Create_item')?['body/DocID']}
    - Status: Pending Review
    
    Please review and approve via the SharePoint approval workflow.
    
### Error Handling
- **Configure run after** on each action to handle failures
- **Scope** wrapping all actions with a catch that sends failure notification to MSP admin email
- Retry policy: Fixed interval, 3 retries, 5-minute intervals

## Notes
- This flow runs on the standard Power Automate connector included with M365 E3
- No premium connectors required
- Expected volume: 50-200 runs/month for typical client
- Retention: Set SharePoint list view to archive items older than 4 years (EEOC requirement)

Testing & Validation

• TEST 1 - JD Generation via Copilot Studio: Open Microsoft Teams, navigate to the HR Team channel, invoke the Job Description Generator agent with the prompt 'Create a job description for a Senior Software Engineer in the Engineering department, located in New York, NY, hybrid work'. Verify the output includes all required sections (About, What You'll Do, What You Bring with Required/Preferred split, What We Offer, EEO statement, accommodations statement), includes a salary range (required for NY), uses no gendered language, and ends with the AI-generated draft disclaimer.
• TEST 2 - JD Generation via Zapier Pipeline: Create a test job opening in the ATS (Greenhouse/Workable) with title 'Marketing Manager', department 'Marketing', location 'Denver, CO'. Verify the Zapier trigger fires, the OpenAI API generates a JD, the bias detection runs and returns a score ≥85, the document is saved to the SharePoint 'Generated Documents' library with correct metadata, and a Teams notification is posted to the review channel.
• TEST 3 - Bias Detection Accuracy: Submit three intentionally biased JDs through the bias detection prompt: (1) a JD with gendered language ('he will manage', 'manpower'), (2) a JD with age-coded language ('digital native', 'recent graduate preferred, 10+ years experience'), (3) a JD with disability bias ('must be able to lift 50 lbs' without accommodation statement). Verify each returns a score below 70 and identifies the specific biased phrases with actionable replacement suggestions.
• TEST 4 - Offer Letter Generation End-to-End: In the ATS, move a test candidate to the 'Offer' stage with salary $95,000/year, start date 30 days from now, in California. Verify: Zapier triggers, offer letter is generated with correct candidate name and salary, California-specific language is included (non-compete unenforceability notice), at-will language is present, DocuSign envelope is created with correct signature fields, and the document archives to SharePoint.
• TEST 5 - DocuSign Routing: Using the test offer letter from Test 4, verify the DocuSign envelope routes first to the Hiring Manager (Signer 1), then to the candidate (Signer 2), and HR Manager is CC'd. Verify signing works on both desktop and mobile. Verify the completed envelope triggers the onboarding Zap.
• TEST 6 - Onboarding Packet Generation: After the DocuSign envelope from Test 5 completes, verify the onboarding Zap fires and generates a complete packet including: welcome letter, 5-day first-week schedule, pre-start checklist, benefits enrollment guide, policy acknowledgment list, key contacts, and IT setup instructions. Verify the packet is saved to SharePoint and a welcome email is sent to the new hire's email address with the packet attached.
• TEST 7 - Power Automate Approval Workflow: Upload a test JD to the 'Generated Documents' SharePoint library. Verify the approval request is sent to the HR Manager's email and Teams. Test the Approve path (verify status updates to 'Approved' and compliance log is updated). Test the Reject path (verify status updates to 'Rejected' and rejection notification with comments is sent to the document creator).
• TEST 8 - Compliance Logging: After running Tests 2-6, navigate to the 'AI Compliance Log' SharePoint list and verify that each generated document has a corresponding log entry with: unique Document ID, correct Document Type, AI Model 'gpt-4.1', generation timestamp, and initial Review Status of 'Pending Review'. Verify approved documents show the reviewer name and review date.
• TEST 9 - Multi-Jurisdiction Compliance: Generate offer letters for employees in California, New York, Colorado, Montana, and a state with no special requirements (e.g., Texas). Verify: CA letter warns about non-compete unenforceability, NY/CO letters include pay ranges, Montana letter uses 'good cause' instead of 'at-will' language, and Texas letter uses standard at-will language.
• TEST 10 - Volume and Performance Test: Generate 20 job descriptions in rapid succession (simulating a staffing agency's weekly batch). Verify all 20 complete without API errors, total generation time is under 10 minutes, OpenAI API costs are within expected range ($2-5 for the batch), and Zapier task consumption is as expected (60-100 tasks for 20 JDs with bias checks).
• TEST 11 - Failure and Retry Test: Temporarily set an invalid OpenAI API key in Zapier and trigger a JD generation. Verify the Zap fails gracefully, an error notification is sent to the MSP admin, no blank/corrupt document is saved to SharePoint, and after restoring the correct API key the Zap processes successfully on retry.
• TEST 12 - User Acceptance Testing (UAT): Schedule a 2-hour session with the HR Manager and lead Recruiter. Have them generate 3 JDs, 2 offer letters, and 1 onboarding packet using real (or realistic) data. Collect feedback on: output quality and accuracy, tone and brand voice match, time saved vs. manual process, ease of use, and any missing fields or sections. Document all feedback and adjust prompts before go-live.

Client Handoff

The client handoff should be a formal 90-minute session with all HR stakeholders (HR Manager, Recruiters, HR Generalists, Legal reviewer, and optionally the IT contact). Cover the following topics:

Maintenance

Ongoing MSP Responsibilities:

Weekly (15–30 min):

• Review Zapier task usage dashboard—verify no failed Zaps, check task consumption against plan limits
• Spot-check 2–3 entries in the AI Compliance Log to verify logging is working correctly
• Monitor OpenAI API usage dashboard for unexpected cost spikes

Monthly (1–2 hours):

• Review and optimize prompt performance: analyze user feedback on generated content quality, adjust system prompts if consistent issues are reported (e.g., JDs consistently too long, offer letters missing a field)
• Review Copilot Studio agent analytics: usage frequency, average satisfaction scores, common user queries
• Update software: check for Zapier Zap version updates, Copilot Studio agent improvements, new ATS/HRIS API versions
• Verify license assignments: ensure new HR hires have Copilot licenses, remove licenses for departed staff
• Send monthly usage report to client: documents generated by type, bias scores, approval rates, cost summary

Quarterly (2–4 hours):

• Compliance review: check for new AI hiring regulations at federal, state, and local levels. Key dates to watch: NYC LL144 enforcement updates, Illinois HB 3773 (effective Jan 1, 2026), Colorado AI Act (effective June 30, 2026), EU AI Act milestones
• Bias audit report: aggregate bias scores across all JDs generated in the quarter, identify trending issues, present findings to HR Manager and Legal
• Prompt library version update: incorporate any new company policies, updated benefits, org chart changes, or new job families into the system prompts and training corpus
• Template refresh: update offer letter and onboarding templates for any policy changes, new benefits plans (typically January), or legal requirement changes

Semi-Annually (4–6 hours):

• Comprehensive system health check: test all Zaps end-to-end, verify all integrations are authenticated and functioning, test failover/retry mechanisms
• OpenAI model evaluation: assess whether newer models (e.g., GPT-4.1 successor) offer better quality or lower cost; test and migrate if beneficial
• ROI review with client stakeholders: compare time-to-fill, documents-per-week, and HR staff satisfaction metrics against pre-implementation baseline
• Security review: rotate API keys, audit SharePoint permissions, review Zapier connected accounts

SLA Considerations:

• Response time for system-down issues (Zaps failing, agents unresponsive): 2-hour response, 4-hour resolution during business hours
• Response time for quality issues (bad output, bias detection false negatives): 1-business-day response, 3-business-day resolution
• Prompt library updates after policy changes: 5-business-day turnaround
• Emergency compliance updates (new regulation affecting client): 48-hour assessment, 10-business-day implementation

Escalation Path:

Alternatives

BambooHR All-in-One Approach

Instead of the Microsoft Copilot + OpenAI API architecture, use BambooHR as the primary HRIS/ATS with its built-in AI Job Description Generator, native onboarding workflows, and e-signature capabilities. Supplement with a lightweight OpenAI API integration only for offer letter generation and advanced customization. This approach consolidates the HR tech stack into a single vendor.

Textio-Centric Approach for DEI-Focused Clients

Lead with Textio as the primary content generation and bias detection platform for job descriptions, supplemented by Microsoft Copilot for offer letters and onboarding documents. Textio provides real-time inclusive language scoring, predictive performance analytics, and A/B testing for job posting effectiveness. This approach prioritizes bias reduction and DEI compliance above all else.

Low-Cost Starter: Copilot-Only Approach

Use only Microsoft 365 Copilot (no Copilot Studio agents, no OpenAI API, no Zapier automation) for semi-automated HR content generation. HR staff use Copilot in Word to draft JDs and offer letters using natural language prompts, with manually uploaded templates as reference. No automated ATS/HRIS integration—staff manually copy content between systems.

Open-Source Self-Hosted LLM Approach

Deploy an open-source LLM (Llama 3 70B or Mistral Large) on-premises or in Azure VM with GPU, using a custom web interface for HR staff. All data stays on-premises/in client's cloud tenant—no third-party API calls. Template management via a custom document management system.