DEV Community

Winola Joe
Winola Joe

Posted on Edited on

# Building HearMeOut.cc with Next.js: Lessons I Learned Along the Way


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
Enter fullscreen mode Exit fullscreen mode

or

noStore()
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

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)