If you speak a foreign language, you can test the skill level of how well you speak and understand. It’s called the Common European Framework of Reference for Languages, or CEFRL in short, and ranges from A1 to C2. Correspondingly, how are coding skills qualified?
For coding levels, there is no such official classification. And yet, your coding level will decide which jobs you can apply to and what salary you will earn. Then, when can you call yourself a junior, intermediate, or senior developer?
As official as these terms may sound, they basically mean beginner, advanced, and specialist. They refer to the amount of practical experience you have gained as a programmer. As a junior you might have already learned many programming languages and tools, but you do not have any experience on the job yet.
A junior coder learned coding at school, at college or university, or is self-trained. He or she has probably tried their hands at side-projects, but does not have relevant work experience. Relevant means: while maybe having work experience from other jobs, they still do not have any in the field of software development.
Junior developers usually already have a solid programming proficiency. They most likely have built apps (in the case of the mobile developer) or websites (as web developer) for school practice or for their own project ideas. Nevertheless, they lack the experience of a software developer who has already worked in a job with real-life projects.
Commonly, junior developer get mentored by colleagues with more experience. This can take the form of an organized mentorship or rather informal guidance or pair programming sessions.
Since juniors still lack experience with some tools and technologies, they often need help with debugging, testing, and troubleshooting. As boring as these tasks may sound, they make up the largest part of day-to-day work and are best learnt from someone experienced who can show you first hand.
During the first two or three years on the job, you are still heavily learning new things. It is called paying the dues and is what anyone in any profession has to go through. Ideally, an intermediate or senior colleague accompanies this period as your designated and dedicated mentor.
After a couple of years, you will have gained so much experience that you are visibly better at coding. You will feel a clear change of perspective, and find yourself regularly in the situation where you share your knowledge with newer colleagues. Time to step up the ladder to the title of intermediate developer.
An intermediate developer is someone who typically has two to four years of work experience in programming.
The coding skills are solid. Typical software development tasks have become a routine. Debugging and testing are familiar and do not pose an obstacle, and as an intermediate you find your way through troubleshooting issues.
One thing characteristic for intermediate developer, though, is being fascinated by third party tools. Obviously, third party tools take work off their plates and make life as a software developer easier. They solve common problems, make code slimmer, and let the developer focus on the actual development task.
Typically though, intermediate developers tend to over-engineer their code. They tend to like using third-party tools, and keep adding dependencies.
This is not always good, because dependencies mean more maintenance work and boilerplate code. External libraries can bring their own problems, and a large number of dependencies makes the build time longer.
Also, design patterns are great and helpful, no doubt. But if you apply them before it’s actually necessary, they increase code complexity rather than reducing it. Simplifying code later on is more difficult than keeping it slim from the start.
Intermediate coders are often fascinated by clever solutions. But these solutions may also bring new problems. The estimation of what will reduce problems or add new ones needs years of experience.
As an intermediate programmer, you should keep that in mind. And as for the software architecture, consult a senior before making a decision that’s hard to change later.
In contrast to the intermediate developer, a senior usually makes better decisions. With four or more years of experience, he or she is an expert in their respective technology stack.
Senior developers have mastered the arts of coding, testing, debugging and troubleshooting. They know best practices from their own experience. Instead of just extending existing code, they carefully look at the code, improve and simplify where possible. They prefer a simple over a sophisticated solution.
Many years of experience enable them to foresee certain problems. They question if a new tool or library will be helpful, and they can estimate the relevance and complexity of new solutions quite well. In short, they are good at telling what works and what doesn’t.
One other characteristic of a senior developer is that they know the priority and complexity of tasks. In a planning meeting, they will contribute better estimations, and often get an informal veto in the team.
They are usually not afraid to reject a task, for instance if the implementation of a new feature is too hard compared to its value. They are good at communicating the reasons for that, to their developer teammates as well as their project managers.
Some developers already have a talent for communication from the start. For others, it needs years of experience of team work to get their communication skills to a senior level. Seniors are expected to be able to explain technical matters in a way that’s easy to understand. That means that also non-technical staff members and even customers will understand them.
This is the reason why senior developers are picked to attend meetings with the customer or to go on consulting missions. And there is no one more qualified to train junior and intermediate programmers or to be their mentor.
One other group is worth mentioning here: trainees.
In Germany, it is less common for companies to open explicit trainee positions. What we mean by that are also interns or apprentices. They are developers who are still learning, and who get trained on the job for that. They have less technical skills than juniors and equal little work experience.
They learn their necessary skills on the job as an employee. The benefit is that they learn with real-life projects. They learn by doing, which is often a much quicker way, because it skips certain theoretical lessons.
Trainees code with guidance, often in pair programming. When they have to code on their own, they will get the easiest and often the more repetitive tasks.
The quality of the training depends mainly on the mentor’s expertise and availability. A trainee will learn better if there’s a skilled instructor who challenges and supports them. But as it is with learning anything: the more effort you put yourself, the better you learn.
Of course, a good programmer is more than just the years on the job. Technical skills as well as structured and inspired thinking matter in the long run. Don’t worry if you have to start your career at a junior or even trainee position. Everyone was once exactly where you are now. Software development is a field that is quite strict about your hard skills. But it is also very fair. The better you get, the higher is your market value. And with your dedication and constant learning you will eventually get to the level you want to be.