The first drafts
From a Simple Web App to Rethinking Everything: Building LearnLang v0.1
When I started building the first version of LearnLang, I wasn’t thinking about scale, mobile ergonomics, or long‑term architecture. I just wanted something that worked—something I could use myself, something my daughter could use, something real enough to test the idea.
So I reached for the tools I knew best: Go for the backend, Next.js for the frontend, and TailwindCSS to make it look clean without overthinking design. It was the classic “founder’s first draft”: fast, scrappy, and built with more optimism than planning.
A web app pretending to be an app
The earliest LearnLang prototype was entirely web‑based. It was responsive, it adapted to different screen sizes, and on mobile it looked like an app. I used modals everywhere—adding words, editing entries, reviewing items. It was functional, and for a while, that was enough.
But the more I used it on my phone, the more I realized something important: a responsive website is not the same as a mobile‑first experience.
Even when it behaves well, it still feels like a website.
Why I needed a mobile‑first frontend
A few things became impossible to ignore:
- Thumb ergonomics
— A responsive layout still assumes a desktop mindset. Buttons end up in awkward places. Interactions require precision. Nothing feels natural for one‑handed use. - Modal fatigue
— Modals are fine on desktop. On mobile, they feel heavy and interruptive. Every action becomes a small negotiation. - Flow and speed
— Mobile browsers simply don’t match the fluidity of an interface designed for touch-first interactions. - User expectations
— People expect mobile tools to be fast, smooth, and always ready—even if they’re technically “just websites.”
I didn’t want to build a native app, at least not yet. But I also didn’t want LearnLang to feel like a website squeezed into a phone screen. The goal became clear: build a web app that feels native. Fast transitions, minimal modals, gestures where appropriate, and layouts designed for the way people actually hold their phones.
That shift changed the entire direction of the project.
Authentication: keeping it simple with Firebase
For user accounts, I started with Firebase Auth. It was the quickest way to get secure authentication without building everything myself. And to keep things simple, I enabled only Google Sign‑In.
No password resets. No email verification flows. No complex onboarding.
Just: “Sign in with Google and start learning.”
It wasn’t the final solution, but it was the right one for the early days—fast, reliable, and frictionless.
The backend: Go, a local database, and the first growing pains
The backend was a small Go service running on my machine with a local database. It was perfect for rapid iteration:
- zero latency
- zero cloud costs
- zero deployment overhead
But it also meant:
- no real multi‑device sync
- no backups
- no user‑scoped data
- no scalability
Eventually, I started teasing the migration to Supabase, which gave me a proper hosted Postgres, authentication integration, and a path toward real production infrastructure.
That was the moment LearnLang started feeling less like a personal experiment and more like a product.
Audio, images, and the cloud storage dilemma
Even in the first version, I supported audio and images. I wanted vocabulary to feel alive—hear pronunciation, attach pictures, make learning richer.
Naturally, the next step seemed obvious: move everything to Amazon S3 or another cloud provider.
But then I hit a problem I hadn’t fully considered.
Copyright risk
If users upload audio or images, I’m the one storing them. And if someone uploads copyrighted material—intentionally or not—I’m responsible for hosting it.
That’s a legal and operational headache I wasn’t ready to take on.
So I paused the cloud storage plan. Not forever—just until I have:
- proper moderation
- clear usage policies
- a scalable storage pipeline
- and the time to implement it responsibly
For now, LearnLang focuses on the core experience: learning, reviewing, and creating content that belongs to the user.
Looking back
The first version of LearnLang was messy, inconsistent, and full of shortcuts. But it was also the version that made the idea real. It taught me what mattered, what didn’t, and what needed to be rebuilt from scratch.
And most importantly, it showed me that LearnLang wasn’t just a side project anymore. It was becoming something worth doing properly.
Comments
Post a Comment