BYON: Build Your Own Netflix

The Jellyfin Setup Tutorial

At one point in every developer’s journey, we all tried to build a “Netflix clone.”

A sleek UI. Movie thumbnails. Maybe an IMDb API plugged in for metadata.

But the moment you actually try to make it real, you quickly realize something:

Media servers are not frontend projects. They are DevOps problems disguised as apps.

This is where most “Netflix clones” die.

In this guide, we’ll go beyond the clone mentality and build something real:

A self-hosted Netflix-style media system using Jellyfin, deployed with Coolify, and polished to feel like a real streaming platform.

We’ll go from:

• Zero setup
• Deploying on Coolify
• Configuring a media server
• And finally, making it look and feel like Netflix using plugins and custom styling

The Reality Check: This Is Not Just Frontend

Before we start building, let’s clear up a misconception.

A Netflix-like system is not:

• Just a React UI
• Just a movie API
• Just a UI clone with posters

It is:

• A media server
• A transcoding pipeline
• A deployment system
• A reverse proxy setup
• A UX layer on top of infrastructure

That’s why we’re using **Jellyfin** — an actual open-source media server that handles the heavy lifting.

Step 1: One-Click Jellyfin Setup with Coolify

Instead of manually configuring containers, ports, and volumes, Coolify lets you deploy Jellyfin in a single click.

If you don’t have Coolify installed,go through our blog on how to set it up.

If you already have Coolify installed, the process is straightforward:

1. Open your Coolify dashboard
2. Go to Projects and create a new project
3. click on add resource and search for jellyfin
4. Click Deploy

That’s it.

Coolify automatically handles:

• Docker image selection (jellyfin/jellyfin)
• Port exposure (default 8096)
• Persistent storage for:
• /config
• /media
• Internal networking and service wiring

Within a few minutes, your media server is live.

At this point, you already have a working system — but it still feels like a server, not a streaming platform.

Let’s change that.

Step 2: Understanding the Architecture You Just Created

What you now have is:

• Jellyfin (media server)
• Docker container running it
• Persistent storage for libraries
• A web UI exposed on a port

In simple terms:

You didn’t build a frontend. You deployed a media system.

Now we enhance the experience layer.

Step 2.5: Uploading Your Media Library (FileZilla & File Management)

Before you start polishing the UI, you need something important in place: actual media files.

A Netflix-like system is only as good as the library behind it, and this is where most setups quietly break down.

Jellyfin doesn’t magically “find movies” — you have to feed it structured media files.

Using FileZilla to Upload Media

A simple and reliable way to get files onto your server is via FTP/SFTP tools like FileZilla.

Once your Coolify server is running and your storage paths (like /media) are mounted, you can:

1. Connect to your server using SFTP credentials from Coolify
2. Navigate to your Jellyfin media directory (e.g. /media)
3. Upload your content in organized folders like:

• Movies
• TV Shows
• Documentaries
• Anime

4. In libraries add media libraries and assign them to the respective folders.

5. Finally click on scan libraries to import all your shows and movies.

Why Folder Structure Matters

Jellyfin heavily relies on structure for metadata matching:

• Each movie should be in its own folder
• TV shows should be split by season
• File names should be clean (avoid random download names)

Example:

/media/movies/Inception (2010)/Inception.mkv
/media/tv/Breaking Bad/Season 01/episode01.mkv

What This Step Really Does

This is the moment your system becomes real.

Without media:

You have infrastructure.

With media:

You have a streaming platform.

Once your library is in place and Jellyfin has scanned it, you’re ready to move on to the experience layer — where the UI starts to feel like Netflix.

Step 3: Making It Feel Like Netflix

Before

At this point i know you are wondering how this basic user interface can even be compared to the almighty Netflix. This is where you get to put on your frontend engineering cap.

We transform Jellyfin from a “server UI” into a Netflix-like experience using:

1. Plugins (Behavior Layer)

Install plugins like:

• Intro Skipper → automatically skips intros and credits
• Trailer plugins → hover previews and metadata enhancements
• Theme plugins → UI customization support
• Remote Upload → Allow ftp uploads from jellyfin ui.

These plugins don’t just add features — they change how the system feels.

2. Custom CSS (Visual Layer)

Jellyfin allows custom CSS injection, which is where we reshape the UI.

There are many theme styles available for use across the internet but if your aim is the netflix theme add the jellyflix import in your branding page :

@import url(“https://cdn.jsdelivr.net/gh/prayag17/JellyFlix@latest/default.css")

Jellyfin branding page

We import styling like:

• Netflix-style dark theme
• Bigger poster cards
• Hover zoom effects
• Clean spacing and grid layout improvements

At this stage, you’re no longer looking at a server dashboard.

You’re looking at a streaming platform.

After

After

3. UI Polish Philosophy

The goal is not to “decorate” Jellyfin.

It’s to:

• Remove friction
• Prioritize discovery
• Make browsing feel passive and immersive

Netflix is not special because of features.

It’s special because it is seamless.

That’s what we’re recreating.

Step 4: Domain + Access Layer (Optional but Important)

Once your setup is stable, you can:

• Attach a custom subdomain — This involves creating an A record in your DNS settings that points to the jellyfin server’s IP

• Route traffic through Coolify’s domain settings — click on settings in the services general configurations and edit the domain to point to your custom domain.Coolify automatically handles SSL Certification making your url https secure

This is what turns it from:

http://server:8096

into:

https://jellyfin.uzanet.co.ke

And at that point, it feels like a real product.

What You Actually Built

If you followed along, you didn’t just “install Jellyfin.”

You built:

• A self-hosted media infrastructure
• A deployment pipeline via Coolify
• A Netflix-like UI layer
• A customizable streaming system

Most importantly:

You moved from “building clones” to building systems.

Closing Thought

Every developer starts by cloning Netflix.

But the real upgrade happens when you realize:

You don’t need Netflix’s frontend.

You need Netflix’s architecture thinking.

And once you understand that, you can build it yourself.