Traits of a Senior Developer

Posted on 9th January 2019 - Takes 7 minutes to read


There are many traits that a senior developer should have. Here's my take on the essentials.

Soft Skills

I feel I need to mention soft skills first and foremost, as they are so frequently overlooked. They're more than just being nice.

Soft skills revolve around an individual's ability to harmoniously interact with others. They're an essential complement to the hard skills more commonly associated with being a great developer.

Senior developers should have the ability to discuss their own thoughts and genuinely take in the opinions of others. Without this, an otherwise senior developer can be at risk of becoming a lone coder, making decisions without the consult of others. This can unintentionally have a negative effect on how they are perceived and how the team works together.

Estimating

Estimation is tough, really tough. In fact, it's so tough, even the best developers will get it very wrong on occasion.

Despite this, the best developers will take into account many factors when creating estimates. Many people, quite logically, will make estimates based on how long it will take to program a feature that satisfies the client's requirements.

This makes an enormous amount of sense, in a perfect world. But we're not in a perfect world quite yet.

There are quite a few extra factors those really good developers will consider when providing an estimate. Here's just a few, that many would not consider.

  • Interaction with 3rd Party Systems - Possibly one of the biggest impacts on time when developing can interactions with third parties. If a developer is tasked to implement a new feature which requires data from an external source, it is critical to consider the extra time this may add to development. There are so many possible questions.

    • Does the API definitely provide the data we need, in the format(s) we need?
    • What experience do I/my team have with integration this type of API.
    • Are we able to and/or permitted to cache to results for performance?
    • Will the API integration depend on data or functionality that our system does not currently have?
    • Is it well documented?
    • Do the terms and conditions allow us to integrate it in the manner the client requested?
    • If there are problems, is the API supplier ability to support our developer?
    • How many hours/days will they take to respond?
  • My experience versus team experience - Developers can sometimes take into account only their own skills and experience when producing estimates. In some software development environments, senior developers may be called upon to provide a time estimate for features they might not necessarily be implementing themselves. A good developer would ideally confirm this, and appropriately adjust their estimates based on their knowledge of their team's skillset and experience.

  • Client requirements flexibility - Every client is different, but very few people know exactly what they want until they see it. For this reason, it is important for developers to base their estimates not just around the strictest implementation of the feature. They should take into account that the requirements may change. They could be either during its development or as future additional features that stand on its shoulders. Flexibility to meet client requirements is key here, and one of the tenants of a good agile development methodology.

Adaptability

The skill set of a developer is one of the main aspects that is considered during the hiring process. However, in practice, assuming sufficient experience, a specific set of skills is not critical. The ability to adapt and learn new skills is much more important.

More experienced and senior developers will have a sufficient breadth of knowledge to be able to apply themselves quickly to new challenges. This involves taking on languages and technologies they may never have encountered before. The best developers can quickly align and utilise their past experiences to aid in the accomplishment of new tasks.

Debugging and Troubleshooting Skills

When something goes wrong, as it will do, the ability to determine the quickest path to solve a problem well is a skill that should not be undervalued. In the course of normal somewhere development, good debugging and troubleshooting skills are incredibly useful. However, these skills really come into their own when virtual 'fire fighting' is needed.

If a production system goes down, an unexpected problem occurs immediately before a client meeting, or a large system is not scaling fast enough, a great developer can quickly enumerate and evaluate options. Upon finding the best option, a solution can quickly be implemented in a way that 'saves the day' and benefits the company as a whole.

Teaching

A defining trait of a good senior developer is their ability to teach and mentor others. This a tough skills to get right. In a way, this is another soft skill, but certainly deserves a section of its own.

Key is the skill of teaching, without accidentally patronising or insulting the intelligence of those being trained. Developers aiming for seniority in this area should ensure they do not consider anything to be obvious and to adapt their teaching style to the skill set and approach to learning of their mentoree.

Communicating Complex Ideas

If you can't explain it simply, you don't understand it well enough. - Albert Einstein

The ability to take a complex idea and explain it in simple terms is really important when disseminating information. This is essential when teaching colleagues new ideas. However, it really becomes a useful skill during client communication. Technical jargon that developers often take for granted, can be difficult for those outside of the field to completely comprehend.

Evading the Shiny New Thing

At its core, shiny object syndrome (SOS) is a disease of distraction, and it affects entrepreneurs specifically because of the qualities that make them unique. Entrepreneurs tend to be highly motivated. They crave new technology and new developments. And they aren’t afraid to start new projects and create new things. - Entrepeneur Europe

Shiny object syndrome is usually associated with entrepreneurs, but as any passionate developers with a bit of free time knows, it can certainly affect them too. In almost all development stacks, new technologies, methodologies, and packages become available all the time. When working with commercial and enterprise software, seasoned developers are able to make sensible choices about which new technologies to adopt.

New possibilities should ideally be trialed in a manner that is of least risk to commercial projects. Once evaluated, they can be introduced safely into future projects, mitigating the delays often associated with attempting to prematurely adopt a new technology.

Admitting what they do not know

No one knows everything, nor should anyone claim to.

Good developers should not boast about technologies that have no idea about, nor promote those that they have little experience with. If questions about a topic they're unfamiliar with, they should say so, and not attempt to over-confidently claim to know everything about the subject.

Overconfidence and deception about skill set can easily lead to commercial problems later down the line.

Admitting their mistakes

To err is human, to forgive divine. - Alexender Pope

All developers have written buggy code, deleted a database they shouldn't have or pushed to the wrong branch. It can't be avoided - we're all human.

What can be avoided, however, is hiding the mistake, or pushing blame. The best developers won't make mistakes often, but when they do, they should admit to them and take responsibility.


skills development soft skills teaching debugging communication agile shiny object syndrome