New terms. New ways of thinking. Syntax errors. And every single roadblock felt like a life sentence.

Then something happened.

I started to understand what was happening behind the scenes — not because I was continuously writing syntax, but because I started understanding the architecture behind it.

One thing I realized I was actually good at was looking for the bigger picture: understanding how data flows through the application and how the different mechanisms work together.

Getting to that understanding takes an immense amount of time. Sometimes, understanding the why takes much longer than actually writing the code.

There are still a couple of blocks left to kick in. My execution isn't where I want it to be yet.

But the start has already been kicked in.

where this big picture clicked??,well ..

When I began my first MERN stack walkthrough with Net Ninja, it genuinely felt like entering a new world.

A world full of new facts, new concepts, new syntax, and — most importantly — the challenge of keeping up with him. (Damn.)

Not gonna lie, sometimes it felt like jumping into a well without knowing how deep it was.

And watching the tutorial wasn't the only part.

I had to learn by myself too.

Whenever I stumbled upon a technical term or syntax that I didn't understand, I'd Google it or GPT it. (Great mentor sometimes. I torture it for my own well-being sometimes.) 😂

That process turned into a rabbit hole.

One question would lead to another question, which would lead to another concept, and suddenly I had spent a ridiculous amount of time understanding something that initially looked like a tiny piece of code.

But strangely, that rabbit hole started feeling like a million-dollar learning experience.

Because eventually, something started changing.

I wasn't just seeing individual lines of code anymore.

I started seeing why they were there.

I started connecting the frontend, backend, routes, controllers, models and database into one continuous flow.

And that's when it clicked.

The big picture wasn't something I could memorize from a tutorial.

It was something I had to slowly build in my head.

btw what is that big picture i am talking about??

The big picture started becoming clearer when I stopped looking at individual concepts and started asking simple questions.

What actually happens when a user clicks the Login button?

Or when a user clicks “Add Workout”?

That's when all those concepts that I had learned separately suddenly started connecting.

I started seeing something like this:
User clicks -> React local state captures the input -> fetch / Axios sends the request -> Browser checks CORS rules -> Request reaches the server -> JWT middleware -> Router -> Controller -> Database / application logic ↓->Response sent back -> Frontend receives it -> dispatch(action) -> reducer processes it -> New global state -> Provider makes the updated state available -> React rerenders -> Updated dashboard

And suddenly I was looking at all the things I had previously learned as if they were pieces of the same machine.

req.body wasn't just some syntax anymore.

JWT wasn't just some random authentication term.

The router wasn't just another file.

dispatch, action, reducer, and Provider weren't isolated React concepts either.

They all had a place in the journey of the data.

And this was probably one of the most satisfying moments of the whole learning process.

Because I realized:

“Wait… I wasn't randomly learning all these things.”

I was collecting pieces without knowing what picture they belonged to.

And then the tunnel got darker. 😂

Just when I thought:

“Yesss 😍 I finally understand how this works!”

I looked deeper.

And suddenly there were HTTP-only cookies, XSS, CSRF, CORS, JWT security, authentication flows...

I was like:

“What the hell is this?!” 😂

It felt like walking through a dark tunnel, finally finding a light at the end, and then realizing the light was actually the entrance to a museum of scary technical artifacts.

Every time I understood one thing, another question appeared.

Why HTTP-only cookies?

What exactly can JavaScript access?

What is XSS?

Why does CSRF matter?

Why does the browser behave differently for different requests?

And that's when I realized something else about development:

Understanding the happy path is only the beginning.

Once you start looking underneath the surface, you start discovering the mechanisms, edge cases, security concerns, and decisions that make the system actually work.

And honestly?

Sometimes the reaction is simply:

“Why did I choose this path?” 🤣

But that's also what made the journey interesting.

The more I entered, the more I explored.

Nothing more, nothing less — I could probably keep filling pages with all the things I came across.

And I can assure you:

BOY OH BOY, THIS WAS AND IS PAINFUL AS HELL!! 🤣

But jokes aside, I realized something about what actually keeps me going.

It isn't motivation.

It isn't even enjoyment.

It's curiosity.

And yeah… curiosity is painful too. 🤣

One question leads to another. One concept opens the door to another concept. Sometimes I spend far more time understanding why something works than actually writing the code.

But somewhere in all that frustration, I realized that I genuinely love creating something on my own.

There is this weird feeling when something that existed only as an idea in your head finally becomes an actual working application.

It's painful.

It's enjoyable.

It's frustrating.

It's satisfying.

Somehow, it's all of those things at the same time.

And that's a completely different vibe.

Learning is one thing. Execution is another.

My learning journey wasn't limited to MERN either.

