From Zero Experience to a Junior Developer in a Few Months

A simple guide for aspiring software developers to build the skills that employers want

Published in

Level Up Coding

9 min readApr 19, 2022

Photo by ThisisEngineering RAEng on Unsplash

Many aspiring software engineers fear they don’t have the experience and knowledge employers expect to see in job candidates. Sometimes that is true, but there is no need to despair. Getting the required skills for a Junior Developer role isn’t that hard.

Here is a simple strategy to build the skills to compete in the software development job market in 6–9 months:

Step 1. Master a popular programming language.
Step 2. Get familiar with the language ecosystem.
Step 3. Get familiar with modern software engineering practices.
Step 4. Build a small portfolio of projects.

Let’s now look into each step.

Step 1. Master a popular programming language

Choose a language that has:

a wide variety of free learning resources,
a large developer community,
a diverse ecosystem of tools, libraries, and frameworks,
plenty of job opportunities.

That will be the foundation for building all your advanced software engineering skills in the future.

1.1 Pick the right programming language

Javascript is the obvious choice these days as it meets all the criteria mentioned above. Swift, Kotlin, Python, Ruby, and perhaps Go are other safe options.

Languages like C# and Java may be a reasonable choice too. Both have a vast developer community and plenty of learning materials. However, their ecosystems may be too big to navigate for a novice, and getting familiar with them may take time. Yet, if you’ve already invested time in learning C#/.NET or Java and are enjoying it — keep going.

Emerging and niche programming languages (Rust, Elixir, etc.) may be fun to learn. However, the developers who want to use them to build commercial software may have fewer job opportunities. For example, the number of job opportunities for Rust developers is incomparable to the size of the Javascript job market.

1.2 Master the programming language

You need to get familiar with the syntax and the constructs of the language and learn to apply it to solve programming problems:

Read the documentation to understand the syntax and concepts.
Do a few tutorials to practice using the language.
Read a couple of books on it.

All three activities are essential, and it’s best to do them in parallel.

The documentation should give you a complete picture of the language features. If you skip this and jump straight to tutorials, your knowledge will be fragmented. What is worse, you will be unaware of the gaps.

Tutorials will help you apply your theoretical knowledge by writing code. For efficiency, do tutorials that cover as many language features as possible. Read the reference and do tutorials in parallel. This way you’ll learn the language sooner.

By reading a book or two on your chosen programming language, you’ll learn best practices, tips and tricks and see examples beyond the language reference. In other words, you’ll know how to use the language efficiently. To pick the best books, look up which ones are recommended for the beginners in your chosen language, then select a couple from the list to read.

A good book may take a few weeks to read but can teach you more than you’d learn by exploring the language features on your own for half a year.

1.3 Learn to write readable and idiomatic code.

Books and tutorials will help you here again. “The Art of Readable Code” is an excellent book on the topic.

In addition, read the source code of the popular open-source projects in the language you’re learning. You may come across many good ideas for structuring your code, naming variables, etc.

Step 2. Get familiar with the language ecosystem.

Now expand your knowledge by getting familiar with the libraries, frameworks, and tools used to build software in your chosen language.

2.1 Get familiar with the popular open-source libraries

Experienced software engineers avoid reinventing the wheel while building commercial applications. Instead, they use open-source libraries to solve common problems and speed up development.

The size of its open-source ecosystem is another reason to choose a popular language like Javascript, Ruby, or Python to learn. Using one of those languages, you’ll be creating software faster than with an emerging or niche language where you may have to do more work yourself.

Let’s look at Javascript as an example. To get familiar with its ecosystem, create a list of popular npm modules and practice using them. You don’t need to learn each one thoroughly. Reading the module documentation and completing a couple of tutorials may be enough.

2.2 Learn a popular framework or two

Professional developers usually build commercial applications using frameworks. Pick a couple of popular ones for your programming language and dive deeper into them. The framework docs, a book/course or two, and tutorials will help you.

2.3 Get familiar with the developer tools

Learn to use one of the popular code editors (such as VS Code) with an extensive ecosystem of plugins. Find the popular plugins to write and manage your code faster.

Learn to use Git and Github. You need to understand how to work with branches (commit, merge, rebase, revert changes) and work with commit history. You won’t need anything beyond the basics at this stage. There are plenty of tutorials online, and you might have done some of them already.

Get familiar (at a high level) with tools for linting code, vulnerability scanners, code quality scanners, etc.

Learn to use the debugger for your language or the debugger in your code editor. If you are learning Javascript, learn to use the debugger in the browser. It will come in handy when you start writing and troubleshooting real applications.

Note that the number of developer tools is huge for any widely used language. There is no point in getting deeply familiar with lots of them. All you need is an overview of the popular ones. It is best to cover more ground at this stage rather than dig deeper.

2.4 Join developer communities

Thousands of other developers use the same language, libraries, and tools as you, and you can learn from their experience.

The first thing is finding and joining online communities: websites like Stackoverflow, communities like https://dev.to/, community Slack chats, virtual meetups, Google groups, etc.

If you can join offline meetups in your area, that’s a chance to meet people like you and people already ahead of you on the journey to becoming great software engineers.

