Skip to content
PRS India

Vidyapath Learning

Halving cost-per-learner on a live-cohort LMS at 4,300 concurrent

A live-cohort LMS rebuilt around one idea: a lecture is a broadcast, not a conference call — WebRTC for the stage, low-latency HLS for the hall, and proctoring that reviews only what it flags.

Client
Vidyapath Learning
Industry
Edtech
Location
Bengaluru, India
Duration
20 weeks
Published
Jul 2024
Updated
Oct 2026

58% lower

Lower infrastructure cost per learner

4300

Peak concurrent learners in a single live class, no incident

71% lower

Lower proctoring cost per exam, same integrity outcomes

0

Question-bank leaks across nine assessment cycles

01

The challenge

Vidyapath Learning runs live, cohort-based upskilling programmes — data engineering, product management, cloud — for working professionals. 40,000 learners on the roll, up to 1,200 concurrent in a single evening class, and a cost problem that was quietly getting worse every month.

They were paying interactive prices for a passive audience

Every live class ran on a general video meeting product, with all 1,200 attendees joined as full participants. But in a lecture, twelve people speak and 1,188 watch. They were paying two-way WebRTC prices, the most expensive way to move video, to deliver a broadcast. The cost per learner for servers rose faster than the price they could charge.

Everything downstream of the class was manual

  • Attendance was reconciled by hand from a meeting export, then keyed into a spreadsheet, then into the certification tracker. For a cohort model where attendance drives certification eligibility, this was the most important data in the business and also the least trusted.
  • The question bank had leaked. Their test tool sent the full paper to the browser when an exam started. A learner with the browser devtools open could read every question — and the answers, in one memorable case — before answering the first one. Screenshots of the bank were circulating in cohort WhatsApp groups.
  • Proctoring cost more than it was worth. Their vendor recorded the full session and charged for a person to review all of it. They were paying to have a person watch 40 minutes of video of someone doing nothing suspicious, thousands of times a month.

And it all happened at once

Traffic is not spread across the day. It comes as a spike. Working professionals attend class between 8pm and 10pm IST. The platform was idle for twenty hours a day and under heavy load for four, and it was built for that peak.

02

What we built

Split the room: WebRTC for the stage, HLS for the hall

The one change that fixed the economics. Live seats — the instructor, TAs, and up to ~200 learners on the "stage" — run over managed WebRTC. Everybody else receives low-latency HLS, which is far cheaper to send to many viewers, and it is what they were watching anyway. A learner who raises a hand is promoted from HLS to WebRTC in a couple of seconds and moved back when they are done.

We did not build our own SFU. Running one is a big job, not a feature, and the managed provider's edge footprint across India is not something we could copy for a client of this size. We spent the build budget on the move-up and move-back logic instead, because that is where the money was.

Attendance from heartbeats, not from clicks

"Joined" is not attendance — a learner who opens the tab and walks away is not attending. The player emits a heartbeat every 30 seconds, heartbeats go onto a queue, and a worker groups them into presence times. Certification eligibility reads the aggregate. Nobody keys anything into a spreadsheet, and the definition of attendance is now a line of code that anyone can question openly, not a habit kept in one operations manager's head.

Assessments: never send the paper

Items are served one at a time, picked at request time from a checked pool, with limits on how often each question is shown, so no single question wears out across a group. The client never holds an item it has not been asked. Timing is server-side, always — client clocks lie, and on an exam, some of them lie deliberately.

Proctoring: flag cheaply, review expensively

We inverted the vendor's cost model. The browser emits cheap integrity signals — visibility change, fullscreen exit, paste events, a second display appearing — and the webcam takes one frame every 8 seconds and uploads it straight to object storage through a presigned PUT, so the frames never pass through the app servers. Human review is triggered only on flagged sessions.

Roughly 92% of sessions are never flagged, and paying a human to watch those was the entire cost problem. Recording and reviewing everything is the lazy design. Recording cheaply and reviewing only some sessions is what the problem needs.

Scale on queue depth, not CPU

The 8pm burst is limited by data reads and writes — the CPU graph barely moves while the platform is overwhelmed. Adding servers based on CPU meant they arrived after the class had already slowed. We scale on queue depth and connection count, which show the load early, and we start extra capacity before each class, because the timetable is known in advance. Reporting runs against a read replica so a director pulling a group report cannot slow down a live lecture.

03

The outcome

Moved one group at a time over a term. The old and new classes ran side by side for three weeks, so learners could go back if the new one was worse. After the second week, nobody switched back.

Results

  • Infrastructure cost per learner fell 58%. The overwhelming majority is the WebRTC-to-HLS split. This was not a small tweak; it corrected a basic mistake about what a lecture is.
  • Peak concurrency reached 4,300 without incident — more than triple the load that used to break them — during a free masterclass they ran because they finally trusted the platform to take it.
  • Proctoring cost per exam dropped 71%. Same integrity outcomes, a fraction of the human review hours, because people now only check where a check is needed.
  • Zero question-bank leaks since launch, across nine assessment cycles. The bank cannot leak from a client that is never sent it.

What it did to the business

Attendance data went from a spreadsheet somebody maintained to a stream the product reads, and the certificate process stopped being a monthly manual task. More importantly, the cost picture flipped: adding learners to a cohort now costs them very little, so each extra cohort now makes money, which it clearly did not before.

They have since doubled cohort sizes on their two largest programmes without adding infrastructure spend, which is the outcome that turns an engineering project into a business one.

Under the hood

How it's built.

Technology

  • Laravel
  • React
  • TypeScript
  • PostgreSQL
  • Redis
  • Laravel Horizon
  • Managed WebRTC (SFU)
  • Low-Latency HLS
  • AWS S3 + CloudFront
  • Kubernetes
  • Terraform

Services used

  • Education Platform Development
  • Custom Software Development
  • Cloud & DevOps
  • Performance Engineering
  • UI/UX Design

They asked one question in the first workshop — how many of your 1,200 attendees ever unmute? The answer was twelve. That question ended up halving our cost per learner.

Nikhil Varma VP Engineering, Vidyapath Learning

Same problem?

Let's build something that ships.