Test case execution is the stage where planned test cases are carried out to check if a software application performs as expected. Each function, feature, or user flow is tested in various scenarios to assess the system’s response. The process helps verify that the built product behaves as intended before it reaches users.
In software testing, test case execution stands as the point where all preparation pays off. After designing and reviewing the test cases, the testing team runs them to confirm that every component meets its expected results.
Teams that complete this step carefully can find gaps and validate fixes in time. Below, we explain this process in detail, along with its importance and best practices.
TL;DR
- Test case execution is the activity of running planned tests and comparing actual results with expected results to determine how the software behaves.
- Execution can be manual or automated, and teams may combine human and automated activities depending on the test, product, and risks involved.
- Test results should be recorded clearly so teams can distinguish successful tests from failures, blocked tests, tests requiring another run, and other project-specific outcomes.
- When a defect is fixed, the affected test can be rerun to confirm the fix; regression testing may also be performed to check whether the change caused problems elsewhere.
- Effective execution depends on appropriate prioritization, representative test data, maintained automation, manageable dependencies between tests, and accurate execution records.
- A high pass rate alone does not prove that software is stable or defect-free; teams also need to consider coverage, remaining risks, defects, untested areas, and the quality of the tests themselves.
- TestRail supports test runs, assignments, configurable result statuses, milestones, dashboards, reports, and the centralization of manual and externally generated automated test results.
What is test execution in software testing?

Test execution is the part of software testing where teams run their tests to see how the application performs in real use. It’s where all the planning, writing, and reviewing of test cases turn into action.
The process takes place in three stages. It begins with writing test cases, which helps determine what needs to be checked and how. The next step is to run those test cases and observe how the system behaves under testing. Finally, the team reviews the results to confirm that everything works as expected.
Test case execution verifies that the software is ready to meet the end users’ expectations. It helps teams catch errors and verify that the product meets technical and user expectations. By the end of this process, teams know exactly where the software stands with respect to performance and stability.
Here’s how the steps unfold.
Phase 1: Test planning
Every solid round of testing begins with a plan. During this phase, the testing team decides what needs to be tested, how it will be tested, and who will handle each part. Proper test planning helps avoid confusion later and makes the whole process easier to track.
Teams determine the testing scope, tools, deadlines, and success criteria in this stage. A part of this step is dedicated to preparing strong test cases that map to real-world scenarios. Developers who know how to write test cases are proficient at making sure nothing important is missed.
Phase 2: Test case execution
Once the plan and test cases are ready, it’s time to implement them. Testers run each test case and compare the results against what’s expected.
Some tests are handled manually, while others rely on automation tools. Both methods have value. Manual testing helps catch unexpected behavior, while automation handles repetitive or large-scale checks faster.
Accurate reporting is extremely important during this stage, so each result should be recorded clearly, noting which tests passed or failed. The testing team may rerun certain tests if fixes are made to confirm that changes didn’t break anything else in the system.
Phase 3: Test evaluation
Teams must review the results after executing all test cases. In this step, they analyze what went right, what failed, and what requires further attention. Basically, the stage involves understanding how the system behaves as a whole.
Teams gather all test results, compare actual outcomes with expected ones, and document their observations. If certain tests didn’t pass, the issues are shared with developers for correction.
After making the fixes, teams may rerun the tests to confirm the problem has been resolved. In the end, this evaluation provides a view of product quality in terms of deployment.
How does test case execution work?

