DEV Community: Abhavya Gupta

React vs Next.js: Which One Should You Learn First? My Honest Experience

Abhavya Gupta — Fri, 26 Jun 2026 07:29:37 +0000

A few months ago, I was exactly where most beginners are today.

I had finally learned HTML, CSS, and JavaScript. Feeling confident, I searched on YouTube, "What should I learn next?"

And that's where the confusion started.

Half the creators were saying, "Learn React first."

The other half were like, "Don't waste time. Start directly with Next.js because that's what companies use."

At one point, I genuinely thought I was already behind.

If you've been in the same situation, trust me, you're not the only one.

I Almost Started with Next.js...

I remember opening a Next.js tutorial and within the first hour, I was hearing terms like Server Components, Routing, SSR, Hydration, App Router...

Meanwhile, I was still trying to understand why my React component wasn't re rendering.

It felt like trying to drive a Formula 1 car before learning how to ride a bicycle.

That's when I closed the tutorial and went back to React.

And honestly?

That was one of the best decisions I made.

React Taught Me How Things Actually Work

When you're learning React, you're not just learning another framework.

You're learning how modern websites are built.

I finally understood things like:

How components work.

Why state exists.

Why props matter.

How hooks actually make your life easier.

Instead of memorizing code, I started understanding the logic behind it.

And once that clicked...

Everything became easier.

Then I Switched to Next.js

A few weeks later, I gave Next.js another try.

This time something surprising happened.

Instead of feeling scared, I actually enjoyed it.

Routing made sense.

Fetching data felt easier.

Creating pages became faster.

The concepts that once looked complicated suddenly felt natural because I already knew React.

It wasn't magic.

It was just a strong foundation.

So... Should You Skip React?

In my opinion?

No.

Could you technically start with Next.js?

Yes.

Should you?

Probably not.

It's like learning Photoshop before understanding basic design principles.

You'll know which buttons to press, but you won't know why you're pressing them.

Here's What I'd Do If I Were Starting Again

If someone erased all my knowledge today and asked me to start from scratch, I'd follow this order without thinking twice:

HTML

CSS

JavaScript

React

Build 3 or 4 projects

Then Next.js

Simple.

No shortcuts.

The Truth Nobody Talks About

I think a lot of beginners feel pressured because social media makes it seem like everyone is building AI apps, SaaS products, and billion dollar startups overnight.

The reality is much simpler.

Companies don't hire you because you know ten frameworks.

They hire you because you can solve problems.

And React teaches you exactly that.

Final Thoughts

If you're confused between React and Next.js, don't overthink it.

Learn React first.

Build projects.

Break things.

Fix them.

Get comfortable.

Then move to Next.js.

You'll enjoy the journey much more, and you'll understand what's happening under the hood instead of just copying tutorials.

That's exactly how I approached it, and looking back, I wouldn't change a thing.

What about you? Are you currently learning React, or are you thinking about jumping straight into Next.js? I'd love to hear your experience in the comments.

Abhavya :)

I Added an AI Chatbot to a 3 Month Old Project. Here's What Changed.

Abhavya Gupta — Wed, 17 Jun 2026 15:52:08 +0000

Three months ago, I built a landing page for a fictional cafe called Beanery Cafe.

At the time, I was proud of it.

The design looked clean.

The coffee cards looked great.

The animations felt smooth.

Everything seemed finished.

Or so I thought.

A few days ago, I opened the project again.

As I clicked through the pages, I realized something.

The website looked good, but it wasn't interactive.

Visitors could scroll.

They could read.

They could admire the design.

But they couldn't really engage with it.

That's when I got an idea.

What if visitors could simply ask questions instead?

So I decided to integrate an AI chatbot into the project.

Now users can ask things like:

What's the most popular coffee?
What are your opening hours?
Which drink should I try first?
Do you have desserts?

And instead of searching through sections of the website, they get an instant response.

Why I Added It

The goal wasn't to build the next revolutionary AI product.

I simply wanted to experiment with AI integration and see how it could improve a project I had already built.

Sometimes we focus so much on creating new projects that we forget an older project can become a learning opportunity too.

What I Learned

While implementing the chatbot, I learned a few things.

User Experience Matters More Than Features

The chatbot itself isn't complicated.

But it changes how users interact with the website.

Instead of passively consuming information, visitors can actively ask for it.

AI Can Make Static Projects Feel Dynamic

The landing page was already functional.

The chatbot gave it personality.

It transformed the project from a showcase website into something users could actually have a conversation with.

