Junior/No-prefix: In their first job. You will routinely get promoted from junior to "normal" whilst remaining at the company.

Senior: Second or third job change.

Staff: That one person who has been at the company forever.

Principal: We're an enormous engineering org and need to have a treadmill so we don't lose our people but can't just give them payrises. Most titles also have multiple levels.

My take is that your seniority refers to how much responsibility you can bear.

If I give a solid junior a clear spec, wireframes, guidance on tools and mentorship then they should make progress according to the spec. If what I assign to a junior engineer is impossible to implement or useless to the product, that’s on me.

A senior should be able to succeed with much higher level / vaguely specified tasks. Like, here’s the client. Here’s the team. Go figure out for yourself how you can add the most value. A good senior should be able to figure out if there’s resources or skills the team is missing, and solve what needs solving in order to make the project successful. Sometimes this is non-technical - like raising issues with the client, organising to hire another UX person, etc. A senior should be resourceful.

You can frame the same thing in terms of responsibility scope. A junior is responsible for the assigned task (as the task is described). A senior/principal is responsible for the project being successful or the company’s software meeting the needs of the business.

Senior/staff/principal/etc to me mean beyond vague locations on that junior-to-senior+ engineer resourcefulness axis. I don’t think there’s any agreed upon definitions across the industry. (Though google, microsoft, etc all have their own internal working definitions)

Titles primarily exist to justify higher pay inside a team, and/or lower pay wrt to some other company.

In simple terms, Sr. usually is an understanding that you are on your own. Do not expect any one else to tell you how or what to do. Also, the ones without Sr. title may become your responsibililty.

Though debatable, it has nothing to do with your technical skill set or experience.

It's pretty arbitrary, and depends also on what you negotiate when getting hired. I've seen people that got hired as seniors that performed just as well/poorly/... (depending on your perspective) as mid-level folks.

I've also seen the title of "senior" in one organization being wildly different to a "senior" in another organization within the same company. For example, for some reason, the "API dev team" had insanely high bar whereas the "submodule X team" had seniors left and right, quality-wise nowhere near seniors from the "API dev team".

This all has led me to believe getting promoted is simply about renegotiating your salary with the company, and has very little to do with your actual skill. It has more to do with who's your direct manager, and what is your relationship with him/her.

Personal and anecdotal experience only of course.

My understanding is the following: No-prefix < Senior < Staff < Principal.

In details, I see it this way:

No-prefix: focuses on the here and now with little responsibilities about long term strategy/cooperation with other teams.

Senior: he/she can be/is a TL. Sets the direction for the team and thinks about medium/long term strategy/shape of the code base. Also, they tend to be the liaison between the team they are under and other teams, but in a tactical/ad-hoc way.

Staff: Like senior, but more on the strategic side of things (i.e. longer term planning).

Principal: Usually the TLM/uber TL for a working group (few teams). Can also be a director for a working group.

As pointed out by other replies, It is subjective and also company-dependent. In startups these levels tend to be compressed, in FAANG companies there's a distinct increase of responsibilities with each title.

Do definitions of those even exist?

I think it's up to the company whether you're Senior, Ninja, Shaman or Necromant Developer

There are no strict definitions, different companies do it differently, have different requirements and role descriptions. Usually the path is junior -> no prefix -> senior -> staff/lead -> principal (some companies have only the first 3/4, then only management above).

One good source I found is gov.uk site: https://www.gov.uk/guidance/software-developer

Variations on the perceived value of an engineer in one organization