Test execution is a key stage of the software testing process. It’s when quality assurance (QA) teams run planned test cases to verify that an application works properly and adheres to its requirements.
An effective test execution process involves much more than running tests. QA teams use the process to actively identify testing gaps and incorrect assumptions. This helps them expand test coverage and strengthen the overall testing process for improved software quality.
In this guide, you’ll learn how test execution works. We explain the common approaches used by QA teams and how tools like TestRail support the testing process and track results.
What is test execution?
Test execution is the process of running test cases and comparing actual results against expected outcomes. QA teams use test execution to confirm that software behaves as intended, identify defects, and generate the results stakeholders need to evaluate release readiness.
In the software testing lifecycle, test execution typically happens after requirements analysis, test planning, test case design, and test environment setup. It is the point where planned testing work becomes measurable evidence about product quality.
The results from test execution help QA teams answer important questions:
- Does the application meet requirements?
- Which test cases passed, failed, were blocked, or still need to be run?
- Where are defects occurring?
- Is test coverage sufficient?
- Are there risks that need to be resolved before release?
What happens during test execution?
During test execution, QA teams run manual, automated, or hybrid test cases and compare the actual results with the expected results defined during test design.
When results do not match expectations, testers document the issue, add relevant evidence, and report defects to the development team. That evidence may include screenshots, logs, environment details, reproduction steps, browser or device information, and links to the related requirement or user story.
After developers resolve a defect, QA teams retest the fix and may run regression tests to confirm that the change did not introduce new issues elsewhere in the application.
A strong test execution process gives teams a clear record of what was tested, what passed, what failed, and what still needs attention.
Where test execution fits in the testing lifecycle
The Software Testing Life Cycle occurs across six stages. Each part of the process plays a role in evaluating an application’s performance. The phases of the STLC include:
- Requirement analysis: The STLC begins with a comprehensive analysis of an application’s requirements. QA teams determine testing goals and define cases that support test coverage.
- Test planning: During this stage, QA teams determine their testing strategy. They assess the effort required for testing, its costs, and what resources are required. Test planning helps teams outline test timelines, risks, and the appropriate testing environment.
- Test case design: In this phase, QA teams develop and refine test cases. The goal is to create tests that cover an application’s requirements, including critical scenarios and edge cases. At the end of this phase, QA teams have a series of automated and manual tests to use for execution.
- Test execution: QA teams run test cases created during the planning and design phases. They compare expected results with actual outcomes to pinpoint errors and defects.
- Defect tracking and reporting: Errors identified during test execution are thoroughly documented and shared with stakeholders. Developers review the defects and implement fixes to correct errors. QA teams then conduct regression testing to verify that the fixes correct the identified issues and don’t adversely impact other parts of the application.
- Test closure and reporting: During the final phase of the STLC, QA teams evaluate their process, share key results, and determine where improvements can support future testing. They write up a summary of the testing process to provide to stakeholders.
Test execution is a critical step in the STLC. It’s the action phase, where teams run planned tests and identify problems in the software.
Why QA teams run test execution
Test execution helps teams move from assumptions about quality to measurable results. Before software is released, QA teams need to verify that the application works as expected, supports key user workflows, and meets business and technical requirements.
Validate application behavior
Every application has expected behaviors, features, and user workflows. Test execution helps QA teams confirm that those features work correctly in real conditions.
For example, a QA team testing an e-commerce application might execute test cases for account creation, product search, cart updates, checkout, payment processing, and order confirmation. Each result helps confirm whether the application meets its functional requirements.
Identify defects and failures
Users notice when software behaves unexpectedly. Test execution helps QA teams find bugs, crashes, broken workflows, performance issues, and other defects before those issues reach production.
When testers document defects clearly, developers have the context they need to reproduce the issue, understand its impact, and implement a fix.
Measure test coverage and readiness
Test execution results help teams understand how much of the application has been tested and whether the product is ready to move forward.
Common execution statuses include passed, failed, blocked, skipped, retest, or not run, depending on the team’s process and test management tool. Tracking these outcomes helps QA leaders identify gaps, assess risk, and decide whether additional testing is needed.
Types of test execution
Test execution approaches usually fall into three categories: manual, automated, and hybrid.
Manual test execution
Manual test execution happens when testers run test cases by hand without relying on automation scripts to complete the steps. Testers follow defined steps, interact with the application, observe behavior, record evidence, and document results.
Manual testing is especially useful for exploratory work, usability review, complex workflows, and scenarios that require human judgment.
Common manual testing activities include:
- Exploratory testing: Testers explore the application to discover defects, usability concerns, edge cases, or unexpected behavior that scripted tests may miss.
- Ad hoc testing: Testers investigate a specific issue or area of concern without following a formal test plan.
- Usability testing: Teams evaluate how intuitive, efficient, and user-friendly an application is for real users.
- Functional testing: QA teams verify that application features work according to requirements.
- Smoke testing: Teams check critical functionality to determine whether a build is stable enough for deeper testing.
Manual testing can reveal issues that automated tests may overlook. However, relying only on manual execution can slow down delivery, create inconsistent reporting, and make it difficult to scale test coverage as the product grows.
Automated test execution
Automated test execution uses scripts, frameworks, and tools to run tests with minimal human intervention after the automation is configured.
Automation is especially valuable for repetitive, high-volume, and regression-heavy testing. Automated tests can run quickly, execute in parallel, and provide consistent results across builds and environments.
Common tests that are often automated include:
- Unit testing: Tests that validate individual functions, methods, or components.
- Integration testing: Tests that confirm whether modules, services, APIs, or systems work together as expected.
- Regression testing: Tests that verify new code changes did not break existing functionality.
- Performance testing: Tests that evaluate speed, stability, scalability, and behavior under load.
Automated execution requires upfront investment in frameworks, scripts, maintenance, and test data. Over time, it can help teams reduce repetitive manual work and increase confidence in frequent releases.
Hybrid test execution
Hybrid test execution combines manual and automated testing. Many QA teams use this approach because it balances speed, coverage, and human judgment.
In a hybrid model, teams often automate repetitive tests such as regression, unit, and API checks. Manual testers then focus on exploratory testing, usability, complex workflows, edge cases, and areas that require context or interpretation.
A hybrid approach can help QA teams improve coverage, shorten execution cycles, and use tester time more strategically.
The test execution process
Most QA teams follow three core steps during test execution: preparation, execution, and reporting.
1. Prepare for test execution
Before running tests, QA teams review test cases to confirm they are complete, current, and aligned with requirements. They also check that any automated scripts are working and that test data is available.
Preparation may include:
- Reviewing test cases and expected results
- Validating automated scripts
- Preparing the test environment
- Checking permissions, accounts, and integrations
- Confirming devices, browsers, or operating systems
- Creating or refreshing test data
- Assigning test cases to testers
Good preparation reduces blocked tests, duplicate effort, and inconsistent results.
2. Run test cases
During execution, QA teams run the tests defined in the test plan.
For manual tests, testers follow each step, compare actual results with expected outcomes, and document what happened. For automated tests, the automation framework runs the script and generates logs or result files.
In both cases, the goal is to create a reliable record of the test outcome.
3. Report results
After running tests, QA teams review results and assign the appropriate status. Common statuses include:
- Passed: The actual result matched the expected result.
- Failed: The actual result did not match the expected result.
- Blocked: A dependency or issue prevented the test from being completed.
- Skipped or not run: The test was not executed during this cycle.
- Retest: The test needs to be run again after a fix or change.
For failed tests, QA teams document the defect and connect it to the relevant test case, requirement, user story, or release milestone. They also track execution progress, coverage, and defect trends for reporting.
Where test execution breaks down
Even experienced QA teams can run into execution problems. These are some of the most common issues.
Managing large test suites
As an application grows, the test suite often grows with it. Over time, teams may need to manage hundreds or thousands of test cases across features, environments, releases, and teams.
Without a structured system, it becomes difficult to know which tests should be run, who owns them, which tests are outdated, and how results connect to requirements.
A test management tool can help QA teams organize test cases in a central repository, assign tests, filter by priority or area, and track execution progress.
Inconsistent reporting across testers
Different testers may document results in different ways. One tester might include detailed reproduction steps and screenshots, while another may only mark a test as failed.
This inconsistency makes it harder to analyze results, reproduce defects, and report progress accurately.
Standardized test cases, result statuses, templates, and reporting workflows help teams create cleaner execution data.
Coordination gaps in distributed QA teams
Distributed QA teams often work across time zones, locations, and environments. Without clear visibility, teams may duplicate work, miss critical tests, or lose context in chat threads and emails.
Centralized test management helps teams see what has been assigned, what is in progress, what has failed, and what still needs to be completed.
Disconnected manual and automated testing
Manual and automated testing often happen in separate tools. Manual test results may live in spreadsheets, while automation results stay in CI/CD logs.
When results are disconnected, QA leaders have a harder time understanding overall quality. Bringing manual and automated results into a shared reporting workflow helps teams see the full picture.
Test execution best practices
Optimizing test execution starts with incorporating a few best practices into your process.
Prioritize high-risk tests
In a fast-moving development cycle, it’s impossible to test every single scenario that users may face. To keep the project moving, employ a test prioritization strategy that evaluates the most critical features and workflows first. This allows you to verify key functionality early on.
Categorize tests based on their priority level. Top-level tests should cover functions and features that are imperative to a project’s overall functionality. If these tests fail, the application may be unsuitable for release.
Medium-level tests evaluate aspects of a project that are still important but have less impact on the overall application if they don’t work.
Low-level tests cover edge cases and lesser features that users rarely interact with. These tests can be performed outside the regular test cycle, when QA teams may have more time.
Write test cases with clear steps and expected outcomes
Each test case should include a defined list of steps and an expected outcome. This helps facilitate a fast and accurate testing process, providing testers with clear steps to follow without guesswork.
Implementing a test report template supports reporting consistency and defect tracking.
Track pass rates, coverage, and defect density
Monitoring certain metrics during the test execution process helps teams make informed decisions about an application’s readiness. Key metrics to track include:
- Pass/fail rates: Every time a test runs, record the outcome. Monitoring pass and fail rates over time allows teams to identify which functions or features are most susceptible to issues.
- Test coverage: This metric tracks the completeness of testing. Higher test coverage signifies that an application’s components are thoroughly evaluated. A lower metric may indicate the need for additional test cases.
- Defect density: With this metric, teams compare the number of defects with an application’s size or lines of code. High defect density can indicate poor code quality.
Testing management software can monitor metrics and incorporate them into dashboards and reports, giving teams clear insight into an application’s viability.
Managing test execution with TestRail
TestRail helps QA teams plan, organize, execute, and report on testing from a centralized test management platform.
Organize test runs
In TestRail, teams can group selected test cases into structured test runs. Test runs help teams define what needs to be executed during a specific cycle, sprint, release, or regression effort.
QA leads can assign tests to individual testers, track ownership, and monitor progress across projects, environments, and releases.
Monitor execution progress
TestRail helps teams track test results and execution progress in real time. Teams can submit results, assign statuses, add comments, attach evidence, and capture details that support defect investigation.
Dashboards and reports help stakeholders understand which tests passed, failed, were blocked, or still need to be completed.
Connect testing to development workflows
TestRail integrates with tools such as Jira, Azure DevOps, GitHub, and Bugzilla so teams can connect test execution with defects, requirements, and development work.
For CI/CD workflows, teams can use TestRail’s API or CLI to publish automated test results from pipelines and frameworks into TestRail. This helps QA and engineering teams review manual and automated results together instead of jumping between disconnected tools.
Report on quality and release readiness
TestRail reports help teams analyze test execution progress, test plan status, milestone activity, defects, and trends over time.
These reports can help QA leaders communicate release readiness, identify bottlenecks, and show stakeholders where quality risks remain.
Scaling test execution as QA teams grow
In the initial stages of building an application, QA testing needs may be small. However, as the project grows or the company develops more applications, so do the QA requirements expand. These tips can help teams prepare to scale and enhance their test optimization strategies.
Organizing test suites across projects and teams
Testing scalability requires efficient management. Organize tests into dedicated suites for each project, and assign them to specific team members. This gives each tester clear responsibility for their part in the testing process and helps avoid missed or overlooked tests.
Retain traceability over each project’s requirements. Mapping tests to specific parts of a project’s codebase and requisites can help teams manage testing coverage.
Combining manual and automated testing
A hybrid approach to test execution often works best. It leverages the strengths of automation and manual testing strategies to enhance QA team efficiency without sacrificing test coverage.
The exploratory testing common in manual testing can uncover hidden defects that automated testing won’t find. On the other hand, using automated assessments for repetitive testing saves time and allows human testers to focus their efforts on more critical tasks.
Using test data to improve quality
The main purpose of testing is to enhance software quality. QA teams can analyze the data generated from testing and identify recurring issues that indicate problems with specific modules, functions, features, or integrations.
Insights from test execution can strengthen future testing strategies. For example, if tests fail late in the development process, teams may create new test cases to identify problems earlier. This can shorten an application’s software development cycle and minimize late-stage pressure on developers.
From manual tracking to structured test execution
In early-stage software development, teams may be able to track test execution manually. But as products become more complex, manual tracking can create confusion, slow down reporting, and make it harder to understand release readiness.
A structured test execution process helps teams organize test cases, assign ownership, track results, document defects, and connect testing back to requirements. It also gives stakeholders a clearer view of progress and risk.
By combining manual and automated testing, QA teams can improve coverage, reduce repetitive work, and focus tester time on the areas where human judgment matters most.
Test management platforms like TestRail support structured test execution by helping teams manage test cases, organize test runs, track results, integrate with development workflows, and report on quality across projects and releases.
To see how TestRail can support your team’s test execution process. Sign up for a free 30-day trial today.
FAQ
What is test execution in software testing?
Test execution is the process of running planned test cases and comparing actual results with expected outcomes. It helps QA teams verify application behavior, identify defects, and assess release readiness.
What are the main steps in the test execution process?
The main steps are preparing for execution, running test cases, recording results, reporting defects, retesting fixes, and summarizing execution progress for stakeholders.
What is the difference between manual and automated test execution?
Manual test execution is performed by testers who follow test steps and document results by hand. Automated test execution uses scripts and frameworks to run tests and generate results with minimal human intervention after setup.
What metrics should QA teams track during test execution?
QA teams often track pass/fail rate, test coverage, defect density, blocked tests, retest rate, execution progress, and defect severity.
How does TestRail help with test execution?
TestRail helps teams organize test cases, create test runs and plans, assign tests, submit results, track progress, connect defects to development tools, and report on quality across projects and releases.
