Like many people, I started my development career from another role. I taught myself coding and then built software to help the business and myself. It was well received, but I did not feel like a "real" developer yet.
This experience convinced me that software was what I
wanted to do, so I looked for a junior developer role. This wasn't easy,
most companies want people who can come in and start being productive
right away, and there were many skills I lacked from not working in
a"true" software development environment. Eventually, I was taken in as a
When handing in my resignation, I was offered a
pay rise to more than I would be getting in the new role. I was
also offered a new position, the position of "Senior" developer.
I had a choice. I could stay, and drive development projects, leading a
team of newly hired junior developers. My career would leap to a role
of seniority and if I was to move on I could say I had been a "senior"
Or, I could move into a new company as a junior developer, where I would be mentored, and surrounded by more senior developers.
I chose to move.
wanted to see how it was"really"done. How developers work together, how
they feed off each other, how they learn. I wanted to learn. I could
not do that if I was the most senior developer.
Staying was never
an option. I'd be a fraud. The title of senior can be extremely
subjective, given for many reasons. Tenure, age, comparative skill, or
Yet I see this often. Developers who have always
been a senior developer don't get to see how it's "really" done, how large software departments work together. You can't always work out the best ways to do things by yourself. You need exposure to different practices, methodologies, cultures, personalities, and skill levels.
Moving to a junior
role was the best thing I ever did for my career. It taught me to
understand the development process from the ground up, filling in many
skills gaps from being self taught. Some of these skills were technical,
some were interpersonal, but the most important, were both.
Now I realise that the maintainability of our code is one of our most important skills. It's often said that we write code once and maintain it ten times. Most importantly, other people maintain it. If your code isn't maintainable, then bugs happen. If your code is not maintainable, it can bring down companies.
developers who have always been senior may not learn the importance of maintainability. They never have the pleasure of being told off by more senior developers for sloppy, non-reusable code. They didn't have the privilege of being humble and being shown how to write code that others can work with. Nobody complains to them about their code because they are always more senior. So they tend to get away with it, and often end up in charge of a hard-to-maintain monolith that nobody wants to work with.
Senior developers should recognise that without exposure to different working dynamics, or other developers who have worked in different environments, they may be missing out.
Management should compliment in-house, home-grown senior developers with senior developers who have experience where they were not the most senior. Well rounded senior developers with a broad range of experience, who are not afraid to speak up when code is not written with others in mind.
If I had stayed as a "senior" developer, I may never have learnt the value of writing code for others. And I may never have realised.