Friday morning, one of my colleagues asked, “What do you consider to be the difference between a junior, mid-level, and senior developer?”

Being a .NET shop, the obvious answer would be to head over to Scott Hanselman’s blog and pull up this post: What Great .NET Developers Ought To Know (More .NET Interview Questions). Scott has broken out what he considered, at the time, to be the relevant platform- and framework-related knowledge required of a .NET developer at various points in their career.

However, I do not believe that knowledge of a programming language and hosting platform solely defines a great developer, no matter the depth or detail of the knowledge. If a developer is unable to apply that knowledge to a problem domain, it is useless knowledge – a mere parlor trick.

Given a developer has an affinity towards coding and technology, that developer should be able to learn new programming languages, new platforms, and new tools. If a senior developer in a ASP.NET shop moves to a Ruby shop, what would define him or her as a Senior level? Language syntax and idiomatics should only be a small part of the equation.

---

A Different Perspective

I believe developer levels are determined by a combination of autonomy, mastery, and trust. I have a started a list below. This list is not scientific - it just represents my current viewpoint.

Junior Developers

Autonomy: LOW

• Not self-directed
• Need tasks rather than requirements/user stories
• Tasks are expected to be implemented as defined
• Often under the watchful eye of a senior developer
• May need assistance in finding/deriving appropriate solutions

Mastery: LOW->MEDIUM

• Comfortable with the constructs of their main language/platform
• Basic understanding of object-oriented programming
• May have understanding of architectural design patterns and principles (MVC, Single Responsibility Principle)
• Limited comprehension of problem domain
• Can write basic tests/specifications

Trust: LOW

---

Mid-Level Developers

Autonomy: MEDIUM

• Self-directed
• Can work from user stories
• Can normally find/derive appropriate solutions

Mastery: MEDIUM

• Comfortable with the constructs of their main language and platform
• Basic understanding of constructs of additional languages or platforms
• Moderate understanding of object-oriented programming
• Basic understanding of functional programming
• Basic understanding of messaging architectures
• Understands several design patterns and principles
• Can write both state and interaction tests/specifications
• Comprehends problem domain
• Committed to continuous learning

Trust: MEDIUM

• Can represent the needs of the development team
• Is respected in the community

---

Senior Developers

Autonomy: HIGH

• Self-directed
• Can develop user stories
• Can elucidate requirements
• Can generally find, derive, or create appropriate solutions

Mastery: MEDIUM->HIGH

• Comfortable with two or more languages/platforms
• Moderate to high understanding of object-oriented and functional programming
• Moderate to high understanding of messaging
• Can explain design patterns and principles to developers, as well as non-technical staff
• Comprehends problem domain and common domain patterns
• Can write state, interaction, integration tests/specifications
• Committed to continuous learning

Trust: HIGH

• Can represent the needs of the development team
• Can represent the needs of the customer
• Can represent the needs of management
• Is respected in the community

---

Please note that I do have emphasis on language in each level, but language is dwarfed by the need to understand and communicate the problem domain. Also, mastery of a particular platform is less important than autonomy or trust.

What do you think defines a junior, mid, or senior developer?