Implementation Guide: Draft progress reports and parent communications at scale

Hardware Procurement

Acer Chromebook 314 (if client needs teacher devices)

Software Procurement

Prerequisites

• Active Student Information System (SIS) with API access enabled — PowerSchool SIS, Infinite Campus, Skyward, or Aeries. Admin must provide API credentials (preferably a dedicated read-only service account).
• Active Learning Management System (LMS) — Google Classroom, Canvas, or Schoology — with gradebook data populated by teachers.
• School/district Google Workspace for Education or Microsoft 365 Education tenant with SSO configured (SAML 2.0 or OAuth 2.0). All teacher accounts must exist in the identity provider.
• Reliable internet connectivity: minimum 10 Mbps download, recommended 25+ Mbps. Verify by running speed tests from teacher workstations.
• Designated project sponsor on the client side — typically an Assistant Principal, Director of Curriculum, or Technology Coordinator — who can authorize SIS API access and approve report templates.
• Written approval from the school/district Data Privacy Officer or superintendent to deploy AI tools that process student education records under FERPA.
• Existing parent communication channel identified: ParentSquare, ClassDojo, Seesaw, Bloomz, SIS parent portal, or district email system.
• For self-hosted approach only: Physical server rack space or secure closet with adequate ventilation, dedicated 120V/20A electrical outlet, and Ethernet drop to the school LAN.
• Teacher devices capable of running a modern web browser (Chrome 90+, Edge 90+, Safari 15+). Chromebooks, Windows laptops, Macs, or iPads all qualify.
• Minimum one sample set of completed quarterly grades for at least 20 students across 3+ subjects — needed for prompt template calibration and testing.

Installation Steps

Step 1: Compliance and Data Privacy Foundation

Before any software is deployed or data is touched, establish the legal and compliance framework. This step is non-negotiable for education implementations. Execute Data Privacy Agreements (DPAs) with every vendor that will process student data. Use the SDPC National Data Privacy Agreement (NDPA) v2 template where the vendor supports it. For OpenAI, review their Data Processing Addendum and ensure the 'zero data retention' API option is enabled. Document the legitimate educational interest for each tool under FERPA's school official exception.

Step 2: Provision MagicSchool AI Accounts (Turnkey Layer)

Deploy MagicSchool AI as the teacher-facing tool for immediate, ad-hoc report comment and parent email generation. Start with Free tier for pilot group, upgrade to Plus or Enterprise after validation. Configure SSO so teachers log in with existing Google or Microsoft credentials.

Step 3: Configure OpenAI API Account and Security Controls

Set up the OpenAI API account that will power the automated batch report generation pipeline. Create a dedicated organization, enable zero-data-retention, set usage limits, and generate API keys with appropriate scoping.

curl -s https://api.openai.com/v1/chat/completions \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer sk-YOUR_API_KEY' \
  -d '{"model": "gpt-4.1-mini", "messages": [{"role": "user", "content": "Say hello"}], "max_tokens": 50}'

Step 4: Deploy n8n Automation Server

Install n8n Community Edition on a server to orchestrate the report generation pipeline. n8n can be self-hosted on the same on-prem server as Ollama (if using self-hosted approach), on a lightweight VPS, or on a spare workstation. Docker is the recommended deployment method for reliability and easy updates.

sudo apt update && sudo apt install -y docker.io docker-compose
sudo systemctl enable docker && sudo systemctl start docker

mkdir -p /opt/n8n && cd /opt/n8n

cat > docker-compose.yml << 'EOF'
version: '3.8'
services:
  n8n:
    image: n8nio/n8n:latest
    restart: always
    ports:
      - '5678:5678'
    environment:
      - N8N_BASIC_AUTH_ACTIVE=true
      - N8N_BASIC_AUTH_USER=msp_admin
      - N8N_BASIC_AUTH_PASSWORD=CHANGE_THIS_STRONG_PASSWORD
      - N8N_HOST=n8n.schooldomain.org
      - N8N_PROTOCOL=https
      - WEBHOOK_URL=https://n8n.schooldomain.org/
      - N8N_ENCRYPTION_KEY=GENERATE_A_RANDOM_32_CHAR_KEY
      - GENERIC_TIMEZONE=America/New_York
      - TZ=America/New_York
    volumes:
      - n8n_data:/home/node/.n8n
      - ./local-files:/files
volumes:
  n8n_data:
EOF

docker-compose up -d

curl -s http://localhost:5678/healthz

Step 5: Configure SIS API Integration

Set up the connection between n8n and the client's Student Information System to pull grade data, attendance records, and student demographics. This is the most client-specific step and requires coordination with the school's SIS administrator.

PowerSchool SIS API Setup (most common SIS)

