How to Write Test Cases
in Manual Testing?

A modern QA engineer as a manual test case writer faces numerous challenges. These are related to changes in the approach to software development – more teams are adopting flexible methodologies and DevOps principles in their projects. These involve fast iterations and, as a result, frequent changes to the digital solution. To ensure comprehensive test coverage, specialists need to write a large number of test cases. However, increasing the number, sometimes with AI generation test cases should not affect their quality.

― What is a test case?

📝 How to write test cases in manual testing well?

― In what cases will the team benefit from manual test cases, and when is it better to automate them?

This guide will address these and other questions 💡

The Concept of a Test Case and Its Key Components

Test cases refer to a set of conditions used for thorough testing of a specific feature of a software product. They ensure that a particular component of the digital solution works as expected – according to the specifications.

Here is the test case definition provided by ISTQB:

A set of input values, execution preconditions, expected results, and execution postconditions, developed for a particular objective or test condition, such as to exercise a particular program path or to verify compliance with a specific requirement.

What are manual test cases:

A classic test case, regardless of its type, consists of the following components:

• ID – unique identifier used to track test cases.
• Test case description – a brief description of what is being tested.
• Preconditions – conditions that must be met in order to run the test.
• Test steps – a list of actions that need to be performed during software testing.
• Expected test results – the result that should be achieved if the system works correctly.
• Actual results – the result obtained after the testing process is completed (filled in after the test run).
• Status – information about whether the test passed or failed.
• Comments – notes from the tester regarding important aspects of the testing process.
• Execution data – the date the test was conducted and the name of the responsible specialist.
• Marking the feasibility of test automation – the tester’s assumption about which test cases could benefit from automation.

A typical test case template with.xls Google Docs might look like this:

Manual test cases are an essential part of quality assurance. Therefore, today we will discuss in detail how to write classical test cases in manual testing.

What Are Manual Test Cases?

Manual test cases are step-by-step instructions containing actions to verify specific functions of a digital product manually, without using automation tools. Here are examples of what can be tested with them:

→ functionality of a login page
→ shopping cart operation, registration forms
→ correct booking process flow, etc.

To help the testing team achieve their objectives, manual test cases must have a clear structure and precise meaning. This ensures accurate execution and enables their reuse in future projects. Next, we will explore the process of test case writing in detail…

How to Write Test Cases in Manual Testing? Step-by-Step Guide

Writing manual test cases is a process that involves several stages. These should not be overlooked to ensure high test case execution efficiency.

1️⃣ Assigning an Identifier

The tester or TCMS assigns a unique identifier to the test case. This helps in easily locating the record later, especially on projects with an increasing number of test cases.

2️⃣ Describing the Test Case

At this stage, the responsible testing team writes the test case description. It should include the purpose of the test case. A brief description of the expected system behavior can also be included.

3️⃣ Documenting Preconditions

The tester records all test conditions that must be met in order to start the verification process. These include:

• test environment settings
• user authentication requirements
• database access
• necessary device settings
• compliance with software requirements
• dependencies on other modules or services, etc.

5️⃣ Writing Test Steps

The more detailed test cases are, the more accurately the software application will be tested. Therefore, at this stage, the tester needs to carefully outline the steps to be taken during the test.

6️⃣ Defining Necessary Test Data

This step involves listing all the data required for testing. For example, valid and invalid user credentials.

7️⃣ Formulating the Expected Result

At this stage, the tester must define the expected outcome after the test is performed. This means describing the expected system behavior.

8️⃣ Obtaining the Actual Result

After obtaining the actual result of the test, the specialist must document it.

9️⃣ Documenting the Test Status

At this point, the tester compares the expected results with the actual outcomes. If they align, the test is marked as passed. If there are differences, the test is marked as FAILED.

Still have questions? Read Svyatoslav Dyuhanchuk’s guides on handling test cases for manual testing:

• How to write test cases effectively: Example and Template
• Work with thousands of test cases – torment or pleasure 🤔

Example of a Manual Test Case

Let’s consider a test case example that could be written for testing the login functionality of a mobile App and how this example looks in the Test Management System.

Test case ID: @Tbd18e207

Description: Testing the login functionality of the mobile App. Given: A valid username and password. When: The user enters the valid username and password into the appropriate fields on the login page. Then: The user should be redirected to the home page of the app.

Preconditions:

