Momentum LMS - Technical Roadmap & Feature Prioritization

Document Version: 2.5 Last Updated: 2025-12-11 Status: Active Development - MVP Phase (~85% Complete)

Executive Summary

This document provides a comprehensive technical roadmap for Momentum LMS, analyzing the current implementation state, identifying gaps between requested and delivered features, and prioritizing future development based on business value and technical dependencies.

Key Findings (Updated 2025-12-11)

  • Foundation Complete: Infrastructure, database, authentication, and UI framework are production-ready ✅
  • Core Features Implemented: Admin CRUD, progress tracking, course browsing, enrollment flow ✅
  • Advanced Features Delivered: AI generation, badges/achievements, analytics, recommendations ✅
  • Progress Auto-Completion: Course auto-completes when learner finishes last lesson ✅
  • JWT Auth Enhancement: Authorization header JWT parsing enabled for lesson operations ✅
  • Payment Integration: Mocked implementation complete, ready for real Stripe integration 🚧
  • Gamification System: Full badge and achievement system with user statistics implemented (15 badges) ✅
  • Analytics Dashboard: Admin analytics with platform metrics and charts (Recharts) implemented ✅
  • AI Content Generation: Step Functions workflow with Bedrock integration and job tracking implemented ✅
  • Video Script Generation: Intro and lesson video scripts support added ✅
  • PDF Reference Documents: Support for PDF reference materials in AI generation ✅
  • Cross-Region Bedrock: Architecture decision for cross-region Bedrock access documented ✅
  • Docs Subdomain: CloudFront proxy configured for docs subdomain ✅
  • Recommendations Engine: User-based course recommendations with category similarity implemented ✅
  • Rich Content Editing: React Quill integration for course/lesson content editing ✅
  • Comprehensive Admin Panel: 8 settings sections with full user management CRUD ✅
  • Remaining MVP Tasks: Stripe integration, SES email notifications, advanced search (OpenSearch)
  • Current Status: ~85% MVP complete, several Phase 2/3 features delivered early
  • Frontend Pages: 26 pages implemented across admin, courses, auth, dashboard, profile
  • Backend Functions: 12 Lambda function directories fully implemented (including categories)
  • Database Migrations: 13 migrations (schema, seed data, badges, AI generation, analytics, demographics, PDF references, video scripts, video status)

Table of Contents

  1. Current State Assessment
  2. Gap Analysis
  3. Strategic Feature Prioritization
  4. Technical Architecture Alignment
  5. Risk Assessment
  6. Success Metrics
  7. Budget Projections

Current State Assessment

✅ Completed Features

1. Foundation Layer (100% Complete)

Infrastructure (infrastructure/terraform/)

  • AWS infrastructure fully provisioned via Terraform
  • S3 bucket for static website hosting with security policies
  • CloudFront distribution with custom domain (momentum.cloudnnj.com)
  • SSL certificate via AWS Certificate Manager
  • Route 53 DNS configuration
  • VPC with public/private subnets across 2 AZs
  • RDS Aurora PostgreSQL (Serverless v2) in private subnet
  • ElastiCache Redis (Serverless) for caching
  • API Gateway REST API with Lambda integrations
  • GitHub Actions CI/CD pipeline for automated deployments

Database Schema (backend/migrations/001_initial_schema.sql)

  • Users table (synchronized with Cognito)
  • Categories table with seed data (6 categories)
  • Courses table with status tracking (DRAFT, PUBLISHED, ARCHIVED)
  • Lessons table with JSON fields for action items and resources
  • Enrollments table with Stripe integration fields
  • Progress table for lesson completion tracking
  • Payments table for Stripe transaction records
  • Full-text search indexes on courses
  • Proper foreign key constraints and cascading deletes
  • Automatic timestamp triggers (updated_at)

Frontend (frontend/app/)

  • Modern, professional UI with consistent branding
  • Homepage with course discovery and hero section
  • Course catalog page with filtering
  • Individual course detail pages
  • Lesson detail pages with content rendering
  • User dashboard for enrolled courses
  • Admin panel dashboard (skeleton)
  • Responsive design (mobile, tablet, desktop)
  • TailwindCSS styling with custom theme
  • Loading and error states

2. Authentication & Authorization (100% Complete)

AWS Cognito Integration (infrastructure/terraform/cognito.tf)

  • User Pool with email/password authentication
  • User groups: admin, free (premium to be added)
  • MFA support (optional, configurable)
  • Password policies (min 8 chars, uppercase, lowercase, numbers, symbols)
  • Account recovery via email
  • Email verification for new accounts