# Get OAuth token:
curl -X POST https://powerschool.schooldomain.org/oauth/access_token \
  -H 'Content-Type: application/x-www-form-urlencoded' \
  -d 'grant_type=client_credentials&client_id=YOUR_CLIENT_ID&client_secret=YOUR_CLIENT_SECRET'

# Fetch student list (test):
curl -s 'https://powerschool.schooldomain.org/ws/v1/district/student?pagesize=5' \
  -H 'Authorization: Bearer YOUR_ACCESS_TOKEN' \
  -H 'Accept: application/json'

• For Infinite Campus: Use the Campus API (REST) — Documentation: https://content.infinitecampus.com/sis/latest/campus-api/
• For Skyward: Use Skyward API or CSV exports via SFTP
• For Aeries: Use Aeries API — https://support.aeries.com/support/solutions/articles/14000077926

Step 6: Build Core n8n Report Generation Workflow

Create the n8n workflow that orchestrates the full pipeline: trigger → fetch student data from SIS → construct prompt → call OpenAI API → format output → queue for teacher review. This workflow handles batch generation of progress reports for an entire class or grade level.

0 15 * * 5

Step 7: Build Teacher Review and Approval Interface

Create a simple web-based teacher review queue where teachers can read AI-generated drafts, edit them, approve them for sending, or regenerate with different parameters. This can be built as a lightweight web app or as a Google Sheets/Forms integration for simplicity.

Option A: Google Sheets Review Queue (simplest, recommended for Tier 2)

Option B: n8n Form Trigger (built-in, no extra tools needed)

Option C: Custom Web App (Tier 3, for larger deployments)

See custom_ai_components for a React-based review dashboard spec.

Step 8: Configure Parent Communication Delivery

Set up the outbound delivery channel for approved progress reports. This integrates the n8n workflow with the school's existing parent communication platform (ParentSquare, email, SIS parent portal, etc.).

ParentSquare Integration

Method: POST
URL: https://api.parentsquare.com/v1/posts
Headers: Authorization: Bearer {PARENTSQUARE_API_KEY}
Body: { 'title': 'Progress Report - {student_name}',
        'body': '{approved_report_text}',
        'recipient_ids': ['{parent_id}'],
        'post_type': 'direct_message' }

Email (SMTP) Delivery

Host: smtp.schooldomain.org (or smtp.gmail.com for Google Workspace)
Port: 587 (TLS)
User: noreply-reports@schooldomain.org
Password: App-specific password

From: noreply-reports@schooldomain.org
To: {parent_email}
Subject: '{student_name} Progress Report - {term}'
HTML Body: Use the formatted report template

SIS Parent Portal (PowerSchool)

If using PowerSchool, use the 'Log Entry' API to post to the student log (visible in PowerSchool Parent Portal).

POST /ws/v1/student/{student_id}/log_entry
Body: { 'log_entry': { 'entry': '{report_text}', 'entry_author': '{teacher_name}', 'entry_date': '{date}' } }

Step 9: Develop and Calibrate Prompt Templates

Create the prompt templates that transform raw student data into well-written progress reports matching the school's voice, format, and standards. This is the most impactful step for output quality. Work directly with 2-3 experienced teachers to calibrate tone, vocabulary, and content expectations.

Prompt templates are provided in full in the custom_ai_components section. Store prompts in a version-controlled file:

mkdir -p /opt/n8n/prompts
cat > /opt/n8n/prompts/progress_report_v1.json << 'PROMPT_EOF'
# See custom_ai_components for full prompt template JSON
PROMPT_EOF

Step 10: Deploy Monitoring, Logging, and Usage Dashboard

Set up monitoring to track API usage, costs, error rates, generation quality metrics, and teacher adoption. This data feeds the MSP's monthly client report and identifies issues proactively.

1. OpenAI Usage Monitoring

2. n8n Execution Logging

n8n automatically logs all workflow executions. Access at: n8n UI → Executions → Filter by workflow.

N8N_EXECUTIONS_DATA_PRUNE=true
N8N_EXECUTIONS_DATA_MAX_AGE=720

3. Monitoring Dashboard (Google Sheets or Looker Studio)

• Reports generated this period (count)
• Average teacher approval rate (approved vs. regenerated)
• API cost this period
• Teacher adoption rate (active users / total teachers)
• Average time from generation to approval

4. Uptime Monitoring for n8n

5. Error Alerting

Step 11: Conduct Teacher Training and Rollout

Train all teaching staff on using both MagicSchool AI (for ad-hoc use) and the automated pipeline (for batch reporting). Training should cover tool usage, the review/approval process, prompt customization, and compliance responsibilities.

Training Agenda (2-hour session, in-person or virtual)

Hour 1: MagicSchool AI

• Account setup and SSO login (5 min)
• Report card comment generator demo (15 min)
• Parent email drafter demo (15 min)
• Hands-on practice with real student scenarios (20 min)
• Q&A (5 min)

Hour 2: Automated Report Pipeline

