Implementation Guide: Transcribe parent-teacher conferences and generate meeting notes for record keeping

Hardware Procurement

Software Procurement

Prerequisites

• Microsoft 365 Education tenant (A1 minimum, A3 recommended) with Teams enabled for all participating teachers — verify at https://admin.microsoft.com under Licensing
• Reliable Wi-Fi coverage in all conference rooms with minimum 5 Mbps upload speed per room — run speed tests from each conference location using speedtest.net and document results
• School/district IT administrator access to Microsoft 365 Admin Center, Azure AD (Entra ID), and SharePoint Admin Center
• OpenAI API account with billing configured and API key generated — sign up at https://platform.openai.com if not already available
• Otter.ai Business account provisioned with admin access — contact Otter.ai sales for education volume pricing at sales@otter.ai
• FERPA-compliant Data Processing Agreement (DPA) executed between the school district and Otter.ai — Otter provides a standard Student Data Privacy Agreement at https://otter.ai/privacy-policy
• FERPA-compliant DPA executed between the school district and OpenAI — use OpenAI's DPA template at https://openai.com/policies/data-processing-addendum
• Written recording consent form approved by district legal counsel — must comply with state two-party consent laws (mandatory in CA, CT, DE, FL, IL, MD, MA, MI, MT, NH, OR, PA, WA)
• District records retention policy documented and shared with MSP team — transcripts will follow the same retention schedule as other educational records (typically 5-7 years minimum)
• SharePoint site or document library designated for conference transcript storage with appropriate permissions structure aligned to school organizational hierarchy
• PowerSchool, Infinite Campus, or other Student Information System (SIS) admin credentials if SIS integration is in scope — verify API availability
• A minimum of 3-5 volunteer teachers identified for the pilot phase, ideally including at least one special education teacher
• Network firewall rules verified to allow outbound HTTPS traffic to: otter.ai, api.openai.com, graph.microsoft.com, login.microsoftonline.com
• Conference room inventory completed: list all rooms used for parent-teacher conferences with their current AV equipment, network connectivity status, and available USB/power outlets

Installation Steps

...

Step 1: Configure SharePoint Document Library for Transcript Storage

Create a dedicated SharePoint site and document library structure to store all conference transcripts and meeting notes. This becomes the centralized, access-controlled repository for FERPA-compliant record keeping. The library structure should mirror the school's organizational hierarchy: School > Grade Level > Teacher > Academic Year > Individual Conference Notes.

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

# Create the Conference Notes site
New-PnPSite -Type TeamSite -Title 'Conference Notes Archive' -Alias 'conferencenotes' -Description 'FERPA-protected parent-teacher conference transcripts and meeting notes'

# Connect to the new site
Connect-PnPOnline -Url https://TENANT.sharepoint.com/sites/conferencenotes -Interactive

# Create document library
New-PnPList -Title 'Conference Transcripts' -Template DocumentLibrary

# Add custom metadata columns for organization
Add-PnPField -List 'Conference Transcripts' -DisplayName 'Teacher Name' -InternalName 'TeacherName' -Type Text -Required
Add-PnPField -List 'Conference Transcripts' -DisplayName 'Student Name' -InternalName 'StudentName' -Type Text -Required
Add-PnPField -List 'Conference Transcripts' -DisplayName 'Conference Date' -InternalName 'ConferenceDate' -Type DateTime -Required
Add-PnPField -List 'Conference Transcripts' -DisplayName 'Grade Level' -InternalName 'GradeLevel' -Type Choice -Choices 'K','1','2','3','4','5','6','7','8','9','10','11','12'
Add-PnPField -List 'Conference Transcripts' -DisplayName 'Conference Type' -InternalName 'ConferenceType' -Type Choice -Choices 'Regular P-T Conference','IEP Meeting','Behavioral','Academic Concern','Other'
Add-PnPField -List 'Conference Transcripts' -DisplayName 'Consent Obtained' -InternalName 'ConsentObtained' -Type Boolean -Required

# Apply retention label (requires M365 compliance center setup)
# Navigate to Microsoft Purview > Records Management > File Plan
# Create retention label 'Education Record - 7 Year' with 7-year retention period
# Publish label to the Conference Transcripts library

Step 2: Configure Access Controls and Security Groups

Set up Azure AD (Entra ID) security groups and SharePoint permission levels to enforce FERPA-compliant access controls. Only staff with legitimate educational interest should access specific student conference records. Create groups for each role level and apply them to the SharePoint library.

# Connect to Microsoft Graph / Azure AD
Connect-MgGraph -Scopes 'Group.ReadWrite.All','User.Read.All'

# Create security groups
New-MgGroup -DisplayName 'Conference Notes - Teachers' -MailEnabled:$false -MailNickname 'conf-teachers' -SecurityEnabled:$true -Description 'All teachers who conduct parent-teacher conferences'

New-MgGroup -DisplayName 'Conference Notes - Administrators' -MailEnabled:$false -MailNickname 'conf-admins' -SecurityEnabled:$true -Description 'Principals and assistant principals with full access to all conference notes'

