HowWeBuiltaVirtualClassroomPlatformfor10,000+ConcurrentUsers
WebRTC-based live classroom with interactive whiteboards, breakout rooms, automated recording, and student engagement scoring — 500+ sessions weekly.
The Challenge
An education provider serving thousands of students worldwide hit a wall. Their existing setup stitched together Zoom for live classes, Google Docs for whiteboards, and a separate LMS for attendance. Teachers toggled between three tabs during every session. Students dropped off because the experience felt disjointed. And recording? Someone had to remember to hit the button.
The numbers told the story. Average session attendance sat at 58% of enrolled students. Teachers reported spending 12-15 minutes per class on technical setup alone. Recorded sessions were missing for 30% of classes because the manual recording workflow failed silently. The client needed a single platform — live video, whiteboard, screen sharing, breakout rooms, attendance, and recording — all working on both mobile and web.
There was another constraint. The platform had to support 10,000+ concurrent users during peak exam season without degradation. Third-party video APIs like Zoom SDK and Twilio Video were evaluated, but the per-minute costs at that scale would exceed $12,000/month. The client wanted to own the infrastructure.
The Solution
Geminate Solutions assembled a team of 2 Flutter developers, 1 Node.js backend engineer, and 1 WebRTC specialist. We built a cross-platform system: a Flutter app for students on iOS and Android, plus a React web dashboard for teachers and administrators.
The core video layer uses WebRTC with a custom Selective Forwarding Unit (SFU) server. Active speakers transmit directly via WebRTC for sub-200ms latency. For large lecture-style classes with hundreds of passive viewers, we added an HLS fallback that kicks in automatically when concurrent viewers exceed the SFU threshold. This hybrid approach kept infrastructure costs 75% lower than pure WebRTC at scale.
The interactive whiteboard uses Canvas API with Socket.io for real-time synchronization. Every stroke, shape, and text annotation syncs across all participants within 50ms. Teachers can share their screen alongside the whiteboard — or switch between them with a single tap. Automated recording pipes the composite stream (video + whiteboard + screen share) to AWS S3 using FFmpeg, so no session is ever lost.
Flutter, React, Node.js, WebRTC (custom SFU), Socket.io, PostgreSQL, Redis, AWS (S3, CloudFront, EC2), Canvas API, FFmpeg, HLS streaming
Architecture Decisions
The biggest architectural decision was building a custom SFU instead of using a managed WebRTC service. Managed solutions like Vonage or Daily.co charge $0.004-$0.01 per participant minute. At 500+ sessions weekly with an average of 45 participants per session, that would cost $8,000-$15,000 monthly. Our self-hosted SFU on AWS EC2 runs at roughly $2,200/month for the same load. The tradeoff was 3 extra weeks of development time — paid back within the first month of operation.
We chose Redis pub/sub over raw WebSocket broadcasting for whiteboard sync. The reasoning was straightforward. When 200+ students draw on the same canvas, a single WebSocket server becomes a bottleneck. Redis pub/sub distributes events across multiple Node.js instances behind a load balancer. If one instance goes down, students reconnect to another without losing whiteboard state — because the state lives in Redis, not in server memory.
The recording pipeline was trickier than expected. We needed to capture video, whiteboard, and screen share as a single composite stream. The first approach — client-side recording via MediaRecorder API — failed because mobile browsers handle it inconsistently. The final solution captures the composite stream server-side using FFmpeg, transcodes to H.264/AAC, and uploads directly to S3. Processing happens asynchronously so it does not affect live session performance.
For the Flutter mobile app, we used a platform channel bridge to the native WebRTC libraries on iOS and Android. The flutter_webrtc package handled 80% of the requirements, but we wrote custom native code for echo cancellation and noise suppression — two areas where the default implementation was not adequate for classroom environments with background noise.
Key Features Built
Live Interactive Whiteboard
Teachers draw, type, and annotate on a shared canvas that syncs across all participants in real time. The Canvas API renders strokes at 60fps while Socket.io broadcasts coordinate data to every connected client. Undo/redo, shape tools, text boxes, and color palette are all available. We added a follow-teacher mode so students cannot accidentally scroll away from the active drawing area. Whiteboard content persists after the session — students can review annotated slides later.
Breakout Rooms
Teachers split a class into smaller groups with one click. Each breakout room gets its own WebRTC session, whiteboard, and chat. The teacher can hop between rooms, broadcast a message to all rooms, or pull everyone back to the main session. Room assignments can be random, manual, or based on pre-set student groups. We built a timer that auto-closes breakout rooms and returns students to the main classroom when time runs out.
Automated Recording and Playback
Every session records automatically. No button to press, no human to forget. The server-side FFmpeg pipeline captures the composite stream — teacher video, whiteboard activity, and screen share — into a single recording. Files upload to S3 and become available for playback within 15 minutes of session end. Students get chapter markers aligned with whiteboard page changes so they can jump to specific topics.
Student Engagement Scoring
We built a scoring algorithm that tracks five signals: camera on/off status, quiz response time, chat participation, whiteboard interaction frequency, and attendance duration. Each student gets a 0-100 engagement score per session. Teachers see a real-time heatmap showing which students are drifting. Aggregated scores over time help administrators identify students who need additional support before they drop out entirely.
Real-Time Quizzes and Polls
Teachers can launch a quiz mid-session without leaving the classroom view. Multiple choice, true/false, and short answer formats are supported. Results appear as a live bar chart that updates as students submit answers. The quiz engine feeds directly into the engagement scoring system — faster response times contribute positively. Teachers reported this feature alone increased class participation by 40% compared to the old workflow.
Attendance Tracking and Reports
Attendance captures automatically when a student joins a session. The system tracks join time, leave time, and total active duration. A student who joins but keeps the tab minimized for 80% of the session gets flagged differently than someone who was engaged throughout. Weekly and monthly reports export as CSV or PDF. Administrators can set attendance thresholds — below 75% triggers an automatic email notification to the student and parent.
The Results
| Metric | Result | Context |
|---|---|---|
| Weekly Live Sessions | 500+ | Across all subjects and grade levels |
| Concurrent Users | 10,000+ | Peak load during exam season |
| Stream Uptime | 99.2% | Measured over 90-day rolling window |
| Teacher Rating | 4.7 / 5.0 | From post-session feedback surveys |
| Engagement vs Pre-Recorded | 60% higher | Live interactive sessions vs passive video playback |
| Setup Time Per Class | Under 30 seconds | Down from 12-15 minutes with previous tools |
How This Compares to Alternatives
Build a custom virtual classroom or use Zoom SDK? At scale, the per-minute costs of video APIs add up fast. Here's what the real comparison looks like for organizations running 500+ concurrent sessions.
| Approach | Cost | Timeline | Customization | Best For |
|---|---|---|---|---|
| Custom WebRTC Classroom | $80K–$180K upfront | 4–7 months | Full control | EdTech companies running 500+ daily sessions with custom pedagogy |
| Zoom SDK | $8K–$15K/mo at scale | 2–4 weeks | Moderate (Zoom's UI constraints) | Quick launches where Zoom branding is acceptable |
| BigBlueButton | Free (self-hosted) + $2K–$5K/mo infra | 2–6 weeks | High (open source, complex setup) | Universities with DevOps capacity and budget constraints |
| Microsoft Teams Education | Free for schools (M365 license) | 1–2 weeks | Low (Microsoft's ecosystem) | K-12 schools already using Microsoft 365 |
How much does a custom WebRTC classroom save vs Zoom? At 1,000 daily sessions, Zoom SDK runs $12K–$15K per month — that's $144K–$180K annually. A custom WebRTC solution on self-managed infrastructure costs $4K–$8K/mo after the initial build. The savings compound every month, and you aren't limited by Zoom's 40-minute free tier or their UI restrictions.
The WebRTC architecture we built doesn't just work for classrooms. The same pattern powers telemedicine video consultations, live customer support with screen sharing, and corporate training platforms globally. If you're choosing between outsourcing this build or licensing a video SDK, the key question is control: do you need custom layouts, breakout rooms with specific pedagogical workflows, or branded recording? If yes, a custom build with the right technology partner will pay for itself within the first year.
Lessons Learned
WebRTC on mobile is harder than it looks. The flutter_webrtc package handles basic peer connections well, but real-world classrooms have background noise, echo from cheap speakers, and students on 3G networks. We spent two extra weeks writing custom native code for audio processing. That investment paid off — the teacher satisfaction jump from 3.8 to 4.7 was directly tied to audio quality improvements.
Never underestimate the whiteboard sync problem. Our initial implementation sent full canvas snapshots every 100ms. That worked fine with 10 users. At 200 users, it consumed 8MB/s of bandwidth per client. We switched to delta-only updates — sending just the new strokes since the last frame. Bandwidth dropped to 50KB/s per client. The lesson: always load test collaboration features at 10x your expected peak.
The hybrid WebRTC/HLS architecture was the right call, but timing the fallback matters. Switch to HLS too early and teachers notice the latency jump (from 200ms to 4-6 seconds). Switch too late and the SFU server struggles. We settled on a threshold-based trigger: when CPU usage on the SFU exceeds 70% for 30 consecutive seconds, new joiners get HLS. Existing WebRTC connections stay until they disconnect.
Automated recording eliminated a real pain point. Before launch, 30% of sessions went unrecorded because someone forgot to click the record button. After launch, that dropped to 0%. Students started watching recordings at 1.5x speed before exams — an unexpected usage pattern that convinced the client to invest in a chapter-marking feature we had not originally planned.
Frequently Asked Questions
How long does it take to build a virtual classroom platform?
The core virtual classroom with WebRTC video, interactive whiteboard, and screen sharing took 16 weeks to build and deploy. An MVP with basic video conferencing and chat can ship in 8-10 weeks. Adding features like breakout rooms, automated recording, and engagement scoring adds another 4-6 weeks depending on complexity.
How much does a virtual classroom platform cost to develop?
A production-ready virtual classroom platform costs $90,000-$140,000 for the initial build. Monthly infrastructure runs $1,200-$2,500 at scale depending on concurrent user load and recording storage. WebRTC media server costs scale with simultaneous video streams — budget $0.004-$0.008 per participant minute for TURN server relay.
Why use WebRTC instead of a third-party video API like Zoom SDK?
Third-party SDKs charge per-minute fees that compound fast at scale. At 500+ sessions weekly, Zoom SDK would cost $8,000-$15,000 monthly in API fees alone. Self-hosted WebRTC with a custom SFU server costs a fraction of that. It also gives full control over the UI, recording pipeline, and whiteboard integration without vendor lock-in.
Can the platform handle 10,000 concurrent users without lag?
Yes. The architecture uses a hybrid approach — active speakers connect via WebRTC for sub-200ms latency, while passive viewers receive an HLS fallback stream. Redis pub/sub handles real-time whiteboard and chat synchronization across multiple server instances. Load testing confirmed stable performance at 12,000 concurrent connections.
Can you build a similar virtual classroom for our education business?
Absolutely. The WebRTC infrastructure, whiteboard engine, and recording pipeline from this project are reusable components. A new virtual classroom platform using the same architecture typically costs $70,000-$120,000 and takes 12-16 weeks to launch. Contact Geminate Solutions at geminatesolutions.com/get-started for a project assessment.
Is it worth building a custom virtual classroom vs using Zoom SDK?
At 500+ weekly sessions, Zoom SDK fees hit $8,000-$15,000/month. Self-hosted WebRTC runs at $2,200/month for the same load. Healthcare telemedicine uses the same video infrastructure pattern. Enterprise corporate training needs custom branding. Startups in EdTech can't afford per-minute API fees at scale. Custom pays for itself within 10-12 months.
What are the hidden costs of virtual classroom development?
WebRTC TURN server hosting scales with concurrent streams — budget $0.004-$0.008 per participant minute. Recording storage adds $200-$500/month at 500+ sessions weekly. Marketplace course platforms need payment integration for selling recorded content. Logistics companies scheduling trainer sessions need calendar systems. These add 15-25% to the base build cost.
When does custom classroom software make sense for your organization?
When you need features Zoom can't provide. SaaS companies white-label virtual classrooms as a product. eCommerce brands run live product demos. Food delivery chains use it for kitchen staff training. Manufacturing plants deliver safety certification courses. If you're paying $10,000+/month in video tool subscriptions, custom is worth the investment.
How do you avoid waste when building an online learning platform?
Start with live video and chat — skip breakout rooms for the MVP. Fleet companies running driver training don't need whiteboards on day one. Healthcare CME credit tracking can come in phase two. Fintech compliance training needs recording first, interactive features later. Retail employee onboarding works with basic video. Build what drives adoption, add features based on usage data.
Investment Breakdown and ROI
Total project investment: $90,000-$140,000 for the complete virtual classroom platform. That covers the custom WebRTC SFU server, Flutter student app, React teacher dashboard, interactive whiteboard, automated recording pipeline, and 16 weeks of development. Monthly hosting costs run $1,500-$3,000 depending on concurrent user load — WebRTC SFU servers scale with the number of simultaneous video streams, so costs grow as usage grows. Budget another $500-$800 per month for ongoing maintenance, server patches, and feature updates.
The return on investment came primarily from replacing expensive third-party licensing. Zoom SDK alone would've cost $8,000-$15,000 per month at 500+ weekly sessions. The self-hosted WebRTC infrastructure runs at roughly $2,200 per month for the same load. That's a saving of $70,000-$150,000 per year in licensing fees. The platform paid back its entire investment within 10-12 months on licensing savings alone — before counting the value of features like engagement scoring and automated recording that Zoom couldn't provide.
Consider the cost of NOT building a custom platform. The old Zoom + Google Docs + LMS setup cost $12,000-$18,000 per month in combined subscriptions, and it delivered a fragmented experience that drove attendance down to 58%. The affordable custom build unified everything into one platform, pushed attendance to 82%, and the client owns the infrastructure. No vendor lock-in, no per-minute pricing surprises, no monthly subscription that increases every year. The budget spent on building became an asset on the balance sheet, not a recurring line item that never goes away.
Why Outsourcing Made Sense for This Project
WebRTC + Canvas API specialists are rare — and expensive when you find them. Building an in-house team with WebRTC infrastructure experience, Flutter expertise, AND real-time collaboration skills would cost $300,000+ per year in salaries. That's if you can hire them at all — WebRTC engineers with production SFU experience aren't responding to job postings. Through Geminate's staff augmentation model, the client got a dedicated team of 4 developers with proven WebRTC and real-time collaboration patterns, at a fraction of the in-house cost.
The decision to outsource was driven by a tight 16-week deadline. Exam season doesn't wait for recruitment cycles. Hiring an in-house team would've consumed 3-4 months before a single line of code was written. Geminate's remote team had already built WebRTC infrastructure for previous projects — the SFU architecture, HLS fallback pattern, and Canvas whiteboard sync came from battle-tested production code. This offshore development approach turned a 6-month project into a 16-week delivery.
Quality was never a compromise. The dedicated developers wrote custom native code for echo cancellation and noise suppression — the kind of deep engineering work you'd expect from an in-house team, delivered by a technology partner that understood the education context. Weekly demos kept the client's teaching staff involved in UX decisions. The company model worked because Geminate didn't just hire remote developers — they brought a complete engineering squad with complementary skills, ready to ship from week one. That's what cost-effective staff augmentation looks like when you choose the right partner.
Related Resources
Want similar results?
The WebRTC architecture, whiteboard engine, and recording pipeline from this project are directly reusable for your business.