• Overview of the system architecture (10 min, non-technical)
• Teacher review queue walkthrough (20 min)
• How to approve, edit, and regenerate reports (15 min)
• Compliance responsibilities: what to check before approving (10 min)
• Escalation process and support contacts (5 min)

Create Training Materials

Step 12: Full Production Rollout and First Batch Run

Execute the first full production batch of progress reports for the entire school. Monitor closely, provide real-time support, and gather comprehensive feedback for iteration.

Custom AI Components

Progress Report Generation Prompt Template

Type: prompt The core system prompt and user prompt template used to generate individualized student progress reports from structured grade and attendance data. This prompt is designed for GPT-4.1-mini and includes instructions for tone, structure, length, growth mindset language, and actionable feedback. It uses variable placeholders that are populated by the n8n workflow with actual student data from the SIS.

Implementation

System Prompt

You are an experienced K-12 educator writing progress reports for students. You write in a warm, professional, and encouraging tone that balances honest assessment with growth mindset language. You follow these rules strictly:

Report Structure:

• Opening: Brief positive framing of the student's overall progress
• Academic Performance: Subject-by-subject highlights (2-3 sentences per subject area)
• Strengths & Achievements: Specific examples of what the student does well
• Areas for Growth: Diplomatic framing of challenges with concrete suggestions
• Closing: Encouraging statement and invitation for parent communication

User Prompt Template (variables populated by n8n)

Please write a progress report for the following student:

**Student First Name:** {{student_first_name}}
**Grade Level:** {{grade_level}}
**Reporting Period:** {{term_name}} ({{term_dates}})
**Teacher Name:** {{teacher_name}}
**School Name:** {{school_name}}