New-MgGroup -DisplayName 'Conference Notes - Special Education' -MailEnabled:$false -MailNickname 'conf-sped' -SecurityEnabled:$true -Description 'Special education staff with access to IEP-related conference notes'

# Add users to groups (repeat for each user)
$teacherGroupId = (Get-MgGroup -Filter "displayName eq 'Conference Notes - Teachers'").Id
$userId = (Get-MgUser -Filter "userPrincipalName eq 'teacher@school.edu'").Id
New-MgGroupMember -GroupId $teacherGroupId -DirectoryObjectId $userId

# Apply permissions in SharePoint
Connect-PnPOnline -Url https://TENANT.sharepoint.com/sites/conferencenotes -Interactive

# Break inheritance on the document library
Set-PnPList -Identity 'Conference Transcripts' -BreakRoleInheritance -CopyRoleAssignments:$false

# Grant Administrators full control
Set-PnPGroupPermissions -Identity 'Conference Notes - Administrators' -List 'Conference Transcripts' -AddRole 'Full Control'

# Grant Teachers contribute access (they will be further restricted to their own folders via folder-level permissions)
Set-PnPGroupPermissions -Identity 'Conference Notes - Teachers' -List 'Conference Transcripts' -AddRole 'Contribute'

Step 3: Deploy and Configure Speakerphone Hardware in Conference Rooms

Physically install the Jabra Speak2 75 speakerphones in each dedicated conference room and the Anker PowerConf S330 units for teacher classrooms. Configure firmware, verify audio quality, and label each device with room assignment.

Step 4: Provision and Configure Otter.ai Business Accounts

Set up the Otter.ai Business workspace for the school, provision teacher accounts, configure organization-wide settings for education use, and establish the integration with Microsoft Teams and calendar systems.

Step 5: Configure OpenAI API for Custom Meeting Notes Generation

Set up the OpenAI API account, configure API keys with appropriate usage limits, and deploy the custom meeting notes generation prompt that transforms raw transcripts into structured school-format meeting notes. This is the core AI post-processing component that adds education-specific value beyond basic transcription.

# Azure Key Vault (recommended) or .env file

# Store the API key in Azure Key Vault (recommended for M365 environments):
az keyvault create --name school-conference-kv --resource-group school-rg --location eastus
az keyvault secret set --vault-name school-conference-kv --name openai-api-key --value 'sk-...'

# OR in a .env file on the automation server (less secure, for simpler setups):
echo 'OPENAI_API_KEY=sk-...' >> /opt/conference-notes/.env
chmod 600 /opt/conference-notes/.env

# Test the API connection:
curl https://api.openai.com/v1/chat/completions \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer sk-...' \
  -d '{
    "model": "gpt-5.4",
    "messages": [{"role": "user", "content": "Say hello"}],
    "max_tokens": 50
  }'

Step 6: Build the Post-Conference Notes Processing Pipeline

Deploy the custom Python-based automation script that takes an Otter.ai transcript export (or raw transcript text), sends it to GPT-5.4 with an education-specific system prompt, and generates structured meeting notes in the school's standardized format. This script can be triggered manually, via cron job, or via Power Automate webhook.

# 1. Set up the processing environment on the automation server or Azure Function
# Option A: Local server
sudo apt update && sudo apt install -y python3.11 python3.11-venv
python3.11 -m venv /opt/conference-notes/venv
source /opt/conference-notes/venv/bin/activate
pip install openai python-docx requests python-dotenv

# Option B: Azure Function (recommended for M365 environments)
# Install Azure Functions Core Tools
npm install -g azure-functions-core-tools@4 --unsafe-perm true
func init ConferenceNotesProcessor --python
cd ConferenceNotesProcessor
pip install openai python-docx

cat > /opt/conference-notes/process_transcript.py << 'PYTHON_SCRIPT'
import os
import json
import sys
from datetime import datetime
from openai import OpenAI
from docx import Document
from dotenv import load_dotenv

load_dotenv()
client = OpenAI(api_key=os.getenv('OPENAI_API_KEY'))

SYSTEM_PROMPT = '''You are an AI assistant that converts parent-teacher conference transcripts into structured meeting notes for K-12 school record keeping. You must:

1. Extract and format the following sections:
   - MEETING INFORMATION: Date, time, duration, location, teacher name, parent/guardian name(s), student name, grade level
   - ACADEMIC PROGRESS: Summary of academic performance discussed, specific subjects mentioned, grades or assessment results referenced
   - BEHAVIORAL/SOCIAL-EMOTIONAL: Any behavioral observations, social skills discussion, peer relationships
   - STRENGTHS & ACCOMPLISHMENTS: Positive observations and achievements discussed
   - AREAS FOR IMPROVEMENT: Specific areas where growth is needed, with context from the discussion
   - ACTION ITEMS: Numbered list with responsible party (teacher/parent/student) and target date for each
   - FOLLOW-UP: Next meeting date if scheduled, preferred communication method, any referrals discussed
   - ADDITIONAL NOTES: Any other relevant points from the conference

2. Rules:
   - Use professional, neutral language appropriate for educational records
   - Do NOT include verbatim quotes unless they are critical (e.g., a parent\'s specific request)
   - Do NOT include off-topic conversation, pleasantries, or small talk
   - Flag any mentions of bullying, abuse, self-harm, or safety concerns with [ADMINISTRATOR ATTENTION REQUIRED]
   - If IEP, 504 plan, or special education services are mentioned, flag with [SPECIAL EDUCATION REFERENCE]
   - Maintain factual accuracy — do not infer or fabricate details not present in the transcript
   - If the transcript is unclear or inaudible in sections, note [INAUDIBLE SECTION] rather than guessing
   - Output in clean Markdown format
'''

