Why Programmers Shouldn’t Stay in One Company for a Long Time

 I was just speaking with one of my programmers, who had only been with my organization for two months. He started as a junior programmer and never stayed in one firm for longer than a year and a half.

He isn't on his own. Unless they are shareholders in the company, the majority of competent programmers I've seen leave after 1–3 years.

Developers do this for a variety of reasons, and it's perfectly normal. We'll speak about why developers do it later, but first, let's look at some facts regarding how common it is now.

Statistics

It wasn't long ago that an employee worked for the same employer their entire life. However, things have changed since then. Now is a better time to look for a new employment.

In some industries, the situation is still the same. However, in the realm of technology, it's nearly difficult to believe that programmers/developers will work for more than 10–15 years.

There are some instances where a programmer has worked for ten or more years. However, if you question a programmer who has been in the field for less than five years, the majority of them will state they do not want to stay in a job for a long period.

I created a graph using Hackerlife that shows data collected from over ten thousand software engineers in San Francisco. The graph depicts the average tenure of a programmer at some of the world's largest software companies.

Large corporations are the focus of the above visualization. Almost half of these huge firms' programmers leave after two years, and 75 percent leave after three to three and a half years.

The average tenure of other industry professionals is 4.2 years, therefore this is a rather short period of time. And the tech behemoths are actually better at retaining programmers. In startups and medium-sized tech enterprises, the situation is significantly worse.

My personal encounters with programmers

As a recruiter, I've met a lot of programmers during interviews. I always inquire about their previous employment: where they worked, for how long, and why they left.

I don't have specific figures because I didn't keep track, but I noticed that around 70%–80% of candidates departed their employment within two years.

I rarely came across candidates who had worked for a company for more than five years. Out of 200+ candidates, maybe 2–3 will be chosen. Because we are a new company, I have seen less things. Developers who have worked for a large corporation for a long time are unlikely to join a startup.

Why Shouldn't Programmers Stay for a Long Time?

Possibility to learn

This is the most important reason why a programmer should change jobs after a certain amount of time has passed. In the early stages of their professions, programmers must learn a great deal.

In the first year, both the new programmer and the company learn a lot from each other. The organization gains knowledge from its previous experiences, while the programmer gains knowledge from their tech stack, projects, and senior devs.

A programmer produces stuff and becomes an important employee after one year at a corporation. However, programmers aren't always of the same mind.

So, after a year, the programmers have learned nothing useful from the company. Of course, if the company is a tech behemoth, there will be. Small and medium-sized businesses, on the other hand, have a more limited learning opportunity.

That is most likely one of the reasons why programmers leave small businesses at a faster rate. In small businesses, software engineers have an average tenure of 1.5 years, compared to 2.3 years in large businesses.

The question is, at what point does learning come to an end? It never does, to be honest. That doesn't imply you'll have to change employment every few years for the rest of your career.

You can get promoted to a position where you don't have to move jobs as much after about ten years (more or less). But that's a topic for another time.

A More Successful Career

Stacks of technology are evolving at a breakneck pace. For programmers, this is why learning is a never-ending process. It's one of the many reasons why programming is one of the world's most unusual vocations.

Programmers should switch professions not simply to gain new skills, but also to advance their careers. Working at the same employer for a long time slows down career advancement.

Normally, a corporation does not advance at the same rate as programmers improve their skills. The corporation is unable to meet the developers' needs in this case.

If you believe you deserve a better job, you should leave even if you are loyal and dedicated, and even if you discover many learning chances.

Last but not least

So, when is it OK to leave a job? To be honest, there is no correct response. You'll have to figure it out on your own. I simply expressed my viewpoint and provided some data.

I've also seen some of my programmer pals. Those who have switched employment are in a better position than those who have worked for the same firm for a long time. It will also assist you in becoming more self-assured.

You won't be in too much difficulty if your current company experiences a crisis or if you are fired unexpectedly. And if you are unhappy or are not being treated well, you should leave as quickly as possible.