Knowing the theoretical foundations of software testing is very important, but real improvement happens through practice. This blog post presents 10 practice exercises that beginners can complete independently – all you need is a browser, a text editor or spreadsheet, and some curiosity.
The exercises build on each other, so it’s recommended to proceed in order. Where possible, example solutions are provided so you can see what to pay attention to.
1. Exercise: Bug hunting on a website
Visit the following website:
https://automationexercise.com/
Task: Find at least 5 different bugs on the website (e.g. UI, typo, functional, usability issue). Briefly describe them:
- Where is it located?
- What is the bug?
- What effect does it have on the user?
Tip: Check it on mobile as well, and try using interactive elements.
2. Exercise: Creating bug reports
Choose 3 bugs from the previous exercise and create bug reports for them using the following fields:
- Title
- Description (briefly the nature of the bug and circumstances)
- Steps to reproduce
- Expected result
- Actual result
- Priority (low / medium / high)
Tip: Write the reports in a table or a simple document.
3. Exercise: Writing test cases for a login form
Imagine a web application login page with the following fields:
- Email address
- Password
- “Login” button
Task: Write at least 6 test case plans covering the most important positive and negative scenarios.
Example:
| ID | Test Case Description | Precondition | Expected Result |
| TC01 | Successful login with correct email and password | – | Login successful |
| TC02 | Error message appears when fields are empty | – | Shows error |
4. Exercise: Writing questions based on a simple specification
Specification excerpt: The “Password Reset” feature allows the user to request a new password via email. The system checks if the provided email address is registered. If yes, it sends the new password; if not, it displays an error message.
Task: Write 5 questions you would ask developers or business analysts before starting to test.
Example:
- What happens if the email format is invalid?
- How long is the new password valid?
5. Exercise: Practicing boundary value testing – Water slide entry system
Specification excerpt: A water park’s slides have automatic entry gates allowing people to enter based on specified height, age, and weight criteria for three different slides.
Slides and conditions:
- Mini slide
- Height: 80–120 cm
- Age: 3–7 years
- Weight: up to 30 kg
- Family slide
- Height: 110–160 cm
- Age: 6–14 years
- Weight: 30–70 kg
- Giant slide
- Height: 150–200 cm
- Age: over 10 years
- Weight: at least 50 kg
Task: Design boundary value test cases for all three slides.
Consider at least the following:
- 1 value below minimum
- Minimum value
- Middle value
- Maximum value
- 1 value above maximum
Use a table format, e.g.:
| Slide | Height (cm) | Age (years) | Weight (kg) | Accepted? | Comment |
| Mini slide | 79 | 5 | 25 | No | Height too low |
| Mini slide | 80 | 3 | 30 | Yes | Exactly meets all criteria |
| Mini slide | 100 | 4 | 31 | No | Weight too high |
Tip:
- Test boundary values on all three dimensions (height, age, weight).
- Check what happens if one condition fails but the others pass.
- Write at least 3–5 test cases per slide.
This exercise helps you handle boundary values more consciously, especially when multiple conditions apply in one rule.
6. Exercise: Documenting exploratory testing
Visit this demo online store:
https://magento.softwaretestingboard.com/
Task: Spend 15 minutes on the site and note what you tested and what you observed.
- Which functions did you try?
- Did you find any bugs or oddities?
- Which parts were less usable?
7. Exercise: Comparing requirements and test cases
Imagine the following requirement is in a specification:
During registration, the user must accept the Terms and Conditions (T&C) by checking a checkbox. The “Register” button is only active if this is checked.
Task:
- Write 3 test cases for this requirement.
- Explain why testing this is important (business or legal reasons).
8. Exercise: Identifying types of bugs
Read the following bugs and categorize them:
- The “Submit” button text on mobile hangs off the screen.
- Registration accepts invalid email addresses.
- The system slows down when there are 1000 items in the list.
- The date format does not match the specification.
Categories:
- Functional bug
- User interface (UI) bug
- Performance bug
- Usability bug
9. Exercise: Severity and priority of bugs
In this exercise, you receive bug report examples and must determine:
- Severity: How severe is the bug in terms of system functionality?
- Priority: How quickly does this bug need fixing?
Important note: This exercise is thought-provoking. Severity and priority don’t always match and multiple acceptable answers exist depending on:
- What the client considers risky,
- Project goals and deadlines,
- Business impact of the bug,
- Whether it’s a production or test environment.
Task: Read the following bug descriptions and write down what you think their severity and priority are. Justify your decisions!
Use these scales:
- Severity: Critical / High / Medium / Low
- Priority: Immediate / High / Medium / Low
Bug examples:
- Clicking the “Pay” button does nothing in the live webshop.
Tip: The feature is completely unusable, big business impact. - The company logo is missing from the mobile header.
Tip: Display issue, but doesn’t block anything. - The password reset email arrives with a 5–10 minute delay.
Tip: The feature works but user experience is degraded. - The admin panel shows an incorrect year in user statistics.
Tip: Only affects internal users and only one field. - The system crashes if the user tries to add more than 1000 products to the cart.
Tip: Rare case but causes full shutdown. - The online store shows original prices instead of discounted prices, but checkout calculates correctly.
Tip: Misleads customers – sensitive legally/marketing-wise. - The search does not find misspelled keywords (e.g. “televizio” instead of “televízió”).
Tip: The function works but is not smart enough.
Reflect on:
- Which bug is blocking? Which is annoying but not urgent?
- Are there bugs that are technically severe but not urgent?
- And those that are business-critical even if they don’t cause major technical failures?
Bonus: If working in a team, discuss the differences. A good debate helps understand different views on severity and priority.
10. Exercise: Spotting specification errors
You receive a simple application feature description. The text contains multiple types of errors: typos, logical contradictions, mixed language use, missing or insufficient information, circular references, etc.
Task: Read the following specification and list as many errors as you notice!
Specification: The application’s purpose is to track employees’ working hours.
- Employees have access to their time tracking table after logging in.
- The table contains the following columns: date, start time, end time, total time, note, status.
- The “total time” column automatically calculates the difference.
- Admins can edit any employee records except their own.
- Userscanseeonlytheirownentries.
- The status field values can be: approved, rejected, pending.
- Approval only happens if the status is “approved,” or if the status is “pending” and the employee is no longer active.
- Each employee must have a unique identifier.
Tip: Watch out for these types of errors:
- Typos / grammatical errors
- Logical contradictions
- Inconsistent wording
- Circular definitions
- Mixed language use
- Ambiguous concepts
- Missing information (e.g., what exactly does the “status” value mean?)
Write down what you found and justify why you consider it problematic!
+1. Exercise: Summarizing testing experiences
This reflective task helps organize your experiences based on the exercises you completed.
Task:
- Which exercise was the most interesting or instructive for you?
- Which type of bug was new or surprising?
- What was the biggest challenge?
- Which testing method or mindset did you find useful (e.g., boundary value analysis, specification review, bug reporting)?
Summary
These 10 exercises are a great starting point for practicing manual testing as a beginner. By completing them, you will better understand:
- How a bug report is structured
- How to write effective test cases
- What to ask when a requirement is unclear
Additional websites for practice
- https://testautomationpractice.blogspot.com
- https://magento.softwaretestingboard.com
- https://automationexercise.com
If you liked this article, share it with other beginner testers – and remember: a good tester is curious, asks questions, and tries everything!
