What's the difference between Entry Level/Jr/Sr developers?

  • Other than title and pay, what is the difference?

    • What different responsibilities do they have.

    • How knowledgeable/experienced are they?

    • What is the basic measure to determine where a developer fits into this basic structure?

  • HLGEM

    HLGEM Correct answer

    10 years ago

    This will vary but this is how I see it at a place large enough to have distinctions between types of programmers.

    I would say entry level and Junior are the same thing. They are just out of school and have less than two years of work experience. They are assigned the least complex tasks and should be supervised fairly closely. Generally they know about 10% of what they think they know. Usually they have not been through the whole development cycle and so often make some very naive choices if given the opportunity to choose. Sadly many of them don't actually care what the requirement is, they want to build things their way. They often have poor debugging skills.

    Intermediate level is where many programmers fall. They have more than two years experience and generally less than ten, although some can stay at this level their whole careers. They can produce working code with less supervision as long as they are assigned to relatively routine tasks. They are not generally tasked with high level design or highly complicated tasks that require an in-depth level of knowledge. They may be tasked with the design of a piece of the application though, especially as they are in the zone to become a senior developer. They are good at maintenance tasks or tasks where they can focus on just their piece of the puzzle, but are not usually expected to consider the application as a whole unless working with senior developers or being prepped for promotion to senior. They can usually do a decent job of troubleshooting and debugging, but they have to really slog through to get the hard ones. They do not yet have enough experience to see the patterns in the problems that point them to the probable place they are occurring. But they are gaining those skills and rarely need to ask for debugging help. They have probably been through the whole development cycle at least once and seen the results of design problems and are learning how to avoid them in the future. Usually they tend to be more likely to take a requirement at face value and not push it back when it has obvious problems or gaps. They have learned enough to know what they don't know and are starting to gain that knowledge. They are the workhorses of the programming world, they deliver probably 80-90% of the routine code and maybe 10% of the very difficult stuff.

    No one who is senior level even needs to ask this question. They are experts in their chosen technology stacks. They are given the hard tasks (the ones nobody knows how to solve) and often get design responsibilties. They often work independently because they have a proven track record of delivering the goods. They are expected to mentor Junior and intermediate developers. Often they are amazing troubleshooters. They have run into those same problems before and have a very good idea of where to look first. Seniors often mentor outside the workplace as well. They generally have at least ten years of experience and have almost always been on at least one death march and know exactly why some things are to be avoided. They know how to deliver a working product and meet a deadline. They know what corners can be cut and what corners should never be cut. They know at least one and often several languages at the expert level. They have seen a lot of "hot new technologies" hit the workplace and disappear, so they tend to be a bit more conservative about jumping on the bandwagon for the next exciting new development tool (but not completely resistant to change - those would be the older Intermediate developers who never make the leap to Senior). They understand their job is to deliver working software that does what the users want, not to play with fun tools. They are often pickier about where they will work because they can be and because they have seen first hand how bad some places can be. They seek out the places that have the most interesting tasks to do. Often they know more about their company's products than anyone else even if they have been there only a few months. They know they need more than programming knowledge and are good at getting knowledge about the business domain they support as well. They are often aware of issues that juniors never consider and intermediates often don't think about such as regulatory and legal issues in the business domain they support. They can and will push back a requirement because they know what the problems with it will be and can explain the same to the laymen.

    is there a Title (in English) to the "Intermediate level" Google translator uses "Full developer". But it's not a valuable source =)

    Excellent, story-like explanation. I enjoyed reading it.

    @MichelAyres middleweight

    You are just bashing junior developer in your first paragraph. Not everyone is that bad (atleast that's what I think, with my very limited experience in workplace)

    You mention that Seniors ofter mentor junior developers outside of the workplace. Would you have any examples?

    Thanks for this explanation. I am self-taught in iOS dev (no comp-sci education) and have released my first app which has some non-trivial features (i.e CRUD's JSON, some social components, good design). I don't think I am a great programmer but I did write the app back to front and understand what it takes to ship. Where would you place someone like me, hypothetically?

    Likely at the advanced beginner, intermediate level, @SamYoungNY depending on the actual quality and functionality of the app. Shipping is only half of what you need. I have seen too many people ship bad products because they don't have to deal with it after the shipping process. (As a data person, I often end up fixing other people's messes.) With an app of course you might have to deal with it if you own the app, but if a company owns it and others do the maintenance then you're experience is less than complete.

    @NYCTechEngineer, well stack overflow comes to mind. Also local user groups, blogging, writing articles and books.

    I feel like "junior" has become the new "intermediate" and "entry" is still as you describe, but perhaps smarter than you give them credit for.

    @feelinferrety, I didn't say they weren't smart, just that they don't have the experience they need to be fully effective and that most entry level people tend to over estimate their current skill level because they have never seen what advanced really is.

    I have rarely job posts for intermediate level developers. I only see junior or senior. While I think most fall into the category of intermediate developers. I think in job descriptions or even at work, the lack of any prefix ie junior or senior means the person is intermediate. Does that make sense to you?

    @SamYoungNY I would like to put programmers like you on the Super Star level. In the world of micro-services your skills are precious. Don't learn more, otherwise your delivery time and overthinking makes things worser. But don't take my comment seriously. Most client-facing products need to be supported, improved, evolved instead of rewritten. And the skill set is about how to write programs which can be incrementally changed without rewrites and big time efforts. If a client-facing product is large, it cannot be rewritten if designed as monolith. You need a senior to design micro-service UI.

    @BrianHaak Thx - it's interesting what you say. Since last year I've worked on a much larger project than before. I've gotten that feeling of taking a look at code I wrote just a few months ago and saying "wtf? Who thought this was a good idea?" :) - Starting this project from a small kernel into a project that can be extended easily & also able to accommodate non-devs who want to add content has forced me to think about higher level structure. Pairing w a more experienced programmer showed me that I'm missing a lot of opps. to use abstractions. I also have trouble w namespace.

    @HLGEM should add a TLDR; at start of the answer, wasn't expecting more after the third paragraph until i scrolled, will be helpful for devices with short screens.. Just a thought :)

    "the older Intermediate developers who never make the leap to Senior" +1. There's a big difference between getting ten years' experience, and one year of experience, ten times.

    It's hard to narrows down what makes jnr/mid/snr as the roles are very diverse and knowledge within each role additionally diverse. You could arguably be a senior based on the ability to code well within a specific company because you know all of it's products and services etc. mid level - "They have learned enough to know what they don't know and are starting to gain that knowledge." - this is a great observation, and defines one of the main differences between jnr and mid.

License under CC-BY-SA with attribution


Content dated before 6/26/2020 9:53 AM