How to Develop Your Boot Camp Engineers

Bootcamp is like a box of chocolate.

There’s the computer scientist who understands theory but can’t code. There’s the lifelong banker wanting a career change. There’s the fresh-faced 20-year old looking to work in big tech.

While these boot campers have a lot to offer, they typically lack some crucial skills too.

However, because software developers are scarce, companies need to learn to embrace these boot campers…with one caveat.

You need to have a strategic, organization-wide process for developing your boot camp developers into well-rounded, knowledgeable team members.

If you do this well, you should get a nice return in the form of diverse team members, industry-specific knowledge, and improved retention rates.

“Individuals coming from non-traditional backgrounds (boot camp grads) can offer really valuable perspectives when developing software. The guy or gal with the CS degree may have immense technical knowledge, but they also may miss something that appears obvious to an outsider.”

– Phil, SR Developer & Code Forward Instructor

Devetry has led all types of product development teams, working with rookie developers and the most senior computer scientists. Based on both party’s feedback, we’ve created this guide to developing your boot camp developers.

A Post-Boot Camp Curriculum

For most boot campers, there are two categories in which they lack the knowledge and/or experience: computer science principles and a broader category which we’ll refer to as dev-ops. Here are the things they need to know to rise to the next level.

Computer Science Principles

Most boot camp grads come out of their programs knowing how to develop and deploy a web app. However, they may lack knowledge in computer science principles that will help them scale, optimize, and maintain their code. Here are a few common CS principles that may be useful to cover with recent boot camp grads:

Dynamically-Typed, Garbage-Collected Interpreters

Most graduates will be able to spin up an application in JavaScript, Python, Ruby, or another dynamically-typed, garbage-collected, interpreted language. They may even be able to develop a small Single Page Web Application faster than some senior engineers.

But what happens when you need those same boot camps grads to write a microservice or two in GO, modify a legacy C# app, or build out an internal tool written in Rust? Without developing their knowledge of lower-level code, their versatility will remain limited to what they learned in their boot camps.

Common Data Structures and Time Complexity

Most grads will have a notion of what time complexity is and why, for example, nested for loops should be avoided.  However, they may not though have a handle on what data structures to reach for when solving a particular problem, or what built-in method calls may be slowing their app down.

Discussions around the pros and cons of implementations to a problem can be a great way to start. Senior engineers can help boot camp graduates by taking time to go over the following commons structures as well as their methods and associated time complexities:

• Stacks
• Queues
• Hash Maps
• Linked Lists
• Trees
• Arrays

Dev Ops: Architecture, Networking, Deployment, and Testing

Application Architecture

Few people care about architectural decisions until they become a problem. Though boot camp graduates may be well versed in the traditional front-end, back-end, database “stack”, they’re likely less familiar with more exotic patterns.

But again, what happens when you want to take your API and deploy it as part of an auto-scaling cluster? If it’s managing state, memoizing data, or managing user sessions, you’re going to have a bad time. Having recent boot camp grads draw up architecture diagrams and discussing the strengths and limitations of each design can be a great place to start.

Testing

Recent grads have likely worked on small projects where they know every inch of the code. In these scenarios, testing is often a luxury.

However, if a boot camp graduate begins working at a large company, it’s impossible for them to be familiar with the entire codebase. This is when testing becomes a necessity, and it can be quite a change for less-experienced developers to write meaningful tests. Monster classes and tightly-coupled code often makes meaningful testing harder than it should be. Talk to your engineers about the separation of concerns and testability. Teach your grads to write testable interfaces with few side effects.

Patterns like the “Functional Core, Imperative Shell” can be a great place to start.

CI/CD Pipelines

Testing is only as good as how often those tests get run. The last thing you want as a leader is to find out that your product is riddled with bugs because your carefully-crafted tests aren’t even running! Going over how to set up a CI/CD pipeline from scratch with recent graduates can be a great way for them to learn how and where automated tests are running.

“The most valuable lesson I learned going from boot camp grad to senior engineer was that my previous career skills weren’t going to waste.

Going into the bootcamp and even after graduation, I had the mindset that I was “starting over” with my career but really I was just gaining new technical skills. Having previous experience in a financial office setting gave me a chance to practice other skills such as communication, cross-team collaboration, conflict resolution, and even business etiquette. I’ve been fortunate to realize that I can lean on those skills to find success as a software developer.”

– Adrian, SR Developer & Boot Camp Grad

How to Teach These Skills

There are many ways an organization can teach these principles to boot camp developers, and all can be successful if implemented correctly. Here are some options.

Weekly One-on-Ones

One-on-ones can be incredibly useful. These give jr developers the opportunity to showcase code that they’re working on to other technical team members.

Many boot camp developers will write technical code that only they can decipher, but part of being a good developer is writing code that others can read. One-on-ones force developers to explain their code and communicate with other team members.

Group-Based “Office Hours”

You can also schedule weekly office hours where a group gets together and discusses complex engineering topics. A mix of jr, mid, and sr developers is necessary to facilitate helpful conversation.

Devetry has done this using a Google sign up sheet where anyone can request a particular subject.

Technical Book Club

A book club is something typically done in a developer’s spare time, so it may or may not work for your team. However, it encourages both reading and discussion of advanced engineering topics. Here are some books titles that would be interesting reads:

• Game Programming Patterns by Robert Nystrom
• A Philosophy of Software Design
• The Pragmatic Programer
• A collection of articles from https://2ality.com/

A Final Note

Whether you choose one-on-ones, groups, or after-work activities, your team development initiatives are only as good as the leaders running them.

Your most senior developer or talented contributor may not be the best teacher. Therefore, it’s important to choose not only strong technical leaders but those who have a desire and talent for teaching.

Work at Devetry

Whether you’re a boot camp graduate or have a desire to develop them, Devetry is hiring! We’re looking for all levels of software engineers, so check out careers and apply today.