Erugo

Self-hosted file sharing, honestly reviewed. No marketing fluff, just what you get when you stop paying WeTransfer every month.

TL;DR

• What it is: Open-source (MIT) self-hosted file sharing platform — think WeTransfer, but the files stay on your server and the vendor can’t raise your bill [1][2].
• Who it’s for: Freelancers, small agencies, and non-technical founders who regularly send large files to clients and are tired of WeTransfer’s storage caps, ads, or subscription fees.
• Cost savings: WeTransfer Plus runs $12/mo for 1TB storage. Erugo self-hosted runs on a VPS with 512MB RAM — call it $4–6/mo — with no per-transfer limits and no file size cap beyond your disk [1][2].
• Key strength: Minimal footprint, genuinely simple Docker deployment, and a feature set that covers 95% of what people actually use WeTransfer for. The reverse share feature (letting a client upload to you via a one-time token) is a standout [1].
• Key weakness: ~990 GitHub stars is still a relatively young project. The community is small, the documentation is thin beyond the README, and the SQLite default isn’t suitable for serious multi-user deployments without migration to a proper database [1].

---

What is Erugo

Erugo is a self-hosted file sharing platform. You upload files through a drag-and-drop interface, get a human-readable share link like yourdomain.com/shares/quiet-cloud-shrill-thunder, and the recipient downloads through a clean page with no ads, no forced account creation, and no vendor in the middle reading your files [1][2].

The project describes itself as “a powerful, self-hosted file-sharing platform that puts you in complete control of your data” — which is accurate, if slightly pedestrian. What actually makes it interesting to look at isn’t the marketing copy, it’s the combination of a very low barrier to deploy and a feature set that genuinely replaces the paid tier of WeTransfer rather than just approximating the free tier.

It’s built on PHP/Laravel with a Vue.js frontend, MIT licensed, hosted on GitHub, and maintained by a solo developer (deanward) with sponsorship from BoxToPlay for hosting infrastructure [1]. As of this writing it sits at around 990 GitHub stars. That’s small by open-source standards — for context, n8n has 100K+ and Nextcloud has 27K+. But “not famous” is different from “not good,” and Erugo has attracted enough attention to get YouTube coverage from DB Tech and KeepItTechie, both of whom run dedicated self-hosted tool channels [1].

---

Why people choose it

The KeepItTechie YouTube review is titled “Ditch WeTransfer! Self-Host Erugo for Secure File Sharing with Docker” — that framing tells you everything about the audience [1]. People arrive at Erugo from one of two directions: they’re paying for WeTransfer Plus and want to stop, or they’ve tried to use WeTransfer’s free tier for client work and keep running into the 2GB cap and mandatory ads.

The self-hosting angle isn’t incidental to the pitch, it is the pitch. The homepage breaks it down into three clean arguments:

Data sovereignty. Files on WeTransfer route through third-party servers. Erugo files route through your VPS or your home server. For agencies handling client contracts, NDA-covered documents, or sensitive financial files, that difference matters in a way that “we’re SOC 2 compliant” doesn’t fully resolve [2].

Deploy anywhere. The README specifically calls out the Raspberry Pi as a valid deployment target, and the minimum requirements — 512MB RAM, 1 CPU core — make that plausible [1]. Most self-hosted tools quietly require 2–4GB to function reliably. Erugo’s footprint is genuinely small.

MIT license. This matters if you’re thinking about embedding file sharing in your own product, or reselling a client deployment. No “fair-code” gotchas, no per-seat licensing, no usage restrictions [1][2].

What the project doesn’t have is the kind of third-party review depth you’d see for a more mature tool — no G2 reviews, no Trustpilot presence, no analyst coverage. The community is Discord-based and small. For a solo founder evaluating this, that’s a real signal: you’re betting on a project that’s two YouTube videos and a Reddit post or two away from “basically no ecosystem.” Not a dealbreaker for simple file transfer, but worth acknowledging.

---

Features

Core file transfer:

• Drag-and-drop uploads with progress tracking and instant preview [1]
• Folder uploads that preserve directory structure [1]
• Large file support with automatic upload resume — no manually retrying stalled uploads [1]
• Multiple files per share [1]

Share management:

• Human-friendly share URLs (word-based, not UUIDs) [1]
• Optional password protection per share [1][2]
• Configurable expiration dates — set a share to auto-expire after a day, a week, or never [1][2]
• Download limits — cap how many times a file can be retrieved [1][2]
• Dashboard showing download counts and activity per share [1][2]
• Revoke access to any share at any time [1]

Reverse share: This is the feature WeTransfer doesn’t have in its free tier. Erugo lets you generate a one-time token that you send to a client, and they use it to upload files to you — without having an Erugo account [1]. Useful for collecting deliverables, proofs, or submissions without asking the other party to sign up for anything.

Access control and auth:

