Introduction
In January 2025, I committed the first lines of code for what would eventually become Erugo. What started as a personal project to scratch my own creative itch has evolved into a promising self-hosted file-sharing platform that's beginning to find its audience among privacy-conscious individuals and organisations looking for alternatives to commercial services.
But why build yet another file-sharing application in a market that already has plenty of options?
Finding Creative Freedom
As I mentioned in a recent interview, the primary motivation behind Erugo stemmed from wanting creative freedom and ownership:
"In my day job as a developer, I often create tools and applications based on client requirements or company needs – which is fulfilling in its own way, but doesn't always allow for complete creative control.
I wanted to build something from the ground up that reflected my own vision and approach to software design. A file sharing application felt like the perfect canvas because it's something many people use, yet I saw opportunities to do things differently."
This desire to create something entirely my own way—where every design choice and feature implementation reflected my values—drove me to start coding what would eventually become Erugo.
The Problem I Wanted to Solve
While there are many file-sharing solutions available, I found they typically fell into two categories:
- Commercial services like WeTransfer that are convenient but don't give you control over your data
- Self-hosted options that were either too complex to set up or too limited in functionality
I envisioned a solution that combined the best of both worlds: the ease-of-use of commercial services with the privacy and control of self-hosting. I wanted to create a platform that:
- Required minimal configuration to get running
- Offered a clean, intuitive interface that non-technical users would enjoy
- Provided extensive customisation options without complexity
- Respected user privacy by avoiding any telemetry or tracking
- Could be completely white-labeled for organisations
Technology Choices
My original vision for Erugo was built around simplicity and ease of deployment. I initially chose:
- Backend: Go (Golang)
- Frontend: Vue.js (embedded into the Go binary)
- Database: SQLite (for simplicity and portability)
The idea was straightforward but practical: a single, self-contained binary that users could download and run with minimal setup. No complicated dependencies, no separate web server configuration—just one executable file that would handle everything.
However, as the project evolved and I gathered feedback from early users, I realised that many people preferred Docker deployment anyway, which negated the single-binary advantage. At the same time, I found myself spending more time than expected implementing features in Go that would have been much quicker to build with tools I was more proficient with.
This led to one of the most significant decisions in Erugo's development journey: porting the entire application to PHP with Laravel. The new stack became:
- Backend: PHP with Laravel framework
- Frontend: Vue.js
- Database: SQLite (maintaining the simplicity)
- Deployment: Docker-ready
The comprehensive settings page that became much easier to implement with Laravel
This transition wasn't made lightly, but it allowed me to leverage Laravel's robust authentication tools, user management, and database ORM to rapidly build out features that would have taken significantly longer in Go. While I still appreciate Go's performance and simplicity, for this particular project, the development velocity and feature richness that Laravel offered proved more valuable.
Laravel's elegant syntax and powerful features made it an ideal framework for building the backend services, while Vue.js provided the flexibility I needed for creating a responsive, dynamic frontend.
First Steps: January 2025
Looking back at my earliest commits from January 2025, it's fascinating to see how the project began taking shape:
- January 19, 2025: Initial public repo commit (Go version)
- January 30, 2025: Added admin flag to users table
- January 30, 2025: Implemented zip file creation for multiple files
- February 2, 2025: User management functionality
- February 3, 2025: Refactored endpoints, models, and database structure
It was at this point I made the decision to port Erugo to Laravel. This involved totally rebuilding everything I had already done:
- February 23, 2025: Ported Erugo to Laravel PHP (a major milestone)
These early foundations focused on the core functionality: allowing users to upload files and generate secure, shareable links for recipients to download them.
One of the first unique features I implemented was human-friendly share URLs. Instead of using random character strings, Erugo generates memorable URLs like yoursite.com/shares/quiet-cloud-shrill-thunder. This small touch reflected my philosophy that technology should be both functional and human-centred.
Early Challenges
The journey wasn't without challenges. As a solo developer, I had to make difficult decisions about what to prioritise. Some of the early hurdles included:
- Storage management: Ensuring files were stored efficiently and securely
- User experience design: Creating an interface that felt intuitive and clean
- Error handling: Building robust systems for when things inevitably go wrong
- Performance optimisation: Making sure large file transfers worked smoothly
- Dynamic configuration: Laravel is primarily designed for applications with relatively static configurations, so I had to get creative to allow users to manage their configuration options via the web interface
Each of these challenges represented a time management puzzle as much as a technical one. With limited hours to devote to a side project, I had to make strategic decisions about what to tackle first and how to balance immediate functionality with long-term architecture.
Looking Ahead
In this series of articles, I'll be taking you through the journey of developing Erugo—from these humble beginnings to where it stands today, with many exciting features still on the roadmap. We'll explore the technical challenges, design decisions, and pivotal moments that have shaped and continue to shape its evolution.
Next time, I'll dive deeper into how I built the core functionality of Erugo, exploring the database structure, file handling mechanisms, and the initial user interface.
Lessons Learned Along the Way
The shift from Go to Laravel ended up being a practical decision based on project needs and user feedback. While I initially liked the elegant concept of a single binary, it became clear that Docker deployment was the preference for most users anyway. This made me reconsider what was most important for the project: faster feature development or the technical purity of a self-contained executable.
This experience has been a reminder that technology choices should serve the project's practical goals rather than adherence to an initial vision. As developers, we sometimes become attached to our original technical decisions, but being willing to adapt based on real-world feedback usually leads to better outcomes. The Laravel version of Erugo has grown steadily, with features like theming, email notifications, and internationalisation support that would have taken much longer to implement in Go. That said, Erugo is still very much a work in progress, with important features like external authentication, reverse shares, file previews, and more comprehensive testing still on the roadmap. Like many open-source projects, it's a continual journey rather than a finished destination.
If you're using Erugo or considering it for your own file-sharing needs, I'd love to hear your thoughts and experiences. Connect with me on GitHub or join our Discord community.
This article is part of a series chronicling the development of Erugo, a self-hosted file-sharing platform. Keep an eye out for the next instalment, where we'll explore building the foundation of Erugo's core functionality and the technical challenges of porting from Go to Laravel.