def process_transcript(transcript_text, metadata=None):
    if metadata is None:
        metadata = {}
    
    user_message = f"""Please process the following parent-teacher conference transcript into structured meeting notes.

Known metadata:
- School: {metadata.get('school_name', 'Not specified')}
- Teacher: {metadata.get('teacher_name', 'Extract from transcript')}
- Date: {metadata.get('conference_date', 'Extract from transcript')}
- Student: {metadata.get('student_name', 'Extract from transcript')}
- Grade: {metadata.get('grade_level', 'Extract from transcript')}
- Conference Type: {metadata.get('conference_type', 'Regular Parent-Teacher Conference')}

TRANSCRIPT:
---
{transcript_text}
---

Generate the structured meeting notes now."""
    
    response = client.chat.completions.create(
        model='gpt-5.4',
        messages=[
            {'role': 'system', 'content': SYSTEM_PROMPT},
            {'role': 'user', 'content': user_message}
        ],
        temperature=0.2,
        max_tokens=3000
    )
    
    return response.choices[0].message.content

def save_as_docx(notes_markdown, output_path, metadata):
    doc = Document()
    doc.add_heading('Parent-Teacher Conference Notes', level=0)
    doc.add_paragraph(f"Generated: {datetime.now().strftime('%Y-%m-%d %H:%M')} | AI-Assisted Transcription")
    doc.add_paragraph('---')
    
    for line in notes_markdown.split('\n'):
        if line.startswith('# '):
            doc.add_heading(line[2:], level=1)
        elif line.startswith('## '):
            doc.add_heading(line[3:], level=2)
        elif line.startswith('### '):
            doc.add_heading(line[4:], level=3)
        elif line.startswith('- '):
            doc.add_paragraph(line[2:], style='List Bullet')
        elif line.strip().startswith('[ADMINISTRATOR ATTENTION REQUIRED]'):
            p = doc.add_paragraph()
            run = p.add_run(line)
            run.bold = True
            run.font.color.rgb = None  # Will appear in default color; style as needed
        else:
            if line.strip():
                doc.add_paragraph(line)
    
    doc.add_paragraph('---')
    doc.add_paragraph('DISCLAIMER: These notes were generated by AI from an audio transcription. They should be reviewed by the teacher for accuracy before being filed as official records. The original audio recording is retained per district retention policy.')
    
    doc.save(output_path)
    return output_path

if __name__ == '__main__':
    if len(sys.argv) < 2:
        print('Usage: python process_transcript.py <transcript_file.txt> [metadata.json]')
        sys.exit(1)
    
    with open(sys.argv[1], 'r') as f:
        transcript = f.read()
    
    metadata = {}
    if len(sys.argv) > 2:
        with open(sys.argv[2], 'r') as f:
            metadata = json.load(f)
    
    notes = process_transcript(transcript, metadata)
    print(notes)
    
    output_file = sys.argv[1].replace('.txt', '_notes.docx')
    save_as_docx(notes, output_file, metadata)
    print(f'\nWord document saved to: {output_file}')
PYTHON_SCRIPT

cat > /opt/conference-notes/test_transcript.txt << 'EOF'
Teacher: Good evening, thank you for coming in tonight. I'm Ms. Johnson, Tommy's 4th grade teacher.
Parent: Hi, thanks for having us. I'm Sarah, Tommy's mom, and this is my husband Dave.
Teacher: Great to meet you both. So Tommy has been doing really well in reading this quarter. He's reading at a 5th grade level now, which is above grade level.
Parent: Oh that's wonderful to hear!
Teacher: Yes, he really loves the chapter books we've been reading. Math is a bit of a different story though. He's struggling with multiplication facts, especially the 7s and 8s tables. He's currently at a C+ in math.
Parent: We've noticed that at home too. He gets frustrated with homework.
Teacher: I'd recommend 10 minutes of practice each night with flashcards or an app like Reflex Math. I can send home some resources.
Parent: That would be great.
Teacher: Behaviorally, Tommy is a great kid. He's kind to his classmates and participates well. Sometimes he talks a bit too much during independent work time, but it's not a major issue.
Parent: We'll talk to him about that.
Teacher: One more thing - I'd like to have him tested for the gifted program in reading. Would you be open to that?
Parent: Absolutely, what do we need to do?
Teacher: I'll send home the consent form next week. Let's plan to check in again in January to see how the math practice is going. You can always email me at jjohnson@school.edu.
Parent: Sounds good, thank you so much!
EOF

