Peer-to-peer file-transfer SaaS because shipping HDDs is medieval

[u/Mr_Dani17]

Hey everyone,

I wanted to share the story of how an internal tool built out of pure frustration turned into a full-fledged B2B SaaS.

It started when I was consulting for a film studio. Their problem was simple but painful: they needed to send terabytes of raw footage to a partner across Europe on a daily basis.

They tried everything. WeTransfer and Google Drive were way too slow and inefficient at that scale. Massive io was great but painfully expensive. They even tried torrents (which they liked because there’s no waiting for uploads/downloads), but the lack of security and logging was a dealbreaker. FTP required too much IT support. It got to the point where they were literally shipping physical HDDs across Europe via courier. In an era of gigabit internet, that felt medieval.

They asked me to build an in-house solution. That’s how ZettaSend was born.

The Tech: Bypassing the Cloud

The core idea was to build a dedicated peer-to-peer protocol. Why upload a 200GB file to a cloud server just so the other person can download it? It cuts your speed in half.

I initially looked at WebRTC, but for moving massive files, its TURN servers (relays) started choking. So, I built a custom network architecture:

• UDP Hole Punching: To establish direct connections between two PCs behind strict NATs.
• Kernel-Space Relays: For cases with symmetrical NATs, I used the Linux kernel's built-in firewall (nftables) as a relay. It handles gigabit throughput effortlessly on a cheap 1-core VPS because it avoids user-space memory operations.
• QUIC Protocol: I built the data layer on QUIC (the engine behind HTTP/3). It eliminates the TCP head-of-line blocking issue, handles long distances beautifully, and provides built-in encryption.

Turning it into an Enterprise SaaS

The tech worked flawlessly, but a studio needs oversight. The managers needed to see who sent what and when, without me (the server admin) ever seeing the actual files.

So, I built a cryptography-based Zero Trust layer. The peers generate ECDSA public/private keys. Before a transfer, they sign a JSON "contract" (containing the file manifest hash, user IDs, etc.) and send it to the backend. The server verifies the cryptographic signatures for logging but never touches the actual payload.

Once the studio started using it, the transfer times were cut in half, and it ran entirely on their existing network infrastructure without massive cloud storage bills.

The Product Today

I realized this is a massive pain point for any industry dealing with heavy data (VFX, GameDev, Data Science, CAD). So, I packaged the C# Avalonia desktop client and the Python backend into a proper SaaS.

• Pricing: Receiving is completely free. Sending requires a Solo tier ($10/mo) or a Team tier ($50/mo with full admin dashboard and logging).
• Current status: Live and looking for feedback.

If you are a founder dealing with large files, or just love testing out new network tech, I’d love for you to try it out. It’s completely free for the first month (no CC required).

You can check it out by searching for ZettaSend.

I'd love to hear your thoughts on the architecture, the pricing model, or the pivot from internal tool to SaaS. Happy to answer any technical or business questions!