Coding School Graduates and Market Saturation

Coding schools abound these days, and there are now a proliferation of schools designed to handle many backgrounds, aspirations, and cost models. Most people who aspire to be a software engineer today can find a place to learn, and with some work, can find a job. But what happens as the market becomes more and more saturated with coding school graduates?

Differentiation for a Naïve Market

Today, coding schools attempt to differentiate themselves for the sake of their graduates ability to get positions, or choose to opt out of that metric entirely. Everyone wants to be the "Harvard of Hack Schools", or the main supplier of diversity candidates. These methods of differentiation are a bandaid that addresses the question "will our graduates be able to get jobs" with the answer "of course, because they are different than other schools' graduates".

The market for new, junior software engineers today has a cap. As junior engineers mature into mid and higher level developers, leave the industry, found companies and make lateral moves, turnover keeps positions for junior developers open. However, junior engineers are (locally, in silicon valley at least) being produced at a faster rate than those positions are being created. No amount of amazing programs or creative, inspiring teachers can produce candidates that can enter a senior position without the experience they need. So what do we do? Turn down the throttle on junior developer production? We can't very well do that, as we're in a "baby boom" period in software - this happened in the last bubble, and when it burst we had homeless engineers and a mass exodus towards the midwest, where smaller, less well paid, semi-stable jobs awaited.

The market for junior engineers looks a lot like the western logging and mining efforts that ravaged our natural resources last century. There's wealth out there, and the market is going to reach for it. Asking people to produce less, strive less, and leave opportunity on the table is unrealistic and unfair. Fortunately, "replanting" and "conservation" efforts need not be as slow coming, nor as painful for the industry.

An Educated Market Is Bigger

I believe the answer is in preparing the market to receive and contribute to the rapid growth, and success, of candidates produced by coding schools. Recently I wrote about onboarding junior developers, and efforts to this end will help companies capitalize on a talent pipeline that will only grow larger and more sophisticated as time wears on, as well as stabilize the exit point of this pipeline for junior talent. 

However, the onus is not solely on companies to provide stellar onboarding experiences. It lies on both the community, in providing stable, encouraging mentorship, and on the coding schools themselves. Coding schools can offer many things to graduates, from career counseling services to ongoing education in order to make their skills not just broad, but relevant to their specific employer. The biggest thing they can do is spend time educating companies on how to best use their graduates. 

Coding schools teach widely different things, which create a thousand different vocabularies around what junior developers have learned. Some teach the Twelve Factor App, some teach MVC religiously as though it is the only programming paradigm that works. Some teach as agnostically as possible, leaving students to navigate and assert the usefulness of different technologies on their own. These different ideas and paradigms produce diverse candidates that can navigate the spectrum of the market's needs, but what they don't often realize is that their messaging around their curriculum is often the entry point of understanding that companies have about a candidate. You can say "we taught them Python, and how MVC webapps are built", and that sets a company up with both expectations, and explains what still needs to be taught. 

Schools should standardize not their curriculum, but the language that describes the approaches they take, as well as what students can say that they know upon leaving. This doesn't need to be controlled by a committee or ruled by bureaucracy, but can simply be defined by communicating clearly what "they know Javascript" means. does it mean they can manipulate the DOM? Do they understand prototypal inheritance? A good breakdown of what exercises were done, what concepts are covered, and what proficiency means to the school itself can prepare a company for a candidate on the interview side, and once they've begun working. 

Most coding schools have "partner companies", with which they enter both a monetary, but also a trust arrangement. This arrangement means usually that schools receive a recruiting fee, and get first access to graduates, improving chances of a match. The arrangement benefits the school and often is the reason they can keep their doors open. The arrangement only marginally benefits the company, however, and often does not benefit the candidate other than by doing a mass of introductions, and gives them an idea about what kind of company they might like to work for.

I encourage coding schools to prepare material that can help the onboarding process easier for candidates. Sharing the broad curriculum with partner companies, and educationally-minded suggestions about on the job training based on how their students are prepared during the program will help graduates be more successful, helps partner companies hire more and more effectively, and further solidifies the ideals encapsulated in the term "partner".

I'm available for consulting work in this area, and the next few months of my life I'm going to be collecting a series of case studies to test the point that an educated market is better for everyone. If you're interested in providing a case study, or interested in consulting, drop me a line at 

Onboarding Junior Developers

3 months after leaving Hackbright, and I'm still running triage for many of my students who've been hired in the past 6 months. Not that partner companies are mistreating them, or that their skills aren't up to snuff. Most of my triage stems from a lack of real mentorship. Everyone knows that "time-to-useful" with any engineering hire is usually around 2-3 months, but no one really understands what is happening during that time that takes so long, and why some people don't really make it. 

So I'm going to write a book about it.