Social Login (infrastructure/terraform/cognito.tf, PR #13)

  • Google OAuth provider integration
  • Facebook OAuth provider integration
  • Apple Sign In integration
  • Federated identity mapping to Cognito users
  • Attribute mapping (email, name) from providers
  • OAuth callback handling

Lambda Triggers (backend/functions/auth/)

  • Pre-signup: Email validation and custom logic
  • Post-confirmation: User record creation in database
  • Pre-authentication: Account status checks
  • Post-authentication: Login logging and analytics
  • Pre-token generation: Custom claims injection (role, user_id)

Frontend Auth (frontend/app/auth/)

  • Branded sign-in page matching application theme
  • Sign-up page with form validation
  • OAuth callback handler for social login
  • Session management with JWT tokens
  • Role-based routing (admin → admin panel, user → dashboard)
  • Protected route middleware

3. Course Enrollment & Payment (100% Mocked, Ready for Real Integration)

Enrollment Flow (frontend/app/courses/[id]/enrollment/, backend/functions/enrollments/)

  • “Enroll Now” button functional
  • Mocked Stripe Checkout integration (frontend)
  • Mocked Payment Service for testing
  • Enrollment creation via API working
  • Enrollment success page with confirmation
  • EnrollmentRepository with full CRUD operations

Status: ✅ Mock implementation complete, ready for real Stripe integration (estimated 2-3 days work)

4. Lesson Management & Progress Tracking (100% Complete)

Progress Tracking (frontend/app/courses/[id]/lessons/[lessonId]/, backend/functions/progress/)

  • Lesson detail pages fully functional
  • “Mark as Complete” button working
  • Progress persistence in database
  • ProgressRepository with time tracking
  • Progress bars and completion visualization
  • User dashboard showing active courses with progress

Admin Lesson Management (frontend/app/admin/lessons/, backend/functions/lessons/)

  • Full CRUD operations for lessons
  • Rich text editor for lesson content (React Quill)
  • Action items management
  • Lesson ordering within courses
  • Draft/published status

Status: ✅ 100% COMPLETE

5. Admin Panel & Content Management (100% Complete)

Admin Dashboard (frontend/app/admin/)

  • Main admin panel dashboard
  • Course management pages (list, create, edit, delete)
  • Lesson management pages (list, create, edit, delete)
  • Rich text editor for course descriptions and lesson content
  • Authorization enforcement (admin group required)
  • Professional UI matching application branding

Backend API (backend/functions/courses/, backend/functions/lessons/)

  • CourseRepository with full CRUD
  • LessonRepository with full CRUD
  • Proper authorization checks
  • Validation and error handling

Status: ✅ 100% COMPLETE

6. Testing Infrastructure (Comprehensive)

E2E Testing (tests/e2e/)

  • Playwright test suite with 13 test files
  • Auth flow testing (sign in, sign up, sign out)
  • Navigation and routing tests
  • Course browsing and filtering tests
  • Lesson viewing tests
  • Admin panel tests
  • Enrollment flow tests
  • Dashboard tests
  • CI/CD integration via GitHub Actions

Unit & Integration Tests

  • Jest configuration for frontend and backend
  • Repository pattern testing
  • Component testing with React Testing Library
  • Lambda function testing

Status: ✅ COMPREHENSIVE - 80%+ coverage target

7. Infrastructure & DevOps (100% Complete)

Terraform Configuration (infrastructure/terraform/)

  • VPC with public/private subnets (2 AZs)
  • RDS Aurora PostgreSQL Serverless v2
  • ElastiCache Redis Serverless
  • API Gateway with Lambda integration
  • CloudFront CDN
  • Route 53 DNS
  • S3 buckets with lifecycle policies
  • IAM roles and policies
  • Security groups and NACLs

CI/CD Pipeline

  • GitHub Actions workflows
  • Automated testing on PRs
  • Automated deployment to momentum.cloudnnj.com
  • Database migrations

Database Migrations (backend/migrations/)

  • Initial schema migration
  • Email verification field migration
  • Seed data with 6 categories and sample courses
  • Version controlled migration system

Status: ✅ 100% COMPLETE

8. Mock Data System (Development Support)

Mock Data (frontend/lib/mockData/)

  • Mock courses, lessons, and user data
  • Mock enrollment responses
  • Mock payment service
  • Enables local development without backend

Status: ✅ COMPLETE (useful for testing)

9. Gamification & Badges System (100% Complete)

Database Schema (backend/migrations/003_add_badges_and_achievements.sql)

  • Badges table with badge types and tiers (BRONZE, SILVER, GOLD, PLATINUM)
  • User badges table tracking earned badges and progress
  • User statistics table for points, streaks, and completions
  • 15 default badges seeded (course completion, streaks, speed, milestones)
  • Automatic triggers for user stats updates

Backend API (backend/functions/badges/)

  • Badge repository with CRUD operations
  • User badge awarding logic
  • Statistics tracking and updating
  • Progress percentage tracking for badges

Frontend (frontend/app/profile/, frontend/components/badges/)

  • Badge display components
  • User statistics dashboard
  • Progress tracking UI
  • Showcased badges on profiles

Status: ✅ 100% COMPLETE - Full gamification system implemented

10. Analytics Dashboard (100% Complete)

Database Schema (backend/migrations/005_add_analytics_tables.sql)

  • User activity log for tracking logins and sessions
  • Daily platform stats aggregation table
  • Course performance stats table
  • Automated data aggregation

Backend API (backend/functions/analytics/)

  • Platform statistics endpoint
  • Course performance metrics
  • User activity tracking
  • Daily aggregation logic

Frontend (frontend/app/admin/analytics/)

  • Admin analytics dashboard
  • Charts and visualizations (Chart.js)
  • Platform metrics display
  • User activity insights
  • Course performance tracking

Status: ✅ 100% COMPLETE - Comprehensive analytics implemented

11. AI Content Generation (100% Complete)

Infrastructure (infrastructure/terraform/ai-generation.tf)

  • AWS Step Functions workflow for orchestration
  • Amazon Bedrock integration (Claude models)
  • Lambda handlers for each generation step
  • S3 storage for generated content

Database Schema (backend/migrations/004_ai_generation.sql)

  • Course generation jobs table
  • Job status tracking and progress
  • Cost and quality metrics
  • AI-generated flags on courses and lessons

Backend API (backend/functions/ai-generation/)

  • Multi-step generation handlers:
    • validate-input
    • generate-outline
    • generate-lessons
    • save-course
    • error-handler
  • Job tracking and status updates
  • Bedrock API integration

Frontend (frontend/app/admin/ai-generation/)

  • AI course generation interface
  • Job monitoring dashboard
  • Input form for generation parameters
  • Status tracking and progress display

Status: ✅ 100% COMPLETE - Full AI generation workflow implemented

12. Course Recommendations (100% Complete)

Backend API (backend/functions/recommendations/)

  • User-based recommendation algorithm
  • Category similarity scoring
  • Enrollment history analysis
  • Personalized course suggestions

Frontend (frontend/components/recommendations/)

  • Recommended courses display
  • Integration with user dashboard
  • Category-based filtering

Status: ✅ 100% COMPLETE - Recommendation engine implemented

13. Comprehensive Admin Settings (100% Complete)

Admin Dashboard (frontend/app/admin/)

  • 8 comprehensive settings sections:
    1. General Settings
    2. User Management (CRUD)
    3. Course Management
    4. Analytics Dashboard
    5. AI Generation
    6. Badge Management
    7. System Settings
    8. Security Settings

User Management

  • Full CRUD operations for users
  • Role management (admin, premium, free)
  • User search and filtering
  • Account status management

Status: ✅ 100% COMPLETE - Full admin control panel implemented

❌ Remaining MVP Features

Feature Business Impact Technical Complexity Estimated Effort Priority Notes
Real Payment Integration HIGH - Revenue generation Medium 2-3 days P1 Mock complete, swap to Stripe needed
Email Notifications (SES) MEDIUM - User engagement Low 1-2 weeks P2 Infrastructure ready, templates needed
Advanced Search (OpenSearch) MEDIUM - Enhanced discovery Medium 2-3 weeks P3 PostgreSQL full-text sufficient for MVP
Video Generation LOW - Enhanced learning High 3-4 weeks P4 Text-only courses viable for MVP
Real-time Updates LOW - Enhanced UX Medium 1-2 weeks P4 REST polling works fine for MVP

Completed Since Last Update:

  • AI Content Generation (✅ COMPLETE - Step Functions + Bedrock)
  • Analytics Dashboard (✅ COMPLETE - Full admin analytics)
  • Gamification/Badges (✅ COMPLETE - 15 badges + user stats)
  • Recommendations (✅ COMPLETE - User-based algorithm)
  • User Management (✅ COMPLETE - Full CRUD for admins)
  • Admin Panel CRUD (✅ COMPLETE)
  • Progress Tracking Backend (✅ COMPLETE)

MVP Status: ~85% complete. Remaining tasks are payment integration, email notifications, and search enhancements.

Gap Analysis

Build Request Timeline vs. Current Implementation

Phase 1: UI/UX Design (Prompts 1-7) ✅ COMPLETE

  • Requested: Multiple design iterations, professional look and feel, consistent branding
  • Delivered: Clean, professional UI with warm color scheme, consistent across all pages
  • Status: COMPLETE

Phase 2: Infrastructure (Prompt 8) ✅ COMPLETE

  • Requested: AWS deployment, Terraform configuration, CI/CD pipeline
  • Delivered: Full infrastructure provisioned, automated deployments working
  • Status: COMPLETE

Phase 3: Database & API (Prompts 9-10) ✅ COMPLETE

  • Requested: Database setup, API Gateway, Lambda functions, schemas
  • Delivered: All tables created, API endpoints functional, repository pattern implemented
  • Status: COMPLETE

Phase 4: Authentication (Prompts 11-12) ✅ COMPLETE

  • Requested: Cognito integration, role-based access, admin panel, test credentials
  • Delivered: Authentication working, roles implemented, branded auth pages, credentials documented
  • Status: COMPLETE

Phase 5: Social Login (Prompt 13) ✅ COMPLETE

  • Requested: Google, Facebook, Apple social login
  • Delivered: All three providers configured and working
  • Status: COMPLETE

Phase 6: Course Enrollment (Prompt 14) ✅ COMPLETE

  • Requested: Enrollment flow with mocked Stripe integration
  • Delivered: Mock checkout page, mock payment service, enrollment API integration
  • Status: COMPLETE

Phase 7: Core Features (Not Yet Requested) ❌ MISSING

  • Admin Content Management: Backend exists, but Frontend UI is missing pages
  • Real Payment processing: Deferred by request
  • Progress tracking: Frontend mocked, Backend missing
  • AI generation: Not started (core feature from Claude.md)

🆕 NEW FEATURE PROPOSALS (December 2025)

Overview

With the MVP core features now 60-70% complete, we’re proposing 3 new user engagement features that can be built in parallel to enhance the platform before tackling the more complex AI content generation. These features focus on user retention and engagement.

Key Benefits:

  • ✅ Can be built completely independently (no code conflicts)
  • ✅ Each touches different files/components (minimal overlap)
  • ✅ Provides measurable user value and engagement
  • ✅ Can be developed in parallel by separate teams/agents
  • ✅ Estimated 3-4 days per feature (1 week total in parallel)

Feature Proposal 1: Learner Progress Analytics Dashboard

Priority: P1 (User Engagement) Estimated Effort: 3-4 days Business Value: Improve user retention through visibility and motivation

User Story: As a student, I want to see detailed analytics about my learning progress (completion rates, time spent, learning streaks, courses completed) so that I can track my improvement and stay motivated.

Scope:

  • New /dashboard/analytics page with personalized progress metrics
  • Completion rate visualization for enrolled courses
  • Time spent breakdown by course and lesson
  • Learning streak counter and historical data
  • Course completion timeline
  • Weekly/monthly learning activity charts
  • Backend endpoints to aggregate user progress statistics

Technical Implementation:

  • Frontend: /frontend/app/dashboard/analytics/page.tsx, progress chart components
  • Backend: /backend/functions/analytics/, UserProgressAnalyticsRepository
  • Database: Add indexes for analytics queries (no new tables required)
  • Dependencies: Existing progress and enrollment data

Files to Create/Modify:

  • Create: frontend/app/dashboard/analytics/page.tsx
  • Create: frontend/components/dashboard/ProgressChart.tsx
  • Create: backend/functions/analytics/src/index.ts
  • Create: backend/shared/repositories/UserProgressAnalyticsRepository.ts
  • Modify: frontend/components/layout/Header.tsx (add Analytics link)
  • Modify: infrastructure/terraform/lambda.tf (add analytics Lambda)

Success Criteria:

  • User can view personalized analytics dashboard
  • Dashboard displays 4+ distinct metrics
  • Page loads in < 2 seconds
  • No performance impact on existing pages

Feature Proposal 2: Course Completion Badges & Achievements

Priority: P1 (User Engagement) Estimated Effort: 3-4 days Business Value: Gamification increases completion rates and user retention

User Story: As a student, I want to earn badges and achievements when I complete courses and reach milestones so that I can feel accomplished and share my progress.

Scope:

  • Badge system with predefined badge types (Course Completed, First Course, 7-day Streak, etc.)
  • New badges and user_badges database tables
  • Badge display on user profile and dashboard
  • Automatic badge award on course completion
  • Badge share functionality (shareable image URL)
  • Admin panel to view badge statistics

Technical Implementation:

  • Frontend: /frontend/app/profile/page.tsx, badge components
  • Backend: /backend/functions/badges/, BadgeRepository, badge-engine logic
  • Database: New tables for badges and user_badges
  • Dependencies: Existing enrollment completion tracking

Files to Create/Modify:

  • Create: frontend/app/profile/page.tsx
  • Create: frontend/components/ui/Badge.tsx
  • Create: backend/functions/badges/src/index.ts
  • Create: backend/shared/repositories/BadgeRepository.ts
  • Create: backend/migrations/003_badges_tables.sql
  • Modify: frontend/components/layout/Header.tsx (add Profile link)
  • Modify: backend/functions/enrollments/src/index.ts (trigger badge award)

Success Criteria:

  • User sees badge earned upon course completion
  • Profile page displays all earned badges
  • No badges awarded incorrectly
  • Performance impact < 100ms on course completion

Feature Proposal 3: Smart Lesson Recommendations Engine

Priority: P1 (Course Discovery) Estimated Effort: 3-4 days Business Value: Improve course discovery and increase enrollments

User Story: As a student, I want to receive personalized course recommendations based on my learning history so that I can discover relevant courses to continue my learning journey.

Scope:

  • Rule-based recommendation algorithm (no ML required for MVP)
  • “Recommended for You” section on dashboard and courses page
  • Endpoint to get top 5-10 personalized recommendations
  • Recommendations cached per user (recomputed daily)
  • Admin panel to view recommendation metrics
  • Factors: completed courses, current enrollments, category preferences, completion rate

Technical Implementation:

  • Frontend: Recommendation widgets on dashboard and courses page
  • Backend: /backend/functions/recommendations/, recommendation-engine logic
  • Database: Recommendation cache table
  • Dependencies: Existing enrollment and course data

Files to Create/Modify:

  • Create: frontend/components/dashboard/RecommendedCourses.tsx
  • Create: backend/functions/recommendations/src/index.ts
  • Create: backend/shared/utils/recommendation-engine.ts
  • Create: backend/shared/repositories/RecommendationRepository.ts
  • Create: backend/migrations/003_recommendations_cache.sql
  • Modify: frontend/app/dashboard/page.tsx (add recommendation widget)
  • Modify: frontend/app/courses/page.tsx (add recommendation banner)

Success Criteria:

  • Recommendations endpoint returns 5-10 relevant courses in < 500ms
  • Recommendations never include already-enrolled courses
  • Algorithm prioritizes similar categories correctly
  • Recommendations cached for 24 hours
  • Click-through rate > 5% (indicates relevance)

Parallel Implementation Strategy

Branch Strategy:

Feature 1 - Analytics Dashboard: feature/learner-analytics-dashboard
├── Primary files: frontend/app/dashboard/analytics/*, backend/functions/analytics/*
└── Estimated: 3-4 days

Feature 2 - Badges System: feature/course-completion-badges
├── Primary files: frontend/app/profile/*, backend/functions/badges/*
└── Estimated: 3-4 days

Feature 3 - Recommendations: feature/smart-recommendations
├── Primary files: backend/shared/utils/recommendation-engine.ts, frontend/components/dashboard/RecommendedCourses.tsx
└── Estimated: 3-4 days

Merge Order (recommended):

  1. Feature 1 (Analytics) - Pure addition, zero dependencies
  2. Feature 3 (Recommendations) - Can use analytics data optionally
  3. Feature 2 (Badges) - Modifies enrollment completion logic

Conflict Resolution:

  • Minor conflicts expected in 3 files (Header.tsx, lambda.tf, api-gateway.ts)
  • All conflicts are additive (new navigation links, new Lambda functions)
  • Estimated merge conflict resolution time: < 1 hour total

Expected Timeline:

  • Parallel Development: 3-4 days (all 3 features simultaneously)
  • Testing & QA: 2-3 days
  • Code Review: 1-2 days (overlapping with testing)
  • Merge to Main: 1 day
  • Total: ~1 week for all 3 features

Strategic Feature Prioritization

Phase 0: User Engagement Enhancement (Week 1) - NEW

Goal: Improve user retention and engagement before tackling AI content generation

Features (can be built in parallel):

  1. Learner Progress Analytics Dashboard
  2. Course Completion Badges & Achievements
  3. Smart Lesson Recommendations Engine

Why This Phase:

  • Relatively low complexity compared to AI generation
  • Immediate value to existing users
  • Improves key metrics (retention, engagement, course discovery)
  • Builds upon existing data without requiring new infrastructure
  • De-risks AI investment by proving user engagement first

Validation Metrics:

  • Increase in user retention (7-day return rate)
  • Increase in course completion rate
  • Increase in course enrollments from recommendations
  • User feedback on analytics and badges features

Phase 1: MVP Completion (Weeks 2-5) - Make It Sellable

Goal: Enable users to purchase, enroll, and complete courses to generate first revenue.

Feature 1.1: Admin Panel CRUD Implementation (Frontend)

Priority: P0 ✅ COMPLETE Status: Fully implemented and functional

Completed Components:

  • ✅ Admin courses pages (List, Create, Edit, Delete)
  • ✅ Admin lessons pages (List, Create, Edit, Delete)
  • ✅ Rich Text Editor (React Quill)
  • ✅ Backend API integration
  • ✅ Authorization enforcement

Feature 1.2: Progress Tracking Backend

Priority: P1 ✅ COMPLETE Status: Fully implemented and functional

Completed Components:

  • ✅ Progress Lambda handlers (POST /progress, GET /progress)
  • ✅ Frontend integration with real backend API
  • ✅ Mock implementation removed
  • ✅ Time tracking and completion status

Feature 1.3: Payment Integration with Stripe (Real)

Priority: Deferred (Ready for implementation when needed) Status: Mock implementation complete, can swap to real Stripe in 2-3 days Estimated Effort: 2-3 days (infrastructure exists, swap mock service)

MVP Checkpoint Update (2025-11-30):

  • ✅ Phase 1 core features are COMPLETE (except real payment integration which is deferred)
  • ✅ You have a functional LMS ready for content creation and user engagement
  • 🚧 Real Stripe integration deferred until business decision to monetize
  • 🎯 Next focus: User engagement features (Phase 0) before AI content generation (Phase 2)

Phase 2: Content Automation & Differentiation (Weeks 6-11)

Goal: Implement AI-powered content generation - your core competitive advantage.

Feature 2.1: AI Content Generation with Amazon Bedrock

Priority: P1 Effort: 3-4 weeks Business Value: 10x content creation speed, unique value proposition

Why This Feature?

  • Core differentiator vs. Udemy, Coursera, Skillshare
  • Enables rapid scaling of course catalog (100+ courses in months vs. years)
  • Positions Momentum as an AI-first, modern platform
  • Builds moat against competitors without AI capabilities

Technical Architecture:

Admin triggers generation
  → Lambda invokes Step Functions workflow
  → Step 1: Generate course outline (Bedrock/Claude)
  → Step 2: Generate lessons in parallel (7/14/21 lessons)
  → Step 3: Generate action items per lesson
  → Step 4: Store content in database
  → Step 5: Notify admin (SNS)

AWS Services:

  • Amazon Bedrock: Claude 3.5 Sonnet for text generation
  • Step Functions: Orchestrate multi-step workflow (Express Workflows)
  • Lambda: Execute each step in workflow
  • S3: Store raw generation outputs (for audit/retry)
  • SNS: Notify admin when generation complete
  • EventBridge: Schedule batch generation jobs (future)

Prompt Engineering:

// Course Outline Generation
const COURSE_OUTLINE_PROMPT = `
You are an expert instructional designer. Create a comprehensive ${duration}-day
course outline for "${courseTitle}" in the ${category} category.

Target Audience: ${targetAudience}
Course Goals: ${courseGoals}

Generate a JSON structure with:
{
  "courseTitle": "...",
  "description": "...",
  "learningObjectives": ["...", "..."],
  "lessons": [
    {
      "day": 1,
      "title": "...",
      "topics": ["...", "..."],
      "estimatedTime": "15-20 minutes"
    },
    ...
  ]
}

Requirements:
- Each lesson should be completable in 15-20 minutes
- Build progressively (beginner → advanced)
- Include practical, actionable content
- Use clear, simple language
`;

// Lesson Content Generation
const LESSON_CONTENT_PROMPT = `
Generate full content for Day ${day} of ${duration}: "${lessonTitle}"

Previous lessons covered: ${previousTopics}

Include:
1. Introduction (2-3 paragraphs)
2. Main Content (3-5 key concepts with examples)
3. Practical Application (how to use this in real life)
4. 3-5 Action Items (specific, measurable tasks)
5. Key Takeaways (2-3 bullet points)

Format as markdown. Make it engaging and conversational.
`;

Admin UI:

  • “Generate with AI” button on course creation form
  • Input fields:
    • Course topic/title
    • Category selection
    • Duration (7/14/21 days)
    • Target audience (optional)
    • Specific goals/requirements (optional)
  • Progress indicator showing generation steps
  • Review/edit screen for generated content before publishing
  • Regenerate individual lessons if unsatisfactory

API Endpoints:

POST /admin/ai/generate-course     # Start course generation
GET  /admin/ai/jobs/{jobId}        # Check generation status
POST /admin/ai/regenerate-lesson   # Regenerate specific lesson
GET  /admin/ai/usage               # Track Bedrock API costs

Cost Optimization:

  • Implement caching for similar course requests
  • Rate limiting (max X generations per day)
  • Cost tracking per generation (store in database)
  • Monthly budget alerts (CloudWatch alarms)
  • Use Bedrock’s cheaper models for drafts, Claude for final

Quality Control:

  • Admin review required before publishing AI-generated courses
  • Flagging system for low-quality content
  • A/B testing AI vs. human content (completion rates)
  • Feedback loop to improve prompts

Success Criteria:

  • Admin can generate full course (7/14/21 lessons) in under 5 minutes
  • Generated content quality is 80%+ usable (minimal editing)
  • Cost per course generation is under $5
  • 90%+ of generated courses pass admin review

Feature 2.2: Video Content Generation & Delivery

Priority: P2 Effort: 3-4 weeks Business Value: Enhanced learning experience, premium feature

Why After Text Content?

  • Text content alone provides value (MVP viable without video)
  • Video is enhancement, not core requirement
  • More expensive (Synthesia: $30/video, D-ID: similar)
  • Technically complex (transcoding, CDN, DRM)

Video Generation Workflow:

Admin triggers video generation
  → Lambda creates video job (Synthesia API)
  → Poll for completion (async, can take 5-30 minutes)
  → Download video to S3
  → Trigger MediaConvert for transcoding
  → Create HLS/DASH manifests
  → Generate CloudFront signed URL
  → Update lesson record with video_url

Third-Party Video AI Providers (evaluate):

  1. Synthesia: High quality, avatar-based, $30/min
  2. D-ID: Good quality, $0.08-0.20/sec, more affordable
  3. HeyGen: Good quality, competitive pricing, API support

Recommendation: Start with D-ID for cost efficiency, upgrade to Synthesia for premium courses.

AWS Video Infrastructure:

  • S3: Store raw video files (Intelligent-Tiering lifecycle)
  • MediaConvert: Transcode to HLS/DASH for adaptive streaming
  • CloudFront: CDN delivery with signed URLs for premium content
  • Lambda: Generate time-limited signed URLs (24-hour expiry)
  • ECS Fargate: Long-running video processing jobs (batch generation)

Batch Processing (ECS Fargate):

// Worker service that processes video generation queue
// Runs on ECS Fargate to avoid Lambda 15-minute timeout
class VideoGenerationWorker {
  async processJob(job: VideoJob) {
    // 1. Call Synthesia/D-ID API
    // 2. Poll for completion (can take 30+ minutes)
    // 3. Download video
    // 4. Upload to S3
    // 5. Trigger MediaConvert
    // 6. Update database
  }
}

Frontend Video Player:

  • Use Video.js or Plyr for HLS/DASH playback
  • Progress tracking (resume where left off)
  • Playback speed controls
  • Closed captions (future)
  • Download prevention (premium content protection)

API Endpoints:

POST /admin/ai/generate-video      # Create video generation job
GET  /admin/ai/video-jobs/{id}     # Check video job status
GET  /lessons/{id}/video-url       # Get signed CloudFront URL

Content Protection (Premium Courses):

  • CloudFront signed URLs with 24-hour expiry
  • HLS encryption (AES-128)
  • Prevent right-click/download (frontend only, not foolproof)
  • Watermark with user email (future, for leak tracking)

Cost Management:

  • Video generation is expensive - make it admin-triggered, not automatic
  • Offer text-only courses as lower-priced tier
  • Cache generated videos (don’t regenerate on every edit)
  • Lifecycle policy: S3 Standard → Glacier after 90 days

Success Criteria:

  • Admin can generate video for lesson content
  • Video plays smoothly across devices
  • Premium content is protected (signed URLs)
  • Video generation cost is tracked per lesson

Phase 3: Growth & Engagement (Weeks 11-16)

Goal: Drive user acquisition, retention, and course discovery.

Feature 3.1: Search & Discovery with OpenSearch

Priority: P2 Effort: 2-3 weeks Business Value: Improved course discovery → more enrollments

Technical Implementation:

  • Amazon OpenSearch Serverless: Managed search service
  • Index Structure: 
    {
  "course_id": "uuid",
  "title": "course title",
  "description": "full description",
  "category": "category name",
  "duration_days": 7,
  "price": 29.99,
  "status": "PUBLISHED",
  "created_at": "timestamp",
  "enrollment_count": 150,
  "avg_rating": 4.5
}
  • Sync Strategy: Lambda trigger on course create/update to index in OpenSearch

Search Features:

  • Full-text search on title and description
  • Filter by category (checkbox list)
  • Filter by duration (7/14/21 days)
  • Filter by price (free, under $50, etc.)
  • Sort by: relevance, newest, most popular, highest rated
  • Autocomplete/suggestions (as user types)
  • Search analytics (track queries, zero-result queries)

Frontend UI:

  • Search bar in header (global search)
  • Advanced filters sidebar on /courses page
  • Search results page with faceted navigation
  • “Did you mean?” suggestions for typos
  • Highlight search terms in results

API Endpoints:

GET /search?q={query}&category={cat}&duration={days}&sort={field}
GET /search/suggestions?q={partial}
GET /admin/search/analytics

Success Criteria:

  • Users can find relevant courses via search
  • Search response time under 500ms
  • Zero-result rate under 10%

Feature 3.2: Email Notifications & User Engagement

Priority: P2 Effort: 2 weeks Business Value: User retention and engagement

Email Service: Amazon SES (Simple Email Service)

Email Templates (using React Email or MJML):

  1. Welcome Email: After signup
  2. Enrollment Confirmation: After enrolling in course
  3. Lesson Reminder: Daily reminder for enrolled courses
  4. Course Completion: Congratulations + certificate
  5. Streak Reminder: “You’re on a 5-day streak!”
  6. Course Recommendations: Personalized suggestions
  7. Payment Receipt: After successful payment

Push Notifications (Amazon SNS):

  • Lesson available notification
  • New course in favorite category
  • Course completion milestone

Implementation:

  • Lambda function for email sending (triggered by events)
  • Email templates with dynamic content
  • Unsubscribe management (preferences table)
  • Email delivery tracking (opens, clicks via SES)

API Endpoints:

POST /notifications/email          # Send email (internal)
GET  /notifications/preferences    # User's notification settings
PUT  /notifications/preferences    # Update settings

Success Criteria:

  • All transactional emails sent reliably
  • Email open rate > 30%
  • Unsubscribe rate < 5%
  • Lesson reminder emails increase daily active users

Feature 3.3: Real-time Progress Updates (GraphQL Subscriptions)

Priority: P3 Effort: 1-2 weeks Business Value: Enhanced UX, social proof

Technical Shift: Introduce AWS AppSync for real-time features

Use Cases:

  • Dashboard updates in real-time when lesson completed (no refresh)
  • Live enrollment count on course pages (“25 students enrolled today”)
  • “X users are learning this now” social proof

GraphQL Schema (subset):

type Subscription {
  onProgressUpdate(userId: ID!): Progress
    @aws_subscribe(mutations: ["markLessonComplete"])

  onCourseEnrollment(courseId: ID!): Enrollment
    @aws_subscribe(mutations: ["enrollCourse"])
}

Frontend Integration:

  • Apollo Client for GraphQL subscriptions
  • WebSocket connection to AppSync
  • Optimistic UI updates

Note: This is a nice-to-have, not critical for MVP or early growth. Defer if timeline is tight.

Phase 4: Optimization & Scale (Month 5+)

Feature 4.1: Analytics & Business Intelligence

Priority: P3 Effort: 2-3 weeks Business Value: Data-driven decision making

Metrics to Track:

Business Metrics:

  • Monthly Recurring Revenue (MRR)
  • Average Revenue Per User (ARPU)
  • Customer Lifetime Value (LTV)
  • Customer Acquisition Cost (CAC)
  • Churn rate
  • Revenue by course category

Product Metrics:

  • Daily/Weekly/Monthly Active Users (DAU/WAU/MAU)
  • Course enrollment rate (visitors → enrollments)
  • Course completion rate
  • Average time to complete course
  • Lesson completion rate
  • Search-to-enrollment conversion
  • Payment success rate

Content Metrics:

  • Most popular courses
  • Most popular categories
  • Course ratings (future)
  • AI-generated vs. human content performance

Technical Metrics:

  • API response times (P50, P95, P99)
  • Error rates by endpoint
  • Lambda cold start times
  • Database query performance
  • CDN cache hit ratio
  • AWS costs by service

Implementation:

  • CloudWatch Dashboards: Real-time operational metrics
  • CloudWatch Logs Insights: Query application logs
  • Amazon QuickSight: Advanced BI dashboards for business metrics
  • Custom analytics Lambda: Aggregate data for admin dashboard

Admin Analytics Dashboard (/admin/analytics):

  • Revenue chart (daily, weekly, monthly)
  • Enrollment trends
  • Top courses (by revenue, enrollments, completions)
  • User growth chart
  • Conversion funnel visualization
  • Course performance comparison

Success Criteria:

  • Real-time visibility into key business metrics
  • Admins can make data-driven content decisions
  • Automated alerts for anomalies (revenue drop, error spike)

Technical Architecture Alignment

Alignment with Claude.md Vision

✅ What’s Aligned

  1. Serverless-First Approach
    • Lambda for compute
    • Aurora Serverless v2 for database
    • S3 + CloudFront for static hosting
    • Cognito for authentication
    • API Gateway for API layer
  2. Database Schema
    • Matches Claude.md specification exactly
    • All tables implemented (users, courses, lessons, enrollments, progress, payments)
    • Proper indexes for performance
    • Full-text search on courses
  3. TypeScript Everywhere
    • Frontend: Next.js + TypeScript
    • Backend: Lambda functions in TypeScript
    • Shared types between frontend and backend
  4. Infrastructure as Code
    • Terraform for all AWS resources
    • Version controlled
    • Reproducible across environments
  5. Security Best Practices
    • Cognito for identity management
    • VPC for database isolation
    • IAM roles with least privilege
    • Secrets Manager for sensitive data (future)

⚠️ Architectural Deviations

Aspect Claude.md Spec Current Implementation Recommendation
API Type GraphQL (AppSync) REST (API Gateway) Keep REST for now. GraphQL is ideal for real-time features, but REST is working well. Consider GraphQL for Phase 3 real-time features only.
Caching ElastiCache Serverless Provisioned but unused Defer caching until traffic justifies it (10K+ requests/hour). Database is fast enough for MVP.
AI Services Bedrock + Step Functions Not implemented Critical gap. Implement in Phase 2. This is core to competitive differentiation.
GraphQL Codegen Auto-generated types N/A (using REST) Not applicable currently. If adding AppSync, implement codegen.

📋 Missing Components from Claude.md

  1. Step Functions - Needed for AI content generation workflows
  2. Amazon Bedrock - Core AI service for content generation
  3. OpenSearch Serverless - Search functionality (Phase 3)
  4. Amazon SES - Email notifications (Phase 3)
  5. MediaConvert - Video transcoding (Phase 2)
  6. ECS Fargate - Long-running batch jobs for video processing (Phase 2)
  7. QuickSight - Business intelligence (Phase 4)
  8. Amplify Hosting - Currently using S3+CloudFront (works well, no need to change)

Risk Assessment & Mitigation

High-Priority Risks

1. Bedrock Cost Overruns

Risk: AI content generation costs spiral out of control Probability: Medium Impact: High Mitigation:

  • Implement cost tracking per generation (store in database)
  • Set up CloudWatch billing alarms ($100, $500, $1000 thresholds)
  • Rate limiting (max 10 course generations per admin per day)
  • Caching for similar course requests
  • Use cheaper models for drafts, premium models for final
  • Monthly budget review and adjustment

2. Payment Security & Fraud

Risk: Payment fraud, chargebacks, card testing Probability: Low Impact: High Mitigation:

  • Use Stripe Radar (built-in fraud detection)
  • Webhook signature validation (prevent replay attacks)
  • HTTPS only (already enforced)
  • PCI compliance via Stripe (don’t store card data)
  • Rate limiting on payment endpoints
  • Require email verification before purchase
  • Monitor for suspicious patterns (same IP, multiple cards)

3. Video Generation Quality

Risk: AI-generated videos are low quality or unusable Probability: Medium Impact: Medium Mitigation:

  • Human review workflow before publishing
  • Pilot with one provider (D-ID), evaluate quality
  • A/B test with text-only courses (may perform better)
  • Allow admins to regenerate videos
  • Provide editing tools to adjust AI video inputs

4. Database Performance at Scale

Risk: Slow queries as data grows (1M+ users, 10K+ courses) Probability: Low (not immediate) Impact: Medium Mitigation:

  • Already have proper indexes in place
  • Aurora Serverless auto-scales (up to 128 ACUs)
  • Add ElastiCache for read-heavy queries when needed
  • Implement connection pooling (RDS Proxy if needed)
  • Monitor query performance with Aurora Performance Insights
  • Optimize N+1 queries in code

5. Compliance (GDPR, CCPA)

Risk: Legal issues with user data handling Probability: Medium (as user base grows) Impact: High Mitigation:

  • Add user data export functionality (Phase 3)
  • Implement account deletion (hard delete from database)
  • Privacy policy and terms of service
  • Cookie consent banner
  • Data retention policies
  • Audit logs for data access

Medium-Priority Risks

6. Vendor Lock-in (AWS)

Risk: Difficult to migrate off AWS services Probability: Low Impact: Medium Mitigation:

  • Use standard technologies where possible (PostgreSQL, Redis, S3-compatible APIs)
  • Abstract AWS-specific code behind interfaces
  • Infrastructure as Code (Terraform) makes migration easier
  • Not a concern for MVP stage; defer to Series A+

7. Third-Party API Dependency

Risk: Stripe, Synthesia, or D-ID downtime affects product Probability: Low Impact: Medium Mitigation:

  • Graceful degradation (if Stripe down, show maintenance message)
  • Queue payment processing (process when service recovers)
  • Multi-provider strategy for video generation (can switch providers)
  • SLA monitoring and status page subscriptions

Success Metrics by Phase

Phase 1: MVP (Weeks 1-4)

North Star Metric: Monthly Recurring Revenue (MRR)

Metric Target Measurement Method
MRR $1,000 in month 1 Stripe dashboard
Course Enrollment Rate 15% (visitors → enrollments) GA4 conversion tracking
Payment Success Rate >95% Stripe analytics
Course Completion Rate >40% Database query (enrollments with status=COMPLETED)
Average Time to First Enrollment <5 minutes from signup Custom analytics
Free-to-Paid Conversion 10% Database query

Validation Criteria:

  • At least 50 paid enrollments in first month
  • Less than 5% payment failures
  • At least 10 courses published (manually or via AI)

Phase 2: AI Content (Weeks 5-10)

North Star Metric: AI-Generated Courses Published

Metric Target Measurement Method
AI-Generated Courses 50 courses Database count with metadata.generated_by_ai = true
AI Content Quality Score 80%+ usable Admin rating (1-5 stars)
Cost per Course Generation Under $5 Bedrock usage logs
Time to Generate Course Under 5 minutes Step Functions execution time
Courses Published per Week 10+ Database query
AI vs. Human Completion Rate Within 10% A/B test comparison

Validation Criteria:

  • AI-generated courses have similar completion rates as human-created
  • Content generation cost is sustainable (<20% of course price)
  • Admin spends <10 minutes editing per AI-generated course

Phase 3: Growth & Engagement (Weeks 11-16)

North Star Metric: Weekly Active Users (WAU)

Metric Target Measurement Method
WAU 500 users Database query (users with activity in past 7 days)
DAU/WAU Ratio >30% (stickiness) Database query
Email Open Rate >30% SES delivery metrics
Search Usage 40% of sessions include search OpenSearch query logs
Search-to-Enrollment >10% Conversion tracking
Lesson Completion Rate >60% Database query

Validation Criteria:

  • Users return at least 3 times per week
  • Search improves course discovery (higher enrollment from search than browse)
  • Email reminders increase daily active users by 20%

Phase 4: Scale & Optimization (Month 5+)

North Star Metric: Customer Lifetime Value (LTV) to Customer Acquisition Cost (CAC) Ratio

Metric Target Measurement Method
LTV:CAC Ratio >3:1 Financial analysis
Monthly Active Users 5,000+ Database query
API P95 Response Time <300ms CloudWatch metrics
Database Query P95 <50ms Aurora Performance Insights
CloudFront Cache Hit Ratio >90% CloudFront analytics
Monthly AWS Costs <$2,000 Cost Explorer
Gross Margin >70% Financial analysis

Budget Projections

AWS Cost Estimates (Monthly)

MVP Phase (1,000 users, 50 courses)

| Service | Usage | Cost | |———|——-|——| | RDS Aurora Serverless v2 | 2 ACUs avg, 730 hrs/mo | $106 | | ElastiCache Serverless | 1.5 GB storage, 1M ECPUs | $15 | | Lambda | 1M requests, 512MB, 5s avg | $20 | | API Gateway | 1M API calls | $3.50 | | S3 | 50 GB storage, 100 GB transfer | $10 | | CloudFront | 100 GB data transfer | $8.50 | | Cognito | 1,000 MAU | $27.50 | | Route 53 | 1 hosted zone | $0.50 | | Certificate Manager | SSL certificate | $0 (free) | | CloudWatch | Logs, metrics, alarms | $10 | | TOTAL | | ~$201 |

Growth Phase (10,000 users, 500 courses)

| Service | Usage | Cost | |———|——-|——| | RDS Aurora Serverless v2 | 8 ACUs avg | $425 | | ElastiCache Serverless | 5 GB storage, 10M ECPUs | $60 | | Lambda | 10M requests | $180 | | API Gateway | 10M API calls | $35 | | S3 | 500 GB storage, 1 TB transfer | $80 | | CloudFront | 1 TB data transfer | $85 | | Cognito | 10,000 MAU | $275 | | Bedrock | 100 course generations/mo | $200 | | OpenSearch Serverless | 4 OCUs | $360 | | SES | 100K emails | $10 | | CloudWatch | Logs, metrics, alarms | $50 | | TOTAL | | ~$1,760 |

Scale Phase (100,000 users, 2,000 courses)

| Service | Usage | Cost | |———|——-|——| | RDS Aurora Serverless v2 | 32 ACUs avg | $1,700 | | ElastiCache Serverless | 20 GB storage, 100M ECPUs | $350 | | Lambda | 100M requests | $1,600 | | API Gateway | 100M API calls | $350 | | S3 | 2 TB storage, 10 TB transfer | $600 | | CloudFront | 10 TB data transfer | $850 | | Cognito | 100,000 MAU | $2,750 | | Bedrock | 200 course generations/mo | $400 | | OpenSearch Serverless | 8 OCUs | $720 | | MediaConvert | 500 hrs video/mo | $625 | | SES | 1M emails | $100 | | CloudWatch | Logs, metrics, alarms | $200 | | TOTAL | | ~$10,245 |

Third-Party Service Costs

Service Pricing Monthly Estimate (100 videos)
Stripe 2.9% + $0.30 per transaction ~3% of revenue
Synthesia $30 per video (or $1,000/mo subscription) $1,000
D-ID $0.08-0.20 per second (more affordable) $300-400
HeyGen Similar to D-ID $300-400

Recommendation: Start with D-ID for cost efficiency. Revenue from video courses should cover video generation costs.

Implementation Checklist

Phase 1: MVP (Weeks 1-4)

Week 1-2: Payment Integration

  • Set up Stripe account (test mode)
  • Install Stripe SDK in frontend (@stripe/stripe-js)
  • Create checkout flow UI component
  • Implement Lambda functions:
    • create-checkout-session
    • webhook-handler
    • verify-payment
  • Store Stripe API keys in AWS Secrets Manager
  • Add webhook endpoint to API Gateway
  • Test payment flow end-to-end (test cards)
  • Implement error handling (card declined, etc.)
  • Add payment confirmation page

Week 3: Enrollment Flow

  • Add “Enroll Now” button to course page
  • Implement enrollment creation on payment success
  • Build “My Courses” dashboard section
  • Add access control logic (free vs. paid courses)
  • Create enrollment confirmation UI
  • Test enrollment flow end-to-end

Week 4: Progress Tracking

  • Add “Mark as Complete” button to lesson page
  • Implement progress API endpoints
  • Build progress bar component
  • Add time tracking functionality
  • Create “Continue Learning” widget
  • Test progress tracking across multiple users
  • Handle edge cases (completing lessons out of order)

Week 4: Basic Admin Panel

  • Implement course CRUD endpoints
  • Implement lesson CRUD endpoints
  • Build admin course list page
  • Build course creation/edit form
  • Build lesson creation/edit form
  • Add rich text editor for lesson content
  • Implement publish/unpublish toggle
  • Add basic analytics (enrollments, completions)
  • Test all admin operations

Phase 2: AI Content (Weeks 5-10)

Week 5-6: Bedrock Integration

  • Request Amazon Bedrock access (if needed)
  • Set up Bedrock IAM permissions
  • Create Lambda function for Bedrock API calls
  • Develop course outline generation prompt
  • Develop lesson content generation prompt
  • Test prompts and refine based on output quality
  • Implement cost tracking

Week 7-8: Step Functions Workflow

  • Create Step Functions state machine
  • Implement workflow steps:
    • Generate course outline
    • Generate lessons (parallel execution)
    • Generate action items
    • Store in database
  • Add error handling and retries
  • Implement SNS notification on completion
  • Test full workflow end-to-end

Week 9: Admin AI UI

  • Add “Generate with AI” button to admin panel
  • Build AI generation form (topic, category, duration)
  • Create progress indicator for generation
  • Build content review/edit interface
  • Add regenerate functionality
  • Test with multiple course topics

Week 10: Video Generation (Optional)

  • Evaluate video AI providers (D-ID, Synthesia)
  • Set up account with chosen provider
  • Create Lambda function for video generation
  • Implement polling for job completion
  • Set up S3 storage for videos
  • Configure MediaConvert for transcoding
  • Generate CloudFront signed URLs
  • Test video playback on frontend

Phase 3: Growth (Weeks 11-16)

Week 11-12: Search

  • Set up Amazon OpenSearch Serverless
  • Create course index schema
  • Implement Lambda trigger to sync courses to OpenSearch
  • Build search API endpoint
  • Create search UI component
  • Add filters (category, duration, price)
  • Implement autocomplete
  • Test search performance

Week 13-14: Email Notifications

  • Set up Amazon SES (verify domain)
  • Create email templates (React Email or MJML)
  • Implement Lambda function for sending emails
  • Add welcome email
  • Add enrollment confirmation email
  • Add lesson reminder email
  • Add course completion email
  • Implement unsubscribe functionality
  • Test all email flows

Week 15-16: Real-time Features (Optional)

  • Set up AWS AppSync (if pursuing GraphQL)
  • Define GraphQL schema for subscriptions
  • Implement real-time progress updates
  • Add live enrollment counts
  • Integrate Apollo Client in frontend
  • Test WebSocket connections

Conclusion

Summary of Recommendations (Updated 2025-11-30)

  1. ✅ MVP Core Features: COMPLETE
    • Admin panel, progress tracking, enrollment flow, course browsing all functional
    • Platform is ready for content creation and user testing
    • Real Stripe integration can be added in 2-3 days when needed
  2. 🆕 Immediate Priority: User Engagement Features (Phase 0 - Week 1)
    • Implement 3 parallel features: Analytics Dashboard, Badges System, Recommendations Engine
    • Low complexity, high user value
    • Improves retention and engagement metrics before AI investment
    • Can be built in parallel (1 week total)
  3. 🎯 Competitive Differentiation: AI Content Generation (Phase 2 - Weeks 6-11)
    • This remains Momentum’s unique value proposition
    • Enables rapid scaling of course catalog
    • Builds defensible moat against competitors
    • Requires Bedrock access and Step Functions implementation
  4. 📈 Growth Acceleration: Phase 3 features for user acquisition
    • Advanced search (OpenSearch) when PostgreSQL search becomes insufficient
    • Email notifications drive engagement and retention
    • Real-time features enhance UX but remain optional
  5. 🔧 Optimize for Scale: Phase 4 for efficiency and insights
    • Business analytics enable data-driven decisions
    • Cost optimization becomes important at scale
    • Performance monitoring prevents outages

Updated Timeline to Market

  • ✅ MVP Core Complete: NOW (2025-11-30)
  • Enhanced MVP with Engagement Features: 1 week from now
  • AI-Differentiated Product: 6-8 weeks from now
  • Growth-Ready Platform: 12-16 weeks from now

Key Change: We’re ahead of the original timeline! Core MVP features are done. Focus shifts to engagement before AI.

Key Success Factors

  1. Focus on Revenue: Prioritize features that directly enable monetization
  2. Leverage AI: Use AI content generation to build catalog faster than competitors
  3. Data-Driven Iteration: Track metrics from day one, optimize based on data
  4. Cost Discipline: Monitor AWS and third-party costs closely
  5. Quality Control: Human review for AI-generated content ensures quality
  6. User Experience: Consistent, professional UI builds trust and engagement

Next Steps (Updated 2025-11-30)

  1. This Week: Implement Phase 0 user engagement features in parallel
    • Feature 1: Learner Progress Analytics Dashboard
    • Feature 2: Course Completion Badges & Achievements
    • Feature 3: Smart Lesson Recommendations Engine
  2. Week 2: Testing, QA, and merge of engagement features
    • Validate success metrics
    • Gather initial user feedback
    • Monitor retention and engagement improvements
  3. Week 3-4: Prepare for AI content generation
    • Request Amazon Bedrock access
    • Design prompts for course and lesson generation
    • Set up Step Functions workflow
    • Create cost tracking infrastructure

  4. Week 5+: Begin AI content generation implementation (Phase 2)

  5. Deferred: Real Stripe payment integration (when business is ready to monetize)

Document Maintainer: Solution Architecture Team Review Cadence: Bi-weekly during active development Last Reviewed: 2025-12-11 Next Review: 2025-12-25

Appendix

External Resources

Back to top

Momentum LMS © 2025. Distributed under the MIT license.