TESTING & DEBUGGING / LESSON 01

Why Testing Matters.

Understanding why testing is essential for building reliable software

Written by Andrew Lee JenkinsPublished Oct 5, 202610 min readFree lesson

Say you're building a bridge. Would you just slap some steel beams together and hope it holds once the cars start rolling over it? Uh, no. You'd test the materials, double check the measurements, and simulate heavy loads LONG before anybody drives across.

Software works the same way. Testing is how you make sure your code actually does what you think it does, before real people are counting on it.

The Cost of Bugs

Bugs get expensive. Money is part of it, and so is your time, your users' trust, and your reputation.

Here's what can happen when software goes out without proper testing.

A botched software release cost a trading company over $400 million in about 45 minutes
An untested update crashed a banking app and locked millions of people out of their accounts
A missing validation check let hackers walk off with personal data from millions of people

I've had my own (much smaller) version of this. A client's Outlook got a Microsoft update, and 49 form-fill notifications just... vanished. The email system said "delivered." Nothing ever hit the inbox. That's 49 people who reached out to a business and heard crickets, and nobody knew until way after the fact.

The Testing Pyramid

Some tests are quick and cheap, some are slow and heavy. Developers stack them in a pyramid, with the fastest (and most plentiful) tests at the bottom.

Step 1. Unit Tests (Bottom - Most Tests)

These test one function or one lil piece of code all by itself. They run in milliseconds and catch logic mistakes early. Think of it as checking every brick before you build the wall.

Step 2. Integration Tests (Middle)

These test how a few pieces work together. Does the login form actually talk to the database the right way? It's like checking that the bricks really stick together with the mortar.

Step 3. End-to-End Tests (Top - Fewest Tests)

These test the whole app the way a real user would use it. Clicking buttons, filling out forms, moving between pages. It's somebody actually driving across the finished bridge.

Confidence to Change Code

Here's the part nobody tells beginners. The biggest win from testing is the confidence to CHANGE stuff. Without tests, every edit feels like defusing a bomb. With tests, you can clean up and rework code without sweating it.

Example

// Without tests: "Will changing this break something?"
// With tests: "Let me change it and run the tests to find out!"

function calculateTotal(items: CartItem[]): number {
  return items.reduce((sum, item) => sum + item.price * item.quantity, 0);
}

// If you have tests for this function, you can confidently
// refactor it, optimize it, or add new features without worry.

Tests and CI/CD Pipelines

On professional teams, tests run automatically every single time somebody pushes code. That's called Continuous Integration (CI).

A typical setup goes like this.

You write code and push it to GitHub
GitHub Actions runs all your tests automatically
If any test fails, the team hears about it right away
Code only gets deployed to production once every test passes

So a whole lot of bugs get caught before they ever reach your users. It also kills off most of those "well it works on MY machine" arguments (you'll hear that one a lot).

Types of Tests Overview

Test Type	What It Tests	Speed	Example
Unit	Single function	Very fast	Does `add(2, 3)` return `5`?
Integration	Multiple parts together	Medium	Does the API save data to the database?
End-to-End	Full user workflow	Slow	Can a user sign up and see their dashboard?
Snapshot	Rendered output	Fast	Does the button render the same HTML as last time?
Performance	Speed and load	Varies	Can the app handle 1000 users at once?

TL;DR

Testing keeps expensive bugs from reaching production
The testing pyramid helps you balance the different kinds of tests
Tests give you the confidence to rework and improve your code
CI/CD pipelines run your tests automatically on every push
Each type of test has its own job

What's Next?

So that's the why. Next lesson is the hands-on part... you'll write your very first unit tests with a modern testing framework.

Loading the lesson…

Loading activities…