When I got my first programming job, I was in awe of the technical savants who knew coding languages inside and out. I believed that was something to strive for, and that it ultimately was what made a great software developer.
Twenty years later, I’ve worked with a lot of good developers, a few great ones, and a handful of downright awful ones. One of the key things I’ve learned is that technical acumen does not necessarily translate into a great developer. It may not even equate to a good one. It is just one piece of the overall whole that tends to get overvalued when interviewing job candidates.
[ Get exercises and approaches that make disparate teams stronger. Read the digital transformation ebook: Transformation Takes Practice. ]
So what should you be looking for? I’ve found seven traits that stand out when you’re trying to identify truly great IT talent.
Key developer skills, with related interview questions
I’ve known some very sharp technologists who fall flat on their face when it comes to problem-solving. To be an effective problem-solver, you need to pair the right solution to the problem at hand.
I worked with one developer who was so hung up on best practices that he was incapable of meeting a deadline. Best practices are what we all strive for, but they are guidelines – not something to be a slave to. You must have the flexibility to balance the business timeline with the technology requirements to come to a workable solution.
Great developers realize that the technology is there to support the business. They develop elegant solutions that can grow with the business and make people’s lives easier.
“You and two other developers have been given two hours to come up with a solution to automate a manual process. Files are coming into Box, which are manually fed into a Windows Forms application that populates records into a database through the click of a button. You have the source code of the app. How do you approach automating this process from end-to-end in the tight timeframe allotted?”
[ Want DevOps best practices? Watch the on-demand webinar: Lessons from The Phoenix project you can use today. ]
2. Ability to ask the right questions, and listen
Many times, the product owner has only a loose idea of what they want in a system or feature. That is a start, but that mess of ideas needs help getting pulled together into usable requirements. It is critical to not only listen to what they say but also anticipate what they haven’t thought of yet. That can mean the difference between delivering a successful project and being forced to rearchitect it halfway through.
By thinking through the request critically, you can ask targeted questions to tie up any loose ends. This can save countless hours of writing code that targets the wrong thing.
“Tell me about a time you developed a feature for a user and, once delivered, it wasn’t what they wanted. Where was the disconnect, and what did you learn from this experience?”
3. Willingness to jump into the fire
Despite our best efforts and careful preparation, things will go wrong. Systems will fail. How many times have you heard:
- “That’s not my program.”
- “It’s an issue with the server. The network admin needs to fix that.”
- “I can’t help that the database server can’t handle the load.”
When a bug is bringing the business to its knees, great developers don’t trot out a parade of excuses as to why they can’t help. They lead the charge in finding a solution. Often, their feet are to the fire and they are furiously scrambling to bring the system back online. Other times, they aren’t directly solving the issue; instead, they are helping to spur ideas or provide valuable support that leads to the resolution. Great developers find ways of being indispensable when it matters most.
“You get a call from your project manager at 6 a.m. saying your web application is having intermittent access problems by the user community. At first glance, it sounds like an issue with one of the VMs on the load balancer managed by the network team. How do you proceed?”
[ Can you explain why orchestration tools matter to enterprise IT? Get the PDF: How to explain orchestration in plain English. ]
4. Be a great team member
A great maxim to live by is if a team member fails, we all fail. The great thing about being part of a team is everyone brings a unique set of talents and experiences to the table. One developer may struggle mightily with one feature that another developer might breeze through. When teams effectively collaborate, we reduce these individual struggles.
Great developers actively reach out to their team when they hit roadblocks or want feedback on a proposed solution. By abandoning the tunnel vision and keeping an open mind, we can lean on our fellow developers to come up with better solutions.
Seek out candidates who thrive in a team environment. It can be hard to integrate lone wolves.
“Describe a time a team member was struggling and you proactively reached out to help.”