Revisiting Old Projects Is Worth It

One of the best ways to learn isn't always starting something new.

Sometimes it's improving something you've already built.

Looking back at old code, identifying weaknesses, and adding new functionality teaches a lot.

Final Thoughts

This wasn't a huge update.

It didn't require rebuilding the entire project.

It was just a small AI chatbot.

But sometimes small changes create the biggest difference.

The project went from being something users could only look at to something they could interact with.

And that's what made it exciting for me.

If you have old projects sitting in your GitHub repositories, try revisiting one of them.

You might be surprised how much you can improve with the skills you've learned since then.

Abhavya Gupta :)

Nobody Talks About This Part of Learning to Code

Abhavya Gupta — Thu, 11 Jun 2026 09:29:45 +0000

A few months ago, I almost convinced myself that coding just wasn't for me.

Not because I couldn't understand React.js

Not because Next.js was too hard.

Not because I wasn't putting in the hours.

But because every time I opened LinkedIn, GitHub, or YouTube, it felt like everyone else was moving faster than me.

Someone had just landed an internship.
Someone had built an AI SaaS.
Someone had solved 500 DSA problems.

And there I was... spending hours trying to understand why my code wasn't working.

For a long time, I thought learning to code was all about learning technologies.
HTML.
JavaScript.
React.
Next
Node
APIs.
Databases.

But nobody talks about the mental side of the journey.

The part where you spend three hours debugging a problem only to discover a missing character.

The part where you feel productive all day but have nothing impressive to show for it.

The part where you start comparing your Chapter 1 with someone else's Chapter 20.

As a Computer Science student, I've gone through all of it.

I've started courses and left them halfway.

I've switched learning paths more times than I'd like to admit.

I've watched tutorials feeling motivated, only to forget half the concepts a week later.

I've built projects that felt amazing while creating them but looked "too simple" when I compared them to others.

And honestly?
That's normal.

The biggest lesson I've learned is that progress in programming is much quieter than people think.

You don't suddenly wake up as a great developer.
You slowly get better at reading documentation.

You debug faster.
You ask better questions.
You become less afraid of unfamiliar code.

The growth is happening even when it doesn't feel like it.

Today, when I build a project, I still get stuck.

I still Google things.

I still spend time fixing bugs that make me question my life choices.

The difference is that I no longer see those moments as proof that I'm failing.
They're proof that I'm learning.

If you're currently feeling behind, struggling with bugs or wondering whether you're good enough to become a developer, remember this:

The hardest part of learning to code isn't learning the syntax.

It's staying patient when progress feels invisible.

And if you're still showing up despite the frustration...

You're doing better than you think.

Abhavya Gupta :)

I Built a Recipe Finder App to Refresh My API Skills (And Learned More Than Expected)

Abhavya Gupta — Tue, 09 Jun 2026 06:45:44 +0000

As developers, we often learn concepts and move on to the next topic. But if we don't revisit them through practice, it's easy to forget important details.

Recently, I wanted to refresh my API integration skills, so I decided to build a small project called Find My Recipe. The goal wasn't to create a production-ready application. Instead, I wanted a simple project that would help me revise working with APIs, handling responses, and displaying dynamic data on the frontend.

Why This Project?

While learning web development, I spent time understanding how APIs work. I knew the theory, but I wanted to strengthen my practical understanding again.

Rather than building something complicated, I chose a recipe finder application because it allowed me to work with:

Fetching data from an API
Handling asynchronous requests
Managing loading states
Displaying dynamic content
Searching and filtering data

The API

For this project, I used the DummyJSON Recipes API.

It provides recipe data including:

Recipe names
Ingredients
Cooking instructions
Cuisine types
Images
Cooking time information

Since the API already provides structured data, I could focus more on frontend implementation and API handling rather than backend development.

Features

The application includes:

Browse recipes
Search recipes
View recipe details
Display recipe images
Dynamic data fetching from the API
Responsive user interface

Although the feature set is simple, it covers many of the core concepts developers use when working with APIs.

What I Learned

Even small projects teach valuable lessons.

While building this application, I revised:

API Requests

Making requests and understanding the response structure again helped reinforce concepts that are easy to forget without practice.

State Management

Managing loading states and storing fetched data reminded me how important proper state handling is for a good user experience.

Error Handling

Not every request succeeds. Implementing basic error handling made the application more reliable and realistic.

UI Rendering

Working with dynamic data highlighted how frontend applications update and render information based on API responses.

Challenges

One challenge was ensuring that the UI remained user-friendly while data was being fetched.

