What is software testing and why does it matter?
Testing is how a team finds out whether software does what people need, before users find out the hard way. Here's what it is, what it isn't, what it checks and why it's worth the effort.
Every article is short, practical and tagged by level. Filter to find what fits you.
Testing is how a team finds out whether software does what people need, before users find out the hard way. Here's what it is, what it isn't, what it checks and why it's worth the effort.
Seven short ideas that explain why testing works the way it does, from 'you can't test everything' to 'bug-free isn't the same as useful'. They're in every ISTQB Foundation exam and in many junior interviews.
What testers really do, the skills the job needs, how to keep getting better and where the career can take you. A practical guide for anyone thinking about becoming a tester.
Testing job titles are confusing because no one standardised them. Here's what each common title usually means, how they differ, and how to read a job ad to see what the role really is.
People use these four words as if they meant the same thing. They don't. Knowing the difference helps you write better bug reports and find out why problems happen.
Software goes through the same basic stages, whatever method a team uses. Here's what those stages are, where testing fits into each one and why testing only at the end is risky.
Testing isn't one activity but a sequence: understand what to test, plan, design tests, prepare the environment, run them, report and close. Here's each STLC phase, its entry and exit criteria, and how it looks in an Agile team.
Most testing jobs are in Agile teams, and most of those use Scrum. Here's what sprints, stand-ups, backlogs, user stories and story points mean, who does what in a Scrum team, and what a tester's two weeks look like.
Software is tested in layers: single pieces, pieces working together, the whole system and finally whether it's acceptable to users. Here's what each level checks and who usually does it.
Functional testing checks what the software does. Non-functional testing checks how well it does it: speed, security, accessibility and more. Users need both.
Every test design technique belongs to one of three families: black-box (based on what the software should do), white-box (based on how the code is built) and experience-based (based on the tester's knowledge). Here's what each is, when to use it, and the techniques in each.
Verification asks whether you built the product right. Validation asks whether you built the right product. You can pass one and fail the other, so you need both.
You can find bugs without running a single line of code, by reading requirements, designs and code carefully, alone or together. Static testing is often the cheapest testing there is.
Every test should trace back to something the product must do. Learn how to read requirements like a tester, spot the ambiguous and untestable ones, and use a traceability matrix to show what's covered, what isn't, and what a change affects.
Acceptance criteria say when a user story is done. Written as concrete examples, in the Given/When/Then style of BDD, they become shared understanding, test cases and, often, automated tests, all at once.
Three documents testers talk about all the time, at three different heights: the overall approach, the plan for one project and the single check. Here's what each one is and how they fit together.
A good test case can be run by anyone, gives the same verdict every time and checks one clear thing. Here's what to include, the mistakes to avoid and a before-and-after example.
You can't test every possible input, and you don't need to. Equivalence partitioning groups inputs the software should treat the same way, so one test can stand for the whole group.
Bugs love edges: the last allowed value, the first forbidden one, the switch from one rule to the next. Boundary value analysis tells you exactly which values to test there.
Exploratory testing means designing and running tests at the same time, using what you learn to decide what to try next. It finds the bugs nobody thought to script. Here's how to do it with focus.
Thinking like a tester is a set of habits you can learn: questioning assumptions, imagining different users, asking 'what if?' and noticing what's odd. Here are the habits and the quick checklists testers use.
A bug report is how a problem you found becomes a problem someone fixes. Here's what to put in it, a template you can reuse and the habits that get bugs fixed faster.
Every bug moves through a series of statuses: New, Assigned, Fixed, Retest, Closed, and sometimes Reopened, Rejected, Duplicate or Deferred. Here's what each status means, who moves the bug, and what the tester does at each step.
Severity is how much damage a bug does. Priority is how soon it should be fixed. They often match, but not always, and the cases where they don't are the ones that matter.
After a change, two questions matter: is the bug really fixed, and did the change break anything else? Retesting answers the first. Regression testing answers the second.
Two quick checks you'll hear about in every team. A smoke test asks 'is this build stable enough to test at all?' A sanity test asks 'does this specific change work well enough to go on?' Here's the difference.
Clients and servers, URLs, DNS, HTTP requests and responses, status codes, cookies and sessions. The basics behind every web app, explained for testers, so you can tell where a bug lives and describe it precisely.
Every modern browser has built-in developer tools. For a tester, they turn 'it doesn't work' into evidence: the failing request, the JavaScript error, the wrong cookie, the slow file. Here's how to use the Elements, Console, Network, Application and device panels.
Almost every testing job uses a tracker like Jira or Azure DevOps. Learn the issue types and fields you'll fill in, how workflows and boards work, simple JQL searches, and where test cases live, so you're productive from your first week.
Software runs in several copies before it reaches users: development, test, staging, production. Learn what each environment is for, why bugs appear in one and not another, how to check which version you're testing, and why environment differences cause real disasters.
The screen says the order was saved. Was it, really, and correctly? A little SQL lets you check what the application actually stored. Good test data makes your tests realistic, repeatable and safe.
APIs are how apps talk to their servers, and testing them is one of the most requested skills in junior QA ads. Follow along with a free practice API: send requests, read responses, write your first automated checks and run a whole collection.
Manual and automated testing aren't rivals. Each is good at different things. Learn what each does best, what automated tests look like, how to decide which one a check needs and what it means for your career.
The test pyramid is a simple picture of how to balance automated tests: many small, fast ones at the bottom and a few big, slow ones at the top. Here's what each layer means and why the shape matters.
A hands-on walkthrough for complete beginners: install the tools, write a login test against a public practice site, make it fail on purpose, read the report, and put your code on GitHub so employers can see it.
Real features have several inputs, hidden limits and boundaries the screen never shows. Here's how to combine partitions without testing every combination, find the partitions nobody wrote down and measure what you've covered.
Knowing the pyramid is easy. Applying it takes test doubles you can trust, contract tests between services, a shape that fits your architecture and a pipeline that gives fast feedback. Here's how.
Risk-based testing decides what to test, how deeply and in what order, based on what could go wrong and how much it would hurt. Here's how to identify risks, turn them into tests and report the risk that's left.
When a result depends on several conditions at once, decision tables list every combination and the expected outcome. They turn tangled business rules into clear test cases, and expose the rules nobody wrote down.
Orders, accounts, tickets and subscriptions move through states. State transition testing checks every allowed move, and makes sure the forbidden ones really are forbidden.
Users don't use features one at a time. They pursue goals, get interrupted and take detours. Use case testing covers every path to a goal; scenario testing tells realistic stories that combine them.
Browsers, languages, payment methods, user types: the combinations explode quickly. Pairwise testing covers every pair of values with a small fraction of the tests, because most bugs are triggered by just one or two factors.
Exploratory testing finds great bugs, but managers ask: what did you cover, and how much is left? Session-based test management answers that with charters, time-boxed sessions, session sheets and short debriefs.
A test strategy is the team's shared answer to 'how do we test here?'. Here's how to build one step by step: understand the context, choose the approach, decide who does what and keep it short enough that people actually use it.
How long will testing take? Nobody knows exactly, but you can give a reasoned answer. Here's how to plan the testing of a release and estimate it with techniques that work, including how to communicate uncertainty.
Most of an application's logic sits behind its API. Testing there is faster, more stable and more thorough than through the UI. Here's what to check, how to structure API tests and the security checks every tester should run.
UI testing goes wrong in two ways: people mindlessly clicking through scripts, and automated suites that break whenever a button moves. Here's how to test the UI thoughtfully, manually and automatically.
In Agile teams, testing isn't a phase or a department. It happens every day, inside the team. Here's how testers work in Scrum events, how the Agile testing quadrants guide what to test and how to avoid a mini-waterfall in every sprint.
Shift left means finding problems earlier: in requirements, design and code. Shift right means learning from production safely: staged rollouts, feature flags and monitoring. Good teams do both.
In a CI/CD pipeline, every change is built, tested and ready to release within minutes. Continuous testing makes that safe: the right checks at each stage, quality gates that mean something and a pipeline people trust.
Performance testing answers 'is it fast enough, for how many people, for how long?' Here are the main types of performance test, the numbers that matter, how to design a realistic test and the traps that make results meaningless.
You don't need to be a hacker to find security bugs. Many serious flaws are found with a tester's mindset, two test accounts and the browser's developer tools. Here's what to check, the tools that help and the rules you must follow.
Accessibility testing checks that people with disabilities can use the product: with a keyboard, a screen reader, zoom or captions. Here's the standard to test against, the checks every tester can do and how tools and manual testing fit together.
Phones bring problems desktop web doesn't have: thousands of devices, OS versions, interruptions, permissions, flaky networks, app updates and store releases. Here's what to test, how to choose devices, and which tools teams use.
A flaky test passes and fails without any code change. Left alone, flakiness destroys trust in the whole suite. Here's how to find the causes and fix them systematically.
Beyond the likelihood × impact grid: where risk matrices mislead, how FMEA, hazard analysis and threat modelling find risks a workshop misses, how to use data to estimate likelihood and why the assumptions behind a risk assessment need testing too.
Every test suite is a tiny sample of an effectively infinite space of inputs, states and environments. Treating testing as sampling explains why 'enough' is a decision about risk and confidence, and gives you tools to make that decision with numbers.
Running a test is easy; deciding whether its output is right is the hard part. That's the oracle problem. Here are the kinds of oracles testers use, from specifications to differential and heuristic oracles, and how each can fool you.
Code coverage tells you which code your tests ran, not whether they would notice if it were wrong. Mutation testing deliberately plants small bugs and checks whether your tests catch them. It's the most direct measure of test suite strength we have.
Running every mutant against every test is impossible for a large codebase. Here's how teams make mutation testing practical: mutate only what changed, run only relevant tests, filter unproductive mutants and show results where developers already work.
Instead of writing individual examples, you state rules that must hold for all inputs and let a tool generate hundreds of cases, then shrink any failure to its smallest form. Property-based testing finds the edge cases you didn't think of.
When you can't know the correct output for a single input, you can often know how outputs should relate across inputs. Metamorphic testing checks those relations, and has found bugs in compilers, search engines, simulations and machine-learning systems.
Instead of writing test cases one by one, you build a model of how the system should behave and let a tool generate the tests, and often the expected results too. Here's how model-based testing works, where it pays off and what it costs.
Pairwise is a start. Real systems have dozens of parameters, constraints between them and risks that need 3-way or higher coverage. Here's how to model large input spaces, choose strengths, handle constraints, measure the combinatorial coverage of existing tests and run it all in CI.
Real systems aren't simple state diagrams. They have variables and guards, nested and parallel states, timeouts, restarts and recovery modes. Here's how to model them, which coverage criteria find which faults and how to test the transitions that bring whole networks down.
Distributed and concurrent systems fail in ways ordinary tests never reach: partial failures, reordered or duplicated messages, clock skew and rare race conditions. Here's how experts test them, from race detectors and fault injection to Jepsen-style analysis and deterministic simulation.
Systems fail in production whether you plan for it or not. Chaos engineering injects failures deliberately, as controlled experiments with a hypothesis, a small blast radius and an abort button, to find weaknesses before they cause outages.
With dozens of services deployed independently, end-to-end environments become slow, fragile and always out of date. Contract testing checks every consumer–provider pair in isolation and tells you, before deployment, whether a change is safe to release.
Logs, metrics and traces aren't just for operations. They're test oracles you can assert on, a map of how the system is really used and the only way to verify behaviour that only appears in production. Here's how expert testers use observability.
In event-driven systems, requests return before the work is done, messages arrive twice or out of order and services agree only eventually. Here's how to test delivery guarantees, idempotency, ordering, schema evolution and eventual consistency without flaky sleeps.
Machine-learning systems learn their behaviour from data, so classic expected-value testing only goes so far. Here's how to test data, models and the systems around them: evaluation on the right slices, behavioural and metamorphic tests, fairness, robustness and monitoring for drift.
Chatbots, assistants and AI agents built on large language models answer the same question differently, can state falsehoods confidently and can be manipulated through their inputs. Here's how to test them: evaluation sets, grounding checks, prompt injection red teaming and monitoring.
Testing samples behaviour; formal methods reason about all of it, within a model. Here's what model checking, specification languages like TLA+ and proof-based verification can do, what they can't, and why testers are well placed to use them.
Coverage percentages are easy to measure and easy to misread. Test adequacy asks a harder question: is this suite good enough to catch the faults that matter? Here are the main adequacy criteria, what research says about them and how to build a trustworthy picture.
Quality engineering moves the focus from finding bugs at the end to building quality into how software is designed, delivered and run. Here's what changes for testers and teams, which measures matter and how to lead the shift without losing what good testing does best.