Why I Always Ask About Job Tenure When Hiring Engineers

· 4 min read
Why I Always Ask About Job Tenure When Hiring Engineers

I still remember one time being called in to “rescue” during my engineering years. It was a tricky situation — a company had built a complex app that had turned into a tangled mess over the years. What started as a simple tool had morphed into a monster with tendrils reaching into every part of the company. No one fully understood how it worked anymore — it was pure spaghetti code. But it was mission-critical and needed constant babysitting to keep it running.

When the CEO hired me, he gave me six months to untangle the beast and rebuild it from scratch. I worked nights and weekends to map out all the interdependencies and business logic. It was like archeology, excavating through layers of old code and duct tape fixes, trying to comprehend the brittle reason holding it all together.

Of course, I didn’t come close to finishing in 6 months. Or 12. Eventually, I had to scrap the rewrite and keep the legacy system on life support because it would have been too disruptive to replace. I still have nightmares about sifting through legacy Ruby scripts.

The Slow Creep of Technical Debt

I’m reminded of that painful project whenever we encounter a similar situation with a long-term client. You know how it goes — you start with a simple foundation to quickly get the product to the users. A little prototyping here and a few shortcuts there. Perfectly normal.

But then the quick hacks become the core logic as requirements get patched on over time. The ball of mud grows. Before you know it, you’ve got legacy code, technical debt, tangled dependencies, the whole mess. Nothing kills developer productivity and velocity faster.
It’s like watching a child grow up. You don’t notice the changes day-to-day. But after a few years, the cute baby has become a messy, angsty teenager who only communicates with grunts and demands money.

At a certain point, someone in charge decides things have gotten bad enough that it’s time for an intervention. Time to bring in help. They hire an expert with many big ideas about how everything should be done — with cleaner code, proper standards, and all that responsible adult stuff.

The expert tries to tame the beast for a while, and it feels like the new strategy works, just like when you get your teenager to clean their room and do their homework. But then, slowly, the entropy creeps back in. The expert often time leaves after a few attempts. Because the nature of software and teenagers is to resist order and discipline over time. It takes a lot of persistence to deal with these problems because they never go away entirely.

Hiring for the Long Term

This inevitable decay is why I pay close attention to how long candidates worked at previous jobs when hiring for our team. I’ve looked at hundreds of resumes over the years. The stark pattern that jumps out is how rare it is to find an engineer who stayed with the same company for over 2 years. Job hopping every 1–2 years seems normal now.

But that constant change means they haven’t stuck around long enough to shepherd a system from infancy to maturity. To slowly nurture a project from humble beginnings to large-scale production. They likely need to learn firsthand the profound technical challenges of long-term ownership.

Don’t get me wrong — I’m not blaming anyone. It’s wise to capitalize on new opportunities. But it does make hiring for our internal tools challenging. When it comes to our code, we need engineers in it for the long haul. People who grind through the messy teenage years and come out the other side with hard-earned wisdom.

The Allure and Limits of Quick Fixes

I see this urge for quick fixes and shiny new tech in the debate around tools like GitHub Copilot and no-code platforms. They can seem so promising and easy at first, like a shortcut to faster and easier development.
Copilot is fantastic for throwing together a standalone script or simple demo app. But for a large enterprise codebase with tons of complexity and interdependencies? I’m highly skeptical that it can handle that kind of context effectively. It will likely spit out code that ignores standards and requires extensive cleanup.

No-code seems excellent for spinning up an admin dashboard or prototyping a workflow. But talk to me in 5 years after requirements have changed 50 times and the business logic has grown incredibly complex. Then we’ll see if those visual builder tools can keep up or if we need to rip it out and replace it with custom code.

Sometimes, the Old Ways are the Best

There’s no substitute for experience. Having walked the long road many times before, I have seen how early shortcuts created pain down the line. Learned what sustainable practices allow a system to age gracefully over decades rather than months.

So, while we keep up with all the latest development trends and tech, I’m wary of solutions that promise too much too fast. Building great software still requires tenacity, wisdom, and acceptance that the process will always be more challenging than it initially seems.

Sure, we could hack together something that “works” much quicker. But once real businesses depend on it, quick and dirty falls apart. They need solutions built to last. That means taking the time upfront to think through the long tail — architecting for flexibility, maintaining rigorous standards, and, most importantly, bringing on people committed for the long haul.

The quick fix may be tempting. But restoring order and stability requires patience, resilience, and a little stubbornness for entrenched legacy systems. Rather than chase shiny objects, we must cultivate timeless values that see us through the messy teenage years to reliable — if less glamorous — adulthood.

In the end, no framework or buzzword can replace experience and tenacity. Or, as I learned the hard way during that painful legacy system rewrite — resisting the urge to throw it all out and start over, no matter how messy it gets.

Sometimes, you must roll up your sleeves, grab a shovel, and maintain the aging code chugging along. Because as painful as it is, the alternative of a complete rewrite rarely turns out better in the long run.

Originally published on Medium.com