Test case execution happens once the test plan and cases are ready to go. The testers run each case step by step to see how the application behaves. They compare what appears on the screen to the desired results. Each test is marked with a simple status (pass, fail, blocked) to track progress.
When something doesn’t work as planned, teams record the issue in a log with details about what went wrong. Developers use that information to fix the problem. After the fix, testers run the same case again to confirm it’s no longer problematic. Regression testing often follows, which checks that new changes haven’t created fresh problems in other parts of the application.
Manual test case execution
Manual test case execution means that testers follow each step in the test plan themselves instead of using tools or scripts. It’s a hands-on process that helps find unexpected behavior. The approach works well for exploratory tests and complex scenarios that need human judgment.
A written manual test case should outline what to test and how to perform the test. It should also specify what results to look for. Although manual testing takes time, it provides the flexibility that testers need to dig deeper when something doesn’t look right.
Automated test case execution
Automated test case execution relies on tools or scripts to carry out tests without direct human involvement. Once the scripts are ready, the process runs with minimal effort. Sometimes, all it takes is a single command.
The method is ideal for repetitive or large test cycles where speed is important. Automation is also useful for regression testing, performance checks, and any area that benefits from running the same test multiple times. It also helps teams save time and focus human effort on more complex testing needs.
Semi-automated test case execution
Semi-automated testing combines manual and automated steps. Some parts of the process, such as data setup or validation, may still require a tester’s input. Automation tools handle the remaining steps.
It’s a balanced option when teams want to speed up repetitive tasks but still need human supervision for parts that require reasoning or detailed observation.
Test case execution outcomes

After running the test cases, the results reveal the software’s true performance. Each outcome reflects how closely the system aligns with what the developers expect. It’s important to track these outcomes to understand where the product stands in terms of quality and readiness for release.
Passed
A test case is marked as passed when the outcome matches what you expected. Simply put, a feature behaved correctly and didn’t trigger any errors.
Passing test cases shows that a section of the application is functioning as designed. So, the team has confidence to move ahead. The number of passed tests often reflects the product’s stability at a given stage and helps track overall quality over time.
Failed
A failed test case means something didn’t go according to plan. The expected result wasn’t achieved, so the tester logs the issue with enough detail for developers to review.
Sometimes, a single step in a multi-step test can fail, which usually stops the rest of the test from continuing. The developers then fix the issue and rerun the failed case to confirm the correction worked. Frequent failures can point to a design or code issue that needs proper attention before the next release cycle.
Error
An error status appears when the problem isn’t in the software being tested but in the test process itself. This could happen due to a broken test script, missing data, or technical interruptions like server or network downtime.
The test won’t proceed until the issue is resolved. After fixing the cause, the test is run again.
Inconclusive
An inconclusive result means the test didn’t provide a clear outcome. It wasn’t successful, but it didn’t fail for a known reason either. You may see inconclusive results when there isn’t enough data to confirm the behavior, or the test environment doesn’t respond predictably. In these cases, testers review what happened and decide if the case needs to be rerun or redesigned.
Why is test case execution important?

Test case execution is an important part of software development because it turns planning into measurable results. It also prevents last-minute surprises and improves product reliability. More importantly, it directly connects to return on investment, as efficient execution enables early defect detection, thereby saving development costs.
Lower user churn rate
Users don’t really give second chances to buggy apps. So, when an application crashes, people uninstall it and move on. Test case execution prevents this from happening.
Each part of the software, from the interface to the database, is checked under different conditions so the experience feels smooth. As a result, users stay longer because the product works just as they want it to.
Catching bugs early reduces costs
Fixing a defect during development costs far less than patching it after release. Consistent test case execution helps teams identify problems early, when they’re still easy to correct, and saves hours of debugging later. Teams also save money that would otherwise be spent on emergency updates.
Bug-free software
The ideal scenario for any development team is to deliver bug-free software on the first attempt. When test cases are executed carefully, every function is verified before the product reaches production. It helps reduce the chances of defects later and maintains consistent quality across updates.
Test case execution best practices