Step 3. Get familiar with modern software development practices

First of all, get familiar with tools and practices for automated testing and try using test-driven development where you can. It may be hard at first, but eventually, you’ll get more fluent.

3.1 CI/CD

Try using one or two CI/CD platforms. Some have free plans that allow learning the basics of setting up a CI/CD pipeline for a project to run the test suit for each branch and deploy merged pull requests to the production environment.

3.2 Code reviews

Get some experience with code reviews. Read some articles on how to do code reviews and try reviewing your pull requests yourself. If you know others on the same journey, propose doing a few code review sessions for each other. Take a look at the PRs in the repositories of popular open-source projects written in your language and pay attention to what comments reviewers post there.

3.3 Pair programming

Try pair programming if you can with others. Developers often use this technique when working on real projects to solve a complex problem, debug an issue, and transfer knowledge between the teammates.

3.4 Agile development practices

Finally, get familiar with agile software development. Most companies use this process to develop software these days. Again, read some articles or a book or watch some courses.

When working on your projects, practice the principles and practices of the agile process. For example, build a backlog of tasks for your project, estimate each task, organise an agile board for your project (maybe using Trello), prioritise the tasks and plan which ones you will try to complete in a week.

Step 4. Build a small portfolio

Some employers expect job candidates without work experience to have a small portfolio of projects on their resumes. The projects don’t have to be overly impressive; they only need to demonstrate that the candidate has relevant software development skills.

Let’s look into the options you have for building such a portfolio:

Doing a project by yourself
Doing a project with friends
Freelancing
Contributing to open-source projects

4.1 Doing a project by yourself

This option is the easiest. However, your learning opportunities will be limited since no one will review your code and guide you, but you will still be learning.

Think of a simple idea for a project. It can be a basic blogging or a ToDo app. If you run out of ideas — go to Product Hunt, pick an idea you like and implement the minimal functionality.

Build something tiny. Even if you are developing a ToDo app — you will have to solve the same issues as developers of complex apps. When the scope is small, the chance that you will complete and publish your project is higher. If you are building a web app — host it on one of the Cloud hosting providers: AWS, GCP, or Azure. Just try to fit it into the free tier so that it doesn’t cost you any money. If you build a mobile app, consider publishing it too.

4.2 Doing a project with friends

If you have friends with similar experience in software development, talk to them. You may be able to build something together. In my opinion, it’s best to create something non-commercial that you can open-source from day one.

The advantage is that every participant will learn from each other, and you’ll review code, pair-program, and use other teamwork practices.

The downside is that the participants will be inexperienced. You may struggle to make much progress, and you may also run into interpersonal issues quickly as few of you would know how to work in a team and deal with conflicting opinions.

This option is still better than the previous one as it allows you to develop and practice more skills.

4.3 Freelancing

You may find work on freelancer marketplaces even with little experience.

The disadvantages are:

You are less in control of what you’ll be working on in the projects.
You may have to work with poorly written apps and won’t learn much.
You’ll spend precious time finding and applying for projects instead of learning.

The advantages are:

You may get a variety of projects to practice different skills.
You will learn to work with clients, prioritise work, estimate, etc.
You may find some long term projects with a team of developers who will help you learn along the way.
Your clients will pay you for your work.

4.4 Contributing to open-source projects

Contributing to open-source projects is a chance to learn from more experienced developers through code reviews and discussions. In addition, this is a chance to work on an actual production-ready software with real customers, and the fact that they are using it for free is irrelevant.

The benefits of this option are:

You will learn your chosen programming language well.
You’ll use software development practices: testing, code reviews, CI/CD, etc.
You’ll learn to prioritise and plan work.
You’ll learn to work in a team. Many beginners don’t know how to do that as they’ve never worked on real projects.

The tricky part is to pick the right project to join.

On the one hand, you may want to join a popular, well-maintained project with a mature codebase and experienced contributors. However, you may have too little experience to contribute meaningfully. As a result, you won’t know where to start, or other contributors may be skipping your PRs. On the other hand, a simple project may be easier to join but may have less polished code and be poorly maintained.

So, pick an open-source project to contribute carefully. Check the contributor’s guide if it exists. It may clarify where to start: fix bugs, update docs, add test cases, etc. It might not sound like much fun, but all that is an integral part of software development.

Imagine that you have published your open-source library, contributed to a couple of commercial projects as a freelancer, and built yet another ToDo app with a friend to organise your work. Altogether, that will be a good portfolio for a person applying for a Junior Developer role.

Learn how to succeed at the job interview, start strong at your first job, and keep learning from your new colleagues:

Takeaways

It is not too difficult to get the skills for the Junior Developer role in a few months if you have a realistic plan and stick to it.

The best first step for you would be to learn the basics of a popular programming language. Then you can get familiar with its ecosystem: libraries, frameworks, and developer tools.

The following step would be to try modern software development practices and do some real projects to create a portfolio to demonstrate your skills. Your options for building your portfolio would be: doing a project yourself or with friends, freelancing, and contributing to an open-source project.

Once you are in the middle of the last step, you can start preparing for job interviews, talking to recruiters or contacting potential employers directly.

Best of luck at your first software engineering job!