Professional Developers Write Testable Code

Don't stagnate in your career because you never learned how.

View Cohort Options

Your Bootcamp Didn't Teach You How

Your bootcamp didn't prepare you to write tests for your code. None of them do. There's simply not enough room in a 3 month curriculum to teach testing in any meaningful way. But every time you sit down and try to learn it yourself, you're stymied by the task.

Which libraries should you use?

Do you really need to write your tests before writing your feature code?

What exactly should you be testing?

Is it worth all of this extra time that it takes to write the tests?

You know that testing is a necessary skill to advance beyond the junior position that you have now. But you just don't know where to start.

You've read Kent Beck, Martin Fowler, Kent C. Dodds. Maybe you've heard about the Detroit School vs. the London School but don't really grasp the differences. Are they even relevant anymore? When interviewers ask you about testing, you have to admit you don't know how. You got your first job, but what's going to happen when you apply for a more senior position somewhere?

Your bootcamp didn't prepare you for this. It's overwhelming. You know testing is a necessary skill to advance your career, but you continue to put it off just a little bit longer, hoping that eventually it will "just click".

If it feels like you're missing something, it's because you are.

It's not just that you never learned to write tests. Before you can write your tests, you have to understand how to write testable software. You know that feeling when you look at the code you've just written and have no idea how to test it? It's probably because the code itself is untestable. Writing tests for untestable code is always going to be somewhere between frustrating and impossible.

Testing Isn't Magical.
It's a Skill that Takes Practice.

Tests aren't magical fairy dust that you sprinkle onto your code to make it bug-free. Learning to write code that's easy to test--and to write the tests themselves--is just another skill that you have to practice and get good at.

  • What if you knew exactly where to start when you sat down to write your tests?
  • What if you showed up to your next code review with beautifully tested components, and could describe to your technical lead exactly why you made the choices you made?
  • What if you could confidently discuss testing strategies in your next job interview?
  • What if testing was a satisfying and enjoyable part of your development process?
  • And what if you didn't have to learn this all on your own, but could consult with an experienced software engineer and former bootcamp instructor, along with a small cohort of other developers?

You're closer to this reality than you think. You graduated bootcamp. You got a job. You've already proven that you can master complex technical subjects. With some foundational instruction and some practice, you'll be able to apply industry standard testing techniques to the software that you write.

Test Like A Tech Lead: A Course for Bootcamp Grads

I've condensed 12 years of professional experience into seven focused modules that take you from training wheels to writing your own full suite of unit, integration, and end-to-end tests.

Stop worrying if you're doing it right

The best test is the one you actually write. Get past all the minutiae of the academic purists and get down to business

Write testable code like a pro

Writing good tests begins by writing testable code. Learn a simple method for defining the responsibilities and abstractions within your code, making your tests much easier to write.

Self paced, with a lifeline if you get stuck

Work through the course modules at your own pace. With a Slack community and weekly group calls, you'll have plenty of opportunity to ask questions as they arise.

Learn the moving parts of any testing framework

There are common patterns and behaviors to pretty much all testing frameworks. You'll learn how they work so you are prepared to read documentation in your tech stack of choice

Build multiple complete, fully tested features

Loads of exercises--both guided and open ended--mean you'll have plenty of practice writing your own unit, integration, and end-to-end tests

When You Join, You'll Get


Starting with the very basics, I'll take you through the what, why, and how of building an industry-standard test suite for your application


Seven modules each include guided exercises and open-ended prompts to try in your own projects.


