How do we become software developers with the knowledge and skill to do our work well? Training junior developers is an essential piece of building a successful team, but it's a complex and challenging task. The lessons shared in this talk are drawn from experiences training, coaching, and mentoring over 40 junior developers in the past 2 years, including successes, failures, challenges, and rewards will be discussed. Discusses strategies for identifying potential, assessing team fit, guiding technical growth, and coaching new developers in soft skills and interpersonal development.

1. SUNLIGHT & AIR
10 LESSONS FOR GROWING JUNIOR
DEVELOPERS

2. HELLO!

3. WHO AM I?
Hi! I’m Erika.
I’m a software engineer.
I work at Detroit Labs in Detroit, Michigan.
I’m currently the Director of Apprenticeship & Training
programs.
In 2014, our company decided to try an experiment: we
created a 3-month apprenticeship program where people
with no prior software experience were paid to learn, and
offered full-time employment to successful graduates.

4. WHO AM I?
Since 2014, we’ve trained 33 developers through our iOS,
Android, and JavaScript apprenticeship programs.
We’ve trained 12 additional developers through partnership
programs.
In the past 2 years, I have worked individually with 45 junior
developers, including classroom instruction, technical
coaching, soft skills training, mentoring, and providing
ongoing support as they integrate into development teams.

5. WHO ARE YOU?

6. WHAT IS THIS?
In this talk, we’ll cover aspects of effectively growing junior
developers, including:
‣ Choosing the right fit for your team
‣ Getting off to a good start
‣ Setting & managing expectations
‣ Providing effective feedback
‣ Encouraging ongoing growth
‣ Conflict resolution

7. LESSON #1: CHOOSE WELL
‣ Not everyone can or will become 1.) a successful
developer or 2.) an effective team member
‣ A junior developer’s past experience (if they have any)
may not tell you much, so look for potential
‣ Talent is great, but it’s not the most important piece or
even necessarily a requirement
‣ First and foremost, good developers are natural problem-
solvers: they are curious, thoughtful, and persistent

8. LESSON #1: CHOOSE WELL
‣ “Teachability” is key: look for people who aren’t afraid to
ask questions, and are willing to engage in the process of
finding an answer
‣ When evaluating junior developers, as much emphasis
should be placed on soft skills as on technical ability
‣ The ability to receive and effectively incorporate feedback
is essential
‣ Communication, collaboration, conflict resolution

9. LESSON #2: FIND THE RIGHT FIT
‣ The team a junior developer will be joining should be as
involved as possible in the hiring process
‣ Team buy-in is absolutely essential
‣ Adding a new person to a team creates a constellation of
new relationships
‣ The “right fit” will bring new strengths to the team while
challenging them in areas of struggle: better feedback,
communication, and knowledge-sharing are just a few
possible improvements

10. LESSON #3: SET EXPECTATIONS
‣ Set clear, fair, realistic expectations for everyone before a
junior developer joins the team
‣ If senior team members will be expected to dedicate time
to pairing, coaching, and mentoring the new addition,
discuss this in advance to determine interest and ability
‣ It may be necessary to adjust a senior developer’s
workload if he/she is expected to do significant coaching
in addition to his/her own work
‣ Seek input from the team in setting expectations and be
sure to create a feedback loop for adjustments

11. LESSON #3: SET EXPECTATIONS
‣ Set expectations for junior developers in terms of progress
and performance
‣ Junior developers should have specific, measurable goals
to meet on a regular basis (weekly, monthly, etc.)
‣ Junior developers should have a designated person(s) to
ask for help with technical and interpersonal issues
‣ Develop a clear plan of growth: Where are a junior
developer’s skills expected to be in 3 months? 6 months?
In a year? What specific areas need improvement?

12. LESSON #4: PAIR UP
‣ Pair programming from the start is one of the quickest,
most effective ways to ramp up a junior developer who is
new to the team, new to a language/platform, new to
development, or all of the above
‣ Pair junior developers with more experienced developers
(they don’t necessarily have to be senior!) who are good
communicators and have an interest in mentoring
‣ Set expectations for pairing, as junior/senior pairs can
often turn into “shadowing”

