Switching from Netflix to Jellyfin on mobile wasn't just a change in service-it was an experiment in decentralized, software-defined media infrastructure.
In 2018, I began using Netflix. It wasn't the first streaming platform I tried, but it became my default for its seamless interface and broad catalog. Over time, that convenience came at a cost. My household's streaming consumption was locked into proprietary ecosystems. Then, in early 2023, things shifted. The idea of running my own media server began to feel less like a fantasy and more like an engineering problem worth solving.
Now, I have Jellyfin up and running on my home network, with mobile support across iOS and Android, handling everything from high-definition films to TV series. No more contract renewals, and no more catalog shiftsI manage it myself. This article documents the journey: not just a how-to guide, but a realized technical solution that addresses performance, media ingestion, and cross-device streaming at scale.
Why Move From Netflix to Jellyfin?
Netflix is an established, globally distributed service with excellent infrastructure for handling peak loads. It's built on top of AWS, GCP, and proprietary CDN layers. However, when you look under the hood, much of that power comes at the price of control.
I had grown weary of Netflix not just for content changes or pricing. But more so for its lack of local persistence. All my media was hosted on third-party infrastructure with policies I couldn't change. My personal library didn't exist beyond a user session tied to an account.
Jellyfin, on the other hand, provides the opportunity to own your streaming stack. Which in technical terms is an important distinction. It enables you to run everything from ingestion to delivery on your own hardware or cloud infrastructure using a software stack that's designed for open-source media delivery. This isn't just a streaming preference-it's an architecture shift.
The Technical Stack Behind My Jellyfin Setup
Deploying Jellyfin meant selecting tools, services. And infrastructure components that could reliably handle the demands of media streaming. This wasn't just about hosting-it required understanding performance constraints at both the file ingestion stage and during playback across edge clients.
My setup is composed primarily of an Ubuntu Server 22. 04 LTS machine running with Docker containers. Jellyfin runs within a container, which means I can version-control configurations and upgrade safely without manual intervention on host systems.
Here are the main components:
- Ubuntu 22. 04 as the base OS
- Docker for container management using Dockerfile automation
- Nginx proxy to handle internal and reverse proxying
- ZFS pool with snapshots
- OpenZWave for external device integration (in the future)
Performance is critical for media streaming. So I've configured the container to use dedicated CPU cores and memory allocation to keep latency low during playback.
Building a Portable Jellyfin Deployment for Mobile Devices
Cross-platform streaming isn't trivial. The goal wasn't just to stream at home. But to support mobile users on Android and iOS-while maintaining reliability and scalability. My setup is designed with SRE principles in mind: observability, performance tracking. And failure handling.
The Jellyfin mobile app uses a REST-like API exposed via a proxy that also supports authentication flows. I set up reverse proxies using Nginx to route traffic to the containerized Jellyfin server through HTTPS. The challenge here wasn't architecture-it was making it robust across networks with varying bandwidth and quality.
I configured a security policy that aligns with modern security standards. I've implemented:
- Two-factor authentication
- Rate limiting to prevent abuse on the reverse proxy
- HTTPS certificate automation through Let's Encrypt
Configuring Media Handling and Ingestion Workflows
One of the key technical decisions was around media ingestion. Jellyfin is flexible. But it doesn't manage downloading or organizing files by default. That responsibility falls to you.
I use a combination of scripts and automation tools like ffmpeg to convert videos into formats compatible with Jellyfin and the mobile platform. For example, H. 264 encoded movies are automatically transcode to VP9 on demand for low-bandwidth mobile devices.
The media management is handled by a script that scans directories periodically. It uses Jellyfin's API to push metadata Updates. Which includes poster art, release dates. And description tags-making each content item searchable via a structured database.
Cross-Device Performance Optimization
Mobile streaming presents a unique set of challenges: variable bandwidth - backgrounding apps, and client performance. My primary objective here was to balance media quality with device limitations. Jellyfin supports adaptive streaming through HLS and DASH.
In particular, I've found that pre-transcoding videos to multiple resolutions works better than relying solely on dynamic transcoding when devices are offline or limited in processing power. Using a tool like FFmpeg to generate HLS renditions per title speeds up playback and reduces CPU stress on mobile clients.
The performance gains are noticeable. I run around 10 simultaneous users-5 at home, 5 using mobile data-and haven't seen performance drops under normal load conditions.
Security Considerations and Access Control
Security is paramount when running your own media stack. One of the biggest misconceptions is that local deployments are inherently safe. They're not-especially when dealing with public-facing services.
Rather than relying on default user authentication, I built a custom access model that supports OAuth2-based login through an external identity provider. This also includes fine-grained permissions per directory and item within Jellyfin itself.
Access policies are applied using Nginx modules like auth_request, and I've also implemented network-based controls to gate access based on IP ranges-a crucial feature when your server is outside a trusted network.
Observability and Logging for Media Server Operations
I built monitoring using Prometheus and Grafana dashboards, which track streaming duration, user activity patterns - buffer sizes, and transcode performance. It's not just about uptime-it's the data-driven approach to tuning server performance over time.
This is how I identify bottlenecks in file serving or during transcoding. When a user reports buffering issues, my dashboards show if the bottleneck is local or network-based. This visibility has allowed me to refine settings like buffer sizes and quality profiles dynamically.
The system also logs metadata of each playback event, not just what's streaming but when, for how long, and by which client device. These logs feed directly into an external analytics tool that I use for performance reporting.
Beyond Streaming: Jellyfin as a Media Management Platform
Jellyfin is more than just a media player-it's a full platform for organizing content with rich metadata support, automated tagging. And library maintenance features. I've configured it so that new items are automatically tagged with IMDb IDs if available, allowing me to integrate with external APIs like TMDb for rich artwork and details.
The platform also supports:
- Multi-user support
- Plex-like user libraries
- Automatic update discovery and notifications
- Plugin architecture for feature expansion
This means I can manage my own content without relying on Netflix's algorithms or subscription tiers. It's an infrastructure project, not just a streaming client upgrade.
Mobile App Challenges and Solutions
Mobile clients were one of the most significant hurdles-especially in Android, where app permissions and backgrounding behaviors can break playback continuity.
I used Android foreground services to keep streaming active when backgrounded. For iOS, I had to implement a custom approach that leverages system audio APIs, with periodic restarts to ensure connectivity is restored.
In cases of unstable networks or cellular connections, Jellyfin's ability to cache HLS segments locally helps maintain playback without requiring constant re-fetching of content. The mobile apps support smart caching and can be configured to pre-fetch content when connected to Wi-Fi.
Cost-Benefit Analysis: What You Lose in Convenience You Gain in Control
The biggest tradeoff is time investment. I've spent weeks configuring access controls, setting up automated backups, and ensuring performance under load. It's not a drop-in replacement like Netflix.
However, the benefits are tangible:
- Ownership of content-no more sudden catalog removals
- No hidden fees or premium tiers
- Customizable metadata and artwork
- Full control over data privacy
A typical user may see a few extra hours per month in setup. But the long-term gains are clear. The infrastructure is reusable across hardware upgrades or server migrations.
Integration with Cloud Infrastructure and Automation Scripts
Automated deployment and updates are essential for managing media stacks at scale. My Jellyfin setup uses Docker Compose. Which I've wrapped in shell scripts that monitor system status, auto-update containers and handle restarts post-upgrade.
I also integrate Jellyfin with GitHub Actions to deploy configuration changes automatically when I push updates. For redundancy, I run backups using ZFS snapshots. Which capture the entire state of data for rollback if needed.
This system is a form of infrastructure-as-code. Where changes are logged, tested. And deployable-key principles for SRE engineers and DevOps practitioners.
Moving Forward: What's Next in My Jellyfin Journey?
I see a future where I continue expanding Jellyfin's features, particularly plugin usage for custom integrations with smart home devices or AI-based content suggestions. It's not just hosting-it's building an open media stack that mirrors what Netflix does but on my own terms.
Looking ahead, I'm exploring:
- Machine learning tagging using OpenCV and TensorFlow
- Custom UI enhancements
- Integration with local storage solutions like Ceph or GlusterFS
The flexibility is immense-unlike Netflix, I own the pipeline. Even if a single point of failure occurs in my environment, it won't affect global access to content.
Conclusion: It's Not Just Streaming, It's Infrastructure Engineering
Moving from Netflix to Jellyfin wasn't a simple UI swap. It required deep understanding of media formats - networking protocols, and distributed systems, and the resultA media infrastructure that's reliable, customizable. And portable-all wrapped in the security practices that modern SRE teams expect.
It's a reflection of how developers can use open-source platforms to gain control over their digital experiences while building technical expertise along the way. If you're serious about your personal or enterprise media stack, Jellyfin is worth exploring-not as an alternative but as a platform for re-engineering control and automation.
For more on infrastructure automation in media workflows, check out the USENIX NSDI '21 paper on content delivery.
What do you think?
What are your thoughts on decentralized media libraries?
Do you prefer platform control or local ownership in distributed systems?
If you're a developer working on streaming infrastructures, how do you balance performance and user experience?
.Need a Custom App Built?
Let's discuss your project and bring your ideas to life.
Contact Me Today โ