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.

  • Know (and often off the top of their heads) a dozen different ways to implement (and know which one is the best approach)
  • Know the language’s methods, syntax, structure, parameterization, memory leaks, and looping methodologies without the need to regularly consult the documentation
  • Know the best practices for development with authority
  • Know when a framework is required, a nice-to-have, and when to avoid

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.

  • Junior developers need a mentor: a resource and a teacher. Someone who will help more junior staff see mistakes and learn from them, who will help people with difficult problems, all the while not talking down to a weaker skill.
  • Project managers require concise communication that does not involve a blizzard of jargon. Project managers rely on numbers: estimates, dates, times, milestones.
  • Creative staff think in pictures and possibilities, whereas technical minds live for logic and limitation. They can live together very easily, so long as people keep an open mind and give each idea the respect that is due.

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.

Join the Conversation


  1. you hit the nail on the head. I will definitely use some of your truisms so I don’t have to hit people on the head.

  2. Kind of like how the Japanese will write their wish on a strip of paper and tie it to a special tree, I’m leaving this comment in hopes that I’ll someday make it to Senior. And that’s not lazy wistfulness in my comment, I hope people can see the fierce determination in my actions, but I also know that like a waterfall pummelling its rocky base, sometimes things take time.
    Thanks for the insightful post!

  3. Well said Geoff. Glad to know I can still learn from you even though we don’t work together anymore.
    Doug, sometimes you do just have to hit people on the head.

  4. Thanks, Jason!
    I’d like to think that I can still offer advice to friends, and hope that I can make some amends for things I didn’t get a chance to finish.

  5. ….and sometimes you don’t need to hit them on the head – just kick them in the ….. 🙂
    I’m not a senior developer, never will be. But I have worked with and managed a bunch of them over the years. The best ones (from my perspective) take great pride in their work, but park their ego, or perhaps it’s better described as attitude at the door. The worst – well I’m sure many of us have seen one or two of those. Like one of the development team leads on a big project I worked on in Ottawa many years ago who claimed that he wrote bug free code. Talk about waving a red flag in front of someone who was at the time an intermediate QA person (I seem to recall not being terribly polite either). Needless to say, he wasn’t a happy camper a few weeks later when his code was integrated and sent to testing for the first time.

  6. Hello Geof.
    First of all let me tell you this is a great post. I enjoyed it a lot.
    I work as Tech Director at Schematic in our Costa Rica office!! Yeah Costa Rica. Just found out you lived here last year. Too bad I didn’t knew your blog then. I would’ve loved to meet you in person.
    I shared your post with my team.
    I’ll read more of your posts. Nice blog

  7. Hi Rene,
    That’s a shame we never got to get together at all! Especially since (I think) Schematic is just around the block from The Hangar? If you get a chance hit up Jason (he’s “Hale” further up) — he took over from me, and a great guy to get to know!

  8. Lyn,
    Excellent points, and you’re right — the best ones are the ones who can park the ego. I’ve been very fortunate to work with several of those.
    As for the ones who claim to write bug-free code, they’re just BEGGING for a butt-whumping.

  9. LOL – Oh they got the butt-whumping alright! It’s such a painful blow to the ego when folks get caught up like that. Everyone makes mistakes and the wise are the ones that ‘fess up, learn and move on (rather than getting into the “repeat” cycle that should be reserved for a shampoo commercial).

  10. Great post Geoff,
    Another great skill I’ve seen in Senior Developers is the ability to evangelize and promote their team’s skills both to clients and internally.
    If you can showcase a team on a project – no matter what size, it shows a great deal about the Senior Developer’s leadership, pride, passion and confidence NOT ONLY in his/her work but in the team they manage.
    If you can’t help others up the ladder you don’t deserve to be on the rung you’re at.

    1. Ooh! Outstanding point, Jeremy! Yes, evangelism is a great part of being a Senior Developer. The only caveat I’ll throw in is that I’d rather see the Senior evangelising technologies and solutions, moreso than people.
      “Why not people?” you ask.
      It’s that soft skill thing. It’s trick. I’ve found that it’s hard for Seniors to do a consistent job of people, mostly because they’re typically just above the ones they’re managing. It’ easier for Development Managers to evangelise, mostly because they’re less focused on the technology. But that’s just my <extreme-sarcasm>oh-so-humble</extreme-sarcasm> opinion.

    1. Oh, hey, that’s a good one, too! I do agree very well with many of the comments as cautionary points. And I still stick to my guns on the soft-skills part — if you can work well with others, I don’t care how well you can program.

Leave a comment

Your email address will not be published. Required fields are marked *