Your Go-To Blog on React Native, AI & Multimedia

As mentioned in my Demuxed 2025 recap blogpost, I had the pleasure of delivering a lightning talk about a side project I’ve been working on: automatic knowledge extraction from the H.264 specification. Today, I would like to delve deeper into this topic, sharing more details than I could during the brief three-minute talk.

2 weeks ago, my colleagues and I attended the Demuxed 2025 conference in London, UK. It was a great opportunity to meet fellow video devs and share experience gained in the field of multimedia.

To learn more about WebRTC and SFU, check our article.

HLS — scalable workhorse

HLS takes a fundamentally different approach. Instead of maintaining persistent connections, it segments video into small chunks (typically 2–15 seconds) and serves them over standard HTTP. Clients download a manifest file that lists available segments and quality levels, then fetches segments as needed.

This HTTP-based approach means HLS works excellently with existing CDN infrastructure, passes through firewalls and proxies without issues, and scales to millions of viewers with standard web infrastructure. The simplicity of “just files over HTTP” makes HLS remarkably robust and widely compatible. The immediate downside is that the latency and synchronization vary widely depending on the chosen chunk size. This can be a dealbreaker for most applications that require users to be in sync and have the freshest video feed possible.

The only transcoding that needs to happen is when the video is initially received. RTMP is usually chosen for this purpose, which requires transcoding into HLS chunks for distribution. This is not that big of a deal, as the computation required scales linearly with the number of streams, not the viewers, as with WebRTC.

What to consider when choosing between WebRTC and HLS?

WebRTC and HLS are almost polar opposites in their characteristics, which makes choosing between them straightforward, provided you understand your requirements.

Latency — the defining difference

HLS (2–30+ seconds)

The segment-based approach of HLS introduces unavoidable latency. Even with optimized low-latency HLS (LL-HLS), you’re looking at 2–5 seconds minimum. Traditional HLS implementations often have 15–30 seconds of delay due to segment size, buffering requirements, and CDN caching.

WebRTC (< 500ms)

WebRTC delivers sub-second latency consistently, often achieving glass-to-glass delays under 200ms in optimal conditions. This isn’t just “nice to have” for interactive applications — it’s essential. Try having a conversation with even 2 seconds of delay, and you’ll understand why video conferencing platforms universally choose WebRTC.

Synchronization — keeping viewers together

HLS can have significant drift between viewers

Because each viewer fetches segments independently, HLS streams naturally drift apart. Two viewers watching the same “live” stream might be 10–20 seconds apart. Implementing true synchronization requires additional complexity, like synchronized playback timestamps or external coordination mechanisms.

WebRTC can keep everyone on the same page

WebRTC’s real-time nature means all participants experience the stream simultaneously. Synchronization happens naturally without additional engineering effort. This is critical for applications such as watch parties, live auctions, or interactive broadcasts, where viewers need to experience events simultaneously.

How do they scale?

HLS works well with modern infrastructure

HLS scales effortlessly to millions of concurrent viewers using standard CDN infrastructure. Adding viewers is simply a matter of serving files to more people — no different from scaling a website. CDNs handle this automatically with edge caching, making global distribution straightforward and cost-effective.

The only other thing that you need to handle is transcoding to HLS, as you’ll probably receive the data via RTMP. You can sidestep this issue entirely by using an external service provider, but doing that on your own shouldn’t be too hard.

WebRTC is challenging to do on your own

WebRTC’s peer-to-peer nature doesn’t naturally scale beyond small groups. Broadcasting to many viewers requires either mesh networks, SFU servers (Selective Forwarding Units), or MCU servers (Multipoint Control Units). Each approach requires significant infrastructure and careful capacity planning.

Scaling WebRTC to hundreds of viewers is a very challenging task, and you should know that implementing it on your own can cost you lots of money and dev time. WebRTC scalability is mostly a solved issue, and it’s worth paying for a service that handles this complexity for you.

WebRTC vs. HLS — what about the costs?

HLS is as cheap as it gets

HLS leverages commodity CDN bandwidth, typically costing $0.01–0.05 per GB. The infrastructure can be as simple as a single HTTP server. Operational overhead is minimal since it’s essentially static file serving.

