I Killed My Netflix Subscription and Nobody Noticed (Except My Wallet)

Let me tell you about a tax you’ve been paying without realizing it’s a tax.

Every month, a handful of companies quietly remove a few dollars from your account in exchange for the privilege of watching shows that you don’t own, on their terms, for as long as they decide to let you. And here’s the part that should annoy you more than it probably does: they can revoke any of it, at any time, for any reason. A show you loved can vanish overnight because of a licensing dispute you’ll never hear about. The “are you still watching?” popup interrupts you mid-binge like a hall monitor. Your own home movies — the ones you shot yourself, on your own camera, of your own life — don’t even live in the same app as everything else, because why would a billion-dollar streaming company make room for your content?

You’re not really renting movies anymore. You’re renting permission.

So here’s a question worth sitting with for a second: what if you didn’t need their permission at all?

The Quiet Rebellion Called Jellyfin

There’s a piece of free, open-source software called Jellyfin, and what it does, stripped down to its bones, is almost embarrassingly simple: it turns your own server into your own private streaming service. Your shows. Your movies. Your music. Your home videos. All organized into the same slick, scrollable, poster-art interface you already know from the big streaming apps — except every single thing in that library is something you control, on hardware you own, with zero subscription fee, zero ads, and zero chance of some executive deciding to pull it tomorrow.

It’s not piracy software, and it’s worth being precise about that, because there’s a real and important line here. Jellyfin is a media player — a beautifully organized one — for content you already have a legitimate right to. That’s stuff you’ve personally filmed (weddings, trips, your dog being ridiculous), public domain films, Creative Commons releases, and your own ripped collection of discs you actually bought and own. What you put into it is on you; Jellyfin’s just the engine, agnostic about the cargo.

🔧 Technical note: Jellyfin is a fork of an older project called Emby, created back when Emby decided to move parts of itself behind a paywall. A chunk of the community forked the last fully open-source version and kept building it in the open, for free, forever. That’s the actual origin story — a small act of “no, we’re keeping this ours” that turned into one of the most beloved tools in the self-hosting world.

Here’s Where It Gets Interesting

Now, you might be thinking — fine, sure, but is it actually good, or is this one of those open-source things that technically works but looks like it was designed in 2009 by someone who really loved the color beige?

It’s good. Genuinely. Poster art pulled automatically from online databases, smooth scrubbing through episodes, watch progress synced across every device, the ability to keep multiple separate libraries (your movies don’t have to live next to your music), and apps for basically everything — phone, smart TV, browser, tablet. The kind of app where, if you handed someone your phone and said “check out this show,” they wouldn’t immediately clock it as homemade.

And here’s the twist that makes it genuinely worth your time rather than just a fun weekend project: once it’s running, you’ll probably forget it’s not Netflix. That’s not me oversell­ing it — that’s just what happens when the interface gets out of the way and the content just plays.

What You’re Actually Building

Let’s ground this. Picture a small home server — could be a tiny dedicated box, an old laptop you’re repurposing, whatever you’ve got lying around collecting dust. Jellyfin runs on it as a container (more on that in a second), and it watches over folders you point it at. Tell it “here’s where my videos live” and “here’s where my music lives,” and it goes off, reads the file names, fetches matching artwork and metadata from the internet, and presents it all back to you as a clean, browsable library.

🔧 Technical note: Jellyfin runs beautifully inside Docker, which — if you haven’t met it yet — is basically a way of packaging an app together with everything it needs to run, so it behaves identically no matter what machine it’s on. Instead of installing Jellyfin directly onto your operating system (and risking it fighting with other software over shared resources), Docker keeps it in its own little sealed box. If something breaks, you can usually nuke the container and rebuild it in under a minute, without touching anything else on your server. It’s less “installing software” and more “adopting a very well-behaved tenant who never touches your stuff.”

The Setup (Where Most Tutorials Lie to You)

Most guides for self-hosted software make it sound like a five-minute job. It mostly is — except for two specific landmines that trip up almost everyone, and I’d rather you hear about them now than discover them the hard way at 1 AM, the way most of us do.

Landmine #1: Hardware-specific leftovers in the template.