As you work through the exercises, you can post questions and discuss with your instructor (that's me!) and your cohort-mates.


Each week we'll have a group call for more in-depth questions, code review, or additional demos

The feedback on my PR was highly praised...”

I followed a test-first approach (as outlined in Module 1 and diagrams in Module 2) for writing the algorithm and I got the block of work done in a day which probably would've taken me 2 weeks in the past. The feedback on my PR was highly praised and we were able to identify pitfalls in the implementation before we shipped.

- Jai Bhagat

Ben's instruction has had the single largest positive impact on my career to date.

Ben didn’t just help me learn. He helped me learn how to keep learning. I find myself quoting Ben’s lectures, feedback, and rules of thumb to junior and senior team members alike. Repetition and pithy sayings are potent tools that Ben used to encapsulate concepts and make them easy for me to access, use, and communicate.

- Aurora Vaughn

Test Like a Pro

Ready to finally learn how?

Choose which cohort option works for you.

Testing gave me credibility as a self-taught software engineer

Hi. I'm Ben Wilhelm. I'm a self-taught software engineer and former bootcamp instructor. I taught myself web development before bootcamps were a thing. When I was first introduced to automated testing, it seemed like a ridiculous waste of time. Why would I take time to write all this extra code when I could just click through my app and make sure it still worked?

As I built more complex software, and as I built it for paying clients and employers, I began to understand the confidence that a good test suite gave me before pushing my code into the wild.

And as I built even more complex software, I started to understand that good software is composed of focused units with clearly defined responsibilities and a coherent abstraction. In other words, you should be able to unambiguously describe the behavior of a given piece of code in a given circumstance.

You know what that's called? That's called a test case.

That's right. Well-written software is testable software.

This was the epiphany that helped me see why so many people struggle with testing. Tests aren't a thing you layer on at the end to describe what you just wrote. Writing testable software is a skill you develop. Once you've learned to write testable software, the tests basically write themselves.

During my time as a bootcamp instructor, the students who "got it", who built the most jaw-dropping capstone projects, who went on to work at Google, AirBnB, and Amazon, were the ones who could decompose their software into testable units with clear responsibilities.

This course isn't about learning a specific testing library. It's about learning to build your software out of testable units. It's about helping you form your own opinions about the many (sometimes contradictory) testing methodologies, and confidently apply or disregard them. It's about making you a better engineer.

I hope you'll join me.

"Test Like a Tech Lead gave me the confidence to write meaningful unit tests in a professional codebase. It also improved my ability to communicate to my coworkers where testing could be added or improved during code review"

- Delilah Clement

"I had the privilege of being a student of Ben's, for a time--he is an extraordinarily thoughtful and effective teacher."

- Jon Kurinsky

"Ben understood when to step back to have us connect the dots ourselves"

- Nirali Shah

Course Outline


Writing Your First Unit Test

In this first module, I'll cover what your test framework is actually doing and how to structure a simple test. You'll learn a quick mnemonic to help you clarify for yourself what your test cases should be testing for, and we'll talk a bit about the ideals of Test Driven Development vs the practicalities of actually learning to test your code.


Writing Testable Code

I've said it a few times already, but you can't test untestable code. With a clear understanding of how a test suite works, we'll now take a look at how to structure your code to make it easily testable. By learning to decompose the architectural components of your application and clearly define their interdependencies, you'll keep the complexity of your test suite in check. Fun fact: this will also make your code less prone to bugs and easier to comprehend!


What to Mock and When

There are multiple (contradictory) schools of thought when it comes to mocking dependencies in your tests, and that can be very confusing when you're trying to self-educate. In this module, we'll work with just two practical guiding principles to help you decide when and how to mock dependencies.


So What Makes a Good Test, Anyway?

All code is a liability, including your tests. How do you make sure that the work you're putting into these tests is actually worth it? Now that you're comfortable writing them, let's focus on writing good ones. This module is all about maximizing the confidence your tests provide while minimizing the effort they require to write and maintain.


Organizing Your Test Suite

Most test frameworks ship with a ton of features for organizing your tests and keeping your code DRY. Unfortunately, naïvely applying these tools will almost alway make your test suite harder to maintain and even unreliable in its reporting. In this module I'll show you how to organize your test files, access data repeatedly even when it needs to be slightly different between tests, and the one and only time it is acceptable to use a beforeEach() hook.


End to End Tests

End to End tests mean different things to different people. (Are you noticing a theme here?) In this module I'll show two different ways that your E2E tests might work depending on how your team is organized. Then, using the same methods we've used to think through unit and integration tests, we'll decide what and how to test in an E2E context.


Putting It All Together

Now that you've done all the pieces, we'll go back and do it all again from the beginning. I'll provide specs to build an additional feature in the app that we've been building, and you'll use the methods from the previous six modules to build it with a full test suite. You can always check in on Slack if you get stuck, and when you're done you can compare your solution to my own implementation.

Who This Course is For

  • You're a coding bootcamp grad in your first two years of employment
  • You're ready to learn new ways of planning and organizing your code in order to make testing easier
  • You've tried to add tests to your code and found it frustrating
  • Your employer is telling you to start writing tests for your work

Who This Course is NOT For

  • You haven't yet landed your first job in tech
  • You want to learn the nitty-gritty details of a specific library/framework/methodology
  • You're looking for a quick reference guide to testing

You're a professional.
Now learn to test like one.

“...he knew how to respectfully interact and stimulate learning.”

Ben was always allowing us to make mistakes and firing back thoughtful questions about our choices. With a wide range of skill levels in the class, from novice to intermediate, he knew how to respectfully interact and stimulate learning.

- Mary Warrick

“...most amazing instructor ever...”

Ben is a most amazing instructor ever met. He is not just giving an answer, but guide students to think right direction, something missing or finding and fix bugs. He gives specific, practical advice whenever I need help.

- Minkyu Yang


Which language and testing library does this course cover?

The course teaches how to think about your code, organize it into testable units, then test those units. It’s agnostic of any particular language or framework but examples will be presented in JavaScript using Jest as our test runner. You are free to use any language and library that you like for the exercises

Will this course help me get my first job in software?

Probably not. If your goal is to land that first job, there are much more efficient ways to spend your time and money.

Does the course cover JUnit/RSpec/PyTest/Jasmine/Mocha etc?

Examples are presented in JavaScript using Jest, but the course will give you a conceptual understanding of how pretty much all testing frameworks work. This way you can confidently approach the documentation and tutorials for your test runner of choice.

If I change my mind can I get a refund?

Absolutely. Simply email me within 60 days of the course start date to receive a full refund, no questions asked.

Will this course help me get a promotion?

That’s what it’s designed to do! If you’re currently in your first job after bootcamp, I’m willing to bet that you were at least a little surprised by the sheer number of things that didn’t fit into your bootcamp curriculum. The subjects in this course are foundational to the kind of professional-level work that will be expected of you in a more senior position.

When does the program start and finish? Will I fall behind?

It starts whenever you start. All content is self-paced and you can work on the exercises at your own speed. Weekly group calls are designed for you to pop in and get answers to your questions or go deeper into a topic.

Does this course cover the specifics of TDD vs BDD vs ATDD vs *DD?

It’s impossible to talk about testing software without talking about Test Driven Development. That said, TDD is just one very prescriptive method to use when writing tests. The course covers the basics of TDD and some of its variants; enough to extract some of the ideas and practices that I think are valuable, and maybe give you some talking points in your next interview ;) The course itself teaches a much more pragmatic method which is appropriate for less experienced engineers.

Cohort Options

Go Alone

For those who want recorded content only, with no interest in personalized instruction or a cohort community.

Accountability Cohort

For engineers who want to get the most out of the course. Multiple channels for communicating with me and with your peers to keep you progressing through the material.

  • Weekly live office hours
  • Slack community
  • Immediate access to
    - recorded lessons
    - exercises
    - Code repository
  • Option to upgrade to an Accountability Cohort
  • Weekly live office hours with me
  • Slack community
  • Immediate access to
    - recorded lessons
    - exercises
    - Code repository
  • Limited cohort size


Sign me up


Sign me up

Ready to Get Started?

Today could be the day that you finally learn to test your software.

You passed it! ⬆️