Cutting Live Broadcast Latency From 7 to 2 Seconds for a Group Chat App
ChatBCC is an invite-only community app where actors, reality stars, and athletes host group chats and talk directly with their fans. The product was built around chat, and it worked well for that. But hosts kept asking for a way to go live together, talk with their community in real time, or react to a new episode moments after it drops.
We worked together to build Live Spaces with Fishjam, our multimedia hub solution. Using Fishjam, we were able to reduce broadcast latency from 7 seconds to around 2 seconds while lowering costs by roughly 40% compared to market alternatives.
- Mobile app development
- Backend development
- System architecture
- Real-time video integration
- Performance optimization
- UX/UI improvements
- App Clip implementation
- Observability & triage
- Fishjam multimedia hub
- React Native
- React
- Apollo GraphQL
- Swift
- Kotlin
- GraphQL
- TypeScript
- React Router

Challenges & goals
Building Live Spaces meant introducing an entirely new product category within ChatBCC. To make it right, together with ChatBCC, we rethought the underlying infrastructure, data consistency model, and the entire session lifecycle. During our collaboration with the client, we aimed to give hosts a new tool for engaging communities, drive new membership growth, and tie live sessions into the existing message system.
For this to happen, we focused on:
- Evaluating and choosing the right broadcast stack
- Composing multiple host streams into a single viewer feed without ballooning infrastructure costs
- Maintaining state consistency across four separate systems: Fishjam, the compositor, the mobile app, and the API layer.
Building and benchmarking three PoCs of Live Spaces in two weeks
Live Spaces is a real-time video session built directly into a ChatBCC room – hosts broadcast live to their members, viewers watch and react, all without leaving the community where the conversation happens.
Before implementation began, we worked together with ChatBCC to evaluate different architectures for Live Spaces and identify the solution best suited to their product and business goals. One of the options we considered was Fishjam – our multimedia hub built and maintained as a commercial product. It provides a complete real-time media stack, including a WebRTC SFU, server-side compositing, and broadcast capabilities.
Together, we decided to build and benchmark Fishjam and LiveKit side by side under real-world conditions to make a data-driven technology decision. The architecture assumed two distinct delivery paths: WebRTC for communication between participants hosting the session, and LL-HLS via MUX for distributing the stream to viewers at scale. The initial evaluation focused on two variants:
- LiveKit + MUX (LL-HLS delivery)
- Fishjam + MUX (LL-HLS delivery)
Within two weeks, both implementations were running and ready for comparison. The primary evaluation criterion was latency between participants hosting the live session and viewers watching and interacting through comments and reactions.
During testing and demos, together with the client, we observed approximately 7 seconds of end-to-end latency in both variants. Since participant-to-participant communication used WebRTC and remained near real-time, the bottleneck was clearly the LL-HLS delivery path through MUX on the viewer side.
Based on these findings, we proposed a third approach that removed MUX entirely and relied on Fishjam's WebRTC-based delivery end to end, enabling significantly lower participant-to-viewer latency and a more interactive live experience. Thanks to Fishjam, the client was able to reduce the latency to ~2 seconds.
Cost was another advantage of our multimedia hub. Here’s a simple breakdown and comparison for a reference session (60 minutes, 3 hosts, 500 viewers, streamed in 720p resolution at 2 Mb/s):
- Fishjam: ~$20
- Fishjam + MUX: ~$33.50
- LiveKit + MUX: ~$34
Fishjam made it possible to reduce the broadcasting costs by ~40%. For a platform where live sessions happen regularly across many host communities, that difference adds up fast.
How Fishjam handles compositing and broadcast
Fishjam takes the audio and video streams from all hosts and combines them into a single broadcast stream that can be delivered to viewers at scale. The key thing is that compositing isn't a separate service or a piece of custom infrastructure; it's built directly into the Fishjam platform.
Layouts, speaker tiles, VAD speaking outlines, avatars, names, mic/cam state, and even different broadcast and recording variants are configured in backend code, applied by Fishjam’s compositing service and distributed through its broadcasting capabilities.
For the ChatBCC team, this meant they didn't have to spend engineering time building and maintaining complex multimedia backend infrastructure. Instead, they could focus on developing more cool product features. With most of the heavy lifting handled by Fishjam, the integration is simple and lightweight while enabling low-latency, cost-effective live streaming at scale.

Working directly with the creators of the tool makes all the difference
Throughout the project, we worked closely with both the ChatBCC team and the Fishjam engineers, allowing us to iterate on the compositing capabilities that power Live Spaces.
When something didn't work, we could simply talk to the engineers building Fishjam and work through issues together. One example worth mentioning was conference room stability. After significant debugging, we traced the root cause to the SDK level – something that couldn't be patched from JavaScript. The fix ultimately required changes to the underlying WebRTC implementation and close collaboration with Fishjam's core team. That kind of access simply isn't available when you're a customer of a third-party platform.

Keeping four systems in sync
The Live Spaces feature has a lifecycle: green room, going live, multi-host transitions, recording, teardown. At every stage, API layer, Fishjam, the compositor, and the mobile app need to agree on what's happening, but in production, they don't always get the memo at the same time.
We noticed that some of the most challenging issues only surfaced under real-world conditions and were difficult to spot in development environments. For example, on iOS, moving the app to the background could permanently disable the camera due to differences in how production and development builds handled app lifecycle/state. In another case, an incoming alarm or phone notification at the exact moment a user joined a room could leave audio in a broken state.
We also investigated numerous reports of microphone failures that ultimately turned out to be caused by unexpected interactions with Bluetooth audio devices. Resolving these issues required analyzing how the application behaved across different devices, operating systems, and real-world user environments.
Many of these issues only surfaced under production conditions, which is why we dogfooded the feature internally, running team syncs through the app to uncover edge cases long before they reached users.

Our approach to testing a real-time product
The Live Spaces feature couldn't run in a simulator, so development and testing had to happen primarily on real devices. To speed up iteration, together with the client we decided to try out SimCam, our tool that emulates a camera feed within the iOS Simulator, allowing us to test video workflows without constantly setting up physical hardware.
We also worked on refining cross-platform audio – since iOS and Android expose different audio session APIs, they behave differently when it comes to device switching, echo cancellation, and background modes. To ensure a consistent experience across both platforms, together with the client we decided to use customized fork of React Native WebRTC, which provides native modules for iOS and Android.


Results
We worked with ChatBCC to take Live Spaces from an idea to a complete, low-latency, and affordable real-time media pipeline. Some of the highlights of our collaboration include:
- ~2s broadcast latency achieved with Fishjam (down from over 7s initially)
- ~40% lower broadcast cost per reference session
- 3 comparative PoCs delivered in just 2 weeks to allow the client to make a data-based architecture decision
- 70+ merged PRs and 15,128 lines of code on mobile
- 70+ merged PRs and 16,974 lines of code on backend