13. LESSON #4: PAIR UP
‣ Junior developers should be actively driving and
navigating during pairing sessions
‣ Pairing partners should encourage questions and provide
direction, but not always give answers: as the junior
developer gains skills and confidence, he/she should be
increasingly responsible for figuring out answers on his/
her own
‣ Teach junior developers to seek direction instead of
answers: “I’m struggling with [X] problem. I’ve tried [Y]
options without success. My current hypothesis is [Z]. What
should my next step be? Why?”

14. LESSON #5: BALANCE
STRUCTURE AND FREEDOM
‣ Junior developers need structure to thrive, especially at
first
‣ Structure includes clear expectations and goals, assigned
tasks, accountability, supervision, and regular feedback
‣ Providing structure creates a framework for the future,
when the junior developer will manage his/her work and
learning more independently, and will become more
skilled at self-assessment

15. LESSON #5: BALANCE
STRUCTURE AND FREEDOM
‣ Freedom interspersed with structure can accelerate
learning and increase motivation and enthusiasm
‣ Giving a junior developer assigned time to work on a
personal project can significantly build his/her skills and
confidence
‣ Learning projects should have specific requirements in
terms of difficulty and complexity, and regular updates
and demos should be provided

16. LESSON #6: POSITIVE
FEEDBACK
‣ Feedback (of all kinds) is one of the most important pieces
of growing junior developers
‣ Positive feedback tends to get lost in the shuffle, especially
when the focus is on growth and improvement
‣ Positive feedback builds confidence, improves
collaboration and team relationships, and increases
motivation
‣ Positive feedback should be specific, timely, and sincere

17. LESSON #7: CONSTRUCTIVE
FEEDBACK
‣ The term “constructive feedback” helps to reduce the
stressful connotations of the term “negative feedback”
‣ Constructive feedback can be stressful and anxiety-
provoking for anyone who struggles with receiving
feedback, but it is almost always difficult for junior
developers, who tend to already have a lot of anxiety
about their performance
‣ Avoid giving major constructive feedback “on the spot”

18. LESSON #7: CONSTRUCTIVE
FEEDBACK
‣ Significant constructive feedback should be given in a
structured setting, such as a 1:1 meeting
‣ It may be helpful to provide constructive feedback in
advance of an in-person meeting (e.g., through email) to
give the recipient time to sort through his/her initial
reaction, which may be emotional
‣ Give constructive feedback on a regular, frequent basis in
order to lessen anxiety and increase the likelihood that
feedback will be accepted non-defensively

19. LESSON #8: LISTEN & SUPPORT
‣ The junior developer should have regular 1:1 meetings
with someone who can provide support and confidential
listening, as well as help addressing any issues that arise
‣ Junior developers are often hesitant to raise issues with
the team, and regular meetings with a supportive person
decrease the likelihood that problems will go undetected
‣ Support is extremely important to success: adjusting to a
new job and a team (and in some cases, a new technology
or even a new career) can be stressful, emotional, and
sometimes overwhelming

20. LESSON #9: ADDRESS ISSUES
‣ Tensions and challenges are inevitable
‣ Create a framework for later problem-solving by
acknowledging up front that adding a junior member to
the team may bring up challenges on all sides
‣ Ignoring problems leaves senior developers feeling
frustrated, resentful, and/or overwhelmed
‣ Failure to address obvious team tensions leaves junior
developers feeling unwanted, anxious, and/or hopeless
‣ Issues that go ignored can become toxic to the team

21. LESSON #10: ENJOY THE RIDE
‣ The right junior developer can bring a lot of enthusiasm,
energy, learning, and commitment to the team
‣ Coaching & mentoring a junior developer can be
extremely rewarding for more seasoned team members
‣ The process of growing a junior developer creates many
opportunities for reflection, feedback, improvement, and
growth as a team
‣ Junior developers who receive intentional mentorship,
coaching, and support tend to have strong loyalty to the
team, their teammates, and the company

22. QUESTIONS?

23. ERIKA
CARLSON
@eacarlson
erika@detroitlabs.com