Email pour l'EdTech : Modèles de communication avec les étudiants

Les plateformes éducatives ont des besoins email spécifiques : multiples parties prenantes, contenu adapté à l’âge et conformité aux réglementations sur la confidentialité des élèves. Voici comment concevoir des systèmes d’email EdTech efficaces.

Le paysage des emails en EdTech

Les plateformes EdTech communiquent avec :

• —Étudiants (différents groupes d’âge)
• —Parents/tuteurs (pour les mineurs)
• —Enseignants et professeurs
• —Administrateurs

Chaque public nécessite un contenu, un ton et un timing d’envoi différents.

Modèles de notifications aux étudiants

Rappels de devoirs

interface AssignmentReminder {
  student: {
    name: string;
    email: string;
    gradeLevel: number;
  };
  assignment: {
    title: string;
    course: string;
    dueDate: Date;
    estimatedTime: string;
  };
}

// Age-appropriate messaging
function getAssignmentTemplate(gradeLevel: number): string {
  if (gradeLevel <= 5) {
    return 'assignment-reminder-elementary';
  } else if (gradeLevel <= 8) {
    return 'assignment-reminder-middle';
  }
  return 'assignment-reminder-high';
}


### Grade and feedback notifications

```typescript
interface GradeNotification {
  student: Student;
  assignment: {
    title: string;
    course: string;
    grade: string;
    points: number;
    maxPoints: number;
    feedback?: string;
  };
  instructor: {
    name: string;
  };
}

await sendEmail({
  to: student.email,
  subject: `Grade posted: ${assignment.title}`,
  template: 'grade-posted',
  data: {
    student,
    assignment,
    viewUrl: `${baseUrl}/assignments/${assignment.id}`
  }
});

Communications aux parents/tuteurs

Rapports de progression

interface ParentProgressReport {
  parent: {
    name: string;
    email: string;
  };
  student: {
    name: string;
    gradeLevel: number;
  };
  period: string;
  courses: Array<{
    name: string;
    grade: string;
    attendance: string;
    teacherNotes?: string;
  }>;
}

// Weekly parent digest
async function sendParentWeeklyDigest(parent: Parent, student: Student) {
  const weekData = await getStudentWeekSummary(student.id);
  
  await sendEmail({
    to: parent.email,
    subject: `${student.firstName}'s weekly progress`,
    template: 'parent-weekly-digest',
    data: {
      parent,
      student,
      assignments: weekData.completedAssignments,
      upcoming: weekData.upcomingDeadlines,
      grades: weekData.recentGrades,
      attendance: weekData.attendanceSummary
    }
  });
}

Demandes de consentement et d'autorisation

// Field trip permission
await sendEmail({
  to: parent.email,
  subject: `Permission needed: ${event.name}`,
  template: 'permission-request',
  data: {
    student: student.name,
    event: {
      name: event.name,
      date: event.date,
      location: event.location,
      description: event.description
    },
    deadline: event.permissionDeadline,
    approveUrl: `${baseUrl}/permissions/${permission.id}/approve`,
    denyUrl: `${baseUrl}/permissions/${permission.id}/deny`
  }
});

Notifications pour les enseignants

Alertes sur l'activité de la classe

interface InstructorAlert {
  instructor: Instructor;
  alert: {
    type: 'submission' | 'question' | 'absence' | 'grade_dispute';
    student: string;
    course: string;
    details: string;
  };
}

// Batch submissions notification
async function notifyNewSubmissions(instructor: Instructor) {
  const submissions = await getPendingSubmissions(instructor.id, {
    since: subHours(new Date(), 24)
  });
  
  if (submissions.length === 0) return;
  
  await sendEmail({
    to: instructor.email,
    subject: `${submissions.length} new submissions to grade`,
    template: 'submissions-digest',
    data: {
      instructor,
      submissions: groupBy(submissions, 'course'),
      gradingUrl: `${baseUrl}/grading`
    }
  });
}

Conformité COPPA et FERPA

Communications selon l'âge

async function sendStudentEmail(student: Student, email: EmailData) {
  // Check if student is a minor
  if (student.age < 13) {
    // COPPA: Send to parent instead
    const parent = await getParentContact(student.id);
    if (!parent) {
      throw new Error('No parent contact for minor student');
    }
    
    await sendEmail({
      to: parent.email,
      subject: `For ${student.firstName}: ${email.subject}`,
      template: 'parent-forwarded',
      data: {
        parent,
        student,
        originalEmail: email
      }
    });
  } else if (student.age < 18) {
    // Minor but can receive email
    // CC parent if preference set
    const ccParent = await shouldCCParent(student.id);
    
    await sendEmail({
      to: student.email,
      cc: ccParent ? await getParentEmail(student.id) : undefined,
      ...email
    });
  } else {
    // Adult student
    await sendEmail({
      to: student.email,
      ...email
    });
  }
}

Minimisation des données

// Only include necessary student data
interface SafeStudentData {
  firstName: string;  // No last name in emails
  courseId: string;   // Reference, not full details
  // Never include: full name, student ID, grades in subject lines
}

Emails du cycle de vie du cours

Confirmation d'inscription

await sendEmail({
  to: student.email,
  subject: `Enrolled: ${course.name}`,
  template: 'enrollment-confirmation',
  data: {
    student,
    course: {
      name: course.name,
      instructor: course.instructor.name,
      startDate: course.startDate,
      schedule: course.schedule
    },
    nextSteps: [
      'Access your course materials',
      'Introduce yourself in the discussion forum',
      'Review the syllabus'
    ],
    courseUrl: `${baseUrl}/courses/${course.id}`
  }
});

Achèvement du cours

await sendEmail({
  to: student.email,
  subject: `Congratulations! You completed ${course.name}`,
  template: 'course-completion',
  data: {
    student,
    course,
    finalGrade: enrollment.finalGrade,
    certificate: enrollment.certificateUrl,
    nextCourses: await getRecommendedCourses(student.id, course.id)
  }
});

Préférences de notification

interface EdTechNotificationPrefs {
  // Student preferences
  assignmentReminders: boolean;
  gradeNotifications: boolean;
  courseAnnouncements: boolean;
  discussionReplies: boolean;
  
  // Parent preferences
  weeklyDigest: boolean;
  gradeAlerts: boolean;
  attendanceAlerts: boolean;
  
  // Timing
  reminderTiming: '1day' | '3days' | '1week';
  digestDay: 'friday' | 'sunday';
}

Bonnes pratiques

1. —Contenu adapté à l'âge - Ajuster le ton et la complexité selon le niveau scolaire
2. —Confidentialité avant tout - Ne jamais inclure de données sensibles dans les lignes d’objet
3. —Visibilité des parents - Tenir les tuteurs informés pour les mineurs
4. —Rappels orientés action - Inclure des liens directs vers les devoirs
5. —Célébrer la progression - Le renforcement positif stimule l’engagement
6. —Respecter les horaires - Éviter l’envoi pendant les heures de cours ou tard dans la nuit

Les emails en EdTech doivent accompagner le parcours d’apprentissage tout en respectant la confidentialité des élèves et les exigences d’implication des parents.