Lessons I learned as a software engineer

Imagine stepping into a time machine. What advice do you bring back?

Looking back, there’s so much I wish I told my younger self in tech. About the real life behind it. If you're starting out or stuck midway, these 10 lessons are for you.

1. Coding is important, but communication is everything.

You can write great code, but if you can't communicate, it won’t matter. You hear this a lot like clear writing is clear thinking. That’s true. This is how ideas spread and projects ship. Explain your work simply, document it well, and keep your team in sync.

Impact only matters if others understand it.

2. Code reviews aren’t critiques.

When I started, code reviews felt scary like coworkers were only looking for mistakes. Now I see them as chances to learn and grow. Each comment helps me be a better engineer. I am now more satisfied when I get comments to my PRs.

3. The best debugging tool is a break.

You know that feeling when you’ve been staring at a bug for hours, only to solve it in 10 seconds after stepping away? Yeah, that’s not a coincidence.

4. One bug, one fix, one test.

Every bug is a learning opportunity whether in code or in life. When you encounter one, don’t just patch it. Ask yourself: What can I do to prevent it next time?

After fixing a production issue, improve logging, monitoring, and tests.
That way, we can catch problems earlier next time.

5. Mistakes are part of the process.

No matter how experienced you become, bugs will still find their way into your code. That’s okay. Mistakes aren’t failures; they’re feedback.

6. Don’t over-engineer.

Early on, I thought great code meant handling every edge case and future feature.

I once built a complex config system for a feature that only needed two field settings. Looking back, a simple approach would've been easier to build and maintain.

7. Test your code. Future you will thank you.

Writing tests can feel tedious, but they save time and catch bugs when it matters most. They give you confidence to ship and refactor. Never refactor without them in place.

Otherwise someone say later that the service you started is a garbage and better to create a new one.

8. Learn the business side.

Knowing why a decision is made matters as much as knowing how to build it. Software solves real problems. It is not code for code’s sake.

I worked on a notification feature that felt useless. After release, users left so many comments that it helped them catch key updates. That changed my view of the problem.

9. Efficiency is your superpower.

Small improvements grow over time. Faster typing, better tools and more make a big difference long term.

10. The “perfect” job doesn’t exist.

There’s no single role or company that will check every box. Focus on growth, impact, and culture over perfection.

A friend of mine switched teams or Big Tech jobs over small disagreements. But eventually he understood different opinions are normal and part of the process. However, he already left behind compounding effect and time for future growth. And stayed on the more or less same compensation and level.

Conclusion

To my younger self and beginners: be patient, and keep learning. You’ve got this.

If you found this helpful, please like or share it with a friend and consider subscribing if you haven’t already.

Thanks for reading,
Adlet Balzhanov

---

Connect with me on LinkedIn, just use the button below. I read every message. Cheers!