python3 /opt/conference-notes/process_transcript.py /opt/conference-notes/test_transcript.txt

# Verify output: should produce structured meeting notes and a .docx file

Step 7: Configure Power Automate Workflow for End-to-End Automation

Create a Power Automate flow that orchestrates the complete post-conference pipeline: detects when a new transcript is uploaded to SharePoint, calls the OpenAI API to generate structured notes, saves the formatted notes back to SharePoint with proper metadata, and optionally notifies the teacher for review.

• Flow Name: 'Conference Transcript to Meeting Notes' | Type: Automated Cloud Flow | Configure via: https://make.powerautomate.com
• TRIGGER — Connector: SharePoint | Action: 'When a file is created (properties only)' | Site Address: https://TENANT.sharepoint.com/sites/conferencenotes | Library Name: Conference Transcripts | Folder: /Transcripts/Raw
• STEP 1: Get file content — Action: SharePoint > Get file content | Site Address: [same as trigger] | File Identifier: [File Identifier from trigger]
• STEP 2: Compose transcript text — Action: Data Operations > Compose | Input: base64ToString(body('Get_file_content')['$content'])
• STEP 3: Call OpenAI API — Action: HTTP | Method: POST | URI: https://api.openai.com/v1/chat/completions | Headers: Content-Type: application/json, Authorization: Bearer [API Key from Azure Key Vault]
• STEP 4: Parse JSON response — Action: Data Operations > Parse JSON | Content: body('HTTP') | Schema: use 'Generate from sample' with a sample OpenAI API response
• STEP 5: Create the notes file in SharePoint — Action: SharePoint > Create file | Site Address: [same] | Folder Path: /Transcripts/Processed | File Name: @{triggerBody()?['{FilenameWithExtension}']}_notes.md | File Content: @{body('Parse_JSON')?['choices'][0]?['message']?['content']}
• STEP 6: Update file metadata — Action: SharePoint > Update file properties | Set TeacherName, StudentName, ConferenceDate, GradeLevel from trigger metadata | Set ConsentObtained: Yes
• STEP 7: Send review notification to teacher — Action: Send an email (V2) - Office 365 Outlook | To: [Teacher email from metadata] | Subject: 'Conference Notes Ready for Review - @{triggerBody()?["StudentName"]}' | Body: 'Your parent-teacher conference notes have been generated and are ready for review. Please review for accuracy within 48 hours and mark as "Reviewed" in the document library. [Link to file]'
• STEP 8: (Optional) Send summary to parent — Condition: If metadata field 'SendToParent' = true | Action: Send email with summarized notes (action items only, not full transcript)

{
  "model": "gpt-5.4",
  "messages": [
    {"role": "system", "content": "[PASTE SYSTEM_PROMPT FROM STEP 6]"},
    {"role": "user", "content": "Process this transcript: @{outputs('Compose')}"}
  ],
  "temperature": 0.2,
  "max_tokens": 3000
}

Step 8: Configure Consent Management Workflow

Set up a digital consent collection system integrated with the school's existing parent communication platform. This ensures no recording begins without documented parental consent, which is legally mandatory in two-party consent states and a FERPA best practice everywhere.

• Option A: Microsoft Forms consent workflow
• 1. Create a Microsoft Form: Navigate to https://forms.office.com | Title: 'Parent-Teacher Conference Recording Consent' | Add fields: Student Full Name (required, text), Student Grade (required, choice), Teacher Name (required, choice), Parent/Guardian Full Name (required, text), 'I consent to audio recording and AI transcription of the parent-teacher conference' (required, choice: Yes/No), 'I understand that the transcript will be used for educational record keeping' (required, choice: Yes/No), 'I would like to receive a copy of the meeting summary' (optional, choice: Yes/No), Digital Signature (required, text), Date (required, date)
• 2. Create Power Automate flow: 'When a new response is submitted' — Trigger: Microsoft Forms > When a new response is submitted | Action: Get response details | Condition: If consent = 'Yes' on both required consent fields → Yes: Update SharePoint list 'Consent Records' with student name, date, consent status → No: Send email to teacher noting parent declined recording
• Option B: ParentSquare integration — If the school uses ParentSquare, create a permission slip:
• 1. Log into ParentSquare admin
• 2. Navigate to Forms > Create New Form
• 3. Create 'Conference Recording Consent' form with equivalent fields
• 4. Set distribution to go out 2 weeks before conference dates
• 5. Export responses as CSV for record keeping

