From VHS Tapes to a Private Linux Media Server

Origins of the Project

This project started with something much more personal than building a server.

My family has decades of home videos that were originally recorded on VHS tapes. Years ago, many of those tapes were transferred onto DVDs to preserve them as the original tapes aged.

But DVDs created a new problem.

The memories were technically preserved, but accessing them meant finding the right disc, putting it into a DVD player or computer, and navigating through old media. As technology continued moving away from physical media, I wanted a better long-term solution.

My goal was simple:

Preserve our family videos digitally and make them easy for my family to watch, while keeping the data private and under our control.

Preserving the Archive

The project began with media preservation rather than Linux or server administration.

The immediate task was to move the collection off the DVDs.

The discs used the traditional DVD-Video file structure, which typically consists of VIDEO_TS directories containing files such as .VOB, .IFO, and .BUP.

While this format works for DVDs, it isn't ideal for a modern digital media library.

I transferred the contents of the discs to an SSD and converted the footage into modern video files, primarily MP4, that could be easily organized, played, and streamed across different devices.

After working through the collection, I ended up with more than 100 GB of digitized family footage.

The journey of the data now looked something like this:

At this point, the footage was finally digital and organized.

Digitization solved the format problem, but it did not solve storage or access.

Choosing Privacy Over Convenience

The obvious solution would have been the cloud.

I could upload the videos to a video-sharing platform or cloud storage service and send my family links.

Technically, that would work.

But these aren't movies or public videos. They're personal family memories.

I didn't want convenience to automatically mean handing the entire collection to a third-party platform.

That changed the question from "Where can I upload these videos?" to "Can I host them myself?"

That question became the foundation for the technical decisions that followed.

Repurposing Existing Hardware

I already had an older PC available, so rather than purchasing dedicated server hardware, I decided to repurpose what I had.

I removed Windows and installed Ubuntu Server, turning the machine into a dedicated Linux server.

The SSD containing the digitized footage became part of the server's storage.

This was also an opportunity to become more comfortable working with Linux outside of a virtual machine or temporary lab environment.

Instead of completing an exercise and shutting the machine down afterward, I was now administering a system that served an actual purpose.

That meant thinking about storage, file permissions, services, networking, remote administration, reliability, and security as parts of one system.

And because this was real data that mattered to me, mistakes suddenly mattered too.

Building the Streaming Platform

Having the files on a server solved the storage problem, but I didn't want my family browsing through directories filled with MP4 files.

I wanted accessing the videos to feel natural.

That's where Jellyfin came in.

Jellyfin is an open-source, self-hosted media server. I installed it on the Ubuntu server and connected it to the family video library stored on the SSD.

Instead of navigating folders, the collection could now be accessed through a media interface.

In simple terms, I had created something resembling a private family Netflix, except the infrastructure and media remained under my control.

The initial architecture was relatively simple:

The simplicity is actually something I like about the project. There aren't unnecessary services or complicated infrastructure just for the sake of making the project sound impressive.

It solves a real problem.

Privacy as a Design Requirement

One of the most important parts of this project is something that isn't visible in a screenshot.

Privacy influenced the architecture from the beginning.

The entire reason for self-hosting was to avoid unnecessarily placing a large archive of private family footage on a public or third-party video platform.

That also means being intentional about what I document publicly.

I can explain the architecture, technologies, and lessons from this project without publishing information such as internal addresses, credentials, detailed network configurations, or other information that could unnecessarily expose the environment.

Security isn't just about adding security tools after building something.

Sometimes it begins with deciding what data should leave your environment in the first place.

More Than a Media Server

The part I find most interesting is still the full lifecycle of the data.

These videos began as magnetic recordings on VHS tapes.

They were transferred to DVDs.

I extracted and converted them into modern digital video files.

Those files moved onto an SSD.

That SSD became storage for an Ubuntu Linux server.

Jellyfin turned the server into a private streaming platform.

Remote access allowed that platform to reach family members thousands of kilometres away.

And now I'm thinking about NAS storage, redundancy, backups, cybersecurity, private cloud services, and locally hosted AI.

The chain has become:

Decades of technological change are represented in that one chain.

And instead of throwing away an older PC, I was able to give it another purpose.

What began as an attempt to preserve family memories became a practical exercise in Linux, networking, data migration, self-hosting, storage, privacy, cybersecurity, redundancy, and AI.

But the biggest shift has been how I think about the project itself.

I started by asking:

"How can I preserve these videos?"

Now I'm asking:

"What would private digital infrastructure for a family actually look like?"

I don't have the complete answer yet.

That's what makes me want to keep building it.