Working in software is hard — no matter what level you are at. But as a junior developer who is maybe fresh out of school or has just switched to the industry, this journey can be extra challenging.

Comparing myself to a year ago, I have definitely come a long way as a junior developer, from a fresh university graduate to a developer who can input on design decisions and make a real impact on various projects. I think that is a big accomplishment for my first year since entering the field.

But improvement doesn’t come for free. In the past year, I purposefully put myself in uncomfortable situations to get better — and it paid off. In this article, I want to share six tips that really sped up my improvement as a software developer.

1. Have a Personal PR Checklist
As you start to actually work with your team, reviewing others’ PRs is guaranteed to happen.
It’s important to efficiently and correctly review a PR. The implementer can make mistakes, and as the reviewer, you are the last line of defense before potential bugs get merged.

However, carefully reviewing a PR takes time. Therefore, you want to find a balance between the time spent and the quality of your review.

Creating a PR checklist can be really helpful in these situations. You can make a list of things that you need to pay close attention to and keep them in mind when reviewing code.

For example, when I’m reviewing a frontend PR, I pull down the branch and check the following:
Does the code compile/run locally? Does it have console errors?                                                                      Does the code change satisfy the exit criteria of the task? Does it match with the mock?
UI edge cases (truncation on long text, Redux race condition, loading/failure screens)
Mobile responsiveness
Can UI strings be translated?
No missing tests

Then, I will move on to more subjective things:

Coding style. More importantly, does it match the current style?
Maintainability of the code. Does it need comments?
CSS and JS best practices (if you can use const , don’t use let ).

By going through the items on this list, I can be confident that I did my best when reviewing and would’ve caught all the visible bugs if there were any. Of course, having a list won’t 100% eliminate bugs, but it can drastically reduce the chances of one.

Lastly, it’s important to always ask about what you don’t understand on a PR. As a junior developer, the best way to learn something is to see how others are doing it — and a PR shows you exactly that. If there is something on a PR you don’t understand, never hesitate to ask.

2. Learn To Take Notes

This might sound obvious, but I think we all overlooked the importance of note-taking when we first started as developers.

Taking notes does not mean simply have a to-do list every day (although that is important to have as well). You should take notes on everything that is worth remembering.

I take notes on everything. This can be 1-1 topics with managers, a bug I struggled for hours to resolve, an internal engineering process that I wasn’t aware of, problems I faced when bootstrapping a repository, or useful documentation I found online that can solve a particular problem.

Your memory is never as good as ink on paper (or a Notes app). You will forget things because, as a developer, you will be encountering new challenges every day.

Having a record of what you encountered and what you’ve done can be very beneficial not only to yourself but to other developers as well. It can save you time in the future if you run into a similar problem, and it’s possible that another developer might run into them as well.

3. Analyze Yourself and Find Patterns

Being able to deliver on tasks with speed and quality is not the only thing that differentiates a senior developer from a junior one. But that doesn’t mean it’s not an important differentiator.

What makes a senior developer “senior”?

One of the main differences is that they can produce more value for the organization by taking on more complex tasks and deliver with quality and speed.

Your output rate is still one of the most important factors that can influence your performance, so it’s very important to speed up your output while maintaining correctness.

As you go from task to task, analyze how you approach them and find patterns.

If you consistently fail to deliver tasks on time and it’s not an issue with assessing the complexity of the tasks, then there is a problem.

In cases like this, analyze how you approached the tasks and try to find patterns in what went wrong and what took you the most amount of time. For example, I noticed that for complex bugs, I dive into debugging without having a plan. This substantially hinders my speed, as I would be looking in the wrong direction.

Once you find a pattern, you can act on it to speed up your output.
You can also find patterns when things are going well for you. Analyze if there is a method that works really well for you and keep applying it. It’s all about knowing how you work best as a developer.

4. Learn How To Ask Questions

Asking questions is normal. You will definitely find yourself stuck on a problem at some point and having to ask others for help.

However, asking questions is a skill as well. You need to construct your questions in a way that will not only give you the answer you want but also make it easy for the recipient to answer.

Especially when we are mostly working remotely, you shouldn’t bombard others with meaningless questions that can be answered with a simple Google search.

I always try my best to ask questions in a way that will lead to a yes-or-no answer. This means I show what I tried, the result I got, and any suspicions or educated guesses I have.

Whoever I’m asking can simply answer “yes” or “no” and give an explanation of the answer or point me in the right direction.

Learn to ask questions intelligently and effectively. You will not only get the answer you are looking for, but you will also save time for both yourself and the person you asked.

Show that you tried before asking and that you respect others’ time. You don’t want to have the reputation of bothering others with every single question you have.

5. Take Tickets for Tasks You Don’t Know How To Do

If you are working in a team, there will be a set of tickets that a team needs to finish in a sprint. There will be some tickets for tasks that you have no idea how to do or even approach.

These are the best kinds of tasks to pick up as a junior developer if time constraints allow it. They are also the best kinds of tickets with which to prove your abilities to your manager.

Don’t be scared in these kinds of situations. Completing a ticket for a task that you don’t know how to do will force you to learn completely new things and become more familiar with your organization’s code base.

Learning is supposed to be hard and challenging. If you always take tasks that you know how to do, then they will become less and less challenging. How are you supposed to learn the backend if you are only writing frontend components? You have to step outside of your comfort zones to learn and grow as a developer.

Of course, when you are completely stuck, always reach out for help. Chances are, when you’re working on a task that is outside of your current abilities, others in your team will notice and expect questions from you.

6. Become the Go-To Person for Something

As you work as a junior developer, one of the main focuses should be becoming the go-to person for one area of the code base.

This can be as big as an entire project (kudos if you can do this) or as small as a single feature inside a big application.

The best way to advance as a junior developer is to set a standard for yourself beyond your current capabilities. If you look at senior developers, they are often the go-to person for multiple projects and repositories.

Becoming the “expert” in an area forces you to fully understand the code. That means understanding what it does, why it was written that way, the design decisions that were made, and how it fits into the whole picture. It also proves to your manager and other developers that you’ve made an impact in the organization and can be relied upon.

Note that this is not easy to do and you will have to make sacrifices. You can’t stop when a feature is implemented. You can only stop when you fully understand that feature. That might mean taking additional time to read through the code and documentation or even picking up work outside of your current team.

Conclusion

Being a junior developer can definitely be stressful at first, but the good news is that it’s manageable. The expectations set on you will be lower and your mistakes will be less catastrophic. I’m definitely glad and have no regrets about choosing this path.

So take advantage of this period time and keep a calm mindset. Remember that everyone has to start somewhere and work their way up, writes betterprogramming.pub.