→ The latest version of the mobile app is installed on the user’s device.
→ The device is connected to a stable internet connection.
→ A valid user account is created and activated.
→ The app has all necessary permissions granted.
→ Push notifications are enabled (in case login confirmation or two-factor authentication is required).

Test steps:

1. Launch the mobile App on the device.
2. If the App opens to the welcome screen, tap Login to proceed to the login page.
3. In the username/email field, enter a valid username or email address.
4. In the password field, enter the correct password associated with the username.
5. Tap the Login button to submit the credentials.
6. Wait for the App to process the login request.
7. Ensure the App redirects to the home page, indicating a successful login.

Test data:

→ Valid credentials – username and password of a registered user. For example, testuser@example.com / Password123!
→ Invalid credentials for negative testing. For example, wronguser@example.com / WrongPassword1 or empty fields.
→ Blocked account data after failed login attempts to check for error messages related to account locking.
→ Valid two-factor authentication login (if applicable).

Expected test results:

• User successfully logs in.
• The App redirects the user to the home page.
• Information specific to the user is displayed on the screen, such as a welcome message or profile data.
• No error messages appear.
• The login button is disabled after submission to prevent repeated requests.

Actual test results:

After entering valid credentials on the login page, the user successfully logged in and was redirected to the home page.

Status:

✅ Passed

Mark test result of the executed test case, in the field below you may leave the notion for clear context understanding.

All updates and version edits to test cases can be easily tracked within the test management system.

Best Practices for Writing Manual Test Cases

To ensure high quality of the software and a better user experience, use our recommendations on how to write test cases in manual testing. Here are the key ones:

#1. Stick to a simple and clear writing style

The content of your test cases is important, but a good test case should also be written in simple language that is easy to understand for the whole team.

To avoid misunderstandings, it is recommended to follow standardized test case writing rules, such as those outlined in the Test Writing Style Guide by W3.

#2. Write a correct test scenario

Suppose you created too general a test scenario, like:

❌ Test the functionality of the shopping cart. It does not specify which aspects of the cart should be tested, such as adding or removing items, updating quantities, viewing total costs, applying discounts, etc. Accordingly, the tester will not know which test cases to write and what exactly to check.

✅ Check updating the quantity of items in the cart. In this situation, it is one of the possible scenarios. From this formulation, it becomes clear that the tester needs to verify that:

• the user can update the quantity of items in the cart.
• changing the quantity correctly affects the total cost of the items.
• the system displays an error message when trying to add more items than are available in stock.
• etc.

#3. Do not combine a variety of verification options in single test case

Isolated validation is must have! Each test has a clear purpose. A single test case should ideally test one specific behavior or scenario. Mixing both types in one test may complicate the test logic and make it harder to pinpoint the source of failure.

The same keeping positive and negative tests separate makes test cases easier to understand and maintain.

Principle of atomicity in testing suggests each test case should cover a single aspect of functionality.

#4. Prioritize writing more detailed test cases

This approach will allow you to conduct thorough and effective testing. Detailed test cases provide clarity, consistency, and traceability, reducing the risk of missing critical defects. Ultimately, you will be able to deliver higher-quality software solutions to the market.

#5. Explore the functionality of the software product

With a deep understanding of the software, the tester should regularly explore its functionality. Only through hands-on experience can new issues be discovered, and the tester will understand when to update the test cases.

#6. Visualize data in test cases

Adding screenshots, tables, diagrams, and other visual elements can bring multiple benefits to the team:

• Improved communication – stakeholders will find it easier to understand the expected behavior of the system.
• Quick issue diagnosis – visualization helps quickly pinpoint what went wrong.
• Quality documentation of the process – test cases can serve as project documentation.
• Increased testing accuracy – screenshots can visually confirm that the system behaves as expected.

#7. Optimize the test case creation process

To optimize the process, use the practice of creating your own test case template and reusing steps. This is well implemented in testomat.io The TMS contains a vast base of steps, and when writing a new test case, the auto-completion feature suggests the appropriate step as you begin typing its name.

Another powerful practice for enhancing your test cases is parameterization. This involves passing a parameter with multiple values into a test. In other words, you can run several variations of the same test, speeding up the testing process.

Benefits of Writing High-Quality Manual Test Cases for Your Team