Do you want to excel at test case execution? Follow these practices.
Execute based on priority
When executing tests, start with high-priority ones that cover core functionalities or areas most at risk of failure. Run these first to detect must-not-miss defects before they impact larger test cycles or production releases.
Automate test cases
Is repetitive manual testing eating up your schedule? Turn to automation.
Teams can automate high-volume or regression tests to save time and get consistent results. Automation tools also enable you to focus on edge-case scenarios where human insight can add significant value. Just make sure you maintain your scripts regularly so that they don’t become outdated with each new release.
Select test data wisely
The quality of test data usually determines how accurate the outcomes will be. Good data selection means covering positive and negative scenarios. You must also closely monitor real-world conditions to ensure your tests can reveal hidden issues that may not surface with generic or limited datasets.
Design independent test cases
Each test case should stand on its own. Independent test cases reduce dependencies, making it easier to execute tests in any order or in parallel. Plus, these cases prevent one failed test from blocking another. So, your tests can run uninterrupted.
Reuse test cases
Maintaining a centralized test case repository helps avoid reinventing the wheel with each new project. Reuse the test cases to save time and keep releases consistent.
Suppose your team has already tested the user login module for one product. The test covered various scenarios, including valid credentials, invalid passwords, and password resets. Now, you are designing another application with similar authentication logic. You can reuse those same test cases to accelerate testing and maintain the same quality standards across projects.
Track test case execution metrics
Quality assurance (QA) metrics help you see testing efficiency and product readiness. Monitor QA metrics, such as test execution rate, defect density, and pass/fail ratios, to understand how well your process performs. These numbers will help you plan for better future releases.
Review blocked tests
Blocked tests slow down progress and leave potential bugs undetected. Review them regularly to identify the cause and resolve them as early as possible.
Generate test case execution records
Keep detailed test execution records to trace issues, analyze outcomes, and maintain accountability. Documentation also provides a reference point for audits and future test cycles. In the latter, this information helps you maintain consistency across testing standards. These documents further demonstrate that due diligence is an integral part of your process.
Collect, organize, prioritize, and report on test cases with TestRail