• User management with an invite system — only authorized users can create shares [1]
• External authentication provider support (visible in the README’s login screen screenshot) [1]

Customization:

• Built-in light and dark themes [1][2]
• Custom theme creation via web interface [1]
• Logo and color customization [1][2]
• White-labeling for organizations — deploy it as your own branded file portal [1][2]

Technical:

• SQLite by default (bundled, zero config) [1]
• REST API [1]
• Multi-language support [1]
• Docker-first deployment [1]

What’s not here: end-to-end encryption (files are stored on disk, accessible to anyone with server access), no built-in virus scanning, no real-time collaboration, no preview for most file types beyond images. If you need WeTransfer’s “review and comment” layer, Erugo doesn’t replace that — it replaces the send and receive part.

---

Pricing: SaaS vs self-hosted math

WeTransfer for comparison:

• Free: 2GB per transfer, watermarked links, ads
• Plus: ~$12/mo — 1TB cloud storage, no ads, longer expiry, custom backgrounds
• Pro/Teams: higher tiers, custom pricing for organizations

Erugo self-hosted:

• Software: $0 (MIT) [1]
• VPS: $4–10/mo depending on provider (Hetzner, Contabo, DigitalOcean)
• Storage: whatever you attach to the server
• Total: $4–10/mo, unlimited transfers, no per-file caps

Concrete math: A freelancer paying for WeTransfer Plus at $12/mo spends $144/year. A $5 Hetzner VPS running Erugo is $60/year, with storage you control. That’s $84/year saved — small in absolute terms, but the self-hosted version also has no per-file size limits and no vendor reading your metadata for product analytics.

The more meaningful savings appear for agencies sharing files regularly with clients. WeTransfer Pro pricing isn’t public, but it’s positioned well above $12/mo. An agency replacing even a $25/mo WeTransfer plan with a $10/mo VPS saves $180/year, and the VPS can run other services in parallel.

Pricing data for Erugo’s own SaaS tier (if it exists) is not available — the project appears to be self-host-only with no managed cloud offering [1][2].

---

Deployment reality check

This is where Erugo earns its reputation. The docker-compose from the README is four lines:

services:
  app:
    image: wardy784/erugo:latest
    restart: unless-stopped
    volumes:
      - ./erugo-storage:/var/www/html/storage
    ports:
      - "9998:80"

Run docker compose up -d and you have a running instance on port 9998 [1]. That’s it for a basic setup. No separate database container, no Redis, no Nginx config — SQLite handles persistence by default.

What you actually need:

• A Linux VPS with 512MB RAM minimum (1GB recommended for comfortable operation)
• Docker and docker-compose
• A domain and reverse proxy (Caddy or nginx) if you want HTTPS — required for any external use
• Nothing else for a basic deployment

What can go sideways:

The SQLite default is fine for a single user or a small team with low concurrency, but it’s not a production database. If you’re running this for an agency with multiple users uploading simultaneously, you’ll want to migrate to PostgreSQL or MySQL. The README doesn’t prominently document this migration path, which is a documentation gap worth noting.

The project is maintained by a single developer. The README includes a Ko-fi donation link and the infrastructure is sponsored [1]. That’s the real risk profile: not that the software is bad, but that a solo maintainer can disappear, get busy, or burn out. The MIT license means you can fork and continue, but “you can maintain it yourself” is cold comfort if you’re not a PHP/Laravel developer.

Realistic setup time for a technical user: 20–30 minutes to a working HTTPS instance. For a non-technical founder following one of the YouTube guides: 1–2 hours including domain configuration. The DB Tech and KeepItTechie videos make this accessible to people who’ve never touched Docker before [1].

External auth provider support exists (visible in README screenshots) but setup documentation is not in the README — you’d need to dig into the codebase or Discord [1].

---

Pros and cons

Pros

• Genuinely minimal deployment. Four-line docker-compose, 512MB RAM, SQLite default. This is the least friction path to self-hosted file sharing that exists in the category [1].
• MIT licensed. No commercial restrictions, no “fair-code” ambiguity. Fork it, brand it, embed it in your product [1][2].
• Reverse share tokens. The ability to give a client a one-time upload link without requiring them to have an account is a real workflow win that WeTransfer doesn’t offer in free tiers [1].
• Human-readable share URLs. Word-based slugs instead of UUIDs are a small detail that makes sharing via email or chat measurably better [1].
• White-labeling. Built-in theme customization and logo support makes this deployable as a branded client portal, not just a personal tool [1][2].
• Large file support with resume. Stalled uploads auto-resume — you’re not babysitting an 8GB transfer [1].
• Raspberry Pi viable. The footprint is small enough to run on home hardware, which matters for the purely privacy-motivated use case [1][2].

Cons