Connect-PnPOnline -Url https://TENANT.sharepoint.com/sites/conferencenotes -Interactive
New-PnPList -Title 'Conference Consent Records' -Template GenericList
Add-PnPField -List 'Conference Consent Records' -DisplayName 'Student Name' -InternalName 'StudentName' -Type Text -Required
Add-PnPField -List 'Conference Consent Records' -DisplayName 'Parent Name' -InternalName 'ParentName' -Type Text -Required
Add-PnPField -List 'Conference Consent Records' -DisplayName 'Consent Given' -InternalName 'ConsentGiven' -Type Boolean -Required
Add-PnPField -List 'Conference Consent Records' -DisplayName 'Consent Date' -InternalName 'ConsentDate' -Type DateTime -Required
Add-PnPField -List 'Conference Consent Records' -DisplayName 'Academic Year' -InternalName 'AcademicYear' -Type Text
Add-PnPField -List 'Conference Consent Records' -DisplayName 'Teacher' -InternalName 'Teacher' -Type Text

Step 9: Conduct Pilot Testing with Volunteer Teachers

Run a controlled pilot with 3-5 volunteer teachers over a 2-week period to validate the entire workflow end-to-end: audio capture quality, transcription accuracy, AI summarization quality, storage/access controls, and teacher satisfaction. Use actual parent-teacher conferences (with consent) or simulated conferences with staff role-playing.

• Audio quality rating (1–5)
• Transcription accuracy rating (1–5)
• Meeting notes quality/usefulness rating (1–5)
• Time saved compared to manual notes (estimated minutes)
• Issues encountered (free text)
• Suggestions for improvement (free text)
• Would you recommend this to colleagues? (Yes/No)

• Manually compare 3 transcripts against the audio for Word Error Rate (WER)
• Target: <10% WER for clear audio in quiet rooms
• Document results for the handoff report

Step 10: Train Staff and Roll Out to All Teachers

Conduct training sessions for all participating teachers, provide documentation, configure remaining accounts, and execute full school rollout. Training should cover the technology, the consent workflow, the review process, and FERPA responsibilities.

Custom AI Components

Conference Notes Generator System Prompt

Type: prompt The core GPT-5.4 system prompt that transforms raw parent-teacher conference transcripts into structured, FERPA-aware meeting notes suitable for educational record keeping. This prompt is engineered for consistency, safety flagging, and professional educational language. It is used by both the Python processing script and the Power Automate HTTP action.

Transcript Accuracy Validator

Type: skill A secondary AI call that validates the generated meeting notes against the original transcript to catch hallucinations, omissions, or misattributions. This acts as a quality assurance layer before the notes are saved to the official record. It compares key facts between the transcript and notes and reports discrepancies.

Implementation

def validate_notes(transcript_text, generated_notes):
    """Validate generated meeting notes against original transcript for accuracy."""
    
    validation_prompt = '''You are a quality assurance reviewer for AI-generated parent-teacher conference notes. Compare the generated notes against the original transcript and check for:

1. HALLUCINATIONS: Any facts, grades, names, dates, or action items in the notes that are NOT in the transcript
2. OMISSIONS: Any important topics, decisions, or action items from the transcript that are MISSING from the notes
3. MISATTRIBUTIONS: Any statements attributed to the wrong speaker
4. ACCURACY: Verify all grades, scores, dates, and specific claims match the transcript exactly

Output a JSON object with this structure:
{
  "validation_passed": true/false,
  "confidence_score": 0.0-1.0,
  "hallucinations": ["list of any fabricated details"],
  "omissions": ["list of any missing important details"],
  "misattributions": ["list of any speaker attribution errors"],
  "accuracy_issues": ["list of any factual mismatches"],
  "recommendation": "APPROVE" or "FLAG_FOR_REVIEW" or "REGENERATE"
}

Be strict — err on the side of flagging potential issues rather than missing them.'''

    response = client.chat.completions.create(
        model='gpt-5.4',
        messages=[
            {'role': 'system', 'content': validation_prompt},
            {'role': 'user', 'content': f'ORIGINAL TRANSCRIPT:\n---\n{transcript_text}\n---\n\nGENERATED NOTES:\n---\n{generated_notes}\n---\n\nValidate the notes against the transcript.'}
        ],
        temperature=0.1,
        max_tokens=1000,
        response_format={'type': 'json_object'}
    )
    
    validation_result = json.loads(response.choices[0].message.content)
    
    if validation_result.get('recommendation') == 'REGENERATE':
        print('WARNING: Validation failed - notes should be regenerated')
        print(f'Issues: {json.dumps(validation_result, indent=2)}')
    elif validation_result.get('recommendation') == 'FLAG_FOR_REVIEW':
        print('NOTICE: Notes flagged for manual teacher review')
        print(f'Potential issues: {json.dumps(validation_result, indent=2)}')
    else:
        print(f'Validation passed with confidence: {validation_result.get("confidence_score", "N/A")}')
    
    return validation_result

Parent Summary Email Generator

Type: prompt A separate, more concise prompt that generates a parent-friendly summary email from the full meeting notes. This version excludes internal school commentary, administrative flags, and sensitive observations — providing parents only with the agreed-upon action items, next steps, and positive highlights appropriate for direct parent communication.

Implementation:

