How Cloud Computing Is Used in Indian EdTech Companies Today

#!/usr/bin/env bash
# Create two quality levels and an HLS playlist for practice (needs ffmpeg)
set -euo pipefail
IN=lesson01.mp4

ffmpeg -i "$IN" -vf scale=-2:360 -c:v libx264 -preset veryfast -crf 28 \
  -c:a aac -b:a 64k -hls_time 6 -hls_playlist_type vod 360p.m3u8

ffmpeg -i "$IN" -vf scale=-2:720 -c:v libx264 -preset veryfast -crf 23 \
  -c:a aac -b:a 128k -hls_time 6 -hls_playlist_type vod 720p.m3u8

cat > master.m3u8 <<'EOF'
#EXTM3U
#EXT-X-STREAM-INF:BANDWIDTH=800000,RESOLUTION=640x360
360p.m3u8
#EXT-X-STREAM-INF:BANDWIDTH=2500000,RESOLUTION=1280x720
720p.m3u8
EOF
echo "HLS files ready"

# pip install boto3
# Short-lived link to a private lesson file (practice bucket)
import boto3

s3 = boto3.client("s3", region_name="ap-south-1")

def lesson_link(learner_enrolled: bool, key: str) -> str:
    if not learner_enrolled:
        raise PermissionError("not enrolled")
    return s3.generate_presigned_url(
        "get_object",
        Params={"Bucket": "practice-lessons-bucket", "Key": key},
        ExpiresIn=900,   # 15 minutes
    )

print(lesson_link(True, "course-101/lesson01/master.m3u8"))

resource "aws_autoscaling_schedule" "exam_morning" {
  scheduled_action_name  = "scale-up-before-exam"
  autoscaling_group_name = aws_autoscaling_group.exam_app.name
  min_size               = 12
  max_size               = 60
  desired_capacity       = 20
  start_time             = "2026-11-15T03:30:00Z"   # 09:00 IST exam
}

resource "aws_autoscaling_schedule" "exam_after" {
  scheduled_action_name  = "scale-down-after-exam"
  autoscaling_group_name = aws_autoscaling_group.exam_app.name
  min_size               = 2
  max_size               = 20
  desired_capacity       = 2
  start_time             = "2026-11-15T07:30:00Z"
}

import json
import queue
import threading

submissions = queue.Queue()
saved = []

def api_submit(learner_id: str, answers: dict) -> str:
    submissions.put(json.dumps({"learner": learner_id, "answers": answers}))
    return "received"          # respond quickly, process in background

def worker():
    while True:
        item = submissions.get()
        saved.append(json.loads(item))   # write to database in real systems
        submissions.task_done()

threading.Thread(target=worker, daemon=True).start()
for i in range(5):
    api_submit(f"L{i}", {"q1": "b"})
submissions.join()
print("saved submissions:", len(saved))

resource "aws_s3_bucket_lifecycle_configuration" "lessons" {
  bucket = aws_s3_bucket.lessons.id

  rule {
    id     = "archive-old-transcodes"
    status = "Enabled"
    filter { prefix = "transcoded/" }

    transition {
      days          = 90
      storage_class = "STANDARD_IA"
    }
    transition {
      days          = 365
      storage_class = "GLACIER_IR"
    }
  }
}

resource "aws_db_instance" "learners" {
  identifier             = "learner-records"
  engine                 = "postgres"
  instance_class         = "db.t3.micro"
  allocated_storage      = 20
  username               = "appadmin"
  password               = var.db_password
  storage_encrypted      = true
  publicly_accessible    = false
  db_subnet_group_name   = aws_db_subnet_group.private.name
  vpc_security_group_ids = [aws_security_group.db.id]
  backup_retention_period = 7
  skip_final_snapshot    = true   # practice only
}

Project: Mini learning platform on AWS (dummy content)

- Private bucket for lessons; HLS files created with ffmpeg
- CDN with signed URLs for enrolled learners
- Exam API behind a load balancer with scheduled pre-scaling
- Answer submissions through a queue and worker
- Encrypted PostgreSQL for learner records in private subnets
- Lifecycle rule moving old transcodes to cheaper storage
- Billing alarm and teardown script

[ ] Load test at expected peak plus margin
[ ] Scheduled scale-up before start time
[ ] Question pages cached where possible
[ ] Submissions queued; worker scaled
[ ] Database connections and limits reviewed
[ ] Dashboards: logins, errors, queue depth
[ ] On-call and rollback plan ready

[ ] Only needed learner data collected
[ ] Encryption at rest and in transit
[ ] Databases not publicly accessible
[ ] Staff access by role, logged
[ ] Backups enabled and restore tested
[ ] Dummy data only in test environments