What software testers do: edge cases, boundary values and odd input, and why an app can pass every test yet miss what users need. Verification vs validation.
Software Testers, explained by cats. Kitty builds an app. Clean. Fast. “Production-ready.” Tester Cat goes feral on it. Uploading five gigabyte files on bad Wi-Fi. Dark mode. Light mode. Ultra-dark mode. Passwords with symbols, numbers, and emotional damage. AI suggestions.
Auto-everything. Every payment method except fish. Edge cases. Impossible cases. Cases that shouldn’t exist. A lizard in a textbox. Minus one orders. many many many clicks. Finally… Tester Cat closes the laptop: “All tests passed.” A real customer cat downloads the app.
Very normal. Very calm. And wonders: “Where’s the search button?” Silence. Because Tester Cat tested everything… except the one thing real cats actually wanted.
Software testers find the ways an app breaks before customers do. That means pushing it far past normal use, and also stepping back to ask whether it does what people need at all.
That second question matters, because an app can pass every test and still let its users down.
What a tester does
A developer usually checks that a feature works: type a valid email, press save, see the profile update. A tester assumes it doesn't, and goes looking for the conditions that prove it. Their work falls into a few overlapping kinds:
Functional testing: does each feature do what the requirements say?
Edge-case testing: what happens at the limits, and past them?
Exploratory testing: using the app without a fixed script, following hunches about where bugs hide.
Regression testing: re-checking old features after a change, so a fix in one place doesn't break another.
Some of this is manual and some is automated, as tests that run on every commit. Testers often work without seeing the code, judging only what the app does, which is the black-box approach.
Edge cases: testing the limits
An edge case is an input or situation at the extreme end of what the app expects, such as the biggest file or the slowest network. Bugs gather there because developers write code for the normal path first and forget the limits.
Typical edge cases a tester tries:
Size and speed: a 5 GB upload on a weak Wi-Fi signal. Does the upload resume, time out cleanly or hang forever? How an app behaves under heavy load is its own field, .
Software Testers, explained by cats. Kitty builds an app. Clean. Fast. “Production-ready.” Tester Cat goes feral on it. Uploading five gigabyte files on bad Wi-Fi. Dark mode. Light mode. Ultra-dark mode. Passwords with symbols, numbers, and emotional damage. AI suggestions.
Auto-everything. Every payment method except fish. Edge cases. Impossible cases. Cases that shouldn’t exist. A lizard in a textbox. Minus one orders. many many many clicks. Finally… Tester Cat closes the laptop: “All tests passed.” A real customer cat downloads the app.
Very normal. Very calm. And wonders: “Where’s the search button?” Silence. Because Tester Cat tested everything… except the one thing real cats actually wanted.
Odd input: passwords full of symbols, names with accents or apostrophes, emoji, text pasted into a number field.
Impossible values: an order for -1 items, a date of birth in the future.
Repeated actions: tapping 'Pay' ten times in a second. Does the customer get charged ten times?
Settings combinations: dark mode, large text and a small screen, all at once.
Some cases seem silly ('who would type a lizard into a text box?'), but real users paste odd things by accident, and attackers paste them on purpose. A crash on strange input can be a security hole as well as a bug.
A worked example: an order quantity field
Say a shop lets you order between 1 and 99 of an item. Testing every possible input would take for ever, so testers use two standard techniques.
Equivalence partitioning splits the inputs into groups the code should treat the same way: too small (0 and below), valid (1 to 99) and too large (100 and above), plus input that isn't a number at all. One value from each group stands in for the rest.
Boundary value analysis then tests the edges between those groups, because that's where off-by-one mistakes live: a developer who writes < 99 instead of <= 99 rejects a valid order of 99. So the tester checks 0, 1, 99 and 100, plus -1 and a value that isn't a number.
With pytest, the whole table fits in one parametrised test:
Six cases cover what hundreds of random numbers would. If the limit moves to 50 next year, update the limit in the function and change the table to test its new boundaries.
Verification and validation
The video ends with every test passing and the first real customer asking where the search button is. Testing asks two separate questions, and the gap sits between them:
Verification: did we build the product right? Does it match the specification?
Validation: did we build the right product? Does it solve the problem users have?
The automated edge-case tests above are verification: they check the behaviour the team expected. If nobody wrote 'users can search the catalogue' into the requirements, a suite built only from those requirements may never check for search. Exploratory and usability testing can still uncover that gap. A green test run only means the app does what the tests check.
Why the obvious gap gets missed
Missing features are hard to catch because a test needs something to compare against. A bug is a difference between what was asked for and what was built. A missing feature is a gap in what was asked for, so that comparison never happens.
It gets worse the longer a team works on an app. Developers and testers know where everything is, so they never need a search button: they go straight to the page they want. A new user knows none of that.
This is why requirements work matters as much as testing. Someone has to talk to users and turn what they need into stories and acceptance criteria before testing starts, which is a large part of what a business analyst does.
How teams catch what users want
A few practices close the validation gap:
Acceptance criteria written with users in mind: 'A customer can find a product by name' is testable, and it would have flagged the missing search.
Usability testing: give the app to five or so real people, ask them to complete a task, and watch without helping. Where they hesitate or get stuck tells you more than any checklist.
Early releases to a small group: a beta, or a feature turned on for a few users first, shows how people really use it before everyone gets it.
Analytics and feedback: watch what people look for, where they give up, and what support tickets ask.
None of these replace edge-case testing. A team needs both: one keeps the app from breaking, the other keeps it useful.
Common mistakes
Treating 100% passing as 'done': passing tests say nothing about tests that were never written.
Only testing the happy path: if every test uses sensible input, the first unusual user finds the bugs.
Testing only at the end: testers who join early question vague requirements before code exists, when gaps are cheapest to fix.
Never watching a real user: the people who built the app are poor judges of what a newcomer finds obvious.
Key takeaways
A tester looks for the ways an app breaks: edge cases, odd input, impossible values and repeated actions.
Equivalence partitioning and boundary value analysis turn endless inputs into a handful of strong test cases.
Verification checks the app was built right; validation checks it was the right thing to build.
A suite based only on written requirements can miss needed features; exploratory and usability testing help uncover those gaps.
Usability testing with real people catches needs that nobody wrote down.