A lot of one-click Jellyfin installers (the kind bundled into home-server dashboards) are templated off setups built for Raspberry Pi hardware. Which means the install script might try to attach Raspberry-Pi-only hardware devices — camera modules, GPU interfaces specific to that board — to a container running on completely different hardware. The result: the container refuses to even start, and the error message gives you almost no useful hint as to why.

The fix is almost insultingly simple once you know it: before you launch the container, check what devices it’s trying to attach, and strip out anything Pi-specific that doesn’t apply to your actual hardware. Keep only the generic graphics device passthrough (commonly something like /dev/dri:/dev/dri, which just lets Jellyfin use your hardware's video decoding for smoother transcoding) and remove anything named after Pi-only components.

Landmine #2: The “it’s running but I can’t connect” mystery.

This one’s sneaky because it looks like the app crashed, but it didn’t — it’s alive, the port is technically open, but every connection attempt just resets, like knocking on a door where someone’s clearly home but won’t open it.

The actual cause, nine times out of ten: permissions. A lot of popular Jellyfin Docker images run internally as a specific, low-privilege user (not “root,” deliberately, for security reasons) — often user ID 911. If the folders Jellyfin needs to write to ever get touched by something else running as a different user — another app, the dashboard software itself — ownership can quietly shift, and Jellyfin loses write access to its own database without any obvious error telling you so.

The fix:

chown -R 911:911 /path/to/your/jellyfin/config
chown -R 911:911 /path/to/your/jellyfin/videos
chmod -R 755 /path/to/your/jellyfin/videos

(Swap /path/to/your/jellyfin/... for wherever you've actually pointed Jellyfin's folders — common setups use something like /data/jellyfin/config and /data/jellyfin/videos.)

That one command fixes a problem that, without knowing the cause, looks completely unsolvable.

Building Your Library

Once it’s actually running, the structure is refreshingly simple. Two libraries, typically:

• Movies/Videos — pointed at a folder like /media/videos
• Music — pointed at a folder like /media/music

And then there’s the fun part: filling them.

For your own ripped media, you just drop files into those folders directly. But there’s also a tool worth knowing about called yt-dlp — a free, actively maintained command-line downloader that can pull down audio or video directly onto your server. Combined with ffmpeg (a free, open-source media conversion tool used by, conservatively, half the internet’s video infrastructure behind the scenes), you can grab and convert media straight into your library folders from the command line:

yt-dlp --extract-audio --audio-format mp3 --audio-quality 0 -o "/media/music/%(title)s.%(ext)s" "URL"
yt-dlp -f "bestvideo[height<=1080]+bestaudio/best" --merge-output-format mp4 -o "/media/videos/%(title)s.%(ext)s" "URL"

⚠️ The part I’d be a bad guide for skipping: these tools are content-neutral — they’ll download whatever URL you give them, no questions asked. That neutrality is exactly why what you point them at matters so much. Recordings you made, content explicitly released under open licenses (Creative Commons, public domain), your own purchased media — all genuinely fine. Downloading and self-hosting something like a paid course or training program you don’t have a personal license for is a different story entirely, even though the tool won’t stop you and won’t even blink. The software is neutral. You’re not just a user here — you’re the one making the call on every file that goes in.

The Payoff: Watching From Anywhere

Here’s where last week’s Tailscale setup quietly pays for itself.

At home, you’d reach your Jellyfin server at something like:

http://192.168.1.50:8097

(your actual local address will differ — that’s just an example shape)

But because your server’s also sitting on your private Tailscale network now, the exact same library is reachable from anywhere on Earth using its Tailscale address instead:

http://100.81.6.70:8097

(again, an example — yours will be a different set of numbers, found the same way as in the Tailscale post)

Same server. Same shows. Same login. The only thing that changed is which address you typed — and suddenly, “my home media server” quietly became “my personal Netflix that follows me to any wifi on the planet.”

So, Why Bother

Here’s the honest pitch, no hard sell needed: you already pay for this convenience every month, to companies who can take it away from you at will. Jellyfin flips that arrangement entirely — more setup time upfront, in exchange for something that’s actually, permanently, fully yours. No price hikes. No “this title is leaving next month.” No ads wedged between episodes you’re paying to avoid ads on anyway.

And once it’s running? It just runs. Quietly, in the background, on a little box you mostly forget exists — right up until the moment you’re at someone else’s house, pull up your own library on your phone, and watch their face do a small double-take.