What question destroys fake seniors in an interview?

Summary

In this video, the speaker discusses the challenges of identifying 'fake senior' developers during interviews. They emphasize that true seniority is not just about coding but also about adaptability, debugging, and understanding complex systems. The speaker shares questions that reveal a candidate's experience level, such as testing strategies and debugging approaches, and stresses the importance of hiring developers with practical, large-scale experience rather than just theoretical knowledge.

Takeaways

• 😌 The speaker discusses the difficulty in defining 'senior' in software development and criticizes some who claim the title without the necessary skills or experience.
• 🔍 The speaker suggests that 'fake seniors' are often indistinguishable from mid-level developers in terms of their capabilities and adaptability.
• 💼 The speaker emphasizes the high cost to companies of employing 'seniors' who lack the breadth of skills expected at their level.
• 🚀 The speaker advocates for the importance of working at a large scale to gain exposure to complex systems and to truly understand what it means to be a senior developer.
• 📈 The speaker argues that the IT industry is evolving, with new titles like 'principal engineer' or 'staff engineer' emerging, potentially redefining what 'senior' means.
• 🤔 The speaker outlines specific questions that can reveal a candidate's true level of experience, such as how they test their code and debug production issues.
• 🛠️ The speaker highlights the importance of having a deep understanding of multiple areas of the development process, which is indicative of a true senior developer.
• 📊 The speaker stresses that real seniors can provide in-depth answers to open-ended questions about development strategies and rationales.
• 💬 The speaker points out that 'fake seniors' often give high-level, vague answers that lack the detail and reasoning of someone with genuine experience.
• 💼 The speaker concludes by advising companies to hire people who can deeply understand and answer these questions to ensure they are getting value for their investment.

Q & A

What is the main issue with defining 'senior' in the context of software development?

The main issue is that seniority is not well-defined, and often those who call themselves seniors do not possess the expected skills or experience. There's a disparity between the cost of hiring a senior developer and their actual contribution, which is not significantly different from a mid-level developer in some cases.

Why is adaptability important for senior developers?

Senior developers should be able to adapt to changes in tooling and work environments, such as devops, which is becoming standard practice. The inability to adapt can indicate a lack of senior-level skills.

What is the significance of the term 'fake senior' used in the script?

A 'fake senior' refers to individuals who claim to be senior developers but do not demonstrate the necessary experience or skills expected of someone at that level.

How does the complexity of systems impact the skills required for developers?

As system complexity increases, developers are expected to know more and adapt to various tools and technologies. This is to ensure efficiency and effective problem-solving without the need to hire additional resources for every new tool or technology.

What is the value of working at a large scale in software development?

Working at a large scale exposes developers to the realities of running complex systems, which is a valuable experience that contributes to their growth and understanding of what it takes to be a true senior developer.

Why are specific, experience-based questions effective in identifying 'fake seniors'?

Experience-based questions reveal a candidate's depth of knowledge and practical experience. 'Fake seniors' often lack the detailed understanding and breadth of experience expected at a senior level, which becomes evident when they are unable to provide in-depth answers.

What is the first question suggested in the script to gauge a developer's experience level?

The first question suggested is 'How do you test your code?' which can reveal a lot about a developer's experience and approach to software development.

How does a real senior developer differ in their approach to testing compared to a less experienced developer?

A real senior developer will have a nuanced understanding of different testing strategies such as unit testing, integration testing, regression testing, BDD, end-to-end testing, etc., and will be able to explain how and why they choose certain strategies based on project needs.

What other questions can be asked to distinguish between a real senior and a 'fake senior'?

Questions about debugging production code, tool selection, setting up CI pipelines, and other development process-related topics can reveal a candidate's practical experience and depth of knowledge.

Why is it important to have knowledgeable people involved in the hiring process for senior developer roles?

Having knowledgeable interviewers ensures that candidates are thoroughly assessed for their claimed seniority level. It helps to avoid hiring 'fake seniors' who may not deliver the expected value.

What is the key takeaway from the script regarding the hiring of senior developers?

The key takeaway is that hiring should focus on experience and the ability to handle complex challenges rather than just technical knowledge, as the latter can be superficially demonstrated.

Outlines

00:00

🤔 The Challenge of Identifying 'Fake Seniors' in Tech Interviews

