I want to document my journey creating a Web App, from start to finish. I will cover the stacks I use, why and where I use them, the issues I run into, how I solved them (or how I tried to), and a simple weekly update on where the app is. This is for other developers who want to learn from the process, or just follow along through each week, and maybe give feedback.
The Past few weeks
When I first set out to build something meaningful, I didn’t have all the answers. All I knew was that I wanted to create a project that added value to people’s lives — something beyond another throwaway side project. What followed was a winding journey through brainstorming, tech stack debates, monorepo headaches, and small victories that brought me closer to turning the idea into reality.
Below is a simple account of what I did, why I chose things, the problems I ran into, and what I’m shipping next. I’m still learning, so if you see something I missed, please tell me.
Brainstorming
I had a long list of ideas: utilities, productivity apps, small SaaS things. I settled on an idea that needs group interaction, simple decision mechanics, and a clear outcome people can share. I’m keeping the product details intentionally vague for now — I want to show progress before showing the full idea.
Main goals that guided decisions:
- Very low friction onboarding. Users must sign in quickly.
- Group interaction must be obvious and simple.
- Outcomes should be clear and impactful.
Those goals changed what I picked for the stack.
The stack I chose
Once the concept felt real, the next big question was: what tech stack should I use?
I started with my own idea:
- Backend: Golang + Gin
- Frontend: React + TypeScript
- Database: MongoDB
- CI/CD: GitHub Actions
- Cloud: AWS
It looked solid on paper, but it was heavy — too much too soon for an MVP.
With feedback and some research, I pivoted. The stack simplified:
- Frontend: Next.js (React 19)
- UI: ShadCN + Tailwind CSS v4
- State & Data: React Query + Supabase
- Backend: Not separate at first — lean on Supabase (auth + database + APIs)
- Infra: ShadCN Monorepo for structure, pnpm for package management
- Deployment: Vercel for frontend, Supabase for backend services
This stripped-down stack let me move faster, learn less at once, and focus on the app’s value.
The Problems
Then came the monorepo learning curve.
At first, the concept of a monorepo felt like a buzzword. Why not just build a single app and call it a day? But the benefits — shared UI, consistent tooling, easy scaling — became clear once I imagined the project growing.
- apps/web → the Next.js frontend
- packages/ui → shared ShadCN/Tailwind components
- (future) apps/api → backend if needed
Of course, this wasn’t painless. I hit walls:
- Passing event handlers between apps/web and packages/ui caused React’s Server/Client component errors.
- Tailwind v3 vs v4 caused confusion. I learned that v4 was cutting-edge but not yet production-hardened. But since ShadCN docs used v4, I committed to it.
- Even simple commands like checking Tailwind’s version gave me headaches.
But each obstacle taught me something about how monorepos actually work, and slowly the fog cleared.
Another set of battles came from the developer environment.
- My system was on Node 18, but ShadCN demanded Node 20.
- I had to upgrade to the LTS version of Node 20 system-wide.
- Then I moved from npm to pnpm, as npm was giving issues with the template repository ShadCN had given me. It felt like forever, fixing tooling instead of building features. But once the environment stabilized, everything felt smoother.
Lessons learnt
- Start with the product, not the tech – It’s tempting to dive into frameworks, but the clarity came when I nailed down the app’s concept.
- Monorepos are powerful, but opinionated – They force discipline and structure, which should pay off later.
- Cut scope early – Using my original Tech stack seemed like a good move at first, but once I realised how manual the setup would be I knew cutting all that would give me time to put my focus elsewhere.
- Stay current, but not reckless – I adopted Tailwind v4 because ShadCN required it, but I wouldn’t have done so otherwise yet.
- Expect friction – Whether it was Node upgrades, pnpm quirks, or Tailwind commands, every step had its “why isn’t this working?” moment.
Where I'm at
- The monorepo is up with Next.js, ShadCN, Tailwind v4, and pnpm.
- Supabase will handle authentication, database, and backend logic for now.
- Core pages are defined: Login, Dashboard, Weekly Interactions, Voting, Results.
- The app has a clear user flow and a technical foundation to support it.
It’s still early days, but I’ve moved from “random idea” to a structured project with momentum. The path wasn’t straight, but every obstacle clarified why I was doing this in the first place.
This isn’t just a coding project anymore — it’s a journey in learning, focus, and creating something that might actually matter.
Top comments (2)
Dude this is gold. Documenting your journey is a good way to start writing for the internet, showing your expertise and what and how you're learning or building. Keep it up!
Thank you, I am trying to document the journey. This way I keep track of where I am, and also sharpen my writing skills while I'm at it