WebRTC can get expensive

WebRTC requires specialized media servers that process streams in real-time. You’re paying for compute, not just bandwidth. Costs can be 10–100x higher than HLS for the same number of viewers. Additionally, you need STUN/TURN servers for NAT traversal, which adds complexity and cost. The engineering expertise required to operate WebRTC infrastructure reliably is also a significant hidden cost.

Paid services usually charge per minute of connection of a single peer and can range from $0.001 to $0.01 per peer connection-minute, which is significantly higher than HLS.

There is one special case to mention here — when you just need one-on-one calls. In this case, you can get the system working basically for free. Many applications showcase this, from free P2P file transfer, video calls, to streamer utilities. As long as you don’t need too many participants and server-side control over the call, you can just use the browser’s WebRTC implementation.

Ease of implementation and developer experience

HLS is as simple as HTTP

Implementing HLS playback requires a few lines of code using standard video players. Most platforms have native support (iOS, Android, smart TVs). The streaming pipeline is well-understood: encode, segment, upload to CDN, done. Debugging involves checking HTTP requests and examining manifest files.

WebRTC — challenging without abstractions

WebRTC implementation, on the other hand, is really complex. You may need to debug:

• ICE candidate gathering and exchange
• STUN/TURN server configuration
• Codec negotiations and SDP offer/answer dance
• Network topology changes and reconnection logic
• Browser-specific quirks and compatibility issues
• Media server scaling and load balancing

Experienced teams often spend months or years getting WebRTC right. It’s definitely not a walk in the park. On the other hand, the difficulty of using a set of SDKs for an existing WebRTC provider simply depends on their quality, and can be as easy as an HLS implementation.

Making the decision — choose a framework tailored to your project

HLS and WebRTC implementation

HLS implementation is straightforward enough to build yourself. Depending on your use case and business model, you may still opt for a more managed solution, especially because of the transcoding required on the ingest point from RTMP to HLS. It’s hard to go wrong with any reputable service here, but they may have subtle differences that you should consider.

The most important factors to consider when implementing HLS are the chunk size and the CDN provider. Both will directly affect the latency, synchronization, and cost of the solution. We would recommend you steer clear of LL-HLS, as support for this standard can be lacking across platforms, and tuning the segment size will suffice most of the time.

But what about WebRTC? Trust me, you don’t want to build your own WebRTC infrastructure. The time and expertise required to make it work, even from existing open-source software, can quickly become expensive.

Instead, use managed providers. Infrastructure providers handle the complexity of WebRTC behind abstractions that are much easier to use. When looking for WebRTC providers, you should consider their reliability, developer experience, costs, and any additional features that you may need.

Fishjam — making WebRTC truly accessible to developers

At Software Mansion, we’ve built Fishjam to make WebRTC easy to use for everyone. We have combined knowledge from our multimedia-focused projects, such as Membrane, Smelter, and Elixir WebRTC, and React Native open-source libraries like Reanimated, Screens, and Gesture Handler to craft the best solution, allowing you to add real-time streaming to your mobile and web applications.

The journey to release Fishjam took us two years, and it took a lot of existing knowledge from many experienced people. After all that, we can confidently say that WebRTC is haaard, but the good news is that you don’t have to experience that yourself.

Fishjam features:

• Easy-to-use SDKs
• Seamless integration with AI voice agents, transcription, and moderation services
• First-party integration with Smelter for programmable transitions, overlays, and interactive experiences (see our demo and the article about it)
• All at a very fair price

You can learn more and try out Fishjam for free at fishjam.io. And if you need any help along the way, don’t hesitate to contact us at [email protected].

We’re Software Mansion: multimedia experts, AI explorers, React Native core contributors, community builders, and software development consultants.

Chances are, you’ve come across gesture recognition before. If you’ve ever given someone a thumbs up with Apple’s Reactions or played around with Snapchat or TikTok filters, your device was recognizing your gestures in real time.

Acknowledgments: This blog presents a joint work between Software Mansion and L7mp Technologies. Special thanks to all contributors, who made this work possible: Michał Śledź, Piotr Wodecki, Jakub Pisarek, and Máté Nagy.