Why we built creator tools that never see your files

Here’s a slightly odd thing to say on a website that offers free tools: we don’t want your files.

Not your thumbnails, not your scripts, not your caption files. We built TubePrep so that we never receive any of them. Everything runs inside your browser tab, and when you close the tab, it’s gone.

That wasn’t an accident or a marketing angle we bolted on afterwards. It was the first decision we made, and it’s worth explaining why.

What you’re actually handing over

Think about what goes into a typical creator utility:

• A thumbnail for a video that isn’t out yet. Sometimes it’s for a brand deal that’s under embargo. Sometimes it’s a reveal: a new product, a big announcement, a face nobody’s supposed to know is on the channel yet.
• A script for that same video, with every beat of the reveal written out.
• A caption file, which is the script again, plus timestamps.

That’s the most sensitive version of your work, at the most sensitive time. And a lot of web tools ask you to upload it to a server you know nothing about, run by people you’ve never heard of, under a privacy policy you didn’t read, to answer a question like “is my text under the duration badge?”

Most of those services are probably fine. Probably nobody is looking. But “probably” is doing a lot of work there, and you can’t check.

The work doesn’t need a server

Here’s the part that bugged us: none of these tasks need a server in the first place.

Overlaying a few rectangles on an image is something browsers have done for well over a decade. Counting the words in a script and dividing by a number is trivial. Removing timestamps from a subtitle file is text processing. Checking that a list of timestamps starts at zero and goes up is, well, also text processing.

Modern browsers can read a file you choose directly from your disk (that’s the File API), draw on images (the Canvas API), and run as much JavaScript as you like. For tools like ours, there’s simply no step where sending the file anywhere makes the result better. It only makes it slower and riskier.

So we didn’t.

How to check whether a tool uploads

You don’t have to take anyone’s word for it, ours included. There are a couple of easy ways to check whether a web tool is sending your file somewhere.

Watch the network tab. In Chrome, Edge, or Firefox, open developer tools (F12 or Ctrl+Shift+I, Cmd+Option+I on a Mac), go to the Network tab, then use the tool. If you see a big request go out with your file in it, typically a POST request roughly the size of your file, it was uploaded.

Go offline. Load the page, then turn off your Wi-Fi and try the tool. If it still works, the processing is happening on your machine. If it spins forever or errors out, it needed a server.

Both checks take about thirty seconds. Run them on TubePrep. We’d genuinely like you to.

What we give up

Being honest about the trade-offs: building this way means there are things we can’t do.

We can’t save your files to an account, because there is no account. We can’t offer “your last ten thumbnails” across devices. We can’t run heavy machine-learning models on a GPU farm to, say, generate chapter titles for you.

We think that’s fine. The tools that need those things should exist, and you can choose them with your eyes open. But the small, frequent checks you do on every single upload shouldn’t come with a data-sharing agreement attached.

The short version

If a tool needs a server to do its job, it should tell you clearly what it uploads and why. If it doesn’t need one, it shouldn’t use one.

That’s the whole philosophy. The four tools we’ve built so far follow it, and anything we add in the future will too.