DEV Community: 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….