In this book, I'm going to discuss some of the programs I've seen work, ways they could be better, and most importantly, how to make junior developers useful, quickly, while making sure they understand how their performance actually is throughout the entire process. There will be case studies, research, fun charts and graphs and instructions on how to cost-and-time-effectively hire and onboard junior developers.

But this is a blog post, not a product announcement, so I'm going to drop some insights on you before that. 

A culture of teaching


How many mid-to-senior level developers reading this right now feel like they know everything they need to know to do their job? That they could functionally program without any reference materials, or debug without Google? Anyone who raised their hands probably doesn't work well with junior developers. 

Everyone who didn't raise their hands understands that knowing isn't the important part, reasoning is. Mentorship makes up the space between a productive jr. developer, and an unproductive one. Mentorship mostly consists of style guidance, help in navigating the typically awful reference materials for a given language, and institutional knowledge about the codebase and it's quirks. Junior developers need this, and it's a people skill to be a good mentor. Not everyone is suited to mentorship, but those that are can multiply the output of a junior developer by their own, and end up with much more than either would have produced alone.

Mentors should plan to spend at least 8 hours a week with a junior developer for the first month of their employment, and 5-6 hours for the next two. That's at least an hour a day, preferably in the morning. This should mostly be spent pair programming, or doing an overview of what you expect them to be able to do, and how they might go about doing it. Usually, an honest end-of-day check in is also important, but this can be done over email. Encouraging honesty about what they are having difficulty with is imperative, so that you can give further reading, or explain concepts that might not yet have solidified.


Fostering a culture of learning doesn't end with mentorship, however. Everyone on the engineering team is a learner, and everyone has the capacity to share knowledge. Having workshops and lunch sessions taught by your engineering staff helps encourage senior staff that sharing their knowledge is important, and helps set expectations that it's not just up to them to handle the hard stuff. Teach a mix of beginner and advanced topics, such as explaining how the complex recommendation engine you use works, as well as a primer on your front-end JS framework. This prevents siloing, and also helps jr. developers to feel they can be honest about their actual skill level. You want to foster the idea that you don't expect them to just know, but that you expect them to ask. Junior developers should also be expected to teach, and asking them to explain in depth things you know they will have had to learn on the job will help them with both their credibility and confidence. 

Re-teaching language fundamentals is a good idea- most developers have to learn a new language for their first job, and going over both basic and advanced techniques will help new developers become more effective, faster. You can lean on your existing talent to do this, over lunches and in afternoon sessions, but you may be able to bootstrap it by inviting user groups to put on classes in your office in the evenings. Asking your junior talent to teach things they don't yet have confidence in causes them to investigate deeper, think more critically, and helps others. Having junior talent do a series of short talks that other junior staff is required to attend allows you to parallelize the effort they're individually putting in, as well as give them expectations to measure up to.

Hiring In Groups

Junior developers work best together, in pairs. Hiring a group of 2-6 (or more, if you have the budget and inclination to take on "classes") can be many times more effective. When working together, two jr. developers can more easily ascertain if they need help, learn faster, and have twice the working memory space. When hired together, most jr. developers are net positive twice as fast than when hired alone. 

New developers need someone who they can realistically compare their knowledge against, and who they can freely toss ideas around with. Many jr. developers don't feel comfortable or feel intimidated by other members on their team, out of a feeling that they are wasting time, or their ideas are primitive and too obvious. Most developers probably can remember a time they didn't speak up because they thought their idea was too obvious (and obviously wrong) and so hadn't been covered by the team, only to bring it up later and be told they could have saved everyone a lot of time.

Setting (real) Expectations

Honestly discussing and setting productivity milestones within the first few weeks are extremely important. Understanding what is expected of them in terms of productivity is important, because most new developers will spend most of their time learning the skills they need to accomplish what is expected of them, and they need to know if (for instance) they need to spend more hours at work getting things done, or if they can go home and learn more about the skills their job demands, or if they can rest their brains. 

Realistic milestones are important - if you feel like your junior developers should be blowing away your milestones, then your expectations aren't real, they're just a minimum that you'll ultimately be disappointed in. 

Hiring a consultant

Ultimately, these things are hard to implement. It's tough to look at your existing team, and know who will make a fantastic mentor, what your junior talent should be learning (and teaching themselves). It's hard to know what they'll be capable of 2 months from now, based on where they are now. Hiring an engineering onboarding consultant, or an educational consultant, can be a fantastic option for those running teams strapped for time, or whose teams lack the empathy capital to spend on hours of mentorship. 

Fortunately, consultants exist who can do this kind of thing. I'm one of them (shameless plug) and can help you design an onboarding process, or help your existing onboarding process accommodate developers from a more diverse set of backgrounds than it currently does. These processes can help your existing team save time, identify stars (and bad apples) faster, and help foster the growth of your entire engineering team. 

If I can help, shoot me an email at