When a live event, webinar, or sports stream suddenly draws a million people at the same time, your video system faces real pressure. Buffering, dropped connections, or high bills can ruin the experience. In 2026, teams handle this mix of low-latency needs for some users and massive scale for others through proven combinations of protocols and infrastructure.
You do not need one magic technology. You choose based on whether your viewers just watch or need to interact. We walk through what “1 million users” really means, the main options, and practical ways to build a system that stays stable and affordable.
Key Takeaways
- Define your latency and interaction needs first–broadcast and real-time demand different architectures.
- SFU handles interactive scale; CDN or MoQ handles passive millions more cheaply.
- Simulcast, SVC, and adaptive bitrate cut bandwidth waste.
- Kubernetes with tuned autoscaling plus geo-distribution keeps the system responsive.
- Hybrid designs usually win for events with mixed audiences.
- Egress costs and monitoring deserve early attention.
- MoQ offers a promising path to combine low delay with broadcast reach.
What “1 Million Viewers” Means in Practice
Two main scenarios exist.
Broadcast (1-to-many): One or a few sources send video to a huge audience. Interaction stays light–maybe chat or reactions. Think major sports events or big webinars.
Interactive real-time: End-to-end delay stays under 500-1000 ms. Viewers react, ask questions, or join small-group video. Examples include telemedicine, online classes, or live auctions.
The first case favors cheap, massive distribution. The second needs fast, two-way connections. Your choice shapes every later decision on servers, protocols, and costs.
Core Technologies for Scaling Video
WebRTC delivers audio and video with low latency, usually under 500 ms. It powers interactive streams, video calls, and AI agents that speak and listen in real time. Browsers support it natively, and it handles NAT traversal well. Pure peer-to-peer works for small groups but breaks quickly beyond 10-12 participants because each device sends copies of its stream to everyone else. Servers fix this.
SFU (Selective Forwarding Unit) sits at the heart of most real-time setups. The publisher sends one stream to the SFU. The SFU forwards copies to viewers without re-encoding. This keeps CPU and bandwidth low on the server side.
In practice you run a tree of SFUs:
- Origin SFU receives the source.
- Regional nodes fan out to edge nodes.
- Edge nodes sit close to viewers.
Cascading spreads load. Popular open-source and managed options include LiveKit (built on Pion), mediasoup, Janus, and Ant Media. One well-tuned server can serve roughly 800 viewers at typical bitrates; clusters reach tens of thousands or more.
Simulcast and SVC prevent overload. Simulcast sends several quality versions at once. SVC encodes one stream with layers that viewers can pick from. Both let you match quality to each person’s connection and cut unnecessary traffic.
HLS, LL-HLS, and CDN shine when pure interaction is not required. The source encodes once, packages into segments, and pushes to a content delivery network. Akamai, Cloudflare, Fastly, or similar edge networks handle the final mile. Standard HLS works for millions but adds 2-6 seconds of delay. Low-Latency HLS brings that down to about 1-2 seconds. It scales cheaper than WebRTC because CDNs cache segments and charge less for massive egress.
Three Common Architectural Approaches
Pure WebRTC + SFU tree suits strict low-latency needs. You keep everything inside WebRTC, add STUN/TURN for connectivity, and use room-based sharding so each SFU handles a subset of sessions. Sticky sessions and dynamic load balancing help when nodes fail.
WebRTC ingest + CDN delivery works well for moderate interaction. The host joins via WebRTC for instant control. The stream then transcodes and moves to CDN for the bulk audience. Many large platforms use this pattern.
Hybrid model splits traffic intelligently. Speakers and moderators stay on WebRTC SFU for sub-second delay. Most passive viewers pull from LL-HLS or DASH via CDN. Chat, reactions, and presence run separately over WebSocket, NATS, or Kafka. This combination powers big webinars and virtual events today.
Scaling the Infrastructure
Kubernetes plus horizontal pod autoscaling handles media servers. You cannot treat SFUs like ordinary REST APIs – each room must stay on one node to avoid tearing streams apart. Set CPU-based scaling thresholds lower than usual so new pods spin up early. Increase cool-down on scale-down to let sessions drain cleanly. LiveKit documentation recommends starting with 4-core, 8 GB nodes that comfortably run 10-25 concurrent jobs.
Geo-distribution matters. Regional clusters and edge nodes cut round-trip time. Anycast DNS or GeoDNS routes users to the nearest point. This lowers packet loss and keeps latency predictable worldwide.
Bandwidth is the biggest practical limit. One 2 Mbps stream times 1 million viewers equals 2 Tbps of egress traffic. Costs climb fast if you serve everything from origin servers. Adaptive bitrate, Simulcast or SVC, modern codecs like VP9 or AV1 (30-50 % savings), and heavy CDN use keep numbers manageable. Minimizing TURN traffic also helps.
Keeping Delay Under 1 Second
WebRTC instead of HLS forms the foundation. Minimize network hops, place edge nodes close to users, and apply good congestion control. Avoid extra transcoding steps. MoQ (Media over QUIC) is gaining traction as a newer option that offers sub-second latency at broadcast scale. Cloudflare rolled out a global MoQ relay network across 330+ cities in 2025. It uses a publish/subscribe model on QUIC, fans out efficiently, and avoids head-of-line blocking. Many teams now combine it with WebRTC for hybrid setups.
Supporting Technologies
- STUN/TURN for NAT traversal.
- Kafka or NATS for scalable signaling and events.
- Redis for presence and room state.
- Prometheus and Grafana to watch CPU, packet loss, jitter, and viewer join times.
- OpenTelemetry for full tracing.
These pieces keep the system observable when traffic spikes.
Typical Challenges at This Scale
Egress bandwidth dominates the bill. CDN costs can still surprise you during peaks. TURN usage adds expense when many users sit behind strict NAT. Sudden node failures cause reconnect storms. Vendor lock-in happens if you rely only on one cloud SDK without fallback plans.
Choosing the Right Approach
Real-World Architecture Example
Picture a music festival stream. Cameras and mixers feed an ingest layer via WebRTC or SRT. An origin cluster normalizes the feed, creates quality ladders, records archives, and adds basic processing.
One path stays real-time: WebRTC SFU nodes serve backstage teams, directors, and interactive VIP viewers with under-500 ms delay. Another path packages into LL-HLS segments and hands off to a global CDN for the million regular fans. Chat and reactions travel separately over WebSocket.
The split prevents any single layer from becoming a bottleneck. Edge proximity, adaptive quality, and independent scaling for signaling keep everything smooth even when the headline act starts and traffic surges. Monitoring catches packet loss or buffer spikes before they affect thousands of people.
Emerging Option: Media over QUIC (MoQ)
MoQ builds on QUIC (the transport behind HTTP/3) and treats media as named tracks that anyone can subscribe to. Relays forward objects without deep inspection, so one publish can reach many subscribers efficiently. Latency stays low while scale grows like a traditional CDN. Cloudflare’s network already demonstrates this at global reach. In 2026 many production teams test MoQ alongside WebRTC and expect it to handle large interactive broadcasts better than older protocols. It remains complementary – WebRTC for small-group interactivity, MoQ for massive fan-out.
Our Expertise in Action
We have built and scaled real-time video systems for platforms that push thousands of concurrent streams under real-world conditions. One online tutoring service we worked with handles up to 2,000 simultaneous students during peak exam periods using LiveKit SFU, adaptive HLS/DASH, and Kubernetes autoscaling. Latency stayed under 500 ms, and the platform earned an AWS innovation award for stability.
A virtual fitness platform scaled live group classes and 1-on-1 sessions to thousands of monthly active users with zero noticeable lag. We used LiveKit, WebRTC, and Redis-backed presence to keep scheduling and video in sync even during evening rush hours.
For a large e-learning SaaS serving over 100,000 users, we delivered secure WebRTC classrooms with whiteboards, screen sharing, and compliance features. The system grew steadily while maintaining GDPR and HIPAA standards.
In each case we combined spec-driven planning with hands-on testing under simulated packet loss and high load. These projects showed us how to balance low latency for active participants with cost-effective delivery for large audiences–exactly the trade-offs you face at 1 million scale.
FAQ
Can pure WebRTC reach 1 million viewers?
Not directly with peer-to-peer. You need SFU clusters or a hybrid approach. Single SFU nodes manage hundreds; distributed setups reach tens of thousands. For true millions, most teams add CDN delivery for the bulk of viewers.
What is the biggest cost driver?
Egress bandwidth. One high-quality stream to a million people can generate terabits of traffic. CDN usage, adaptive bitrate, and efficient codecs like AV1 keep this under control.
How low can latency really go at scale?
WebRTC or MoQ can stay under 500-1000 ms for interactive users. LL-HLS reaches 1-2 seconds for passive viewers. Pure HLS adds more delay but costs less.
Do we need to run our own servers?
Not always. Managed platforms like LiveKit Cloud handle scaling and give predictable pricing. Self-hosted Kubernetes works well when you want full data control or specific compliance.
Is MoQ ready for production in 2026?
Early production use is growing, especially on Cloudflare’s global network. Many teams run it alongside WebRTC for the best of both worlds. Full browser support continues to expand.
How do we test before launch?
Load-test with realistic geographic distribution, varying network conditions, and sudden spikes. Tools like Prometheus help catch issues early.
What about mobile users on variable connections?
Simulcast or SVC plus edge proximity help. We always tune for 4G/5G handoffs and add fallback qualities.
Can we add AI features later?
Yes, real-time noise suppression, upscaling, or moderation layers integrate cleanly once the base video pipeline is stable.
Next Steps
If your roadmap includes large-scale video–whether for events, education, fitness, or something new – reach out. We can review your latency targets, expected peak audience, and current stack, then sketch a practical architecture and rough timeline.
.avif)
Comments