Writing high-quality manual test cases is a best practice for teams aiming to achieve high testing efficiency on their projects. Here are the main benefits you’ll get:

1. Improved test coverage. Well-written test cases with detailed steps guarantee a systematic approach to testing every function. This ensures that your digital product will work as expected under different conditions.
2. Consistency in project actions. With high-quality test cases, all testers will clearly understand what to test and how to do it. This ensures that every function is tested the same way, regardless of who is performing the testing.
3. Quick adaptation for new testers. In addition to their main function, test cases serve as informative project documentation. New team members can refer to them to understand the system’s functionality.
4. A solid foundation for automation testing. Well-crafted manual test cases can speed up the automation process if the decision is made to automate testing.
5. Improved quality of digital solutions. Thorough manual testing reduces the likelihood of defects after the release. This improves the product’s quality and increases user satisfaction.

High-quality manual test cases foster collaboration on the project, enhance testing efficiency, and contribute to the overall improvement quality of the software.

Checklists – An Alternative to Test Cases?

Some teams choose to replace writing test cases with checklists. These are task lists that a tester needs to complete to conduct testing. However, unlike test cases, checklists are less detailed and do not contain detailed steps.

An example of a checklist might look like this:

Checklists are advisable to use in the following cases:

• when the team prioritizes testing speed.
• when testers need to repeatedly perform the same tests.
• when it’s necessary to verify the product’s compliance with basic requirements before moving on to more complex QA processes.
• for specific types of manual testing, such as smoke, regression, or exploratory testing.

However, if you are focused on documenting the testing process and results, as well as conducting a comprehensive review of the digital solution, test cases are indispensable.
In some projects, the practice of combining both approaches is used. This can make your testing process more thorough and effective.

Efficient Organization of Manual Test Cases

After writing manual test cases, they need to be organized properly. This will significantly increase the effectiveness of test execution. Here are several recommendations on how to do this most effectively:

• Create a test suite to group related test cases.
• Use test case prioritization to first check the most critical functionality.
• Include all components in test cases, including clear descriptions and detailed steps.
• Assign responsible testers and set clear deadlines for testing.

Specialized tools, such as testomat.io, can also assist with this. The system streamlines test case management, enhancing its efficiency.

When to Automate Manual Test Cases

Recent studies reveal that the global automated testing market was valued at $28.5 billion in 2023. Projections indicate that this figure will surge to $104.2 billion by 2031:

This trend can be attributed to a single fact: while manual testing is effective, there are instances where automating the QA process is more practical. These include:

• Running repetitive test cases. For example, tests that need to be executed with every new build or release.
• Testing stable functionality. If a feature is not expected to change in the near future and the test cases do not require constant updates, they can be automated.
• Checking high-risk components of the application. Automation allows for large volumes of testing in a short period, quickly identifying critical defects.
• Cross-browser and cross-device testing. Automated tests can be quickly launched in different test environments, speeding up the verification process.
• Long test cases with multiple scenarios. Running them with automation tools will be much faster.
• Specific types of testing. For example, automated regression testing can be run after each build. This ensures that code changes do not introduce new defects.

👉 Use progressive tools for automation. They allow you to quickly turn manual test cases into automated ones and execute them.

Key Mistakes to Avoid

Teams can make several mistakes when writing test cases that hinder successful testing. Let’s focus on the most common ones:

• vague formulation of goals and expected results
• insufficiently detailed steps
• failure to document preconditions
• weak analysis of specific requirements, leading to insufficient coverage
• lack of clear writing standards
• unjustified rejection of automation
• ignoring prioritization
• weak collaboration on the project
• insufficient attention to test case management.

Each of these mistakes can lead to reduced effectiveness of manual testing. We hope this guide helps you avoid them.

Test Management System as Home to Test Cases

Traditionally, testers use spreadsheets to create a list of test cases. This method is valid. However, it is much more convenient to use a dedicated test case management tool for this purpose. There are many platforms available to users, including TestRail, TestLink, Xray, and others.

It is convenient to write manual test cases in the Testomat.io test management tool:

Explore the detailed process in our manual.

Final Thoughts

Writing test cases in manual testing as fast as possible is relevant for every team that faces the need for manual testing on a project. Among the main recommendations are: follow a clear structure, implement writing standards, and support collaboration on the project. Also, do not neglect automation when it is feasible. This approach to testing will make your testing efforts as productive as possible.