Quick Facts

Client: Regional Telecom Operator
Industry: OTT / IPTV / Streaming
Platform: Android TV Native App + Web Admin Dashboard
Market: Regional (expanding)
Users: Households, Administrators, Operators
Core Tech: Spring Boot, Kotlin, ExoPlayer, PostgreSQL, Redis, React.js
RigRex Services: Product Strategy, Full-Stack Development, Android TV Development, Admin Dashboard, Microservices Architecture

Background

A regional telecom operator expanding into OTT services needed a differentiated offering that combined live TV with modern streaming flexibility. Subscribers were migrating to global streaming platforms, and the client had no unified platform to compete. Content was sourced from multiple providers using M3U and M3U8 playlist formats with no management layer, making it difficult to onboard new channels or update lineups. Family households demanded robust parental controls, a feature absent from generic IPTV players, and the client lacked a centralized dashboard to monitor subscriber activity, manage content, or troubleshoot issues in real time.

The Challenge

Business Challenges

• Subscribers migrating to global streaming platforms
• No differentiated offering combining live TV with modern streaming flexibility
• Family households required robust parental controls not available in generic IPTV players
• No centralized operational visibility into subscriber activity or content performance

Operational Pain Points

• Content sourced from multiple providers with no unified management layer
• Onboarding new channels or updating lineups was difficult and manual
• No automated recording or time-shifting capabilities
• Operators had no real-time monitoring or troubleshooting tools

Technical Challenges

• Building a scalable microservices backend handling 5,000+ concurrent streams per node
• Processing large EPG XML files (50+ MB) without memory pressure
• Supporting dozens of stream URL formats across M3U playlists
• D-pad navigation UX for complex EPG grids and multi-tab interfaces
• On-device recording with conflict resolution and storage management
• Server-side enforcement of parental controls that cannot be bypassed client-side

‍

What Was Built

Architecture and Tech Stack

Backend:

• Framework: Spring Boot 3.x (Kotlin)
• Authentication: Spring Security + JWT
• Database: PostgreSQL 15
• Caching: Redis 7
• Object Storage: MinIO
• Task Scheduling: Spring Scheduler + Quartz
• Messaging: RabbitMQ
• Monitoring: Micrometer + Prometheus + Grafana
• Containerization: Docker + Docker Compose

‍

Android TV:

• Language: Kotlin
• Min SDK: API 21 (Android TV 5.0)
• UI: Leanback Library + Custom Components
• Media Playback: ExoPlayer 2.x (HLS, DASH, RTSP)
• Local Database: Room Persistence Library
• Networking: Retrofit 2 + OkHttp 4
• Dependency Injection: Hilt
• Background Processing: WorkManager
• Architecture: MVVM + Clean Architecture

‍

Admin Dashboard:

• Framework: React.js 18
• State Management: Redux Toolkit
• UI: Ant Design
• Charting: Recharts
• API Client: Axios

‍

Electronic Program Guide (EPG)

A regional telecom operator with 500+ channels and 48 hours of program data needed an EPG system that could deliver sub-second load times without overwhelming mobile devices. The EPG Ingestion Service runs as a scheduled Spring Boot process pulling XMLTV-formatted program data from multiple provider endpoints. A custom parser built with Jackson Streaming API processes large XML files (often exceeding 50 MB) using event-driven parsing rather than loading entire documents into memory.

Program data is normalized into a relational schema with channels, programs, categories, and time slots. A Redis caching layer maintains a 48-hour rolling window of EPG data, serving the Android TV client with sub-50ms response times. On the client side, the EPG is rendered using a custom RecyclerView-based grid component built on top of the Leanback library's browsing framework, supporting horizontal time-based scrolling and vertical channel switching, all optimized for D-pad navigation.

• Sub-800ms first load time, sub-50ms cached response
• XMLTV format for maximum provider compatibility
• Incremental sync transmitting only changed program slots after initial load
• Local Room database cache for offline functionality
• Programs color-coded by genre with detailed descriptions, cast info, and recording options
• Background sync via WorkManager

M3U / M3U8 Playlist Import

Users needed the flexibility to import their own channel playlists from any IPTV subscription. The Playlist Management Service exposes REST endpoints for file upload and URL-based import. A robust parser handles both M3U (static playlists) and M3U8 (HLS master playlists) formats, extracting channel metadata including name, group, logo URL, language, and stream URI.

The parser was designed to handle format inconsistencies commonly found in community-maintained playlists, including missing tags, non-standard attributes, UTF-8 BOM markers, and Windows-style line endings. Imported playlists are validated for stream accessibility via async health checks, and channels with unreachable streams are flagged rather than silently dropped.

ExoPlayer was built with a cascading source factory that attempts HLS parsing first, falls back to progressive download, and finally tries RTSP. A pre-flight probe mechanism tests each stream on import and tags it with the verified playback strategy, ensuring zero-delay channel switching.

• File picker for locally stored .m3u files and URL input for remote playlists
• Full-text search enabled across imported channels
• Custom favorites groups
• Background service refreshes URL-based playlists periodically
• Channel switch latency under 1.5 seconds

User Management and Authentication

