What is software testing?
A plain-English introduction to software testing: what it really means, why software breaks, and what a tester actually does all day.
Imagine you just built a paper plane. Before you show it off, you throw it a few times. Does it fly straight? Does it nose-dive? Does the wing fold? That quick check before you trust it in front of others is, in spirit, exactly what software testing is.
Software testing is the practice of checking whether software does what it is supposed to do, and gracefully handles what it is not supposed to do, before real people rely on it. You try the software the way a user would, look for the places it misbehaves, and report what you find so it can be fixed.
Testing is asking a piece of software a lot of questions (What if I do this? What if I leave this blank? What if I click twice?) and carefully noticing when its answers are wrong.
Why does software even break?
Software is written by humans, and humans make mistakes. A modern app is built from thousands or millions of lines of instructions, written by many people, changed constantly, and run on devices the authors never owned. With that much moving around, things slip:
- A developer misunderstands what was being asked for, and builds the wrong thing correctly.
- Two features that each work fine clash when used together.
- Code that worked yesterday breaks because something else changed today (this is so common it has a name: a regression).
- The software meets a situation nobody imagined: a name with an emoji, a 2 GB upload, a user on a train losing signal mid-payment.
None of these mean the team is bad at their jobs. They mean software is genuinely hard. Testing is how we catch these problems on purpose, in a safe place, instead of letting a paying customer find them by accident.
A tiny example
Say a website has a login form. A developer builds it and it works: they type their email and password, click Log in, and they're in. Done? Not even close. A tester starts asking the awkward questions:
- What if the password is wrong: do I get a clear, polite message, or a scary crash?
- What if I leave the email empty and click Log in?
- What if I paste a password that is 500 characters long?
- What if I type my email in CAPITALS: does it still recognise me?
- What if I click Log in five times fast: do I get logged in five times, or charged twice somewhere later?
Each question is a small test. The developer asked "does it work?" and stopped at the happy answer. The tester asks "how could this go wrong?", and that change of mindset is the whole job in a nutshell.
A useful habit from day one: for every screen, write down the happy path (everything goes right) and then at least three unhappy paths (empty fields, wrong data, doing things out of order). The unhappy paths are where the real bugs hide.
What does a tester actually do all day?
"Testing" is not just clicking around hoping to spot something. Good testing is deliberate. A tester's day usually mixes these activities:
| Activity | What it means in plain words |
|---|---|
| Understand the feature | Read what was asked for, and figure out how a real person would use it. |
| Design tests | Decide which checks are worth doing. You can never try everything, so you choose wisely. |
| Run the tests | Actually try the software, by hand or with a script, and watch closely. |
| Report bugs | When something is wrong, write it down so clearly that a developer can reproduce and fix it. |
| Re-check fixes | After a fix lands, confirm it's truly fixed and that the fix didn't break something else. |
Notice that two of these five are about thinking and writing, not clicking. A big part of being good at QA is communicating clearly: a bug nobody can reproduce rarely gets fixed.
Testing vs. "Quality Assurance" (QA)
You'll hear these two terms used almost interchangeably, and for now that's fine. There is a subtle difference we'll explore later: testing is the act of finding problems in a product, while quality assurance is the wider practice of building good habits and processes so fewer problems happen in the first place. Testing checks the cake after baking; QA improves the recipe and the kitchen. You can be a great tester without worrying about that distinction today.
Where this guide goes next
Now you know the core idea: testing is asking good questions and noticing wrong answers. Next we'll look at why testing matters so much (including a famous, eye-watering example of what happens when a bug escapes), and then we'll start picking up the precise vocabulary the industry uses, one term at a time.
- Software testing is checking that software does what it should, and copes with what it shouldn't, before real users depend on it.
- Software breaks because it is built by humans, changed constantly, and used in situations no one predicted.
- The tester's superpower is a change of question: from "does it work?" to "how could this go wrong?".
- Great testing is as much about clear thinking and clear writing as it is about clicking.