Where It All Began: My Journey into Software Engineering

I sometimes think about how I started my journey as a software engineer.

At the time, I didn't have much experience. I didn't know React deeply. I had never worked on a real production project. I didn't understand how large codebases were structured, and I definitely didn't feel ready to work as a professional developer.

I was 15.

Looking back now, I realize that I didn't start my career because I was ready.

I started because I was given an opportunity — and then I had to become ready.

This is the story of where it all began.

Before My First Internship

I started learning programming at FayzTa'lim, where I went through a full-stack web development program.

At that point, my knowledge was still quite limited.

I knew HTML and CSS, and I had some knowledge of JavaScript and React. I could build relatively simple responsive websites, but I wouldn't say I understood them deeply.

I had also spent some time learning more about frontend development through SAMMI.AC, which helped me go beyond what I had learned in my local course.

On the backend side, I had some experience with Python and Django. But even there, my knowledge was basic. I could work with Django's MVC-style architecture and templates, but I didn't even know how to properly build and expose an API.

So when I eventually had to choose between frontend and backend, frontend felt like the better option.

But there was one thing I didn't have at all:

real-world experience.

I had built things while learning, but I had never worked on a real product with a real team, real users, real deadlines, and real responsibility.

That changed when I found an internship opportunity.

My First Internship

I joined SoffStudy's Way2Job program.

It was a three-month internship built around real projects and a real working environment, with the possibility of receiving a job offer at the end.

For someone like me, it was a huge opportunity.

I was still very young, had limited experience, and honestly didn't know how much I didn't know.

The plan was simple: during those three months, I would work under the guidance of a more experienced frontend developer who could mentor me and help me grow.

My mentor was Abubakr, a strong frontend developer with experience around the middle+ level. He knew frontend deeply and also had a good understanding of backend development.

I remember thinking that I could learn a lot from him.

And I was right.

Just not in the way I expected.

My Mentor Left on the Second Day

On the first day, my mentor interviewed me to understand my current level.

We talked about what I knew, what I didn't know, and where I was technically.

Then, on the second day, he told me that he was leaving SoffHub.

And just like that, I no longer had a mentor.

I remember being unsure about what I was supposed to do next.

I had joined the internship expecting someone more experienced to guide me. Now that person was gone almost immediately.

But there was something else waiting for me.

A real project.

Suddenly, I Was Working on Soff.uz

Instead of spending months learning in isolation, I was put directly into the frontend of Soff.uz.

It was a large existing project built with Next.js.

At that time, it felt huge.

There were so many folders, modules, components, and pieces of code that I often didn't even know where to look.

And the uncomfortable truth was that I didn't understand React or Next.js well enough yet.

But there was no longer much time to simply say:

"I need to learn this first."

The project was already there.

The work was already there.

And I was responsible for it.

That was when I learned something that has stayed with me ever since:

A mentor can accelerate your growth, but responsibility can force you to grow.

Responsibility Changed Everything

At that point, another frontend developer wasn't brought into the team.

That meant I had to take responsibility for a much larger part of the ecosystem than I had expected.

There was the existing Soff platform, and at the same time we were building a new freelance module — essentially a Kwork-like marketplace adapted for the Uzbek market.

For me, this was an enormous responsibility.

I wasn't an experienced React developer suddenly working on a small practice project.

I was a beginner trying to understand a real production codebase while contributing to products that were actually being used.

So I had only one realistic option:

learn.

I had to learn React properly.

Then Next.js.

Then the tools and concepts around them.

Redux.

TanStack Query.

SCSS.

BEM.

Feature-Sliced Design.

SSR and CSR.

And, more importantly, I had to understand how all of these things fit together inside a real application.

I couldn't just watch tutorials and move on.

I had to learn something, apply it, make mistakes, understand why it didn't work, fix it, and continue.

That changed the way I learned software engineering.

Three Months That Changed My Career

During those three months, I didn't stop learning.

We worked on the freelance module and eventually brought it to life.

For me, the project became much more than an internship assignment.

It was my first real experience of what software development actually felt like.

I started understanding how React and Next.js behave in production.

I learned more about different rendering approaches.

I became more comfortable working inside an existing codebase instead of starting everything from scratch.

I learned how tasks are handled in a team.

I learned about time management, communication, responsibility, and the difference between writing code that simply works and writing code that other developers can actually maintain.

And I learned something else that I didn't expect:

sometimes the fastest way to grow is to be given a responsibility that feels slightly bigger than you.

At the beginning, I felt underqualified.

By the end, I was a completely different developer.

Not a senior developer.

Not even close.

But I had crossed an important line.

I had real experience.

I Started Before I Felt Ready

One of the strange things about being young in tech is that you can constantly feel late.

I was only 15, but I remember feeling like I had started too late.

There were people who seemed to know much more than me.

There were developers who had already built impressive projects.

And I still had so much to learn.

Looking back, that feeling was completely unnecessary.

I wasn't late.

I was just at the beginning.

And the only reason I was able to move forward was because I started before I felt completely ready.

That experience changed how I think about learning and career growth.

You don't always need another course.

Sometimes you need a real problem.

You don't always need another tutorial.

Sometimes you need responsibility.

And you don't always need to know everything before starting.

Sometimes you need to start, and then learn what you need along the way.

What I Would Tell Someone Starting Today

If you're currently trying to start your software engineering career, I know it can feel difficult.

There are a lot of beginners in the market, expectations are changing, and AI is changing the way developers work.

I don't think there is one simple reason why starting feels harder today.

But I do believe there are still good ways to get your first opportunity.

Don't ignore internships

Your first job doesn't necessarily have to be your dream job.

Sometimes the first step is simply getting into a real environment.

An internship can give you something tutorials cannot:

real responsibility, real collaboration, and real experience.

For me, an internship became the beginning of my career.

Use AI, but don't let it replace learning

When I started, the AI coding tools we have today didn't exist.

I mostly had documentation, search, courses, and ChatGPT as a conversational tool.

Today, you have much more powerful tools.

Use them.

Ask questions.

Explore unfamiliar code.

Debug faster.

Learn from explanations.

Build things.

But don't use AI as a way to avoid understanding what you're building.

Use it to learn faster, not to learn less.

Build something real

A tutorial project is useful.

But eventually, you need to work on something where your decisions matter.

A real project forces you to think about things tutorials often don't cover:

architecture, maintainability, collaboration, deadlines, bugs, trade-offs, and users.

That experience is difficult.

It is also extremely valuable.

Don't wait until you feel ready

This is probably the biggest lesson I took from my first internship.

I wasn't ready when I started.

I knew that.

The people around me probably knew that too.

But I started anyway.

And the responsibility of working on something real forced me to improve much faster than I expected.

You might feel like you need to learn one more framework, finish one more course, or build one more project before applying.

Maybe you do need more preparation.

But don't turn preparation into an excuse to never start.

Where It All Began

Those three months didn't make me an expert.

They did something more important.

They gave me my first real experience as a developer.

They showed me what professional software development looked like.

They taught me how much I still had to learn.

And, most importantly, they gave me a starting point.

My career didn't begin with a perfect skill set, a perfect portfolio, or years of preparation.

It began with an internship, an unexpected loss of a mentor, a large codebase I barely understood, and a responsibility that felt bigger than me.

At the time, I thought I was simply trying to survive those three months.

Looking back, I realize I was building the foundation of my career.

I didn't start because I was ready.

I became ready because I started.