Developer Seniority

It can be hard to determine what developer seniority levels are, and how to get from one level to the next. I will try to outline each roughly, describe the goals needed to move to the next level, and provide resources on doing that.

It’s important to note that there are several sets of skills that all are all combined and summarized whenever someone is talking about seniority:

hard skills (e.g. ability to program using Ruby, knowledge of Postgres)
soft-hard skills (e.g. broadly applicable programming knowledge that can be used in any language)
soft skills (e.g. communication, presentation)
professional skills (e.g. booking meetings, collaborating with colleagues)
management skills (e.g. leading others [team lead], managing others [manager])

The importance of these skills actually morphs over time: hard skills are most important for an initial position, while later areas become increasingly important as you progress in your career.

Everyone’s style and skills are different and everyone has strengths and weaknesses. That’s okay, but it does make it really hard to compare different people’s seniority levels, and thus to define what any seniority level really means.

That said, there is a way to describe what these levels are really getting at, it’s just very imprecise: your seniority is the net value that you deliver to your employer. (Your salary should be a measure of this too, though it often isn’t – Patrick Mckenzie has lots about that.) So, at a high level, your goals are generally quite aligned with your employer: provide as much value as you can.

To summarize seniority levels in these terms:

pre-Junior: cannot provide any value in a developer role
Junior: provides value with close supervision and frequent assistance
Intermediate: provides value with infrequent guidance
Senior: provides value with no assistance, sometimes collaborating with other teams or functions
Staff: provides outside-the-box value by collaborating throughout the company

Below you’ll find descriptions on what sorts of things that usually means you should focus on as you progress in your career.

Bootcamp: Getting to Junior

Goal: Learn the hard skills that match the roles you want.

Skills:

Hard	Experience using the languages & tools for your target role.
Hard-Soft	Being self directed and learning independently. Understanding well-defined requirements and building to match.
Soft	Basic communication skills: communicating progress, asking for help, participating in meetings. Receiving feedback in code reviews
Professional	How to behave and feel comfortable in an office or remote environment.

Before you have learned how to do the tasks, you obviously don’t have the basic hard skills of being a developer, which means you obviously can’t even begin providing value in a development role. Regardless of what you do here, you are going to need training at your first job. Employers know this (and those that don’t are to be avoided, since you won’t be set up for success), so if they’re hiring for a junior position they are going to rank candidates based on how much hands-on training other employees are going to have to provide that hire. More time others spend with
you = less time they spend on other work = negative value. (It’s not true that this is actually negative value, but that’s a discussion for later in your career.) And more time you spend waiting for and receiving training = less time you are spending on work = less output = less value.

So how do you minimize the amount of training that you’ll need? You train yourself as much as possible, both before and during. You try to already have experience with all the hard skills that you’ll be using in the roles you’re applying to, and you figure out how to learn things yourself. Then, while applying and interviewing you aim to communicate how quickly you’ll get up to speed and produce value.

Unfortunately, this means that no one can provide you with specific resources on how to do these things. The best you can do is follow some of the meta skills.

https://www.joshwcomeau.com/blog/how-to-learn-stuff-quickly/

https://tellspin.app/blog/show-effort-before-asking-questions/

Junior to Intermediate

Goal: Learn how this stuff works in practice.

Skills:

Hard	Deepen your knowledge of the languages and tools, learning how to make the most of it. Independent debugging of simple issues.
Hard-Soft	Learn new tools and technologies on your own. Timeboxing work. Making decisions of when to write clean, tested code and when it’s not worth the time.
Soft	Communicating in a developer team, giving feedback in code reviews.
Professional	Understanding your role in the company. Collaboratiing with others on the same task.

It can be hard to find junioer developer roles because they provide a very small amount of value. Relative to costs, intermediate developers are generally far more cost effective. It’s especially important that you work hard to get the initial experience to move beyond this level.

Applying this stuff will take real-life experience, and so expect this to be a 1-2 year journey minimum.

https://tellspin.app/blog/show-effort-before-asking-questions/

https://www.joshwcomeau.com/blog/how-to-learn-stuff-quickly/

https://addyosmani.com/blog/software-engineering-soft-parts/

https://imwrightshardcode.com/2019/05/when-to-ask-for-help/

https://mixmastamyk.bitbucket.io/pro_soft_dev/index.html

https://www.techrepublic.com/blog/software-engineer/10-tips-to-go-from-a-beginner-to-an-intermediate-developer/#

https://medium.freecodecamp.org/things-i-wish-someone-had-told-me-when-i-was-learning-how-to-code-565fc9dcb329

https://web.archive.org/web/20180422145532/http://jangosteve.com:80/post/380926251/no-one-knows-what-theyre-doing

https://www.haiku-os.org/docs/HIG/index.xml

https://thoughtbot.com/upcase “We’re not a bootcamp, we’re a finishing school”

https://missing.csail.mit.edu/ “The Missing Semester of Your CS Education”

SaaS: https://stripe.com/atlas/guides/business-of-saas

https://www.pluralsight.com

https://developers.redhat.com/blog/2019/07/08/10-tips-for-reviewing-code-you-dont-like/

https://jvns.ca/blog/2022/12/08/a-debugging-manifesto/

Broaden Your Knowledge

This isn’t your primary goal, but it helps.

Roadmap to flesh out your hard skills

https://medium.com/zerotomastery/dont-be-a-junior-developer-the-roadmap-9fde5cf384bb

Intermediate to Senior

If you haven’t already finished going through the developer roadmap, now’s a good time.

Around this time, you may start to find yourself pulled in a particular area of interest. Do you thrive when focused on hard technical problems? Do you prefer to think about the user and business problems? Do you prefer to work with and mentor others? Are you more interested in the structure of the code? Do you get fired up by thinking about making the tools you work with better?

If you’re pulled toward user/business problems, you may identify as a Product-Minded Engineer. If this is something that interests you, there’s some additional discussion on HN that might provide further insight.

https://thoughtbot.com/upcase/analytics-for-developers

https://thoughtbot.com/upcase/design-for-developers

https://medium.com/zerotomastery/developers-edge-how-to-become-a-senior-developer-f1ec1738cf45

Book – The Effective Engineer

https://medium.com/@kentbeck_7670/software-design-is-human-relationships-part-1-of-3-perspective-1bcd53855557 (and following 3 docs)

https://neilkakkar.com/things-I-learnt-from-a-senior-dev.html

https://martinfowler.com/architecture/

https://news.ycombinator.com/item?id=20914236 https://littleblah.com/post/2019-09-01-senior-engineer-checklist/

https://blog.pragmaticengineer.com/the-product-minded-engineer/

https://google.github.io/eng-practices/review/reviewer/ & https://news.ycombinator.com/item?id=20890682

https://www.kitchensoap.com/2012/10/25/on-being-a-senior-engineer/