Career paths for ageing Software Developers

Jason Gorman wrote a great blog post that was inspired by Kent Beck’s post about ageism in software development. I would like to expand on their thoughts and add my own perspective.

When software developers reach a certain age, usually somewhere between 40 and 50, their career path commonly take one of two directions. Either they get “promoted” to become managers or they stay as developers but lose their drive to develop their skills further and keep up with new technologies, practices and tools. A third career path, which I rarely see, would be to continue writing code, but keep growing in the developer role, gain more experience and skills and be more valuable to their employers.

Why is this happening? What can we do to change this? Is it entirely up to the individuals or is there something that people in management roles can do something about? Let me first explain why the two common paths are problematic.

Some developers have successfully changed their career into becoming managers. One common misunderstanding is that this is a promotion. It’s not. It’s a completely different job. It’s an important job, and we definitely need great managers. I also think that it’s hard to manage software developers if you don’t have a developer background. So making managers out of developers is a good thing. Except it’s not for everyone. As I said, it’s a completely different job. One thing that most developers like about their job is that they get to focus for longer periods on a single problem. As a manager you can rarely do that. Quite opposite, you have to deal with many problems in parallel and your job is to be available for constant interruptions. Most developers got into programming because they love writing code. If you want to be a successful manager, their is little or no time to write code. Those are the main reasons why many developers that turn into managers are quite unhappy in their role. The industry loses great programmers, but get mediocre managers in return. So how do we do to get great managers in software? Let me get back to that in another blog post…

Many developers are scared from taking the management route, mainly for good reasons. They like programming and they think that if they go into management, there is no turning back. At that point they have written their last line of code (at least professionally). So what other career options are available for them?

It turns out that in many cases there are none. In many companies, especially large enterprises, a possible route is to become an Enterprise Architect. That usually means that you don’t write code anymore, but instead create lots of high-level diagrams and spend most of the days in meetings discussing those diagrams. The developers usually ignore you and your diagrams because they are too abstract to be useful for them.

So, many developers stay in their role. The problem now is that there are almost no incentives for them to grow, become better at their job and take on more responsibilities. Keeping up with the latest and greatest in software is hard work and it requires dedication. If there is little reward in putting in the extra effort, many people just give up. Instead they focus on job security, trying to keep being valuable to their employer not by bringing up great new ideas but by being the guy (it is usually a guy) that knows everything about the old business critical systems. This usually means they actively or passively fight against any new ideas brought up by younger colleagues. They have become the Grumpy Old Programmer.

How can we motivate those developers to continue learning new skills and techniques? What motivates people are usually, to varying degrees:

  • Interesting work
  • Doing important work that have an impact on the business
  • Being respected by colleagues (peers and managers)
  • Prestige (fancy titles, awards)
  • Money

From what I’ve seen, big corporations in the US like Microsoft and Amazon, tries to solve this problem by introducing career levels with associated titles. I haven’t seen that here in Sweden (yet), but I’m a bit skeptical that it is the right solution. One problem is that people tend to focus on the titles and optimize for climbing that ladder. That means they only do what is required to reach the next level, not what is most beneficial for their personal development or for the company’s business.

Many developers claim that they are not motivated by money. I don’t really believe that. It might not be their primary driver, but the salary is a measure of how much your employer value their employees. Also, your family couldn’t care less about your fancy title. It’s what is on the bottom line on your income statement that pays for the cottage, yacht or the family trip to Bali.

In Sweden, the salary is not commonly used as an incentive to get developers to be better at their job or to take on more responsibility. Your entry salary when you are hired is determined mostly by what you earn in your current position. Once hired, you rarely get a big raise. The only ways to get a significant raise is to switch employer or to become a manager. Maybe this is different in other countries, but at least in Sweden this is a missed opportunity.

A possible solution

In my mind, here is what employers should do:

  • Make clear that if a developer is working on improving skills and abilities, he or she will get more responsibility and/or status as an expert. In addition he or she will get a significant raise.
  • Define new titles as appropriate, but connect them to roles with clear responsibilities. An example would be Lead Developer. In that role you are expected to drive improvements in technology, practices and tools but also to mentor younger, less experienced coworkers. Another example would be an expert role, where you are expected to have deep knowledge in a specific field, e.g. cloud computing or continuous delivery.

In essence, there should be a clear technical career path as an alternative to management. So instead of becoming a miserable manager or a grumpy old developer, you can continue coding, do even more interesting and valuable work. And you can buy that cottage up in the mountains without having to move to the next employer.