EdTech Student Verification: How Coursera Reduced Fake Accounts by 89%

// Educational Platform Phone Verification System
class EducationalVerificationService {
  constructor() {
    this.phoneCheckClient = new PhoneCheckClient({
      apiKey: process.env.PHONE_CHECK_API_KEY,
      baseURL: 'https://api.phone-check.app'
    });
    this.riskEngine = new EducationalRiskEngine();
    this.lmsIntegration = new LMSIntegrationService();
  }

  async verifyStudentRegistration(userData, courseData) {
    try {
      // Primary phone verification
      const phoneValidation = await this.phoneCheckClient.validatePhone(userData.phone);

      if (!phoneValidation.valid) {
        return {
          allowed: false,
          reason: 'Invalid phone number provided',
          riskLevel: 'HIGH'
        };
      }

      // Educational risk assessment
      const riskScore = await this.calculateEducationalRiskScore(
        userData,
        phoneValidation,
        courseData
      );

      // Determine verification requirements
      const verificationLevel = this.determineVerificationLevel(riskScore, courseData);

      // Apply appropriate verification measures
      return await this.applyVerificationMeasures(
        userData,
        phoneValidation,
        verificationLevel
      );

    } catch (error) {
      console.error('Student verification error:', error);
      return {
        allowed: false,
        reason: 'Verification service temporarily unavailable',
        requiresManualReview: true
      };
    }
  }

  async calculateEducationalRiskScore(userData, phoneData, courseData) {
    let riskScore = 0;
    let riskFactors = [];
    let qualitySignals = [];

    // Phone type assessment (30 points)
    if (phoneData.type === 'VOIP') {
      riskScore += 25;
      riskFactors.push('voip_high_risk');
    } else if (phoneData.type === 'MOBILE') {
      riskScore += 5;
      qualitySignals.push('legitimate_mobile');
    } else if (phoneData.type === 'FIXED_LINE') {
      riskScore += 2;
      qualitySignals.push('verified_landline');
    }

    // Carrier reputation analysis (25 points)
    const educationalCarriers = [
      'verizon', 'at&t', 't-mobile', 'sprint',
      'vodafone', 'orange', 'deutsche telekom'
    ];

    if (phoneData.carrier &&
        educationalCarriers.some(carrier =>
          phoneData.carrier.toLowerCase().includes(carrier.toLowerCase()))) {
      riskScore -= 10;
      qualitySignals.push('established_carrier');
    }

    // Disposable number detection (automatic rejection)
    if (phoneData.isDisposable) {
      riskScore += 50;
      riskFactors.push('disposable_number_automatic_reject');
    }

    // Geographic legitimacy check (20 points)
    const userCountry = userData.location?.country;
    const phoneCountry = phoneData.country;

    if (userCountry && phoneCountry !== userCountry) {
      riskScore += 15;
      riskFactors.push('country_mismatch_suspicious');
    }

    // Course-specific risk factors (15 points)
    if (courseData.value === 'HIGH' || courseData.certificateValue > 1000) {
      riskScore += 10;
      // High-value courses require stricter verification
    }

    // Behavioral pattern analysis (10 points)
    if (userData.registrationSource === 'organic') {
      riskScore -= 5;
      qualitySignals.push('organic_registration');
    }

    // Email domain verification
    const educationalDomains = ['.edu', '.ac.', '.school'];
    if (userData.email &&
        educationalDomains.some(domain => userData.email.includes(domain))) {
      riskScore -= 8;
      qualitySignals.push('educational_email_domain');
    }

    return {
      score: Math.max(0, Math.min(100, riskScore)),
      riskFactors,
      qualitySignals,
      phoneIntelligence: {
        valid: phoneData.valid,
        type: phoneData.type,
        carrier: phoneData.carrier,
        country: phoneData.country,
        isDisposable: phoneData.isDisposable
      }
    };
  }

  determineVerificationLevel(riskScore, courseData) {
    if (riskScore >= 70) {
      return 'REJECTED';
    } else if (riskScore >= 50) {
      return 'ENHANCED_VERIFICATION';
    } else if (riskScore >= 30 || courseData.value === 'HIGH') {
      return 'STANDARD_VERIFICATION';
    } else {
      return 'BASIC_VERIFICATION';
    }
  }

