Why I Rebuilt Qenu as QRFile
In December, I made a decision I hadn’t planned on making so soon.
I rebuilt my product from the ground up.
What started as Qenu is now QRFile — same core idea, but a much stronger foundation.
This wasn’t just a rebrand. It was a reset.
A Moment of Clarity
Late last year, I encountered a security incident that forced me to look carefully at the foundations of the app.
No user data was compromised. But it was enough to make me realise something important:
If I was going to build this long-term, it needed to be more secure, more resilient, and easier to maintain.
I could have patched things incrementally.
Instead, I decided to rebuild properly.
Security as a First Principle
Qenu worked — but parts of its architecture required too much manual oversight.
As a solo founder, that’s risky.
I wanted:
- Stronger built-in security defaults
- Better protection against automated spam signups
- Less surface area to maintain myself
- Clear separation between user data and public access
QRFile is built with those principles in mind from day one.
Security shouldn’t be something you “add later.” It should be baked in.
Reducing Infrastructure Overhead
With Qenu, I was spending more time managing infrastructure than improving the product.
Every new feature meant touching multiple moving parts.
That slows you down.
For QRFile, I prioritised:
- Managed systems instead of custom plumbing
- Fewer manual processes
- Cleaner permission rules
- Simpler deployment workflows
The result is a platform that’s easier to evolve — and less fragile.
When you're building solo, simplicity isn’t a luxury. It’s survival.
Fixing the Spam Problem
One issue with the previous version was automated account creation.
Without proper friction controls, bots inevitably find you — even if you’re small.
I didn’t want to:
- Add aggressive captchas
- Increase friction for real users
- Spend time cleaning junk accounts
So I changed the philosophy.
Letting Users Try Before Signing Up
Qenu required account creation early in the process.
That creates friction.
With QRFile, you can:
- Generate a QR code
- Test how it works
- Experience the product
…before signing up.
This does two things:
- Reduces barriers for genuine users
- Naturally filters out low-intent traffic
It’s a better experience and a better long-term model.
Building for Speed
Over time, the old structure started to feel heavier.
Shipping new features wasn’t difficult — but it wasn’t as fast or fluid as I wanted.
QRFile is designed to:
- Be lean
- Be easier to extend
- Make iteration faster
As an indie founder, speed matters.
If ideas take weeks to ship instead of days, momentum dies.
A Clearer Brand
This part was subtle but important.
Qenu.
Short. Minimal. Unique.
But also:
- Cryptic
- Not obviously related to QR codes
- Hard to search
- Hard to immediately understand
If your product is simple, your brand should be too.
QRFile says exactly what it does.
- QR → the format
- File → what you’re sharing
No guessing. No explanation required.
Clarity builds trust.
Lower Friction Authentication
I also wanted the login experience to feel modern and effortless.
QRFile supports streamlined authentication options so users can sign in quickly without dealing with passwords.
Less friction = better activation.
Adding Just Enough Analytics
One thing Qenu lacked was simple insight.
With QRFile, each QR code includes basic scan counts.
Nothing bloated. No complicated dashboards.
Just the answer to the question most people actually care about:
“Is this being scanned?”
What Stayed the Same
The core idea hasn’t changed.
QRFile still focuses on:
- Dynamic QR codes
- Editable destinations
- Hosted files
- Simplicity
No feature bloat. No unnecessary complexity.
Just a tool that works — and keeps working.
What I Learned
Rebuilding taught me a few things:
- Security decisions compound over time
- Friction hides in small details
- Infrastructure choices affect velocity
- Clear branding matters more than clever naming
- Sometimes rebuilding is faster than patching
Qenu was an important first version.
QRFile is the version built with hindsight.
And this time, it’s built to last.