Another was handling cases where search results were empty or data wasn't immediately available.

These may seem like small problems, but solving them helps build better habits for larger projects.

Final Thoughts

This wasn't a large-scale application, but it served its purpose perfectly.

Sometimes the best way to strengthen your skills isn't by building something huge. It's by creating small, focused projects that help reinforce important concepts.

The Find My Recipe project helped me revisit API integration, improve my confidence, and gain more hands-on experience with real-world data.

If you're currently learning web development, I highly recommend building small projects like this. They may look simple, but they teach lessons that tutorials often don't.

Abhavya Gupta :)

The Pressure of Figuring Out Your Career in Tech

Abhavya Gupta — Thu, 28 May 2026 06:53:12 +0000

One thing nobody really talks about in tech is how mentally exhausting it can feel sometimes...

Every day, there’s something new to learn.

New frameworks.
New tools.
New roadmaps.
New people achieving things at 19 while you’re still trying to figure things out.

And somewhere between all of this, you start questioning yourself.

Am I learning fast enough?
Am I too late?
Am I focusing on the right skills?
Will all this effort even work out?

As a student developer, I’ve felt this pressure many times.

Sometimes it feels like everyone around you already knows exactly what they’re doing while you’re still confused about your path.

One person says:
"Learn DSA."

Another says:
"Build projects."

Someone else says:
"Learn AI."

Then another person tells you:
"Web development is too crowded."

And honestly, after hearing all these opinions, it becomes very easy to feel lost.

Social media makes it even harder.

You open LinkedIn or Twitter and suddenly it feels like everyone is:

getting internships
building startups
freelancing
earning online
becoming experts overnight

while you’re still debugging the same error for two hours.

But over time, I’ve realized something important:
Most people are figuring things out as they go.

Even the people who look confident online probably have moments of confusion too.

Tech is such a huge field that nobody can learn everything at once.

And maybe the real goal is not to have everything figured out immediately.

Maybe the goal is simply to keep moving forward.

For me, things started becoming better when I stopped comparing my journey with everyone else’s.

Instead of trying to master everything together, I started focusing on:

improving little by little
building projects
learning consistently
and trusting the process more

I still don’t have everything figured out.

But I’ve learned that growth in tech is rarely loud or instant.

Sometimes it’s just:
showing up daily,
solving small problems,
and continuing even when you feel behind.

And honestly, I think a lot more developers feel this pressure than we realize.

Abhavya :)

Why I Started Building React Projects Instead of Just Watching Tutorials ?

Abhavya Gupta — Mon, 25 May 2026 12:25:16 +0000

Yes, I was just like many beginners.

I used to spend hours watching React tutorials and at the end of the day, I felt productive just because I had completed another video or another playlist.

But after some time, I realized something important:
Watching tutorials is not the same as building skills.

I knew the concepts while watching the instructor code, but the moment I tried to build something on my own, everything suddenly felt difficult.
I would forget syntax.
I would get confused while managing components.
Sometimes even small errors would take hours to fix.

That was the moment I understood that real learning starts only when you begin building your own projects.

So instead of spending all my time consuming tutorials, I decided to start creating projects on my own, even if they were small, imperfect or unfinished.

At first, it was frustrating.
I got stuck almost every day.
There were moments when nothing worked.
Sometimes a tiny mistake in the code would break the entire project and I would spend hours trying to figure it out.

But slowly, those struggles started teaching me things that tutorials never could.

I learned how to debug errors.
I learned how components actually communicate with each other.
I learned how state management works in real projects instead of simple counter examples.

Most importantly, I became more confident while coding independently.

One thing I noticed is that tutorials often make coding look smooth and easy because everything is already planned. But when you build your own project, you have to think like a real developer.

You have to:
• Plan the UI
• Decide component structure
• Manage state properly
• Fix unexpected bugs
• Search documentation
• Learn how to solve problems independently

And honestly, that is where the real growth happens.
Building projects completely changed the way I learn React.

Instead of asking:
“How do I finish another tutorial?”

I started asking:
“How do I build something useful with what I already know?”

That mindset helped me improve much faster.

Even today, I still watch tutorials sometimes.
But now I use them as guidance, not as a replacement for practice.

If you are currently learning React or frontend development, my biggest advice would be:
Start building projects as early as possible.

Your projects do not need to be perfect.
They do not need advanced animations or complicated backend systems.

Even a small project can teach you a lot if you build it yourself.

Because at the end of the day, projects teach you what tutorials cannot….