def generate_parent_email(meeting_notes, teacher_email, school_name):
    response = client.chat.completions.create(
        model='gpt-5.4',
        messages=[
            {'role': 'system', 'content': PARENT_SUMMARY_PROMPT},
            {'role': 'user', 'content': f'Generate a parent email summary from these meeting notes:\n\n{meeting_notes}\n\nTeacher email: {teacher_email}\nSchool: {school_name}'}
        ],
        temperature=0.3,
        max_tokens=500
    )
    return response.choices[0].message.content

Consent Status Checker Integration

Type: integration A lightweight integration component that checks the SharePoint consent records list before allowing a recording to proceed. This is implemented as a Power Automate flow that teachers trigger via a Teams Adaptive Card before each conference, ensuring no recording begins without verified consent.

Implementation:

POWER AUTOMATE FLOW SPECIFICATION:

Flow Name: 'Check Conference Consent'
Trigger Type: Manual trigger from Teams Adaptive Card

Adaptive Card JSON (deploy to Teams channel or personal app):
{
  "type": "AdaptiveCard",
  "$schema": "http://adaptivecards.io/schemas/adaptive-card.json",
  "version": "1.5",
  "body": [
    {
      "type": "TextBlock",
      "text": "Conference Recording Consent Check",
      "weight": "Bolder",
      "size": "Large"
    },
    {
      "type": "Input.Text",
      "id": "studentName",
      "label": "Student Full Name",
      "isRequired": true,
      "placeholder": "Enter student name"
    },
    {
      "type": "Input.ChoiceSet",
      "id": "gradeLevel",
      "label": "Grade Level",
      "isRequired": true,
      "choices": [
        {"title": "K", "value": "K"},
        {"title": "1", "value": "1"},
        {"title": "2", "value": "2"},
        {"title": "3", "value": "3"},
        {"title": "4", "value": "4"},
        {"title": "5", "value": "5"},
        {"title": "6", "value": "6"},
        {"title": "7", "value": "7"},
        {"title": "8", "value": "8"}
      ]
    }
  ],
  "actions": [
    {
      "type": "Action.Submit",
      "title": "Check Consent Status",
      "data": {"action": "checkConsent"}
    }
  ]
}

Flow Logic:
1. Trigger: When Adaptive Card action is submitted
2. Get items from SharePoint list 'Conference Consent Records' where StudentName = input studentName AND AcademicYear = current year
3. Condition: If item found AND ConsentGiven = true
   - YES: Reply to Adaptive Card with green checkmark: '✅ CONSENT VERIFIED for [Student Name]. Recording may proceed. Consent given by [Parent Name] on [Date].'
   - NO (consent denied): Reply with red X: '❌ CONSENT DENIED for [Student Name]. DO NOT record this conference. Take manual notes instead.'
   - NO (no record found): Reply with warning: '⚠️ NO CONSENT RECORD for [Student Name]. Recording is NOT permitted. Send consent form to parent and take manual notes for this conference.'
4. Log the consent check to a SharePoint audit list with timestamp, teacher name, student name, and result

Otter.ai to SharePoint Transcript Sync

Type: workflow An automated workflow that periodically pulls completed transcripts from Otter.ai and uploads them to the SharePoint document library, triggering the downstream meeting notes generation pipeline. This eliminates the manual export step for teachers.

Implementation

import os
import json
import requests
from datetime import datetime, timedelta
from dotenv import load_dotenv

load_dotenv()

OTTER_API_BASE = 'https://otter.ai/forward/api/v1'  # Note: Otter.ai API access requires Business plan
OTTER_EMAIL = os.getenv('OTTER_EMAIL')
OTTER_PASSWORD = os.getenv('OTTER_PASSWORD')
SHAREPOINT_SITE_URL = os.getenv('SHAREPOINT_SITE_URL')  # e.g., https://tenant.sharepoint.com/sites/conferencenotes
SHAREPOINT_CLIENT_ID = os.getenv('SHAREPOINT_CLIENT_ID')
SHAREPOINT_CLIENT_SECRET = os.getenv('SHAREPOINT_CLIENT_SECRET')

def get_otter_speeches(since_hours=24):
    """Fetch recent Otter.ai transcripts.
    NOTE: Otter.ai does not have a public API as of July 2025.
    This implementation uses their internal API endpoints which may change.
    RECOMMENDED ALTERNATIVE: Use Otter.ai webhook notifications if available on Business plan,
    or instruct teachers to use the manual export workflow.
    """
    # Alternative approach using Otter.ai export:
    # 1. Teachers click Export > .txt in Otter.ai after each conference
    # 2. Save to a designated OneDrive/SharePoint sync folder
    # 3. Power Automate detects the new file and triggers processing
    pass

