Working in tech these days feels like winning the career jackpot. Sure, we see headlines about layoffs and AI threatening to make developers obsolete. But from where I sit, demand just keeps growing as companies race to invest in technology to gain an edge.
In the past twenty years, I’ve watched as tech went from something only visionaries utilized to an essential priority for almost every business. These days, companies are scrambling for solutions to collect, analyze, and make sense of their data. The market has responded with an explosion of no-code and low-code tools to help non-technical folks model processes and integrate systems on their own.
For a small team like ours focused on custom enterprise apps, this trend means one thing: more work. Clients love how technology can transform their business, but many existing tools are too complex for them to adopt. There’s a huge demand for experts like us to create tailored solutions, resulting in a constant stream of feature requests.
Of course, we push back on “nice-to-have” features to keep things focused. But sometimes expanding the team is unavoidable to meet demand. So we’re always on the lookout for standout engineers to join our crew.
Finding Tech Talent That Fits
Building a balanced development team is like assembling a sports roster — you need a mix of positions and skill levels. I don’t want to get into the tech stack or processes today. Instead, I want to focus on the experience level of engineers we look for.
At most companies, you’ll see developers grouped into:
- Interns — Straight out of school with zero real-world experience.
- Junior — Little hands-on experience. Everything’s new to them.
- Mid-level — Successfully work on their own but still get stuck occasionally.
- Senior — Seasoned pros who lead complex projects and solve hairy problems.
Why does their level matter so much in hiring? Well, think of expertise like a game controller — certain roles fit best with certain experience levels.
For example, interns are great for non-critical projects or tasks lingering on the backlog. It keeps them engaged while freeing up others.
Junior developers can take on the more tedious work no one else wants if you have someone to coach them. It helps them skill up. Imagine a new college grad starting their first software job, who were assigned ongoing maintenance of an old system no one else wanted to touch. It might be a boring work, but they might see it as a great way to learn the legacy codebase from the inside out. That hands-on experience will prove invaluable later when they will have to modify and add new features to the aging system.
Mid-level devs like designing their own solutions but can lean on senior folks when needed. They bring speed and autonomy. Think of a mid-career developer was brought onto a project to create a new customer portal. They are confident in designing the architecture, but might hit a roadblock integrating the new portal with the complex existing billing system. After banging their head on the problem for a week, they would approach a senior engineering leader for guidance. That mentor would help them see they need to decouple the billing integration into an asynchronous process so it wouldn’t hold up loading the portal. With this outside perspective, the mid-level dev will unblock themselves and complete the project.
Finally, seniors thrive on big picture challenges and complex problem-solving. They take the team to the next level. A senior systems architect who had built large-scale systems at big companies might be brought to the team. The imaginary company would need someone with advanced experience, for example it was experiencing frequent outages as the user base ballooned. Despite trying many surface-level fixes, the underlying infrastructure just wasn’t built to handle that scale. But this senior engineer would identify ways to massively augment the architecture at the lowest levels to sustain rapid growth. Of course, this would take time. But if the team would have kept applying band-aid solutions, the company likely would have crumbled under its own momentum.
Build the Team That Is Right for You
So who should you hire? It depends…
I see many teams just hiring junior folks to save money. But without senior guidance, progress really suffers. Junior hires are like planting saplings — you need patience to reap the rewards.
On the other hand, mid-level developers are a safe, solid choice. They juggle most tasks well and rarely get stuck. Still, for every few mid-level hires, you need at least one senior engineer to prevent slowdowns.
In the end, carefully consider what level of experience your projects require. Resist the urge to only hire juniors to cut costs. But don’t only bring on seniors who over-engineer everything either. The right mix of skill sets and seniority leads to the strongest teams.
Originally published on Medium.com
