When we were given our project, CourierIQ, I knew I wanted to use it as an opportunity to learn something outside what I was already comfortable with.
I was already more familiar with frontend development, so when backend development came into the picture, I was actually excited.
I thought, okay, this is going to be interesting.
I don't want to be someone who only knows one side of development. If I have the opportunity to learn something new, why not?
But when the backend sessions actually started, I quickly realized I had a lot to learn.
We were talking about requests, APIs, endpoints, controllers, services, middleware and all these things that sounded very familiar to everyone else but were honestly confusing to me.
I was hearing all these terms, but I didn't really understand how they connected.
It wasn't until I started doing the hands-on work that things slowly started making sense.
At that point, I had a problem.
I could go through several backend tutorials and slowly learn everything before building CourierIQ.
But the project had a deadline.
And knowing myself, I also knew that I could easily spend weeks watching tutorials, taking notes, starting another tutorial, and still be waiting for that perfect moment when I felt "ready" to build.
So I started thinking about another way I could learn while actually building.
That's when I decided to use AI.
Not because I wanted AI to build my backend for me.
I saw AI as a way to speed up the learning process while working on the actual project.
And this is where my approach became very important.
When I started working with AI on the backend, I gave it a specific role.
I basically told it:
I'm new to backend development. Act like a senior developer mentoring me through this project. Give me the steps I need to follow, explain why I'm doing them, and don't just write the code for me.
I was using Antigravity, and I really enjoyed the support I got from it throughout the process.
One of the first things I wanted to understand was the structure of the backend itself.
Where should my files go?
Why do I need a config folder?
Why are there routes, controllers, services and models?
What is supposed to happen in each one?
For me, this was important because I didn't just want the project to work. I wanted the codebase to actually make sense. So instead of asking AI:
"Build my backend."
I would ask it something more like:
"What should I do first?"
And it would give me the steps.
Create this folder.
Create this file.
This file is responsible for this.
Then move to this part.
Then connect this.
Then test it.
And I would write the code myself.
This was probably one of the most important decisions I made during the process.
It would have been much easier to tell AI:
"Build the authentication system for me."
And then copy whatever it gave me.
But I knew that if I did that, I could end up with a working backend that I didn't actually understand.
And I didn't want that.
I wanted to struggle a little.
I wanted to make mistakes.
I wanted to look at an error and try to figure out what was wrong.
So most of the time, AI gave me the steps and direction, and I handled the implementation.
Sometimes I would write something incorrectly and AI would point out the problem.
Sometimes I would see a piece of code I didn't understand and ask:
"Why are we doing this?"
Or:
"What does this actually do?"
Or even:
"Explain this to me like I'm completely new to it."
And that became part of my learning process.
One of the first moments where I felt like my approach was actually working was when I started setting up the Express application and getting my server running.
Then I moved on to initializing the database.
These might sound like very small things, but for someone who was completely new to backend development, they were actually important moments.
I started understanding that the things I was writing weren't just random lines of code.
There was a reason for the server.
There was a reason for the database connection.
There was a reason for the different folders.
There was a flow.
And slowly, the backend stopped looking like a huge confusing block of code.
It started becoming something I could actually navigate.
Of course, it wasn't all smooth.
JWT was one of those things that made me stop and ask a lot of questions.
I understood that users needed to log in, but then I started seeing tokens, secrets, user IDs and verification.
And I was like...
Wait. Why are we doing all this?
So instead of just copying the JWT code, I started asking questions.
What exactly is inside the token?
Why is the user ID there?
What is the JWT secret?
Why does the backend need it?
How does the backend know whether the token is valid?
That process helped me understand that the token wasn't just some random string the backend generated.
It could represent an authenticated user's session, and the backend could verify it before allowing access to protected resources.
That was one of those moments where asking AI to explain something was more valuable to me than simply getting the code.
The easiest way I can describe my experience is that AI felt like having a senior developer beside me.
Not someone who sits down and writes the entire project for me.
More like someone who says:
"Okay, this is what you need to do next."
Then I try it.
If I get something wrong: "This part isn't right. Here's why. Try it again."
If I don't understand something: "Let's break this down."
And then I continue.
That's how I wanted to use AI.
It wasn't about removing the thinking from the process.
It was about having somewhere to turn when I got stuck.
Interestingly, I used AI differently depending on what I was building.
With frontend development, there were things I already knew how to do, so I was more comfortable letting AI help me with repetitive code or things I had done before.
But backend was different.
I couldn't just tell it to do something because I didn't know enough yet to confidently judge whether what it gave me was actually good.
So I became much more intentional.
I needed explanations.
I needed the structure.
I needed to understand why something existed before I could confidently use it.
That difference actually taught me something about using AI for development:
The less you understand about a technology, the more careful you need to be about blindly accepting AI-generated solutions.
No.
And I don't think I should say that.
After three or four weeks of working through the backend, I wouldn't suddenly call myself a backend expert.
I still have a lot to learn.
There are concepts I haven't worked with deeply yet, and there are definitely things I would struggle to build completely from scratch without some form of guidance.
But I can say something else.
I now have basic knowledge of backend development that I didn't have before.
I understand things that were completely confusing to me at the beginning.
I understand the basic relationship between routes, middleware, controllers, services, models and databases.
I understand why authentication exists and what JWTs are doing in that process.
I understand the importance of validation.
And when I open a backend project now, I don't feel like I'm looking at a completely foreign language.
I can find my way around.
For me, that's progress. The biggest lesson I took from this experience is that how you use AI matters.
You can ask AI to build an entire application for you and have something running in a few minutes.
But having something that runs isn't the same as understanding what you built.
For me, the better approach was to use AI as a copilot. I wanted it to help me move faster, but I still wanted to think.
I wanted to write the code.
I wanted to ask questions.
I wanted to understand the structure.
And most importantly, I wanted to be able to look at the project afterwards and say:
"I may not know everything yet, but I know what is happening here."
That's a very different feeling from simply having AI generate a project and saying, "It works."
Looking back, I definitely wouldn't say my backend journey is finished.
If anything, CourierIQ showed me how much more there is to learn. But I'm glad I didn't wait until I knew everything before starting.
I started confused.
I used AI to guide me.
I asked a lot of questions.
I wrote the code myself.
I made mistakes.
I fixed them.
And somewhere along the way, things started making sense.
So no, AI didn't build my backend for me.
I used AI as a learning tool, a guide, and honestly, a very patient "senior developer" sitting beside me throughout the process.
And I think that's probably the biggest thing I took away from the experience:
AI works best for me when it helps me think, not when it thinks for me.