[-]

Upstairs_Speaker_476@reddit

Juniors need clear instructions and usually handle smaller tasks like code cleanup and bug fixing. Mids can build a feature from start to finish by themselves. Seniors make architectural decisions.

[-]

frederik88917@reddit

How much responsibility vs salary you get

[-]

pydry@reddit

One of my favorite yardsticks is "how impressed by LLM coding" they are.

For some reason juniors and mid levels are pretty honest about this and it definitely highlights skill or lack thereof.

[-]

the thing that clicked for me was watching how juniors vs mid-levels debug. a junior searches the error message, tries things until one works. a mid-level forms a hypothesis first - if this is what I think it is, I should see X - and tests the hypothesis before touching anything. it sounds minor but it cuts debug time dramatically and it catches the actual problem instead of just the symptom. that shift in approach is hard to teach and it mostly comes from getting burned enough times that you stop assuming the first thing you think of is right.

[-]

DullAchingLegs@reddit

Responsibility has always been the definition for me. Juniors aren't responsible for anything. Mid level are responsible for themselves and the folks below them. Seniors are responsible for the mid level. It doesn't really have to do with technical ability.

[-]

WorriedGiraffe2793@reddit

Juniors know they know nothing.

Mid level developers start thinking they know a lot more than they actually do... but (in Dunning-Kruger terms) quickly hit the valley of despair.

Seniors have crossed that chasm after maybe 10-15 years.

[-]

Beregolas@reddit

There are a lot of (somewhat funny) meme answers here, but seriously:

A junior developer is not expected to be able to build a feature without guidance.

A mid level developer is expected to be able to build a feature without guidance, but not a whole system/app/program, and to guide juniors on features.

A senior level developer is expected, to be able to build everything without guidance, and to guide juniors and mid level.

[-]

tacticalpotatopeeler@reddit

Apparently it’s based on who ships the most PRs at my company

[-]

monsto@reddit

Well shit man, after this morning's round of three line bug fixes, I could be your CTO. where do I apply?

[-]

tacticalpotatopeeler@reddit

www.fuckcorporatebullshit.com/apply

[-]

ByronScottJones@reddit

The mid level developer has taken down production. The junior will, eventually.

[-]

VibrantGypsyDildo@reddit

An initiation ritual, as in African tribes.

For me it was introducing a memory leak into Linux kernel.

[-]

serendipitousPi@reddit

Hah jokes on you I nuked production before getting a job by messing up how my testing system used the test database instead of the prod one.

Strangely enough my 2 or 3 users who had only used my app once didn’t seem to care. Almost like it had no effect on them but no obviously it’s going to be a million dollar idea some day.

[-]

SEX_LIES_AUDIOTAPE@reddit

I've got 10yoe and the other day I nuked production with the Nuke Production button I included in my side project app for some reason.

[-]

Practical_Teacher347@reddit

Been there, did that during my second year. Nothing teaches you proper testing and deployment procedures like explaining to the entire company why the main site was showing error pages for 2 hours in Tuesday morning.

[-]

csabinho@reddit

At least it's Tuesday morning and not Friday afternoon.

[-]

NationsAnarchy@reddit

Yeah, it means I am still junior with that definition then lol

[-]

justaguyonthebus@reddit

JR dev will jump in and write a lot of code to do exactly what was requested with out questioning it.

A mid level will rework the scope and requirements to integrate it into the existing system instead of bolting on something unrelated.

A senior level will understand the problem first and why they are making the request to provide a complete solution for the problem.

A principal level will will require meetings to discuss business value and detailed requirements and design documents before writing any code.

[-]

Andrew_7032@reddit (OP)

the fk? your response is the only one that doesn't align with the rest of the people here.

[-]

justaguyonthebus@reddit

Am I wrong?

I could have rehashed what everyone else said but I took it a different direction. Many of those other are spot on.

[-]

AlwaysHopelesslyLost@reddit

I typically delineate them like this:

SE1 - Still learning, makes some dumb mistakes. Can be trusted to sit with a problem and eventually solve it with a bit of help.
SE2 - Mostly self sufficient. Can generally be trusted to sit with a problem and eventually solve it without help. Writes "clever" code frequently. "Clever" code being code-golf esque or wildly excessive because they have not yet refined their skills.
SE3 - Almost never needs help, can solve any issue and can be trusted to plan/architect a decent solution. Doesn't write clever code. Writes simple, clear, maintainable code that does exactly what is needed.

[-]

locri@reddit

SE3 - Almost never needs help, can solve any issue

In my experience, this is rare.

A lot of senior software guys seem more inclined to recruit others to make their own jobs easier for them even at the expense of the entire team's productivity.

I'm torn as to whether this is an elitism thing and they just don't feel other people's time is worth that much or if it's because older people genuinely do have some skill differences.

[-]

AlwaysHopelesslyLost@reddit

It is probably a bit of the peter principle.

[-]

stueynz@reddit

SE4 - can direct SE2 and SE3 and get useful work out of the whole group. Will have SE1 in tears as they still have zero empathy and can’t remember being an SE1.

SE5 - has reached nirvana levels of zen; has gained empathy and can direct SE1 without causing floods of tears. Does not actually write code any more; merely directs the team and leaves the actual writing of code to the others.

[-]

Blando-Cartesian@reddit

Junior codes the happiest of happy paths in a way that maybe kinda works for one user, when the stars are perfectly aligned, and you use it just so.

Mid codes in more robust way, and still misses some cases,

[-]

komic_@reddit

Arrogance

[-]

More_Ferret5914@reddit

Juniors write code that works. Mid-level devs write code that keeps working.