As I started exploring LLMs and other technologies, the picture became much bigger.

The concepts felt rationally satisfying once I understood how they worked.

But understanding something doesn't mean I can immediately execute it.

And I'm okay with that.

Execution takes time.

There are things I can explain but still struggle to implement from scratch. There are things I understand architecturally but need more repetition to make them natural.

And that's fine.

Because at the end of the day, we are the executors — not just the thinkers of our ideas.

The goal isn't to eliminate the gap overnight.

It's to keep closing it.

But I don't want my workflow to simply be:

Prompt → Generate → Copy → Run → Done

That approach can produce a result without necessarily producing understanding.

Instead, I try to use AI to question things.

Why does this code work?

What is happening behind this abstraction?

Why did this error occur?

What would happen if I changed this?

Can I build it myself after understanding the explanation?

Sometimes I'll use generated ideas as a starting point, then experiment with them, break them, change them, and learn from what happens.

For me, the interesting part isn't just getting the answer.

It's using the answer to build a better mental model of the system.

So my preferred loop is closer to:

Question
   ↓
Explore
   ↓
Understand
   ↓
Experiment
   ↓
Make mistakes
   ↓
Debug
   ↓
Build
   ↓
Understand better

rather than:

Prompt → Generate → Result

And I think that's one of the biggest things this journey has taught me so far.

AI can accelerate the journey, but it shouldn't replace the journey.

what is even the worst part ??

Even though we know that execution takes time, knowing that doesn't make the process painless.

Sometimes it stings so much that you start questioning yourself:

Do I really need to push myself this hard?

Should I keep working on this, or should I do something that actually gives me peace?

Why am I disrupting my own peace for this?

And I think that's where the journey becomes much more personal.

Every influencer, colleague, friend, or peer seems to have a different path. And sometimes you can't help but wonder:

“Why are you still doing this? Why are you putting yourself through this every night?”

And honestly, sometimes my answer is simply:

“Because I can't stop.”

There's a line from one of my favorite wrestlers, Nic Nemeth, that captures that feeling for me — that feeling of being unable to simply walk away from the thing you're chasing.

Maybe that's what a lot of developers and other people going through their own journeys experience too.

Every roadblock feels personal when you're the one standing in front of it.

Some roadblocks stay inside the code.

Some get into your head.

And sometimes they even spill into your everyday life.

But I've started to believe that there's a difference between suffering for something blindly and pushing through difficulty because you genuinely value where the journey is taking you.

I'm still not the best at what I do.

I'm not the best at any particular technology.

There are days when I put in the effort and still end up staring at something that doesn't work, wondering:

“Why isn't this working?”

Sometimes it genuinely hurts.

But I keep coming back to the same two things:

independence and the love of the game.

I want to be able to take an idea that exists in my head and eventually turn it into something that actually works.

I want to understand what I'm building instead of simply watching someone else build it.

And maybe that's why I keep taking the plunge.

Not because I have everything figured out.

Not because I'm the best.

Not because every day is enjoyable.

But because standing still feels less meaningful to me than taking another step forward.

That has been my journey so far.
So, what did this journey actually teach me?

If I had to take something away from this entire journey, it wouldn't be a particular framework, programming language, or technology.

It would be the way I started looking at things.

I used to think that being good at development meant being able to write code quickly and remember everything without looking it up.

Now I see it differently.

Understanding and execution are two different things.

I can understand what a system is supposed to do and still struggle to implement it from a blank file. I can understand the architecture and still forget a piece of syntax. And that's okay.

Execution takes repetition.

It takes mistakes.

It takes trying again after something completely refuses to work. 😂

Another thing I learned is that AI doesn't have to replace the learning process.

I can use AI to get an explanation, explore an idea, understand an error, or look at a different approach. But I still want to question the answer, experiment with it, break it, fix it, and understand why it works.

For me, the goal isn't:

Prompt → Generate → Result.

It's more like:

Question → Explore → Understand → Experiment → Make mistakes → Learn → Build.

And somewhere in between all of that, I realized what actually keeps me moving.

Curiosity.

Motivation comes and goes.

Enjoyment comes and goes.

But curiosity keeps asking:

“What happens if I try this?”

And maybe that's enough to keep going.

I'm still learning.

I'm still making mistakes.

I'm still not the best at the technologies I'm working with.

There are still plenty of things I can't execute independently yet.

But I don't think the goal is to become perfect before moving forward.

The goal is to keep closing the gap between what I understand and what I can actually build.

When I started this journey, I felt like I was walking through a dark tunnel without knowing where it would lead.

Now I can see a little further ahead.

And honestly, there's still a ridiculous amount of tunnel left. 😂

But the light is there.

And the start has already been kicked in.