
When I started building HearMeOut.cc, I wanted to keep the stack simple, modern, and easy to iterate on. After trying several frameworks over the years, I eventually chose Next.js.
Hear me out
After months of development, deployment, SEO optimization, and performance tuning, I've collected a number of lessons that I wish I had known earlier. Hopefully they'll save someone else some time.
Why I Chose Next.js
There are many excellent React frameworks today, but Next.js felt like the most balanced choice.
Some reasons:
- Great SEO support
- File-based routing
- Built-in API routes
- Server Components
- Static Generation (SSG)
- Server Side Rendering (SSR)
- Easy deployment
- Huge ecosystem
For a content-focused website like HearMeOut.cc, SEO was one of the biggest priorities.
App Router Is Worth Learning
I started directly with the App Router instead of the old Pages Router.
At first it felt confusing.
- Server Components
- Client Components
- Layouts
- Loading UI
- Parallel routes
- Route groups
There are many new concepts.
But after understanding how data flows between server and client, everything became much cleaner.
One of the biggest benefits is that less JavaScript is sent to the browser by default, which improves loading speed.
Server Components Changed How I Think
Initially I treated every component as a Client Component.
That was a mistake.
Now my default approach is:
Make everything a Server Component unless it actually needs browser interaction.
This simple rule significantly reduced bundle size.
Interactive features like:
- forms
- buttons
- animations
- dialogs
remain Client Components.
Everything else stays on the server.
Metadata Matters More Than You Think
Next.js makes metadata management surprisingly convenient.
Instead of manually editing <head> everywhere, each page can export metadata.
For SEO pages I usually configure:
- title
- description
- canonical URL
- Open Graph
- Twitter Cards
- robots
- alternates
Keeping metadata close to the page itself makes maintenance much easier.
Image Optimization Is Great—Until It Isn't
The built-in Image component is excellent.
However, there are situations where I intentionally use a normal <img>.
For example:
- images already optimized by CDN
- very large image libraries
- third-party image hosting
- reducing server image processing
Using <Image /> everywhere isn't always the best solution.
Understanding the trade-offs matters.
Caching Can Become Confusing
One thing that surprised me was how many layers of caching exist.
You have things like:
- browser cache
- CDN cache
- fetch cache
- route cache
- ISR
- static generation
Sometimes you change data...
...and nothing changes on the page.
Learning when to use:
revalidate
or
noStore()
saved me hours of debugging.
SEO Requires More Than SSR
Many people think:
"I'm using Next.js, so SEO is solved."
Not exactly.
Good SEO still requires work.
For HearMeOut.cc I spent time on:
- meaningful URLs
- canonical tags
- sitemap generation
- robots.txt
- structured data
- internal linking
- page speed
- metadata optimization
Next.js provides the tools, but you still need a good SEO strategy.
Don't Ignore Bundle Size
One habit I developed is checking the production bundle regularly.
It's easy to accidentally import an entire library just to use one function.
A few improvements that helped:
- dynamic imports
- removing unnecessary dependencies
- Server Components
- code splitting
- lazy loading
Small optimizations quickly add up.
Deployment Should Be Automated
One thing I never want to do again is manually uploading files.
My deployment pipeline now looks like this:
Git Push
↓
GitHub
↓
Coolify
↓
Docker Build
↓
Production
Every commit can be deployed consistently.
Automation removes a lot of stress.
Logging Saves Hours
During development I relied mostly on console.log().
As the project grew, structured logging became much more useful.
Good logs answer questions like:
- Which API failed?
- Which request timed out?
- Which page generated an error?
- How long did rendering take?
Debugging becomes much easier.
Performance Is a Continuous Process
Performance isn't something you optimize once.
It's something you monitor continuously.
Some things I regularly check:
- Core Web Vitals
- Lighthouse
- bundle size
- image sizes
- server response time
- database queries
Small improvements every week are better than one massive optimization project.
What I'd Do Differently
If I started again, I would:
- use Server Components by default
- think about caching earlier
- create reusable metadata utilities
- automate deployment from day one
- monitor bundle size regularly
- build SEO into every page instead of adding it later
Final Thoughts
Building HearMeOut.cc with Next.js has been a great experience.
No framework is perfect, but Next.js provides an excellent balance between developer experience, performance, and SEO.
The biggest lesson wasn't learning new APIs.
It was learning when not to use them.
Keeping the application simple, minimizing client-side JavaScript, and letting the server do more work resulted in a faster and easier-to-maintain project.
If you're building a content-heavy website today, Next.js is definitely worth considering.
Thanks for reading!
I'd love to hear what lessons you've learned while building production applications with Next.js. Feel free to share your experience in the comments.
Monday meme
Top comments (0)