  async applyVerificationMeasures(userData, phoneData, verificationLevel) {
    switch (verificationLevel) {
      case 'REJECTED':
        return {
          allowed: false,
          reason: 'High-risk profile detected',
          requiresManualReview: true
        };

      case 'ENHANCED_VERIFICATION':
        // Require additional verification steps
        const enhancedResult = await this.performEnhancedVerification(userData, phoneData);
        return enhancedResult;

      case 'STANDARD_VERIFICATION':
        // Standard phone verification complete
        return {
          allowed: true,
          verificationLevel: 'STANDARD',
          phoneVerified: true,
          restrictions: ['certificate_verification_required']
        };

      case 'BASIC_VERIFICATION':
        // Basic verification sufficient
        return {
          allowed: true,
          verificationLevel: 'BASIC',
          phoneVerified: true,
          restrictions: []
        };

      default:
        return {
          allowed: false,
          reason: 'Unable to determine verification level',
          requiresManualReview: true
        };
    }
  }

  async performEnhancedVerification(userData, phoneData) {
    // Implement additional verification measures for high-risk cases
    const additionalChecks = [
      this.verifyEducationalInstitution(userData),
      this.validateStudentID(userData),
      this.performBehavioralAnalysis(userData)
    ];

    const results = await Promise.allSettled(additionalChecks);
    const passedChecks = results.filter(result => result.status === 'fulfilled').length;

    if (passedChecks >= 2) {
      return {
        allowed: true,
        verificationLevel: 'ENHANCED',
        phoneVerified: true,
        additionalVerification: true,
        restrictions: ['ongoing_monitoring', 'certificate_verification_required']
      };
    } else {
      return {
        allowed: false,
        reason: 'Enhanced verification requirements not met',
        requiresManualReview: true
      };
    }
  }

  async verifyCertificateEligibility(userId, courseId) {
    // Final verification before certificate issuance
    const user = await this.getUserData(userId);
    const course = await this.getCourseData(courseId);

    // Re-verify phone number
    const phoneRevalidation = await this.phoneCheckClient.validatePhone(user.phone);

    if (!phoneRevalidation.valid || phoneRevalidation.isDisposable) {
      return {
        eligible: false,
        reason: 'Phone number no longer valid or appears disposable'
      };
    }

    // Check for suspicious activity patterns
    const suspiciousActivity = await this.detectSuspiciousActivity(userId, courseId);

    if (suspiciousActivity.detected) {
      return {
        eligible: false,
        reason: 'Suspicious activity detected',
        requiresManualReview: true
      };
    }

    return {
      eligible: true,
      verificationTimestamp: new Date().toISOString(),
      phoneRevalidated: true
    };
  }
}

// Integration with Learning Management System
class LMSIntegrationService {
  constructor() {
    this.verificationService = new EducationalVerificationService();
  }

  async middleware(req, res, next) {
    // Intercept key LMS actions for verification
    const { action, userId, courseId } = req.body;

    switch (action) {
      case 'ENROLL_COURSE':
        const enrollmentVerification = await this.verificationService.verifyStudentRegistration(
          req.body.userData,
          req.body.courseData
        );

        if (!enrollmentVerification.allowed) {
          return res.status(403).json({
            error: 'Enrollment blocked',
            reason: enrollmentVerification.reason
          });
        }
        break;

      case 'REQUEST_CERTIFICATE':
        const certificateEligibility = await this.verificationService.verifyCertificateEligibility(
          userId,
          courseId
        );

        if (!certificateEligibility.eligible) {
          return res.status(403).json({
            error: 'Certificate issuance blocked',
            reason: certificateEligibility.reason
          });
        }
        break;

      case 'APPLY_FINANCIAL_AID':
        const aidVerification = await this.verificationService.verifyFinancialAidApplication(
          req.body.applicationData
        );

        if (!aidVerification.allowed) {
          return res.status(403).json({
            error: 'Financial aid application blocked',
            reason: aidVerification.reason
          });
        }
        break;
    }

    next();
  }
}

// Usage in registration flow
async function handleStudentRegistration(req, res) {
  const verificationService = new EducationalVerificationService();

  try {
    const verificationResult = await verificationService.verifyStudentRegistration(
      req.body.studentData,
      req.body.courseData
    );

    if (verificationResult.allowed) {
      // Create student account with verified status
      const student = await createStudentAccount({
        ...req.body.studentData,
        phoneVerified: true,
        verificationLevel: verificationResult.verificationLevel,
        restrictions: verificationResult.restrictions
      });

      res.status(201).json({
        success: true,
        studentId: student.id,
        verificationLevel: verificationResult.verificationLevel
      });
    } else {
      res.status(403).json({
        success: false,
        error: verificationResult.reason,
        requiresManualReview: verificationResult.requiresManualReview
      });
    }
  } catch (error) {
    console.error('Registration verification error:', error);
    res.status(500).json({
      success: false,
      error: 'Verification service temporarily unavailable'
    });
  }
}