A junior needs direction, gets stuck often, and focuses on “how do I implement this.” A mid starts asking “should we even build it this way” and can move without constant hand-holding.

Juniors think in files and functions. Mid-levels think in systems, edge cases, and tradeoffs. They catch problems before they hit production instead of after.

Biggest difference? Reliability. A mid-level dev reduces risk for the team. A junior usually adds some, even if unintentionally.

[-]

qqnowqq@reddit

Agree with this. Not that a mid is error prone or anything either but the higher up you go, the more you can understand how to exercise judgment for applying various fixes instead of just trying to find a single solution.

[-]

disappointer@reddit

Juniors write code that works. Mid-level devs write code that keeps working.

This is like an order of magnitude more of hopium than I have for these roles, but I suspect it all depends on the complexity of the codebase.

For a large enough project: juniors can build the project, and fix some bugs in it. Mid-level devs can also contribute bugs.

[-]

YellowBeaverFever@reddit

It’s about autonomy. A Junior knows basically nothing. They’re in the “sponge phase”, absorbing knowledge. They work on little things like modifying functions in already working code. Half of what they are learning is the tech and the other half is the business. Learning the business is just as important as the tech.

A Mid had a handle on the business and the tech. They aren’t leading projects but can answer questions or know where to go to get answers. They’re not questioning everything and can make decisions, though they’ll still check with seniors to make sure. They’ll understand the systems enough that they can recommend valid improvements.

[-]

TurboOwlKing@reddit

The way I see it, junior has to ask the team way more questions than they can answer, mid asks and answers about the same, senior answers way more than they have to ask

[-]

BakkerJoop@reddit

Or how I've experienced it over the years: the junior doesn't ask enough questions, and the senior doesn't have anybody to answer his questions.

[-]

writeahelloworld@reddit

I 've done all these when i was a mid dev:

1.seen a prod incident that is caused by your sh!t code

Spam all your clients' real emails with your testing emails
Understand how data is retrieved from database/backend, display on frontend webpages as a form, data is saved and sent to backend and stored in db, has a bit of experience in writing code to do all these
Questioned why things are done this way and thinking i have a better idea, then got an explanation from a senior and then feel a bit ashamed of my stupid idea

[-]

Ambitious_Emotion921@reddit

The leap from junior to mid-level is less about how many languages you know and more about your production reality specifically, how much supervision you require to ship stable code.

Key Differentiators

Problem Solving vs. Task Execution: A junior developer often waits for a "how-to" breakdown of a feature. A mid-level developer can take a broad requirement (e.g., "Build a password reset flow") and figure out the edge cases, security implications, and implementation details independently.
Code Maintenance & Scalability: Mid-level devs have been around long enough to see their own code break. They stop just trying to make it "work" and start writing code that is readable, modular, and easy for the next person to maintain.
Tooling & Workflow Efficiency: Juniors often get bogged down in environment setup or boilerplate. Mid-level developers have a refined stack; for instance, I often see them use Runable to quickly spin up documentation or internal prototypes so they can focus on the core logic rather than the "fluff" of a project.
The "Big Picture": Juniors focus on the specific ticket they are working on. Mid-level devs understand how their code affects the entire system, the deployment pipeline, and the end-user experience.

Essentially, a junior is learning the "what," while a mid-level developer has mastered the "how" and is starting to ask "why."

[-]

WarpedPhantom@reddit

Haven’t seen the first one I think of, so here’s mine: the ability to estimate time. Will the feature take a day? A month? Need one or four devs? What about if they’re only working it 1/4 time on it each? Will it be done in an hour if we put 20 devs on it? Why not? \s

The factors add up, and reliable time estimation is what management at medium to large orgs need; it’s where the “creation” process of engineering meets business, and it matters so much more when you’re senior.

[-]

IAmFinah@reddit

Whatever wording the job posting happens to use

[-]

mlitchard@reddit

What kinds of questions they ask when encountering a new problem.

[-]

rajat_codes@reddit

Most Important Difference

JUNIOR:

"How do I make this work?"

MID-LEVEL:

"How do I make this work well and maintain it?"

[-]

Leverkaas2516@reddit

Mid-level has years of experience in a professional environment, working with real people and real requirements, delivering production code. There's a ton of rookie mistakes they've already made and will not make again.

Example: I once decided the splash screen of an internal tool had an ugly background color (which it did, that was true) so I checked in a change to improve it. A few hours later someone was standing over my desk telling me all the reasons you do NOT just merge arbitrary changes on your own just because you feel like it. Every organization has a process, and you don't skip the process on a whim.

That's the kind of mistake that juniors make.

[-]

Beneficial-Panda-640@reddit

Biggest shift is ownership. Juniors need direction on what to do and how, mids can take a problem, break it down, and move it forward without much hand-holding.

Mids also start thinking about tradeoffs and how their work fits into the bigger system, not just getting their piece done.

[-]

LurkingDevloper@reddit

Given the short shelf life of most stacks, I don't think there really is a mid level developer.

It's really just junior -> senior and the core difference is the problem solving ability and familiarity with the stack.

A senior can also pick up new stacks very quickly. A junior will struggle more through syntax and concepts.

[-]

hugazow@reddit

Since our it department was cheap, no git branch could be done. So the “solution” was for me to backroll whenever a mistake happened. So i had this graduation ceremony whenever a newly hired dev pushed something that wasn’t supposed to be thereto, they always reached nervously but i only congratulated them and told them that no harm done, you reach your newbie graduation, keep this a secret from the others.

I’m still friends with these guys despite living in another country.

[-]