def upload_to_sharepoint(file_content, filename, metadata):
    """Upload transcript to SharePoint via Microsoft Graph API."""
    # Get access token
    token_url = f'https://login.microsoftonline.com/{os.getenv("TENANT_ID")}/oauth2/v2.0/token'
    token_response = requests.post(token_url, data={
        'grant_type': 'client_credentials',
        'client_id': SHAREPOINT_CLIENT_ID,
        'client_secret': SHAREPOINT_CLIENT_SECRET,
        'scope': 'https://graph.microsoft.com/.default'
    })
    access_token = token_response.json()['access_token']
    
    # Upload file
    site_id = os.getenv('SHAREPOINT_SITE_ID')
    drive_id = os.getenv('SHAREPOINT_DRIVE_ID')
    upload_url = f'https://graph.microsoft.com/v1.0/sites/{site_id}/drives/{drive_id}/root:/Transcripts/Raw/{filename}:/content'
    
    headers = {
        'Authorization': f'Bearer {access_token}',
        'Content-Type': 'text/plain'
    }
    
    response = requests.put(upload_url, headers=headers, data=file_content.encode('utf-8'))
    
    if response.status_code in [200, 201]:
        print(f'Successfully uploaded {filename} to SharePoint')
        return response.json()
    else:
        print(f'Failed to upload {filename}: {response.status_code} {response.text}')
        return None

if __name__ == '__main__':
    print('Transcript sync job running at', datetime.now().isoformat())
    # In practice, this script monitors the local sync folder for new .txt exports
    # and uploads them to SharePoint with appropriate metadata

Testing & Validation

• AUDIO QUALITY TEST: In each conference room, place the Jabra Speak2 75 at the center of the table with two people seated at opposite ends (4-6 feet apart). Record a 2-minute conversation via Otter.ai where both people speak at normal volume. Verify the transcript achieves >90% word accuracy and correctly identifies both speakers. Repeat with background noise (open door to hallway) and verify accuracy stays above 85%.
• TRANSCRIPTION ACCURACY TEST: Record a 10-minute scripted conversation that includes education-specific vocabulary (IEP, 504, differentiated instruction, formative assessment, grade-level benchmarks, Lexile score). Compare the Otter.ai transcript word-by-word against the script. Calculate Word Error Rate (WER). Acceptance criteria: WER < 10% for clear audio conditions.
• AI NOTES GENERATION TEST: Feed the test transcript from Step 6 through the process_transcript.py script. Verify the output contains all required sections (Meeting Information, Academic Progress, Behavioral/Social-Emotional, Strengths, Areas for Improvement, Action Items, Follow-Up, Additional Notes). Verify no hallucinated information is present. Verify the action items table correctly identifies responsible parties and dates.
• SAFETY FLAGGING TEST: Create a test transcript that includes mentions of bullying, self-harm, and IEP evaluation. Run it through the AI notes generator. Verify that [ADMINISTRATOR ATTENTION REQUIRED] and [SPECIAL EDUCATION REFERENCE] flags appear in the output. This is a critical safety test — the system must NEVER miss these flags.
• CONSENT WORKFLOW TEST: Submit the Adaptive Card consent check for three scenarios: (1) a student with verified consent — expect green checkmark, (2) a student whose parent declined — expect red denial, (3) a student with no consent record — expect yellow warning. Verify all three responses are correct and logged in the audit list.
• POWER AUTOMATE PIPELINE TEST: Upload a .txt transcript file to the SharePoint 'Transcripts/Raw' folder. Verify within 5 minutes that: (1) the Power Automate flow triggers, (2) a processed notes file appears in 'Transcripts/Processed', (3) the teacher receives a review notification email, (4) all SharePoint metadata columns are populated correctly.
• FERPA ACCESS CONTROL TEST: Log in as Teacher A and verify they can see only their own conference folders and transcripts. Log in as Teacher B and verify no access to Teacher A's documents. Log in as a Principal account and verify access to all teacher folders. Log in as a student or parent account (if applicable) and verify zero access to the Conference Notes site.
• PARENT EMAIL SUMMARY TEST: Generate a parent summary email from a set of meeting notes that contain an [ADMINISTRATOR ATTENTION REQUIRED] flag and specific test scores. Verify the parent email does NOT contain the admin flag content and does NOT include specific scores. Verify the tone is warm and professional and the email is under 200 words.
• BACKUP RECORDING TEST: Simulate a network outage by disconnecting the conference room laptop from Wi-Fi. Record a conference using the Zoom H1n backup recorder. After 'restoring' connectivity, transfer the audio file via USB, upload to Otter.ai for transcription, and verify the full pipeline completes successfully.
• END-TO-END TIMING TEST: Record a 30-minute simulated conference from start to finish and measure: (1) time from conference end to transcript availability — target: <5 minutes, (2) time from transcript upload to AI notes generation — target: <3 minutes, (3) total time from conference end to teacher receiving review notification — target: <10 minutes.

Client Handoff

The client handoff should be conducted as a 90-minute on-site session with the school principal, IT coordinator, and 2-3 teacher representatives. Cover the following topics in order:

Documentation to Leave Behind

• Laminated Conference Room Quick-Reference Cards (one per room)
• Printed Teacher Quick-Start Guide (one per teacher)
• Printed Troubleshooting Guide (IT coordinator + principal)
• Compliance Checklist (signed by MSP and school admin)
• DPA copies (Otter.ai, OpenAI)
• System Architecture Diagram
• Admin credential sheet (sealed envelope to IT coordinator)
• Support contact card with MSP phone, email, and ticket portal URL