Authentication is handled via Spring Security with JWT-based stateless sessions supporting three distinct roles: Super Admin (full platform control), Operator (subscriber management and content curation), and Subscriber (profile management and viewing preferences). Each subscriber account supports up to 5 household profiles with independent viewing history, favorites, EPG preferences, and parental control settings.

Profile switching on Android TV is PIN-protected and optimized for D-pad navigation. Token refresh is handled transparently using an OkHttp interceptor that detects 401 responses, acquires a new token, and retries the original request without user intervention.

• JWT-based stateless authentication for horizontal scaling
• Device registration with configurable concurrent stream limit per account
• Self-service password reset via time-limited OTP
• Up to 5 household profiles per subscriber account

Parental Controls

Family households needed robust parental controls that could not be bypassed. The Parental Control Service operates at the profile level with server-side enforcement at two layers: Content Rating Filters (channels and programs filtered based on TV-Y, TV-PG, TV-14, TV-MA ratings) and Channel Blocklist (specific channels blocked regardless of rating). Time-based restrictions configure viewing windows per profile, and all settings are protected behind a 4-digit PIN stored as a bcrypt hash.

The app enforces parental controls locally using cached profile rules, ensuring restrictions apply even during network interruptions. Restricted content is excluded from API responses entirely, not merely hidden client-side.

• Server-side enforcement preventing client-side bypass
• Content rating filters, channel blocklist, and time-based restrictions
• PIN protection with 15-minute lockout after three incorrect attempts
• 38% adoption rate across household accounts

Auto Program Save (Intelligent Recording)

The Recording Scheduler Service combines EPG data with user-defined rules to create an intelligent recording pipeline. Users define capture rules based on specific programs, keywords, time slots, or series linking using EPG series identifiers. The backend evaluates all active rules against the upcoming 48-hour EPG window and pushes matched schedules to the Android TV client via a sync endpoint.

All recording happens entirely on the device using a foreground service that captures the active stream via ExoPlayer's MediaCodec pipeline and writes it directly to local storage (internal or external SD card) as MP4. A StorageManager component monitors available disk space and alerts users when storage drops below a threshold. Automatic cleanup removes recordings older than the configured retention period (default 30 days) with grace period notifications.

• 45% utilization rate across active subscribers
• Specific program, keyword, time slot, and series-based capture rules
• On-device recording with automatic storage management
• Conflict resolution using user-assigned priority rankings
• Playback with seek, pause, and resume position persistence

Admin Dashboard

The administrative dashboard is a React.js single-page application communicating with the Spring Boot backend via a dedicated Admin REST API secured with role-based access control. Dashboard modules include Subscriber Analytics (real-time active viewers, peak usage patterns, popular channels and programs, geographic distribution), Content Management (bulk playlist upload, EPG source configuration, channel ordering), User Administration (subscriber search, account suspension, device management), System Health (real-time stream health checks, API response time percentiles, error rate tracking), and Recording Management (view scheduled and completed recordings, monitor storage utilization).

• Real-time monitoring of 5,000+ concurrent streams per node
• Materialized views for fast dashboard loading
• Preview channels as they appear on Android TV
• Email and Slack notification channels for threshold breaches

Key Engineering Decisions

EPG Data Volume at Scale With 500+ channels and 48 hours of program data, the full EPG payload exceeded 12 MB. Implemented pagination and delta-sync strategy where the initial load fetches only the current 2-hour window for visible channels. Subsequent updates use ETags and server-side diffing to transmit only changed program entries, reducing typical sync payloads to under 50 KB.

Stream Format Compatibility M3U playlists use dozens of stream URL formats (HTTP live streams, RTSP feeds, MMS protocols, direct MP4 links) with inconsistent or missing codec information. Built ExoPlayer with a cascading source factory that attempts HLS parsing first, falls back to progressive download, and finally tries RTSP, with pre-flight probe mechanism testing each stream on import.

D-pad Navigation UX Designing a complex EPG grid and multi-tab interface for television remote input required a focus-management framework maintaining clear visual focus indicators, predictable navigation paths, and contextual shortcut hints. Integrated Android TV's built-in voice input as the primary text entry method with fallback on-screen keyboard.

Results

Platform Performance

• 10,000+ active households
• 99.7% uptime since launch
• Average EPG load time under 800ms (first load)
• Channel switch latency under 1.5 seconds
• 5,000+ concurrent streams per node

Business Impact

• 22% subscriber churn reduction within 6 months post-launch
• 38% parental control adoption across household accounts
• 45% auto-record feature utilization across active subscribers
• 4.4 / 5.0 app store rating

User Engagement

• Subscribers using EPG had 3x longer session times than linear browsers
• EPG emerged as the highest-ROI feature investment based on engagement data

Why It Matters

StreamVault demonstrates that a well-architected IPTV platform built on proven technologies can compete with established players while offering differentiated features like flexible playlist import, intelligent recording, and robust parental controls.

For RigRex, this project showcases expertise in:

• Microservices architecture for high-concurrency streaming platforms
• Native Android TV development with complex D-pad navigation UX
• Event-driven parsing for large-scale data processing
• Server-side security enforcement that cannot be bypassed client-side
• Real-time administrative dashboards with operational visibility

‍