Teaching What I Once Learned

Introduction

My teaching journey started in the same classroom where I first learned how to code.

Back in 2021, I enrolled in a frontend development course at InfoArs. For six months, I learned the fundamentals, HTML, CSS, Bootstrap, and jQuery, while trying to figure out why one missing semicolon could ruin my entire evening.

By the fourth month, I landed my first frontend developer job. Suddenly, tutorials became real deadlines, real bugs, and real clients. It was probably the fastest way possible to learn.

About a year later, I joined an advanced frontend program at Q-Station, focused on JavaScript and React. That was the point where frontend stopped being “making pages look nice” and started becoming actual application development.

Then came the unexpected part.

Around a year after finishing my first course, InfoArs called me back, not as a student this time, but as a teacher.

Teaching Beginners

I started with beginner groups, students who were opening DevTools for the first time and wondering why CSS sometimes feels personal.

My job was to guide them through the basics, HTML, CSS, Bootstrap, and jQuery, while helping them understand how the web actually works underneath the surface.

Teaching beginners changed the way I looked at development. Writing code yourself is one thing, explaining it clearly to someone else is a completely different skill. I learned how to simplify concepts, adjust explanations depending on the student, and avoid the classic “it just works” developer answer.

Every group was different. Some students learned fast, some needed more repetition, and some were one broken flexbox away from giving up. Helping people push through that stage became one of the most rewarding parts of teaching.

Moving to Advanced Frontend

Over time, I moved to more advanced frontend groups focused on JavaScript and React.

The conversations shifted from simple layouts to application structure, state management, component architecture, and debugging problems that somehow only appeared five minutes before class.

At that level, teaching became much more about problem-solving than syntax. I worked with students on how to think through issues, break down larger problems, and build applications that were maintainable, not just working “for now”.

A big part of the process was helping students become comfortable with uncertainty. In development, you rarely know the answer immediately. You investigate, test, fail a few times, then eventually fix the thing you broke twenty minutes earlier.

Mentorship & Impact

As I gained experience, teaching naturally turned into mentorship.

I wasn’t only explaining lessons anymore, I was helping students build confidence, develop problem-solving habits, and transition from tutorials to real projects.

A lot of the role came down to communication. Sometimes students struggled to explain what confused them, so I had to learn how to spot the actual issue behind the question. Usually, the bug was smaller than the panic around it.

Seeing students go from “I don’t understand this at all” to building projects on their own was easily the best part of the experience.

What I Gained

Teaching improved me as a developer just as much as it helped my students.

Explaining concepts repeatedly strengthened my fundamentals and exposed gaps in my own understanding. It also improved the way I structure code and communicate technical decisions.

Beyond programming, teaching made me significantly better at collaboration. It taught me patience, clearer communication, and how to adapt explanations depending on who I’m speaking to, skills that matter just as much in a development team as technical knowledge does.

Conclusion

What started as an unexpected phone call became one of the most valuable experiences in my career.

Returning to the same place where I learned programming, this time as an instructor, gave me the opportunity to help others start their own journey while continuing to improve my own skills along the way.