How to Become a Confident Software Engineer

Six critical steps to build your confidence as a software engineer.

Hi Friends,

Welcome to the 134th issue of the Polymathic Engineer.

It takes time to feel more confident as a software engineer. It took me over five years to feel comfortable in my abilities, and I made many mistakes along the way. When I reflect on it now, I realize I could have significantly accelerated this journey if I had followed a more structured approach from the beginning.

This week, I'd like to share some advice based on what I've learned and what I've seen other successful engineers do.

---

Mentor by OutSystems: Your AI-Powered Assistant for the Full SDLC

This issue is offered by Mentor. Mentor combines low-code and AI to optimize the entire software development lifecycle. It automates repetitive tasks, accelerates app creation, streamlines code reviews, and enforces security checks, reducing manual overhead and minimizing errors. Let Mentor handle the routine work while you focus on the bigger picture.

Explore how Mentor can enhance speed, security, and efficiency across your workflow.

---

1. Learn a Programming Language Well

Knowing a lot about a programming language makes everything else easy. When you understand one language, its syntax, idioms, best practices, and common patterns, you develop problem-solving skills that apply to other languages.

Early in my career, I decided to focus on C++. I spent time learning not only how to write code that works, but also why some methods were better than others. I learned how to handle memory, how to think about performance, and how the small changes between ways of doing the same thing can make a big difference.

The benefits became clear when I later moved to other languages like C#, Java, and Python. I could focus on learning the new syntax and features instead of struggling with basic programming concepts.

Choosing which language to master first matters less than committing to the process of learning it. Pick a language that's relevant to the type of work you want to do, then go deep.

2. Write Unit Tests and Use CI

Writing unit tests might feel like extra work when you're starting, but it's one of the best investments you can make in your confidence as a developer.

Unit tests give you proof that your code works the way you think it does. When you write a test that passes, you know that a specific feature is working correctly. When you make changes later, the same test will tell you if you accidentally broke something.

Continuous Integration makes unit tests even more powerful. CI automatically runs your tests every time you make changes to the code. This way, you know right away if something goes wrong, instead of finding out weeks later when someone else tries to use your code.

The confidence boost from having good tests is enormous. When you need to refactor complex code or add new features to existing systems, tests give you the safety net to make changes boldly. You know that if you break something important, the tests will catch it right away.

3. Make Refactoring a Habit

Refactoring improves the structure and readability of your code without changing what it does. Making this a regular habit will dramatically improve your confidence because you'll always be working with code that is clean and easy to understand.

Clean code is easier to debug, extend, and maintain. When you come back to the code you wrote months ago, you'll understand what it does instead of being confused by it. When you need to add new features, it's easier to see where those features should go.

The important thing is to make refactoring a normal part of your work, not something you do occasionally. When you are done implementing a feature, spend a few minutes cleaning up the code. Look for functions that could be broken up, variable names that aren't clear, and duplicated code that could be extracted into reusable functions.

Learn to use the refactoring tools in your IDE. Most development environments can change the names of variables, extract methods, and rearrange the structure of code instantly. Refactoring is quick and safe with them because they update all references for you. Don't wait until code becomes a complete mess before cleaning it up.

4. Pair with People

Pairing with other developers is an excellent way to improve your skills and build confidence. When you work with experienced engineers, you see how they approach problems, what tools they use, and how they think through tough challenges.

At the beginning of my career, I was afraid to pair with others because I was worried about looking incompetent. This was wrong. I learned faster by pairing than by doing any other task alone. Sitting with other developers and talking through code helped me understand not just what to do, but why to do it.

Pairing also lets you see things from different perspectives. Every developer has their own way of solving problems, and pairing lets you learn multiple approaches instead of just your own. You might discover keyboard shortcuts, ways to fix bugs, or design patterns that you would not have found on your own.

However, pairing is not only about coding. It also works for architectural discussions and problem-solving sessions. The idea is to learn how other developers think, not only how they write code.

As you gain experience, remember to pair with more junior developers, too. Teaching others also helps you understand things better and see problems in new ways.

5. Read Books

Reading technical books is an underrated way to build more confidence as a software engineer. You can learn a lot from books that you can't learn from quick tutorials or Stack Overflow replies.

More important than how many books you read is how you read them. Earlier in my career, I made a mistake by skimming books quickly, but this approach didn't help much. Now I focus on reading fewer books but taking detailed notes and applying what I learn.

Three or four books per year are enough if you read them correctly. I prefer books that cover fundamental concepts rather than specific technologies. Software architecture, algorithms, system design, and clean coding practices will serve you throughout your career.

Some books that had a huge impact on my confidence include "Clean Code," "Design Patterns," and "Design Data Intensive Application". These books taught me not just techniques, but ways of thinking about software that made me a better engineer.

6. Teach What You Learn

Teaching others is one of the most effective ways to solidify your own understanding and build confidence in your skills. If you can explain a concept clearly to someone else, you know you truly understand it.

You can start by sharing what you have learned through blog posts, presentations, or mentoring junior developers. You don't need to be an expert to teach; you just need to know slightly more than the person you're helping. Someone who recently learned a concept can explain it better than an expert because they remember what it was like not to understand it.

Teaching forces you to organize your thoughts and fill in gaps in your knowledge. If you try to explain something and realize you can't do it clearly, that's a sign you need to learn more about that topic.

The best engineers I know are also great teachers. They can take complex problems, explain them in easy terms, and help others understand ideas that are hard to grasp. You don't just naturally have this skill; you have to work at it.

Interesting Read

Here are some interesting articles I read in the past weeks:

• Don't Forget These Non-Functional Requirements by

  Saurabh Dashora

• Retries Have an Evil Twin: Duplicates by

  Raul Junco

• Best AI Code Review Tool for GitHub, GitLab & Bitbucket by

  TheAnkurTyagi