The speaker begins by addressing the difficulty of determining who is truly a senior developer, especially in programming interviews within the EU. They share their personal experience in identifying individuals they label as 'fake seniors', who may not possess the skills or adaptability expected of a senior developer. The speaker criticizes the lack of a clear definition for 'senior' and points out that many self-proclaimed seniors are not significantly different from mid-level developers in terms of their capabilities and cost to the company. They emphasize the importance of being able to adapt to changes, work in a devops environment, and perform tasks beyond just writing code, which are often overlooked in favor of experience and title.

05:01

🔍 Unveiling the 'Fake Seniors' with Open-Ended Questions

The speaker discusses the types of open-ended questions that can reveal whether a candidate is a genuine senior developer or a 'fake senior'. They provide examples of questions that probe a candidate's experience with testing strategies, debugging production code, and setting up CI pipelines. The speaker argues that a real senior developer will have in-depth knowledge and experience across multiple areas of the development process, which allows them to provide detailed and nuanced answers. In contrast, a 'fake senior' may only be able to give high-level, vague answers without the depth of experience that a company might expect for the salary they command.

10:01

🛠️ The Practical Experience That Sets Apart True Senior Developers

In this paragraph, the speaker emphasizes the importance of practical experience in distinguishing true senior developers from those who are less experienced. They discuss how a senior developer's ability to quickly resolve issues and have a 'sixth sense' for what to focus on is valuable and cannot be faked. The speaker shares that they often have to assist developers who, despite having worked for several years, struggle with debugging their own frameworks or stories. The paragraph concludes with the speaker advising that the experience and understanding a senior developer brings is what justifies their higher salary, as opposed to just their coding skills.

Keywords

💡senior developers

Senior developers refer to experienced software engineers who have advanced skills and knowledge in their field. In the video, the speaker discusses the difficulty in defining what constitutes a 'senior' developer and criticizes some who claim this title without the necessary skills or adaptability, such as not being able to work in a devops environment or debug systems effectively.

💡fake seniors

The term 'fake seniors' is used by the speaker to describe individuals who claim to be senior developers but lack the depth of experience or skills expected of someone at that level. The speaker suggests that these individuals are often indistinguishable from mid-level developers in terms of their capabilities and cost to the company.

💡devops environment

A devops environment is a software development approach that combines software development (Dev) and IT operations (Ops) to shorten the development lifecycle and provide continuous delivery of high-quality software. The speaker points out that some 'senior' developers lack the ability to work effectively in such environments, which is a critical skill for modern software development.

💡debugging

Debugging is the process of identifying and fixing errors or bugs in software code. The speaker emphasizes the importance of debugging skills, especially in complex systems, and suggests that the inability to debug effectively is a sign of a 'fake senior' developer.

💡testing strategies

Testing strategies refer to the various methods and approaches used to ensure that software functions correctly and meets specified requirements. The speaker discusses different testing strategies such as unit testing, integration testing, and end-to-end testing, and how a real senior developer would tailor these strategies based on the project's complexity and needs.

💡CI pipeline

A CI (Continuous Integration) pipeline is a tool used in software development to automate the process of integrating code changes from multiple developers into a single software project. The speaker mentions setting up a CI pipeline as one of the tasks that can distinguish a real senior developer from a 'fake senior'.

💡experienced developers

Experienced developers are software engineers who have a deep understanding of the development process, including problem-solving, debugging, and testing strategies. The speaker argues that experienced developers are valuable because they can quickly resolve issues and have a 'sixth sense' for what to focus on in complex projects.

💡mid-level developers

Mid-level developers are software engineers who have a certain level of proficiency but are not yet at the senior level. The speaker compares mid-level developers to 'fake seniors,' suggesting that the latter often perform at a similar level but are compensated at a higher rate without providing additional value.

💡principal engineer

A principal engineer or staff engineer is a senior-level position that often comes with greater responsibility and expertise in software development. The speaker mentions these titles as examples of how the term 'senior' is evolving and may eventually be replaced by other designations that better reflect the required experience and skills.

💡life experience

Life experience in the context of the video refers to the practical, hands-on experience that developers gain through working on challenging projects and facing various technical challenges. The speaker emphasizes that life experience is what sets apart real senior developers from 'fake seniors,' as it cannot be faked and is evident in their ability to answer in-depth questions about the development process.

Highlights

The speaker discusses identifying 'fake senior' developers by asking specific questions.

Seniority in programming is difficult to define and often misunderstood.

Many self-proclaimed seniors lack the adaptability and knowledge expected of their level.

