What makes a Senior Developer

Every so often, someone asks me what I need to see in a senior developer. Why people ask me this is a mystery. I mean, besides the fact that I’m a Know-It-All, could it really be that several years of being a manager have really allowed me to delve into the core of the human psyche, separate the hard skills from the soft, and know what it really means to be “that” person?

Yeah, I’m having a good laugh at this one, too! But since I am a Know-It-All, and someone asks, it’s really hard for me to say “I don’t know”. I mean, it’s not like I don’t have an opinion on it or something…

A Senior Developer is more than just a developer. They encompass several traits and abilities that make them very important to small and large projects alike. They are looked at as a skill centre, teacher, standards guru, and programmer all at the same time (often by different people). The catch is to ensure that a Senior Developer is anointed appropriately — bestowing a Senior designation without due diligence is just asking for trouble.

Hard Skill vs. Soft Skill

Okay, let’s get this elephant out of the way, first.

Any job, and I don’t care if it’s building video games or sewer maintenance, requires two key skills. The first is the “hard” skill — the one needed to actually perform the task at hand. Different jobs require different levels of hard skill, and some of them (such as, oh, brain surgery) require a lot more skill than others. The other key skill — “soft” — is what allows you to interact with others, to see yourself (with ego removed) for who and what you are, and assist you with your growth and education.

The former, for most people, is easy. The latter is the one that a lot of people fail at. You know those people: the jerks, the guys who yell at others, the people who “don’t listen”. Soft skills are hard to learn, and are almost always what hold people back.

And no, this is not a trivial point. Hard skills are needed to be able to manage the work, and soft skills are needed to manage the people. A failure on either is a failure of the whole.

Programming Omnipotence

A Senior Developer needs to have near god-like understanding of their given programming environment. This is because the Senior Developer is often the key resource for that environment, and the one people will look towards to set precedent, and ensure correct habits.

And yes, I do expect some ego along with omnipotence — it goes pretty much hand-in-hand. To some degree, I also encourage it, because that Senior Developer should know more than I do about their given language, and I want them to express that knowledge.

Understand External Dependencies

In my world, technologies rarely live in their own. Just because you can reproduce a complicated Photoshop design into HTML, CSS, and JavaScript means nothing if you can’t get the design to work with the equally-complicated database.

The trick here is that I don’t need a Senior Front-End Developer (be they masters in Flash or HTML/CSS/JavaScript) to also juggle the backend processing tasks. But you’d better expect that I need that the developer understand the process for passing requests to the backend, and how to handle the backend’s results.

Similarly, I expect the Senior Applications Developer to know what sort of information he should expect (or need), the APIs or ASPs he can use to implement the solution (without having to write the entire thing by themselves), handle database requests (without necessarily doing the database work themselves), and the best way to return a result to the front-end.

Likewise, a Senior Database Developer shouldn’t care about the presentation of data, only the best way to organise it to provide optimal normalisation and long-term data management, the correct methods to store  and recall data (via stored procedures, views, queries, and so forth), and managing the database software’s operation.

This also assumes a more granular breakdown of tasks, and having the people available to handle said tasks. Naturally, smaller places will combine roles into a single person. Mind you, they might also eschew titles for simplicity.

Solutions Design

While a Senior Developer isn’t necessarily responsible for an entire implementation, I have the expectation that a Senior Developer can adequately specify the pieces of the puzzle for which they are responsible. Furthermore, they should know how those pieces break down (for assignment to others, if needed), the time it should take to develop those pieces, and ensure that the pieces will integrate.

Fair Communication

Rarely will a Senior Developer work on their own. Almost always, they need to work with others on their team: junior developers, project managers, and creative staff. All of these people require the same amount of respect, even though the messages will differ between them.

This is often a major failing point for people who think they are Senior Developers, but have not yet been granted the title by their company. Inability to communicate properly leads not only to breakdowns in communication, but can cause personalities to clash, further muddying the waters. Technical mastery means nothing if you’re a jerk to others — it means people won’t want to work with you.

People who fail at communication often believe the problem is not with themselves, but with others: “I told them what they needed, it’s not my fault if they didn’t listen.”  The real test is convincing someone else of what you want to do. The inability to convince someone else is not a fault with the other person, but yourself.

Consistency in Deliverables

A key trait amongst Senior Developers is consistency throughout their work. Opening three or four random projects reveals the same programming style, the same general approach, the same naming conventions. A Senior Developer influences these same traits amongst those on a team, ensuring the entire team’s deliverable contains similar consistency.

This is not to preclude change. A good Senior Developer is also a researcher, always looking for better ways to handle a given problem.

Accept Responsibility

With great power comes yadda yadda yadda — you know the story. Being a Senior Developer means taking on the responsibility for part (or all) of a project. You’re the one who’s being asked to deliver something, and possibly lead others in that delivery. Ultimately, if something goes awry, it’s you who made it that way.

“It wasn’t my fault” isn’t something you get to say anymore, even if you handed that task off to a junior developer. When your project manager / lead / boss comes knocking, you’re the one who has to stand up and explain what happened. It’s your neck officially on the line, and you’re the one who’ll be held accountable. (Incidentally, that applies for everyone else above you, too.)

Side-stepping responsibility and putting someone else into the firing line is not only disrespectful, it’s a guaranteed way to strip trustworthiness. One key aspect of responsibility is someone’s trust in you to handle something. Shirking responsibility is the same as saying: “you can’t trust me”.


Finally, here’s where I’ll flip-flop a bit. Earlier up, I said I want a Senior Developer to be egotistic (to a degree) and tell me what they know. I still want that, but I also want to eat my cake, too.  I won’t expect a Senior Developer to be immediately open to other ideas, but I do expect recognition. As the Senior Developer progresses to higher roles, open-mindedness becomes a significantly more important factor.

This also helps prepare the Senior Developer for one inevitability in life: even if you have all the chops, it doesn’t necessarily mean you’ll get the meat.