Success Criteria to Review Together

Maintenance

ONGOING MSP RESPONSIBILITIES:

Weekly (15 minutes)

• Monitor Power Automate flow run history for failures — check https://make.powerautomate.com > Flow runs. Investigate any failed runs and reprocess if needed.
• Check OpenAI API usage dashboard for unexpected cost spikes at https://platform.openai.com/usage
• Review SharePoint 'Pending Review' view to identify any notes that teachers haven't reviewed within 7 days — send a reminder to the school IT coordinator

Monthly (1 hour)

• Review Otter.ai usage metrics: active users, total minutes transcribed, storage consumption. Report to school administration.
• Check speakerphone firmware updates via Jabra Direct. Schedule updates for non-conference periods.
• Review and rotate API keys if security policy requires monthly rotation.
• Check SharePoint storage consumption against the school's M365 storage quota.
• Review consent tracking list for completeness — flag any students with upcoming conferences who lack consent records.

Quarterly (2-3 hours)

• Conduct a 30-minute training refresher session for new teachers or teachers with low adoption.
• Review transcription accuracy on a sample of 5 recent transcripts — compare against teacher corrections to identify systematic errors.
• Update the GPT-5.4 system prompt if teachers report consistent issues (e.g., incorrect section formatting, missing flag triggers).
• Review DPA expiration dates and renew as needed.
• Generate a quarterly utilization report: conferences recorded, notes generated, teacher adoption rate, average accuracy rating, flagged items count.
• Review and update the consent form language if state laws have changed.

Annually (4-6 hours)

• Conduct full access control audit: verify SharePoint permissions match current staff roster, remove departed teachers, add new teachers.
• Review and renew all vendor DPAs.
• Update consent forms for the new academic year.
• Review records retention: archive or delete transcripts past the retention period per district policy.
• Evaluate software pricing changes: check if Otter.ai, OpenAI, or M365 pricing has changed and adjust client billing.
• Assess whether newer AI models or features should be adopted (e.g., new GPT model with better accuracy, new Otter.ai features).
• Present annual ROI report to school administration showing time saved, conferences documented, and system reliability metrics.

SLA Considerations

• Response time during conference weeks (typically 2-3 weeks per semester): 4-hour response, same-day resolution for blocking issues
• Response time during non-conference periods: Next business day response, 48-hour resolution
• System uptime target: 99% during conference weeks (cloud services dependent)
• Escalation path: Teacher → School IT Coordinator → MSP L1 Technician → MSP L2 Engineer → Vendor support (Otter.ai, Microsoft, OpenAI)

Model/Prompt Retraining Triggers

• If teacher accuracy ratings drop below 3/5 on the feedback form, review and revise the GPT-5.4 system prompt
• If OpenAI releases a new model (e.g., GPT-5), test on 10 sample transcripts before migrating
• If school changes their meeting notes format, update the system prompt to match
• If new compliance requirements emerge (new state law, updated FERPA guidance), update prompts and consent workflows immediately

Alternatives

Zero-Cost Microsoft Teams Built-in Transcription

Use only Microsoft Teams' native live transcription feature (available in M365 Education A1, which is free) without any additional software. Teachers start a Teams meeting for each conference (even in-person ones, by joining from the room laptop), enable live transcription, and receive an auto-generated transcript saved to OneDrive. The AI-generated meeting notes step would still use the OpenAI API, but the transcription layer is entirely free.

Self-Hosted Whisper Transcription for Maximum Privacy

Deploy OpenAI's Whisper model locally on a school- or district-owned server using Whisper.cpp or the Speaches self-hosted API. All audio processing occurs on-premises with zero data leaving the school network. Combined with a locally-hosted LLM (e.g., Llama 3 via Ollama) for summarization, this creates a fully air-gapped solution where no student data touches third-party cloud services.

Rev.com Hybrid AI + Human Transcription

Use Rev.com's AI transcription ($0.25/min) for routine conferences and their human transcription service ($1.99/min) for high-stakes meetings such as IEP conferences, disciplinary meetings, or any conference that may result in formal action. This provides 99%+ accuracy for legally sensitive records while keeping costs manageable for routine conferences.

Google Workspace + Google Meet Transcription

For Google-first school districts using Chromebooks and Google Workspace for Education, use Google Meet's built-in transcription feature instead of Teams. Transcripts auto-save to Google Drive as Google Docs. Combine with Google Apps Script (instead of Power Automate) to call the OpenAI API for meeting notes generation and save results to a shared Google Drive structure.

Fathom Free Tier for Budget-Constrained Pilots

Use Fathom's free unlimited transcription tier for individual teachers to pilot the concept at zero software cost. Each teacher installs Fathom and gets unlimited meeting transcription and AI summaries at no charge. The MSP provides only the hardware (speakerphones) and the custom post-processing pipeline.