The speaker criticizes the high cost of seniors who do not offer commensurate value.

Experienced developers should be able to handle complexity and learn new tools.

The speaker advocates for working at a large scale to gain exposure to complex systems.

The industry is moving towards new titles like 'principal engineer' instead of 'senior'.

Interview questions should be open-ended and based on experience.

A real senior developer will have a nuanced understanding of testing strategies.

The speaker gives examples of questions that reveal a developer's experience level.

Different projects require different testing strategies, which a senior should understand.

Senior developers should be able to discuss debugging production code effectively.

The speaker emphasizes the importance of experience over raw coding ability.

Companies should look for developers with a broad range of experience.

The speaker suggests that hiring someone with seniority is an investment in problem-solving.

Fake seniors often lack the depth of experience expected and can be identified through questioning.

The speaker shares personal experiences of helping less experienced developers debug issues.

The speaker concludes by emphasizing that life experience is key to identifying true seniority.

Transcripts

hey guys so today you and I are going to

talk about

questions

so let's get into it

so the questioning question was

was posted on the video I made I don't I

don't even remember it what it's called

what about programming interviews in the

EU

and I'm assuming that I'm bragging or

something like that about my uncanny

ability to spot uh

people's people that I call fake seniors

because the person asks now you got me

curious what kind of questions are those

that destroy fake senior Developers

well that is easy

that is really easy so when I talk about

a fake senior I it's maybe I was

emotional at the that specific point in

time but fake senior is or

you can call it whatever you want guys

the problem with seniority is you can't

really Define what the senior actually

is and the only thing that I see today

is that there is a need for something

that most people who call themselves

seniors are not so when I work with

seniors who cost you have no idea how

much they cost

in term for the company most of them are

actually not there's not that much of a

difference between them and the

mid-level software developer I see

seniors who can't adapt to a basic like

a basic change in their tooling I see

seniors who won't actually know how to

work in a devops environment which is

fairly it's becoming fairly status

practice like they don't know how to

debug a system they don't know how to do

tons and tons of stuff like the only

thing they are capable of doing is

writing the code and as I've said to you

guys before that is the that is the

level a mid-level has to reach to just

be able to write the code but the

reality guys is that the in like the it

is moving and people tell me all the

time oh why do they ask me to know

everything and I go because the

complexity of the systems that you deal

with is just increasing and we can't

just hire more and more people for every

little tool that you don't want to learn

or that you haven't taken the time to

learn and that's why I've told people

quite a few times that the best

investment for you

is to work at large scale

because the larger the scale that you

work at the more exposure you will get

to this realities of what it means to

run 90 system and it's very very rare

that you will get to like a real senior

level most companies won't even if you

call yourself a senior most companies

that know what they're doing won't hire

a quote-unquote scene near who doesn't

know so it doesn't have the sort of

experiences that they are looking for so

we can throw around the term senior

we're just going to invent another term

I think the term now is like principal

engineer staff engineer or like whatever

like we're just going to environment

something else and Senior is going to

become what mid-level used to be

but if you ask me what type of questions

that I usually ask to figure out and

this is the same questions that I ask

everybody when I figure out their

experience level uh give you I gave the

person a few examples first in question

first question is how do you test your

code

now you can answer that question in so

many ways

and if you are a rookie programmer or

someone doesn't really know anything

you're going to stutter a lot and you're

probably going to say something like oh

yeah like I do some local testing and

then you know I've heard about unit

testing and sometimes I write Unity

that's a beginner level answer at Uni

level answer or like a fake senior

answer or someone who works at a agency

and has for most of their life and

actually makes most of the static

websites or something very small where

unit testing or testing strategies are

not necessary

with a real scene you would answer in

that situation it would be that well

basically I write unit tests for that

this is which if we reach a certain

level of complexity but I also write

integration tests if I'm working with

some specific data model that I haven't

tested before or if we have an like a

back-end API or something like that that

I'm connecting to where I need to make

sure that say before the deployment or

something like that that the connection

is actually working if it's a front-end

application I might want to add revision

regression testing if we're working with

something very very complicated we might

want to look at something like bdd or

end-to-end testing or something like

that

it really depends on what strategy we're

picking for like or overall testing

strategy because

ideally we want to reduce the amount of

like higher level testing that we're

doing because if we put all of our

testing at that level we're going to

have quite a lot of making this and a

lot of false alerts in

assuming now of course that we have

alerts for the n10 test if we do

actually decide to go that route and

