10 Considerations When Hiring a Code School Graduate

Code schools are the tech industry’s greatest hope of closing the labor gap and increasing diversity (gender, racial, and cognitive) within the workforce.

The graduates of code schools have actionable skills. In most cases, they acquired them at a lower cost and in less time than their more traditional counterparts.

Yeah, it’s still a little risky.
Yes, it’s untraditional.

It’s also the future of learning. Practical skills BEFORE theoretical knowledge.

I’ve outlined the my top 10 considerations for employers hiring code school graduates.

Whether you are considering hiring a code school graduate or preparing your first onboarding experience, there is something here for you.

  • Communicate Early and Often
  • Look for Hidden Abilities
  • Find the Right Behaviors
  • Start with Education
  • Push Git Skills
  • Limit Permissions, not Potential
  • Teach Tools
  • Remove Barriers
  • Account for Technical Debt
  • Be Patient

Communicate Early and Often

Expectations minus communication equals frustration. There are a lot of benefits to hiring a code school graduate. Excluded from the list is there ability to mind-read. If you have expectations, those should be communicated with early and often.

It seems obvious, but the burden of communication compounds in engineering. Clear communication is key to them turning around and relaying those expectations to the computer.

Under communication is the most common cause for frustration.

Look for Hidden Abilities

Code School students had a life before bootcamp. What was it? It’s easy to discount their lack of technical skill or abilities but there is more value than coding. I’ve hired code school graduates with who worked for the United Nations, military trained, remarkable graphic design skills, people management backgrounds, education instructors, and more.

Many code school students have entire careers. Diversity of thought and experience is one of the largest factors of being a good problem solver.

Find the Right Behaviors

I’ve been hiring code school graduates since 2015. These are a few patterns I’ve noticed among those who performed best:

  • Demonstrates excitement about learning.
  • Demonstrates curiosity about new information.
  • Dabbles with side projects (active learning, explore rabbit holes)
  • Pursues education outside of class.
  • Shows Initiative (attends study sessions, mentors other students)

It’s worth noting, these are specific to technical skills. That’s on purpose. Early in anyones career, I’ve found more value in betting on the right person and behaviors.

Someones starting skills are weaker prediction of success.

Start with Education

Of course, we would love someone with 12-16 weeks of training to jump right into billable work. That’s an unreasonable expectation. While there are some who might succeed, I’ve found leading with education a more predictable path to success for code school graduates.

We actually created a scorecard that outlines the areas we expect them to become proficient over time.

Checkout the Score Card

Push Git Skill

Version control is essential for working on an engineering team. Commits, Pull Requests, and Branching is a key part of collaboration. Most code school graduates come to the table with limited knowledge about the extent of version control.

I’ve found git skills to be the best place to start a code school graduate. If they learn it early and use it often, it will save countless pains later.

Limit Permissions, not Potential

We hired a code school graduate. 2 months later, they reset a client’s production database. This was not their fault, it was mine. We gave them too much control, too early, without coaching them on the power they had.

I’ve regularly been asked it the team member was fired.

Oh course not! All the data was able to be recovered and I can guarantee they’ll never make that mistake again.

Teach the Tools

Your companies has a lot of tools that have nothing to do with software engineers writing better code. Here are a few categories:

  • Notes (Notes, Evernote, Bear, Obsidian …)
  • Text Editor (Sublime, Textmate, VIM …)
  • Project Management (Jira, Asana, Basecamp …)
  • Source Code (Github, BitBucket, GitLab …)
  • Dev Ops (Heroku, AWS …)
  • Chat (Slack, Teams, Hipchat …)
  • Docs (Docs, Word, Notion …)
  • Calendar (iCal, Google Calendar …)
  • Video Call (Zoom, Hangouts, Slack …)

A lack of clarity here can be disorienting for new hires. Effective onboarding should account for communication and training round these. The rest of your team will probably thank you to.

Remove Barriers

Companies are filled with distractions. Few organizations prioritize focus and remove distractions. The average team member within a business would be luck to get 1-2 hours of uninterrupted time.

A companies regular motions can be massive barriers to early stage professionals or those also trying to make sense of a complex job, like programming. The cost of context switching for code school graduates is high. It has nothing to do with intelligence, but is the weight of being a novice.

Meetings, emails, slack messages, checkins, etc. Context switching counts triple for early stage professionals, which is where code school graduates are.

Account for Technical Debt

Do you have legacy code you need maintained? Expect friction. Legacy systems are often filled with expired plugins, unused code, outdated conventions. Every ounce of complexity they inherit is worth pounds of problems. As you planning their ramp toward a meaningful contributor, technical debt should be considered a multiple, not a percentage.

Is there housekeeping you can do ahead of time? Where might you reduce the complexity before expecting them to get oriented.

Be Patient

Software engineering isn’t manual labor. It is knowledge work. It takes time to understand deeper nuance within programming and your unique business case. There will be mistakes and missteps. That is part of learning.

Get notified as soon as new content becomes available. Stay in the loop.