Skip to content

How We Test — Practical Manual & Automated Approaches

Glossary

Manual testing
Testing done by a person following steps, exploring, or checking behavior directly.

Exploratory testing
Trying things out with intent: learning the system while actively looking for issues.

Automated test
A piece of code that checks another piece of code. It can be run anytime, by anyone, and always behaves the same.

Regression
A feature that used to work but breaks after another change.

Test suite
A collection of tests that can be run together.

Assertion
A small check in automated tests that verifies something is true.

Fixture
A setup step that prepares the environment for a test.

Testing in a real project is a mix of manual checks and automated tests. You don’t have to choose one or the other. Each serves a different purpose, and together they give your team confidence. Manual testing helps you quickly explore new features. Automated testing protects old features from breaking. In a student project, you don’t need a giant test plan—you just need consistent habits that make your work predictable.

Manual Testing: Flexible, Human

Manual testing is what most beginners do naturally: they click around, run the program, try a few inputs. This is valuable—if you do it with intention. The goal is not random clicking, but structured exploration: “What happens if I try this? What should happen?”

Everyday analogy

When you shake a table to check if it wobbles,
that’s manual testing.

What Manual Testing Is Good For

  • Early feature checks (“Does this new thing basically work?”)
  • Visual behavior (UI layout, text, formatting)
  • Weird edge cases that are easier to try manually than code
  • Understanding how parts of the system fit together

Keep It Useful: Small Habits

  • Write down the steps you took
  • Try a normal case, a weird case, and a “broken” case
  • Always test after you change something
  • Share your steps so others can repeat them

The trap

Clicking around without notes feels productive
but creates zero shared knowledge.

Exploratory Testing: The Smart Version of Manual Checks

Exploratory testing means thinking while testing. You follow your curiosity—but with a purpose. You adjust your next step based on what you just discovered.

  • “This behaved strangely… what if I try this input?”
  • “The error message looks wrong… what edge case triggers it?”
  • “What happens if I cancel halfway?”

It is flexible, creative, and very human.

Three guiding questions

  • What did I learn?
  • What should I try next?
  • What seems risky?

Automated Testing: Repeatable and Honest

Automated tests are small pieces of code that prove other code works. They run fast, never tire, and don’t forget steps. They prevent regressions and give the team confidence that changes didn’t break anything.

Automation is not magic

An automated test only checks what you tell it to check.

What Automated Testing Is Good For

  • Small functions with clear inputs and outputs
  • Code that should behave the same every time
  • Catching regressions
  • Running tests before pushing code

Even one automated test is better than none.

A Simple Automated Test (Python / pytest)

1
2
3
def test_add_two_numbers():
    result = add(2, 3)
    assert result == 5

Small. Repeatable. Honest.
This test can be run by anyone on the team, anytime. If it breaks, you know exactly where to look.

Assertions do the heavy lifting

An assertion is just a check:
“This should be true. If not, stop.”

How Manual and Automated Tests Support Each Other

Manual tests help you discover behavior.
Automated tests help you lock down behavior.

A healthy workflow looks like this:

  1. Try the feature manually
  2. Understand how it should behave
  3. Turn the important part into an automated test
  4. Keep the test for future changes

Choosing What to Automate

You don’t need automation everywhere. Focus on tests that give value:

  • Code that breaks easily
  • Logic that is important to the feature
  • Anything you fixed once (bugs love to return)
  • Repeated checks you run often

Automating everything is a waste

Automate the valuable checks, not every corner case.

Keeping Testing Practical in Student Projects

  • Write a few reproducible manual tests for each feature
  • Add a few automated tests for the core logic
  • Rerun everything after each change
  • Share steps, commands, and scripts in the repo
  • Keep tests small, clear, and easy to run

Testing is not extra work—it is what keeps your work solid.

Slow is smooth. Smooth is fast.

Testing slows you down a little today
so the project doesn’t collapse tomorrow.