then we can look at Contract testing of

course if we have some type of apis that

need to connect to each other it really

depends on what the overall like

investment in our testing strategy is

okay

that is

an example of multiple test strategies

because a real senior will know that it

very much depends on the project if

you're working on like his tiny little

MVP or something like that there's no

real need for you to do unit testing

unless you have something very

complicated that you're doing like a

specific function that does something

super Advanced but if you have a

distributed system with tons of

different microservices and things like

that it's actually very important for

you to and in that case it's like I

could we can expand on that because it's

not just about the testing in that

scenario it's also about telemetrics and

observability because you can't debug

certain things in a distributed system

or figure out if something is working or

not working by only doing testing the

integration testing I was talking about

you can do that but you could also say

that well actually we want to do some

Canary releasing or something like that

to make sure that it's working or we

might want to take a look at load

testing things depending on like as I

said what level do you want to put this

thing in because you you're going to

figure out very quickly if you're

experienced software developer that you

don't have time to do all that at the

same time and deliver all the features

at the same time you have to budget

things and then take it in layers

because if you go with the basics first

and then focus on the areas that you

usually have the most issues in you will

have a more efficient testing strategy

than if you just do basically nothing

so that's an example of a question that

is very open-ended it's basically all

experienced experience based and no real

senior

is or sorry a fake singer is going to be

able to answer that in the sort of

extent that a company like you can hear

whether or not they've done this stuff

before or not it's the same thing how

did you debug production code is another

one what tools would you pick for your

team why that one how do you set up a CI

pipeline for your team and these are

just the generic ones we can go specific

as well on back and front and what type

of role they have and so forth because

real seniors guys they usually when they

talk they usually have a lot of

experience with multiple areas of the

development process and they can give

you answers that are fairly in depth

that's what I'm talking about they have

life experience and that's the big

difference between a senior and the

mid-level usually like the fake seniors

like they are just mid-levels that you

pay a lot more because like they

basically code at the same level as a

mid-level software developer but they

don't also they don't have any life

experience you can't ask them to do or

even have the stuff that I'm talking

about and that's not the real like

that's not a good investment for you as

a company because you're just gonna pay

them tons and tons of money for

basically the same output you would get

from a mid-level who needs help to

figure out how to work in a devops

environment or how to do anything that

is more advanced than just the basic

coding on a story

so what I want you to take away from

this is that the quote-unquote questions

that destroy fake seniors is experienced

ones you can make them as open as you

want you don't have to take the ones

that I have it's really that simple you

ask them about specific things that are

relevant to the development process that

puts pressure on you because you need to

know this stuff which is why I tell

people that when you're hiring software

developers or seniors or things like

that you to have

people who really know their in

that conversation because I can promise

you guys that there are tons of people

who speak with the authority and the

confidence of a senior software

developer but if you actually ask them

these sorts of questions they will just

give you very high level loose answers

where they tell you what they know about

not really what they're doing or the

reasoning behind how to think about it

or like what like what is the

rationality between one choice or

another

and that's usually because they don't

really know that stuff they know that it

is important to know about it and

they've heard that others know about it

but they themselves don't really know

about it and that experience is what you

pay is in you for not necessarily that

they know how to code better than

everybody else but because they know how

to quickly resolve issues and figure out

sort of get a sixth sense for what's

going on what we should focus on so

forth and so forth they have to be more

experienced than the mid-level because

otherwise as soon as something that is a

little bit out of the domain knowledge

of say a mid-level they're sort of stump

which is one of the things that say for

example me I have to help quite a lot

with when my developers who have worked

for many like most of them have worked

for at least five years when they don't

really know how to debug their own

framework or figure out their own story

guess who gets to help them to figure

that out and if we if I can't help them

we're basically that's what I'm

talking about that's the thing that

trips up a fake secret because they

haven't actually done enough work in

their own tools or their you know at the

these the various company larger scale

companies or in situations where they

have to really challenge themselves

because this experience that I'm talking

about that you can hear when you ask

someone these questions that's life

experience and you can't fake that it

doesn't matter like you you will never

fake it because you have to live a life

where you face those challenges before

you know how to answer those questions

in the way that you would expect a

senior to to do and if you don't hear

that's that level of understanding of

the different topics it's very likely

that you're dealing with someone who's

just saying that they're seeing you and

you're going to pay them a lot but

they're probably not going to give you

much outputting like you could just hire

mid-level or a junior instead have a

great day