The Difference Between Jr, Mid-Level and Senior Software Developers
About a month or so back, a (self proclaimed) Junior Developer asked me, “In your opinion, what is the difference between a Junior Developer and a Senior Developer?” That was an interesting question and definitely something that deserves some thought. Why? Because I don’t think it has much to do with the amount of time spent being a Software Developer. I do, however, think it has a lot to do with how how the Developer perceives their work, how they interact with their peers and how they approach problems.
The Junior Developer
Junior Developers are inexperienced. In some cases, they recently graduated from college and are working full-time as a Software Developer for the first time. However, in all cases, they require time from other team members. That’s because Junior Developers generally cannot complete complex work on their own.
Junior Developers approach software development with a goal of “making it work.” To them, working software and good software are equivalent. As a consequence, they perceive growth in their craft as learning the syntax of one or more particular languages, learning some technical approach(es), or maybe even learning why some particular technical minutia works.
The Mid-Level Developer
Mid-Level Developers can generally operate on their own to solve targeted technical problems. They may even be considered very technically strong in one or more areas. In some organizations, I have even seen Mid-Level Developers who were referred to as Senior Developers. Heck, when I was a Mid-Level Developer, I was considered by many (including myself) to be a Senior Developer.
But Mid-Level Developers are not Senior Developers. They may have mastered their craft from the perspective of a Junior Developer or even from the perspective of other Mid-Level Developers, but there is a massive gulf between Mid-Level Developers and Senior Developers. Why? Because it requires a change in perspective.
A Mid-Level developer may know how to technically solve complex problems. But they may also be the person who wants to take 3 weeks to squeeze out a sliver of performance at an incredible cost in complexity. Like the Junior Developer, the Mid-Level developer views working software and good software as equivalent. And Mid-Level Developers are generally pretty good at making working software.
The Senior Developer
The leap from Mid-Level Developer to Senior Developer begins with a realization that there is still much to learn. And it ends with understanding that good software is software that both does what it’s supposed to do and can scale for development. Senior Developers don’t think in terms of individual classes, methods, functions or low-level technical particulars. They think in terms of object oriented and application design patterns.
Senior Developers don’t solve problems by throwing code at them. And they don’t solve problems alone. They are an effective member of a team who approaches problems at the application level instead of at the bits and bytes level.
Senior Developers speak the same language as Junior and Mid-Level Developers, but they approach problems from a different direction. To Senior Developers, there is a difference between good software and working software. And that difference is how it’s put together, how it’s used, and how it will be reused.
This story was reposted to https://medium.com/blu-flame-technologies/the-difference-between-jr-mid-level-and-senior-software-developers-e8bf69ea5e3a with the author’s permission.
Thank you for reading. If you liked this post, please check out the Blu Flame Technologies Blog.
