From Writing APIs to Understanding Systems: My First 3 Months as a Backend Engineer

From Writing APIs to Thinking in Systems: My First 3 Months as a Backend Engineer

When I started my journey as an intern, I believed backend development was mainly about writing APIs.

I was comfortable working with frameworks like FastAPI and had a basic idea of how systems should be structured. But that understanding was mostly theoretical.

Once I started working on real projects, I realized something important:

Writing APIs is easy. Understanding systems is not.

Where I Started

Before joining, my approach was simple:

• Take a requirement
• Write an API
• Return a response

I focused more on code than on how things actually worked behind the scenes.

I did not think much about:

• how data flows across the system
• how different components interact
• what happens when something breaks

The Shift: From Code to Flow

Working on a real backend system forced me to slow down and understand the complete flow.

Instead of just writing endpoints, I had to think about:

• how input is processed internally
• how data is validated before execution
• how different layers of the system connect
• how to handle incorrect or unexpected behavior

This was the point where backend stopped being just “code” and started becoming a system.

Learning to Handle Real Problems

One of the biggest differences between practice and real work is this:

In real systems, things fail in unexpected ways.

I faced multiple situations where:

• logic worked in theory but failed in execution
• small mistakes caused larger system issues
• fixing one part affected another part of the system

This forced me to move away from trial-and-error coding and start debugging properly.

I learned to:

• read logs carefully
• trace the flow step by step
• identify the root cause instead of guessing

My First Real Challenge: Deployment

Until this point, I had only worked in a local environment.

Running a full system with multiple services was a completely new experience.

Setting up containers, connecting services, and making everything run together was not straightforward.

The biggest challenge I faced was with the database setup.

• configuration changes were not reflecting
• authentication errors kept appearing
• the system behaved inconsistently

At one point, I was completely stuck.

What helped me move forward was:

• checking logs instead of guessing
• understanding how data is persisted
• asking for help when needed

This experience taught me that deployment is not just a final step—it is part of the system itself.

A Mistake That Changed My Approach

In the beginning, I relied heavily on AI-generated code.

It helped me move fast, but it also created a problem:

I was using code without fully understanding it.

This became a major issue when I had to debug or modify something.

I realized that:

• speed without understanding is risky
• generated code is not always reliable
• real confidence comes from understanding, not copying

After that, I started focusing more on:

• reading code carefully
• understanding logic before using it
• thinking through the flow

What Changed in My Thinking

Before:

• Focused on writing code quickly
• Thought backend = APIs
• Relied on output without validation

Now:

• Focus on understanding the complete system
• Think in terms of data flow, not just endpoints
• Validate logic before execution
• Treat debugging as a core skill

What I Understand Now

Backend development is not just about writing code.

It is about:

• how data moves through the system
• how components interact with each other
• how failures are handled
• how to keep the system reliable

Conclusion

My initial understanding of backend development was limited to writing APIs.

Working on real systems changed that completely.

Now, I approach problems with a focus on:

• system flow
• data correctness
• debugging and reliability

I am still learning, but this shift—from writing code to understanding systems—has been the most important part of my journey so far.