Live streaming platform: from backend to frontend

The client:

Live streaming platform provider

Intention:

Revamp the existing solution to meet upcoming event streaming demands and scale for future use with no custom optimizations

Oxagile’s team:

Back-end and front-end engineers, iOS and Android developers, DevOps

The solution delivered:

A fully re-engineered and redesigned live streaming solution, built for scalability, low latency, and integrated advertising

Platforms:

Web, iOS, Android

Core success metrics

ultra-low live streaming latency

high-throughput data processing per stream

end-to-end solution delivery timeline

Project setup: tight deadlines, ambitious goals

“The client requested a product revamp to be completed within a short timeframe ahead of a major live sports streaming event. This was not a simple, one-off feature update. It marked a pivotal stage in the product’s evolution. The goal was to lay the foundation for a scalable solution capable of streaming future events without any custom tuning.

For Oxagile, it was clear that successful delivery would require senior-level domain and technical expertise. The team needed specialists who could move quickly, collaborate closely, manage multiple workstreams, and ramp up on the solution’s architecture with minimal delay.’”

— Oxagile’s Delivery Manager

Translating the business case into clear tasks

Low-latency live streaming

Deliver real-time streams with minimal delays, so fans can experience the action as it happens without missing a moment.

In-portal ad management

Give the client precise control over ad settings, managed directly within the live streaming platform.

In-stream ad delivery

Integrate and display targeted ads smoothly during live streaming sessions.

The live streaming solution we set out to re-engineer

When we received the request and kicked off the project, we took a deep dive into the system, which looked like this:

Monolithic
All platform logic concentrated in a single, oversized JSON file

Manual
Reliant on hand-edited updates by administrators

Rigid
Difficult to modify or adapt without direct file changes

The platform we built from scratch, lightning fast

Oxagile comments on the project:

“We delivered a full transformation in a remarkably short time. The team engineered a robust backend, a serverless AWS architecture, an admin panel, and redesigned mobile UX/UI. The result was a unified system that’s easy to manage, well-structured, scalable, and secure.

For the client, it was a true step change: moving from a fragmented, file-based setup to a custom solution capable of livestreaming a major international sports tournament and scaling to support more events in the future. It also opened the door to new event producers looking to broadcast and monetize them through advertising.”

digital advertising platform

A look back at the transformation journey

Admin panel and backend

With full ownership of the project delivery, we crafted a well-organized, intuitive live streaming solution from scratch.

Engineering scope:

Developed a robust backend architecture using AWS services, a database, and a caching layer
Created a full-featured admin panel from scratch to replace manual event configuration
Introduced an intuitive interface for managing events, organizations, and advertising campaigns
Transformed system management into a centralized, user-friendly control hub for web and mobile
Engineered the admin panel to be flexible, scalable, and easy to extend with new features

Advertising setup for iOS

We introduced mobile ad logic in the iOS app, fully configurable via an admin panel.

The advertising configurations:

Ads are preloaded, cached, and prioritized for smooth playback
Up to three videos loaded concurrently to avoid network strain
Delays between showing ads prevented overlapping playback
The admin dashboard controlled uploads, timing, and repetitions
Real-time, socket-based insertion placed ads into slots
Analytics tracking at 25% viewing intervals, caching events and sending them at regular intervals
Supported formats included squeezeback and overlay

Customizing rewind for Android

Oxagile’s mobile team implemented a custom rewind feature for the client’s Android live streaming app.

Engineering scope:

Designed a workaround for live streams not compatible with HLS/DASH formats
Built a custom buffering mechanism by recording live data to a temporary file
Enabled dual-source playback (live stream + buffered file) to support rewind functionality
Overcame limitations of the native player and the client’s SDK, which lacked fast-forward/rewind capabilities
Developed logic to store, timestamp, and retrieve buffered segments for smooth playback
Implemented state reset and playback position tracking across player instances
Delivered flexible rewind functionality (e.g., 30 seconds and beyond)

What makes this system valuable to the client

Elastic scalability
Low-latency design
Resilient by design
Observability & monitoring
Scalable performance tuning path

Elastic scalability

A horizontally scalable, stateless architecture that automatically handles growing demand.

Tech stack that drives this:

API Gateway
AWS Lambda
Amazon Kinesis
Amazon Cognito
Redis
SSM Parameter Store

Low-latency design

Optimized request handling and data access ensure fast response times.

Tech stack that drives this:

Fastify
Redis caching (TTL + jitter)
Batched database writes

Resilient by design

A fault-tolerant system with built-in retries and managed infrastructure ensures reliability.

Tech stack that drives this:

AWS Lambda retries
Kinesis retry policies
Fully managed AWS services

Observability & monitoring

Strong visibility into system behavior and performance is achieved.

Tech stack that drives this:

AWS Lambda Powertools
Amazon CloudWatch

Scalable performance tuning path

The system is ready to support extreme loads with targeted optimizations.

Tech stack that drives this:

k6/Gatling for load testing
Lambda concurrency controls
API Gateway throttling
Provisioned Concurrency

Project technologies

Languages

Kotlin • Swift

AWS

EventBridge • IoT Core • Lambda • API Gateway • Cognito • RDS • S3 • CloudFront • Kinensis

Frontend

React Native with native iOS and Android Player SDK

Backend

Node.js • Fastify • Prisma • Postgres

Infrastructure

Serverless Framework

How Oxagile delivered value under strict deadlines

Trust →

A predictable weekly demo rhythm kept the client closely aligned on progress and direction. The team made decisions independently. This transparency provided with confidence even in high-pressure, no-margin-for-delay conditions.

Team autonomy →

Without external architectural oversight, Oxagile was trusted to make all technical decisions internally. This enabled fast execution, rapid mobilization, and the ability to build complex systems from scratch under strict time constraints.

Full ownership →

Oxagile took end-to-end responsibility for delivery, from architecture to implementation. With shared responsibilities across the team and no single points of failure, the solution was built to be resilient and scalable.