• ~990 stars = young project. Small community, limited third-party documentation, no real ecosystem around it. If you hit a bug or an unusual deployment scenario, you’re in the Discord or the GitHub issues [1].
• Solo maintainer. The project’s continuity depends on one person’s continued interest and availability. The MIT license is your fallback, not a guarantee [1].
• SQLite default needs documentation. The path from “SQLite default” to “PostgreSQL for production” isn’t clearly documented in the README, which creates a gap for serious multi-user deployments [1].
• No end-to-end encryption. Files sit on disk in plaintext. Anyone with server access can read them. This is the norm for this category, but worth stating explicitly [1].
• No virus scanning. Erugo doesn’t inspect uploaded files. For public-facing deployments, you’d want to layer in ClamAV or similar separately.
• External auth documentation is thin. Auth provider support exists but isn’t documented in the README — you’re on your own or in the Discord [1].
• No managed cloud option. You’re fully responsible for hosting, backups, uptime, and updates. There’s no “we’ll host it for you” fallback if self-hosting becomes inconvenient [1][2].

---

Who should use this / who shouldn’t

Use Erugo if:

• You’re paying for WeTransfer Plus ($12/mo) and you’re comfortable deploying a Docker container, or willing to learn once.
• You regularly send large files to clients and want to brand the experience — the white-labeling makes this look professional rather than “my garage self-hosted thing.”
• You need to collect files from clients without asking them to create accounts (reverse share).
• You’re running a privacy-sensitive operation where files routing through WeTransfer’s servers is genuinely a concern.
• You have a Raspberry Pi or home server collecting dust.

Skip it if:

• You want “set it and forget it” reliability with someone else responsible for uptime. This is self-hosted, which means you own the operations burden.
• You need real-time review and comment on files — Erugo sends files, it doesn’t collaborate on them.
• You’re sharing files with clients who need a polished SaaS-level experience and any rough edge will cost you a relationship.
• Your team is larger than 10–15 users with concurrent upload needs — the SQLite default will become a problem before the software otherwise limits you.
• You need built-in virus scanning for uploaded content.

Stay on WeTransfer if:

• You send files occasionally (less than a few times a week) and the free 2GB cap is fine.
• You’ve never touched a Linux server and have no one to help you with setup.

---

Alternatives worth considering

• WeTransfer — the incumbent this most directly replaces. Closed-source SaaS, $12/mo for Plus. Easier, no maintenance, vendor dependency. The obvious comparison [1].
• Nextcloud — the Swiss army knife of self-hosting. Has file sharing built in, plus calendar, contacts, office docs, and two dozen other features. Massively more complex to deploy and maintain. Choose Nextcloud if you need more than file transfer; choose Erugo if you need exactly file transfer and nothing else.
• Send (formerly Firefox Send) — Mozilla killed the hosted version in 2020 but the server software is still alive as community forks (Timvisee’s Send fork). End-to-end encrypted, zero-knowledge, but even more minimal than Erugo — no dashboard, no user management.
• Lufi — older PHP-based self-hosted file transfer. Less actively maintained, less polished UI.
• Plik — Go-based, CLI-friendly, less UI-focused. Better for developers sending files between machines than for non-technical client workflows.
• Filerun — more full-featured self-hosted file manager with sharing. Closer to Nextcloud than WeTransfer in scope.

For a non-technical founder wanting to ditch WeTransfer, the realistic shortlist is Erugo vs Nextcloud. Pick Erugo if you want a minimal tool that does one thing. Pick Nextcloud if you want a full self-hosted productivity suite and are willing to invest the setup time.

---

Bottom line

Erugo is a focused tool that solves a specific problem: replacing WeTransfer for people who send files to clients regularly and don’t want to keep paying for the privilege. It doesn’t try to be a full file manager or a collaboration platform — it tries to be the clean, MIT-licensed, self-hostable version of WeTransfer that you can brand as your own and deploy in an afternoon. The trade-offs are real: young project, solo maintainer, thin documentation, no managed cloud option. But for the target use case — a freelancer or small agency paying $12–25/mo to WeTransfer who has basic Docker comfort — the math is clear and the feature set covers what actually matters. The reverse share feature alone justifies the switch if you regularly collect files from clients.

If the setup is the blocker, that’s exactly what upready.dev deploys for clients. One-time fee, done, you own the infrastructure.

---

Sources

1. Erugo GitHub Repository and README — primary source for all features, deployment, license, and project metadata. https://github.com/erugooss/erugo

2. Erugo Official Website — homepage and product marketing copy. https://erugo.app

3. DB Tech (YouTube) — “Erugo - Self-Hosted File Sharing Platform” — video review cited in project README. https://www.youtube.com/watch?v=zqipBHSSPm4

4. KeepItTechie (YouTube) — “Ditch WeTransfer! Self-Host Erugo for Secure File Sharing with Docker” — video review cited in project README. https://www.youtube.com/watch?v=FrcBALXDIRU