**Academic Data:**
{{#each subjects}}
- {{subject_name}}: Current Grade: {{letter_grade}} ({{percentage}}%)
  Recent Assessment: {{recent_assessment_name}}: {{recent_assessment_score}}
  Teacher Notes: {{teacher_comment}}
{{/each}}

**Attendance This Term:**
- Days Present: {{days_present}} / {{total_days}}
- Days Absent: {{days_absent}}
- Tardies: {{tardies}}

**Behavioral/Social-Emotional Notes (if available):**
{{behavioral_notes}}

**Special Instructions from Teacher:**
{{special_instructions}}

**Preferred Report Length:** {{word_count_target}} words
**Tone Preference:** {{tone}} (options: warm-professional, formal-academic, casual-friendly)

Write the progress report now.

Example API Call

{
  "model": "gpt-4.1-mini",
  "messages": [
    {"role": "system", "content": "[SYSTEM PROMPT ABOVE]"},
    {"role": "user", "content": "[USER PROMPT WITH VARIABLES FILLED]"}
  ],
  "max_tokens": 1024,
  "temperature": 0.7,
  "top_p": 0.95
}

Prompt Variants

Store these as separate prompt files for different use cases:

• progress_report_elementary.txt — Simpler vocabulary, more focus on social skills and behavior
• progress_report_middle_school.txt — Balance of academic and social-emotional
• progress_report_high_school.txt — Academic focus, college-readiness language
• parent_email_concern.txt — For communicating specific concerns diplomatically
• parent_email_celebration.txt — For sharing achievements and milestones
• tutoring_session_summary.txt — For tutoring centers: session-by-session summaries

Parent Communication Email Prompt Template

Type: prompt A prompt template specifically for generating parent communication emails for various scenarios: weekly updates, attendance concerns, academic achievements, upcoming conferences, and general check-ins. This is used alongside the progress report prompt for more frequent, shorter communications.

Implementation

System Prompt

You are a friendly, professional K-12 teacher writing an email to a student's parent or guardian. Your communication style is:

Weekly Update Email

Subject: {{student_first_name}}'s Week in {{subject_name}} - {{week_date}}

Dear {{parent_salutation}},

I wanted to share a quick update on how {{student_first_name}} is doing in {{subject_name}} this week.

**This Week's Highlights:**
{{weekly_highlights}}

**What We're Working On:**
{{current_unit_topic}}

**How You Can Support at Home:**
{{home_support_suggestion}}

Please don't hesitate to reach out if you have any questions.

Warm regards,
{{teacher_name}}
{{teacher_email}} | {{school_phone}}

Attendance Concern Email

Subject: Checking In — {{student_first_name}}'s Attendance

Dear {{parent_salutation}},

I hope this message finds you well. I'm reaching out because I've noticed that {{student_first_name}} has missed {{days_absent}} days this term, and I want to make sure everything is okay.

{{student_first_name}} is a valued member of our classroom, and when present, {{positive_observation}}. Consistent attendance helps {{him_her_them}} stay connected with the material and classmates.

If there are any challenges I can help with, or if there's anything the school can do to support your family, please let me know. I'm happy to chat by phone or schedule a meeting at your convenience.

With care,
{{teacher_name}}

Achievement Celebration Email

Subject: Great News About {{student_first_name}}! 🌟

Dear {{parent_salutation}},

I'm excited to share some wonderful news! {{achievement_description}}

{{specific_details}}

You should be very proud — this reflects {{student_first_name}}'s {{positive_trait}}. Keep encouraging {{him_her_them}} at home!

Best,
{{teacher_name}}

API Parameters for Parent Emails

{
  "model": "gpt-4.1-mini",
  "temperature": 0.6,
  "max_tokens": 512,
  "top_p": 0.9
}

n8n Batch Report Generation Workflow

Type: workflow The complete n8n workflow that orchestrates bulk progress report generation. It pulls student data from the SIS via API, iterates over each student, calls the OpenAI API with the prompt template, writes results to the teacher review queue (Google Sheets), and handles errors gracefully. Includes rate limiting, retry logic, and status tracking.

Implementation

n8n Workflow JSON (import via n8n UI → Import from JSON)

{
  "name": "AI Progress Report Generator - Batch",
  "nodes": [
    {
      "parameters": {
        "rule": {
          "interval": [{"triggerAtHour": 6}]
        }
      },
      "name": "Schedule Trigger",
      "type": "n8n-nodes-base.scheduleTrigger",
      "position": [240, 300],
      "notes": "Trigger daily at 6 AM during reporting periods. Disable outside reporting windows."
    },
    {
      "parameters": {
        "method": "POST",
        "url": "https://powerschool.schooldomain.org/oauth/access_token",
        "sendBody": true,
        "bodyParameters": {
          "parameters": [
            {"name": "grant_type", "value": "client_credentials"},
            {"name": "client_id", "value": "={{$env.PS_CLIENT_ID}}"},
            {"name": "client_secret", "value": "={{$env.PS_CLIENT_SECRET}}"}
          ]
        }
      },
      "name": "Get SIS Auth Token",
      "type": "n8n-nodes-base.httpRequest",
      "position": [460, 300]
    },
    {
      "parameters": {
        "method": "GET",
        "url": "https://powerschool.schooldomain.org/ws/v1/district/student?pagesize=100&q=grade_level>=K;grade_level<=12",
        "headerParameters": {
          "parameters": [
            {"name": "Authorization", "value": "=Bearer {{$node['Get SIS Auth Token'].json.access_token}}"}
          ]
        }
      },
      "name": "Fetch Student Roster",
      "type": "n8n-nodes-base.httpRequest",
      "position": [680, 300]
    },
    {
      "parameters": {
        "fieldToSplitOut": "students.student"
      },
      "name": "Split Students",
      "type": "n8n-nodes-base.splitOut",
      "position": [900, 300],
      "notes": "Iterate over each student record individually"
    },
    {
      "parameters": {
        "method": "GET",
        "url": "=https://powerschool.schooldomain.org/ws/v1/student/{{$json.id}}/grade?expansion=grade",
        "headerParameters": {
          "parameters": [
            {"name": "Authorization", "value": "=Bearer {{$node['Get SIS Auth Token'].json.access_token}}"}
          ]
        }
      },
      "name": "Fetch Student Grades",
      "type": "n8n-nodes-base.httpRequest",
      "position": [1120, 300]
    },
    {
      "parameters": {
        "jsCode": "// Construct the prompt from student data\nconst student = $input.first().json;\nconst grades = student.grades || [];\n\nlet subjectsText = '';\nfor (const g of grades) {\n  subjectsText += `- ${g.course_name}: Current Grade: ${g.letter_grade} (${g.percent}%)\\n`;\n  subjectsText += `  Teacher Notes: ${g.comment || 'No additional notes'}\\n`;\n}\n\nconst prompt = `Please write a progress report for the following student:\n\n**Student First Name:** ${student.first_name}\n**Grade Level:** ${student.grade_level}\n**Reporting Period:** ${$env.CURRENT_TERM_NAME}\n**School Name:** ${$env.SCHOOL_NAME}\n\n**Academic Data:**\n${subjectsText}\n\n**Attendance This Term:**\n- Days Present: ${student.days_present || 'N/A'}\n- Days Absent: ${student.days_absent || 'N/A'}\n\n**Preferred Report Length:** 200 words\n**Tone Preference:** warm-professional\n\nWrite the progress report now.`;\n\nreturn [{ json: { student_id: student.id, student_name: student.first_name + ' ' + student.last_name, prompt: prompt } }];"
      },
      "name": "Build Prompt",
      "type": "n8n-nodes-base.code",
      "position": [1340, 300]
    },
    {
      "parameters": {
        "resource": "chat",
        "model": "gpt-4.1-mini",
        "messages": {
          "values": [
            {
              "role": "system",
              "content": "You are an experienced K-12 educator writing progress reports for students. You write in a warm, professional, and encouraging tone that balances honest assessment with growth mindset language. You follow these rules: 1) NEVER fabricate information not in the data. 2) Reference specific subjects and grades. 3) Use strengths-based language. 4) Include one actionable suggestion. 5) Include one specific achievement. 6) Keep to 150-300 words. 7) End encouragingly."
            },
            {
              "role": "user",
              "content": "={{$json.prompt}}"
            }
          ]
        },
        "options": {
          "temperature": 0.7,
          "maxTokens": 1024
        }
      },
      "name": "Generate Report (OpenAI)",
      "type": "@n8n/n8n-nodes-langchain.openAi",
      "position": [1560, 300],
      "retryOnFail": true,
      "maxTries": 3,
      "waitBetweenTries": 5000
    },
    {
      "parameters": {
        "options": {"pause": 500}
      },
      "name": "Rate Limiter",
      "type": "n8n-nodes-base.wait",
      "position": [1780, 300],
      "notes": "500ms pause between API calls to respect rate limits"
    },
    {
      "parameters": {
        "operation": "append",
        "documentId": "YOUR_GOOGLE_SHEET_ID",
        "sheetName": "Review Queue",
        "columns": {
          "mappingMode": "defineBelow",
          "value": {
            "Student Name": "={{$node['Build Prompt'].json.student_name}}",
            "Student ID": "={{$node['Build Prompt'].json.student_id}}",
            "Generated Report": "={{$json.message.content}}",
            "Status": "Pending Review",
            "Generated At": "={{new Date().toISOString()}}",
            "Teacher Edits": "",
            "Approved By": ""
          }
        }
      },
      "name": "Write to Review Queue",
      "type": "n8n-nodes-base.googleSheets",
      "position": [2000, 300]
    }
  ],
  "connections": {
    "Schedule Trigger": {"main": [[{"node": "Get SIS Auth Token", "type": "main", "index": 0}]]},
    "Get SIS Auth Token": {"main": [[{"node": "Fetch Student Roster", "type": "main", "index": 0}]]},
    "Fetch Student Roster": {"main": [[{"node": "Split Students", "type": "main", "index": 0}]]},
    "Split Students": {"main": [[{"node": "Fetch Student Grades", "type": "main", "index": 0}]]},
    "Fetch Student Grades": {"main": [[{"node": "Build Prompt", "type": "main", "index": 0}]]},
    "Build Prompt": {"main": [[{"node": "Generate Report (OpenAI)", "type": "main", "index": 0}]]},
    "Generate Report (OpenAI)": {"main": [[{"node": "Rate Limiter", "type": "main", "index": 0}]]},
    "Rate Limiter": {"main": [[{"node": "Write to Review Queue", "type": "main", "index": 0}]]}
  }
}

Environment Variables to Configure in n8n

PS_CLIENT_ID=your_powerschool_client_id
PS_CLIENT_SECRET=your_powerschool_client_secret
OPENAI_API_KEY=sk-your-api-key
CURRENT_TERM_NAME=Q3 2025
SCHOOL_NAME=Lincoln Elementary School

Notes

• Replace YOUR_GOOGLE_SHEET_ID with the actual Google Sheet ID created in Step 7
• The workflow uses PowerSchool API endpoints — adapt URL patterns for Infinite Campus, Skyward, or Aeries
• The Split Students node processes students sequentially with the Rate Limiter ensuring 500ms between API calls
• retryOnFail on the OpenAI node handles transient API errors with 3 retries and 5-second backoff
• For schools with 500+ students, consider splitting into batches of 50-100 to avoid long-running executions

Approved Report Delivery Workflow

Type: workflow A secondary n8n workflow that monitors the Google Sheets review queue for teacher-approved reports, then delivers them to parents via the configured communication channel (email, ParentSquare, or SIS portal). Runs on a polling schedule to detect newly approved reports.

Implementation:

Workflow Logic

n8n Workflow Configuration

# import this into your n8n instance. Replace YOUR_GOOGLE_SHEET_ID and
# schooldomain.org with your actual values.

{
  "name": "Approved Report Delivery",
  "nodes": [
    {
      "name": "Poll Every 30 Min",
      "type": "n8n-nodes-base.scheduleTrigger",
      "parameters": {"rule": {"interval": [{"field": "minutes", "minutesInterval": 30}]}}
    },
    {
      "name": "Read Approved Reports",
      "type": "n8n-nodes-base.googleSheets",
      "parameters": {
        "operation": "read",
        "documentId": "YOUR_GOOGLE_SHEET_ID",
        "sheetName": "Review Queue",
        "filters": {"column": "Status", "value": "Approved"}
      }
    },
    {
      "name": "Filter Undelivered",
      "type": "n8n-nodes-base.filter",
      "parameters": {"conditions": {"string": [{"value1": "={{$json.Delivered}}", "value2": ""}]}}
    },
    {
      "name": "Fetch Parent Email",
      "type": "n8n-nodes-base.httpRequest",
      "parameters": {
        "url": "=https://powerschool.schooldomain.org/ws/v1/student/{{$json['Student ID']}}/contact"
      }
    },
    {
      "name": "Send Email",
      "type": "n8n-nodes-base.emailSend",
      "parameters": {
        "fromEmail": "reports@schooldomain.org",
        "toEmail": "={{$json.parent_email}}",
        "subject": "={{$json['Student Name']}} - Progress Report",
        "html": "=<div style='font-family: Arial, sans-serif; max-width: 600px; margin: 0 auto;'><h2 style='color: #2c5282;'>Progress Report</h2><p>Dear Parent/Guardian of {{$json['Student Name']}},</p><div style='background: #f7fafc; padding: 16px; border-radius: 8px; margin: 16px 0;'>{{($json['Teacher Edits'] || $json['Generated Report']).replace(/\n/g, '<br>')}}</div><p style='font-size: 12px; color: #718096;'>This report was drafted with AI assistance and reviewed by your child's teacher. Please contact the school with any questions.</p></div>"
      }
    },
    {
      "name": "Mark Delivered",
      "type": "n8n-nodes-base.googleSheets",
      "parameters": {
        "operation": "update",
        "documentId": "YOUR_GOOGLE_SHEET_ID",
        "sheetName": "Review Queue",
        "columns": {"value": {"Delivered": "Yes", "Delivered At": "={{new Date().toISOString()}}"}}
      }
    }
  ]
}

Email HTML Template

Store as a file at /opt/n8n/templates/report_email.html and reference in the workflow. Include school logo, responsive design for mobile, and footer with AI disclosure and contact info.

Data Minimization Filter

Type: integration A code node within the n8n pipeline that strips unnecessary Personally Identifiable Information (PII) before sending data to the OpenAI API. This ensures FERPA compliance by transmitting only the minimum data required for report generation — no SSNs, full addresses, parent names, medical records, IEP details, or disciplinary records.

Implementation:

// Data Minimization Filter
// Purpose: Strip all unnecessary PII before data reaches the LLM API
// FERPA Compliance: Only send minimum necessary data for report generation

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

// ALLOWED fields (whitelist approach — everything else is dropped)
const sanitizedStudent = {
  // Identification: first name only, no last name sent to API
  first_name: rawStudent.first_name || rawStudent.name?.first || 'Student',
  
  // Academic context (no PII)
  grade_level: rawStudent.grade_level,
  
  // Grades (core data for report generation)
  grades: (rawStudent.grades || []).map(g => ({
    course_name: g.course_name || g.subject,
    letter_grade: g.letter_grade || g.grade,
    percent: g.percent || g.percentage,
    comment: g.comment || g.teacher_notes || '',
    recent_assessment_name: g.recent_assessment || '',
    recent_assessment_score: g.recent_score || ''
  })),
  
  // Attendance (aggregated numbers only, no dates)
  days_present: rawStudent.attendance?.days_present || rawStudent.days_present,
  days_absent: rawStudent.attendance?.days_absent || rawStudent.days_absent,
  tardies: rawStudent.attendance?.tardies || rawStudent.tardies,
  
  // Pass through the student ID for internal tracking (NOT sent to API)
  _internal_student_id: rawStudent.id || rawStudent.student_id,
  _internal_student_full_name: `${rawStudent.first_name} ${rawStudent.last_name}`
};

// BLOCKED fields — log if they were present (for audit trail)
const blockedFields = [
  'last_name', 'ssn', 'social_security', 'address', 'street',
  'city', 'zip', 'phone', 'email', 'parent_name', 'guardian',
  'iep', 'special_education', 'medical', 'health', 'disability',
  'discipline', 'suspension', 'expulsion', 'counselor_notes',
  'ethnicity', 'race', 'gender', 'dob', 'date_of_birth',
  'free_lunch', 'reduced_lunch', 'ell', 'language'
];

const detectedBlocked = blockedFields.filter(f => 
  rawStudent[f] !== undefined && rawStudent[f] !== null
);

if (detectedBlocked.length > 0) {
  console.log(`[DATA MINIMIZATION] Stripped ${detectedBlocked.length} PII fields: ${detectedBlocked.join(', ')}`);
}

return [{ json: sanitizedStudent }];

Audit Log

Add a second output from this node that writes to a separate 'PII Audit Log' Google Sheet. This log demonstrates compliance during audits without containing any actual PII.

• Timestamp
• Student ID (internal)
• Number of fields stripped
• Field names stripped

Report Quality Scoring Agent

Type: agent An AI-powered quality assurance agent that evaluates each generated progress report against a rubric before it enters the teacher review queue. It scores reports on factual consistency (does the report match the input data?), tone appropriateness, actionability, and completeness. Reports scoring below threshold are automatically regenerated with adjusted parameters.

Implementation

Implementation: Second OpenAI API Call in the n8n Pipeline

Quality Scoring Prompt

{
  "model": "gpt-4.1-mini",
  "messages": [
    {
      "role": "system",
      "content": "You are a quality assurance reviewer for AI-generated student progress reports. Score the following report on these criteria (1-5 each):\n\n1. FACTUAL_ACCURACY: Does the report accurately reflect the provided data? Are grades, subjects, and attendance numbers correct? (5 = perfect accuracy, 1 = contains fabricated info)\n2. TONE: Is the tone warm, professional, and growth-oriented? (5 = perfect, 1 = harsh/robotic/inappropriate)\n3. ACTIONABILITY: Does it include specific, practical suggestions? (5 = concrete next steps, 1 = vague platitudes)\n4. COMPLETENESS: Does it cover all subjects and key data points? (5 = comprehensive, 1 = missing major areas)\n5. PARENT_READABILITY: Would a non-educator parent easily understand this? (5 = very clear, 1 = jargon-heavy)\n\nRespond ONLY with valid JSON in this exact format:\n{\"factual_accuracy\": N, \"tone\": N, \"actionability\": N, \"completeness\": N, \"parent_readability\": N, \"total\": N, \"pass\": true/false, \"issues\": \"brief description of any issues\"}\n\nA report PASSES if total >= 18 (out of 25). Otherwise it FAILS."
    },
    {
      "role": "user",
      "content": "STUDENT DATA PROVIDED TO GENERATOR:\n{{input_data}}\n\nGENERATED REPORT:\n{{generated_report}}\n\nScore this report."
    }
  ],
  "temperature": 0.1,
  "max_tokens": 256,
  "response_format": {"type": "json_object"}
}

n8n Code Node for Quality Gate Logic

// Parse QA scores
const qaResult = JSON.parse($json.message.content);
const report = $node['Generate Report (OpenAI)'].json.message.content;
const studentData = $node['Build Prompt'].json;

if (qaResult.pass === true) {
  // Report passes quality check — send to review queue
  return [{
    json: {
      ...studentData,
      generated_report: report,
      qa_score: qaResult.total,
      qa_details: qaResult,
      status: 'Pending Review'
    }
  }];
} else {
  // Report fails — log and regenerate with higher temperature
  console.log(`[QA FAIL] Student ${studentData.student_name}: Score ${qaResult.total}/25. Issues: ${qaResult.issues}`);
  
  // Add to regeneration queue (max 2 retries)
  const retryCount = (studentData._retry_count || 0) + 1;
  if (retryCount <= 2) {
    return [{
      json: {
        ...studentData,
        _retry_count: retryCount,
        _qa_feedback: qaResult.issues,
        _regenerate: true
      }
    }];
  } else {
    // After 2 retries, send to teacher with QA warning
    return [{
      json: {
        ...studentData,
        generated_report: report,
        qa_score: qaResult.total,
        qa_warning: `AUTO-QA WARNING: This report scored ${qaResult.total}/25 after 3 attempts. Issues: ${qaResult.issues}. Please review carefully and edit as needed.`,
        status: 'Needs Attention'
      }
    }];
  }
}

Cost Impact

Adds ~$0.001 per report for the QA scoring call. For 500 students: ~$0.50 per reporting cycle. Negligible cost for significant quality improvement.

FERPA Compliance Documentation Generator

Type: prompt A prompt template and process for generating the required FERPA compliance documentation: Legitimate Educational Interest memo, Vendor Assessment Checklist, and Data Privacy Impact Assessment. The MSP runs this once during setup and updates annually.

Implementation

Legitimate Educational Interest Memo Template

[SCHOOL/DISTRICT LETTERHEAD] MEMORANDUM TO: [Superintendent / Data Privacy Officer] FROM: [MSP Company Name], Technology Services Provider DATE: [Date] RE: Legitimate Educational Interest Determination — AI Progress Report Generation System

1. PURPOSE

This memo documents the legitimate educational interest for deploying an AI-assisted progress report and parent communication generation system under FERPA's school official exception (34 CFR § 99.31(a)(1)).

2. VENDORS AND DATA PROCESSORS

3. LEGITIMATE EDUCATIONAL INTEREST

The AI progress report system serves a legitimate educational interest by:

4. DATA MINIMIZATION MEASURES

• Student last names are NOT transmitted to LLM APIs
• Only academic data (grades, attendance counts) is processed
• No IEP, medical, disciplinary, or demographic data is included
• A technical data minimization filter strips PII fields before API transmission
• OpenAI zero-data-retention is enabled (data is not stored or used for training)

5. SECURITY MEASURES

• API keys stored in encrypted secrets management
• All data transmitted via TLS 1.2+
• n8n server access restricted to MSP administrators
• Teacher review queue requires SSO authentication
• Audit logging of all data access and generation events

6. ANNUAL REVIEW

This determination will be reviewed annually by [Date] or whenever a vendor change occurs. Approved: _________________________ Date: _________ [Superintendent / DPO Name]

Vendor DPA Checklist

Use this checklist for each vendor:

Testing & Validation

Client Handoff

Client Handoff Checklist

Training Delivered (minimum 2-hour session with all teaching staff)

Documentation Left Behind

Success Criteria Review (with client sponsor)

Maintenance

Ongoing MSP Maintenance Responsibilities

Weekly (15 minutes)

• Check n8n server health: verify uptime monitor (UptimeRobot) shows no downtime incidents
• Review n8n execution logs for failed workflows; investigate and resolve any errors
• Monitor OpenAI API usage dashboard for unexpected spikes

Monthly (1-2 hours)

• Generate and deliver usage report to client: reports generated, teacher adoption rate, API costs, approval rate
• Review and rotate API keys if security policy requires it
• Apply n8n Docker image updates: docker-compose pull && docker-compose up -d
• Check for MagicSchool AI platform updates or new features; notify teachers of relevant additions
• Review PII audit log for any anomalies

Quarterly (4-8 hours, aligned with reporting cycles)

• Prompt template review and calibration session with 2-3 teachers: refine prompts based on previous cycle's feedback
• Update prompt templates if grading scales, standards, or school branding change
• Review and update DPAs if vendor terms have changed
• Conduct mini-compliance audit: verify zero-data-retention is still enabled, DPAs are current, documentation is complete
• Capacity planning: review if student count has changed significantly and adjust API budget limits
• Teacher satisfaction survey (5 questions, Google Form)

Annually (8-16 hours)

• Full compliance review: update Legitimate Educational Interest memo, re-verify all vendor DPAs, refresh vendor assessment checklists
• Evaluate new AI models: test newer OpenAI/Anthropic/Google models for quality and cost improvements
• Review and update training materials for new teachers
• Conduct annual teacher training refresher (1-hour session)
• Strategic review with client sponsor: ROI assessment, expansion opportunities (more communication types, more automation)
• Renew software licenses: MagicSchool AI Enterprise, Microsoft 365 Copilot add-ons, ParentSquare

SLA Considerations

• Response Time: 4-hour response for critical issues (pipeline down during reporting period), 24-hour for non-critical
• Reporting Period Support: MSP provides priority support during the 2-week window around quarterly reporting deadlines
• Uptime Target: 99.5% for n8n server; note that cloud API uptime (OpenAI, MagicSchool) is outside MSP's direct control but should be monitored
• Escalation Path: L1 (MSP helpdesk) → L2 (Integration engineer) → L3 (Vendor support for API issues)

Model/Prompt Retraining Triggers

• School changes grading scale or reporting format
• State standards or curriculum are updated
• Teacher feedback indicates systematic tone or quality issues
• OpenAI deprecates the current model version (typically 6-12 months notice)
• Parent feedback indicates communications are confusing or inappropriate
• New school year starts (update term names, teacher assignments, grade level mappings)

Alternatives

Turnkey SaaS Only (MagicSchool AI + Khanmigo, No Custom Pipeline)

Deploy only MagicSchool AI and Khanmigo accounts to teachers with SSO integration. Teachers manually enter student data into the web UI and generate reports one at a time. No SIS API integration, no n8n automation, no batch processing. This is the simplest possible implementation.

Microsoft 365 Copilot for Education Approach

For schools deeply invested in the Microsoft ecosystem (M365 A3/A5), deploy Copilot for Education as the primary AI tool. Teachers use Copilot in Word to draft progress reports from templates and Copilot in Outlook to compose parent emails. Admin staff use Copilot in Excel to analyze grade data. No custom pipeline or SIS integration — relies entirely on Microsoft's built-in AI.

Self-Hosted LLM with Ollama (Maximum Privacy)

Deploy a local LLM (Llama 3.1 8B or Mistral 7B) on an on-premises Dell PowerEdge server with Ollama. All data processing occurs entirely within the school's network — zero student data leaves the building. The n8n workflow connects to the local Ollama API endpoint instead of OpenAI's cloud API.

PowerSchool PowerBuddy Integration

For schools using PowerSchool as their SIS, leverage PowerSchool's native PowerBuddy AI assistant which is built directly into the SIS. PowerBuddy for Engagement provides parent-facing AI communications. This approach avoids third-party integrations entirely — the AI is embedded in the system that already holds all student data.

Google Gemini + Workspace for Education

For schools in the Google ecosystem, use Gemini AI integrated into Google Workspace for Education. Teachers use Gemini in Google Docs to draft reports and in Gmail to compose parent emails. Leverage Gemini's LTI integration with Canvas/Schoology for pulling LMS data. Use the Gemini API (2.0 Flash at $0.10/million input tokens) for batch processing via n8n.