There’s no denying that managing test cases can feel overwhelming, especially when you have complex software at hand. TestRail brings everything together in one organized platform to resolve this issue. It provides you with a central place where you can structure test cases, suites, and runs. Team leaders can assign milestones while monitoring real-time progress through dashboards.
Since every result is updated and recorded, QA teams can track what they’ve done and what needs attention. Trusted by over 10,000 QA teams, TestRail has the seal of approval from big names like Amazon and Adobe.
Frequently Asked Questions
What is test case execution?
Test case execution is the activity of running a test against a component or system and observing the actual result.
The result is then normally compared with the expected result and recorded so the team can understand the outcome. This is consistent with the ISTQB definition of test execution.
Is test planning part of test execution?
No.
Test planning and test execution are related activities, but they are not the same thing.
Planning determines matters such as objectives, scope, resources, approach, schedules, and priorities. Test execution is the later activity of actually running the selected tests.
The blog’s three phases—planning, execution, and evaluation—are better understood as a simplified description of a wider testing workflow, rather than three phases of test execution itself.
What happens during test execution?
Depending on the test, teams may:
- Prepare required data or preconditions
- Execute manual steps or automated scripts
- Observe actual results
- Compare actual and expected results
- Record test status and evidence
- Investigate unexpected outcomes
- Report defects or other anomalies where appropriate
Not every test requires every one of these activities.
Can test execution be manual or automated?
Yes.
ISTQB describes test execution as something that may be performed manually or automatically.
Manual execution involves a person carrying out the relevant actions and evaluating results. Automated execution uses software to perform some or all of the test actions and comparisons.
What is semi-automated testing?
“Semi-automated testing” is an informal description commonly used for workflows that combine manual and automated activities.
For example, automation might prepare data and navigate to a particular state while a human evaluates usability or visual behavior.
It is not necessary to treat semi-automated testing as a separate formal category of test execution.
What does it mean when a test passes?
A test passes when its actual result satisfies the expected result or applicable pass criteria.
ISTQB defines a failed test result as one where the actual result does not match the expected result.
A passing test provides evidence that the tested condition behaved as expected in that execution. It does not prove that the entire feature or product is defect-free.
What does it mean when a test fails?
A failed test indicates that an expected result was not achieved.
The cause should then be investigated. A failed test does not automatically prove that the product contains a defect; the cause could instead be an incorrect test, bad test data, a configuration issue, an environment failure, or another problem.
Does every failed test need a defect report?
No.
The failure should be investigated first.
If the failure results from a product defect, teams will commonly create or link a defect. If it results from an obsolete test case, broken automation, test-data issue, or environment problem, a product defect may not be appropriate.
What is a blocked test?
A blocked test is a test that cannot currently be executed because something prevents it from proceeding.
For example, a required environment may be unavailable or a prerequisite defect may prevent access to the functionality being tested.
TestRail includes Blocked as one of its default result statuses.
Are “Error” and “Inconclusive” universal test statuses?
No.
Teams and tools can use different result-status models.
For example, TestRail’s default system statuses are:
- Passed
- Blocked
- Untested
- Retest
- Failed
Administrators can also create custom result statuses.
Therefore, the blog’s Error and Inconclusive categories are possible ways a team might classify outcomes, but they should not be presented as universal test-execution statuses.
What is the difference between retesting and regression testing?
Retesting, often called confirmation testing, checks whether a specific previously observed problem has been corrected.
Regression testing checks whether changes have unintentionally affected existing behavior elsewhere.
A team may therefore retest the original failure and then perform appropriate regression tests around affected functionality.
Does a fix always require the entire regression suite to be rerun?
No.
The appropriate regression scope depends on the change, architecture, dependencies, risks, available time, and test strategy.
Some changes justify broad regression testing, while others may only require a focused selection of tests.
Is manual testing better at finding unexpected defects?
Not automatically.
Human-led exploratory testing can be particularly useful for discovering unexpected behavior because testers can observe, learn, and change direction during the session.
However, automated testing can also reveal unexpected failures. The relative effectiveness depends on the type of defect, test design, system, and testing technique.
When is automated test execution useful?
Automation is often useful for tests that are:
- Repeated frequently
- Stable enough to automate economically
- Deterministic
- Time-consuming to perform manually
- Needed across many configurations
- Suitable for automated assertions
Regression suites, unit tests, API tests, integration tests, and many performance tests are common examples.
Does automated testing run completely without people?
Not necessarily.
Even when execution itself is automatic, people typically design, review, maintain, debug, interpret, and improve the automation.
Automation can reduce manual execution effort without removing the need for engineering and testing judgment.
Should high-priority test cases always run first?
Prioritization is useful, but the execution order should reflect the project’s risks and dependencies.
TestRail includes a test-case Priority field that can help teams decide which cases should receive attention first when time or resources are constrained.
However, prerequisites, environment availability, test dependencies, and the purpose of a particular run may require a different order.
Should every test case be independent?
Independence is often desirable because it makes tests easier to execute in isolation, parallelize, diagnose, and maintain.
But complete independence is not always practical.
Some workflow, state-transition, integration, migration, or end-to-end tests intentionally depend on a particular system state or sequence. The goal should therefore be to avoid unnecessary dependencies, rather than insist that every test must be completely independent.
Can test cases be reused across different products?
Sometimes, but they should not simply be copied because two products appear similar.
A reusable test is appropriate only when its assumptions, requirements, workflow, expected results, data, and configuration remain valid for the new context.
For example, two applications may both contain login functionality while having different authentication rules, password policies, MFA requirements, permissions, or security expectations.
How important is test data during execution?
Test data can materially affect test results.
Good test data should represent the conditions needed to evaluate the relevant behavior. Depending on the test, that can include valid, invalid, boundary, exceptional, empty, large, or otherwise risk-relevant values.
Teams should also follow applicable privacy, security, and data-handling requirements when using production-derived or sensitive information.
Does a high test pass rate mean the software is stable?
Not necessarily.
A 100% pass rate for a weak or incomplete test suite provides little assurance.
Release confidence should consider factors such as:
- What was tested
- What was not tested
- Requirements and risk coverage
- Test quality
- Remaining defects
- Environment differences
- Known limitations
- Relevant non-functional testing
Pass/fail ratios are useful signals, but they should not be treated as complete measures of software quality.
Does test execution produce bug-free software?
No.
Testing can reveal defects and provide information about product quality and risk, but it cannot prove that non-trivial software contains no defects.
The blog’s “Bug-free software” section should therefore be reframed as something like “Reducing the risk of defects reaching users.”
Does test execution guarantee lower user churn?
No.
Reliable software can contribute to customer satisfaction, and severe defects can certainly cause users to abandon products.
But user churn is affected by many factors, including price, competition, usability, product value, customer support, and market conditions. Test execution alone cannot guarantee a particular churn outcome.
Is it always cheaper to find a bug earlier?
Finding problems earlier can reduce the amount of rework in many situations.
However, there is no universal cost relationship that applies to every defect. The cost depends on the nature of the problem, dependencies, architecture, release process, affected users, and many other factors.
It is therefore safer to say that earlier detection can reduce remediation cost and disruption, rather than making an absolute cost claim.
What test-execution metrics should teams track?
Useful measures depend on the team’s goals. They may include:
- Number or percentage of tests executed
- Passed, failed, blocked, and untested tests
- Execution progress against plan
- Defects found
- Remaining high-risk tests
- Execution duration
- Automated versus manual results
No single metric should be used as a complete measure of quality.
Is defect density a test-execution metric?
It can be used as a broader quality metric, but it is not purely a test-execution measure.
Defect density relates a number of defects to some defined size measure, such as lines of code, function points, modules, or another agreed denominator. Its usefulness depends heavily on consistent definitions and context.
Why should blocked tests be reviewed?
Blocked tests represent testing that has not yet provided the intended evidence.
Reviewing them helps teams identify whether the cause is an environment issue, missing dependency, unresolved defect, unavailable data, access problem, or another obstacle and decide what action is needed.
Why keep test execution records?
Execution records help teams understand what was tested, when it was tested, what result occurred, and what supporting evidence or defects were associated with that execution.
They can support debugging, reporting, historical analysis, repeatability, and—in contexts where records are required—audits or compliance evidence.
Not every software project has the same documentation or regulatory obligations.
What are TestRail’s default test-result statuses?
TestRail currently provides five default system statuses:
- Passed
- Blocked
- Untested
- Retest
- Failed
Organizations can also configure custom result statuses to match their processes.
Can TestRail assign tests to individual testers?
Yes.
TestRail allows test runs or individual tests within a run to be assigned to users. Assignments can also be changed when submitting results.
Can TestRail track releases or other testing milestones?
Yes.
TestRail milestones can represent significant testing objectives such as a software release, completion of a particular testing activity, or another business objective. Test runs and plans can be associated with milestones to track progress and results.
Does TestRail provide real-time test progress dashboards?
Yes.
TestRail’s summary charts automatically update as tests and results are added. Current documentation describes status, activity, progress, defects, workload, and other charts across runs, plans, milestones, projects, and dashboards.
Can TestRail summarize several test runs in one report?
Yes.
The Runs Summary report provides an overview of progress and testing activity across one or more selected test runs, including test-result status and run-level progress.
Can automated test results be sent to TestRail?
Yes.
TestRail’s TRCLI command-line tool can upload automation results to TestRail from JUnit and JUnit-style reports generated by frameworks including JUnit, TestNG, NUnit, Cypress, Playwright, and others. Current documentation also describes support for performance-test results such as JMeter output.
Does TestRail execute automated tests itself?
Generally, no.
The automation framework or CI/CD pipeline runs the tests. TestRail then receives and manages their results.
TRCLI, for example, parses external automation reports and uploads the resulting test information into TestRail.
Can TestRail centralize manual and automated results?
Yes.
TestRail supports manually entered test results as well as programmatically imported results from external automation. Centralizing those results allows teams to use TestRail’s dashboards and reports across their testing activities.
What is the main goal of effective test case execution?
The goal is to produce reliable information about the behavior of the system under the conditions that were tested.
Good execution does not prove perfection. It gives the team evidence that helps it identify failures, evaluate risk, confirm fixes, understand coverage, and make better decisions about the software.
Ready to work smarter? Try TestRail for free.




