Ievgen Ievdokymov

Written by: Senior AQA Engineer

Ievgen Ievdokymov

Updated: 13.11.2026

18 min read

The choice between manual and automated testing is often framed as a contest. It is the wrong question.

Manual testing is valuable when a person needs to investigate, interpret, or notice something unexpected. Automation is valuable when a team needs the same check to run quickly, consistently, and repeatedly. Most products need both.

Industry data supports this mixed approach. Katalon’s 2025 State of Software Quality survey, based on responses from more than 1,400 QA professionals, found that 82% still use manual testing in their daily work, while regression testing is the most commonly automated category. Meanwhile, the World Quality Report 2025–26 reported that organizations with test-case automation had automated an average of 33% of their tests.

These numbers do not suggest that automation has failed. They show that software testing involves more than executing predefined checks.

Manual vs automated testing: The short answer

Manual testing means a person directly explores or evaluates the software, using their judgment to interpret its behavior.

Automated testing uses scripts and tools to perform predefined actions, compare actual and expected results, and report what happened.

Use automation for stable, repeatable, and frequently executed checks. Use manual testing for exploration, usability, new functionality, ambiguous behavior, and situations that require human interpretation.

For most projects, the right answer is not manual or automated testing. It is a deliberate combination based on product risk, execution frequency, feedback speed, and maintenance cost.

Manual and automated testing in numbers

Recent industry surveys illustrate why neither approach is disappearing:

  • 82% of testers use manual testing in their daily work, according to Katalon’s survey of more than 1,400 QA professionals.

  • Around 45% automate regression testing, making it the most commonly automated testing type in the same survey.

  • Respondents named insufficient testing time at 55% and high workload at 44% among their most common barriers to meeting quality goals.

  • The World Quality Report 2025–26 found that the average share of automated test cases was 33%.

  • The same report found that 60% of organizations struggle with secure, scalable test data, a reminder that writing scripts is only one part of successful automation.

  • While 43% of organizations are experimenting with generative AI in quality assurance, only 15% have scaled it enterprise-wide, according to Capgemini’s report highlights.

These figures come from surveys with different respondent groups and methodologies, so they should not be treated as universal benchmarks. Their shared message is more useful: teams are expanding automation while continuing to depend on human-led testing.

What is manual testing?

Manual testing is the process of examining software with direct human involvement. A tester interacts with the system, observes its behavior, compares results with expectations, and investigates anything unusual.

That can include following a documented test case, but modern manual testing is broader than clicking through a list of steps. It may involve:

  • exploratory testing;

  • scenario-based testing;

  • usability evaluation;

  • accessibility review;

  • requirements analysis;

  • API exploration;

  • checking network requests and logs;

  • querying a database;

  • reproducing production defects;

  • evaluating workflows from a user’s perspective;

  • user acceptance testing.

A manual tester may use browser developer tools, API clients, database consoles, proxies, logs, device farms, and monitoring dashboards. The fact that the final judgment is made by a person does not make the work non-technical.

Manual testing is especially useful when the tester needs to learn while testing. An unexpected result can change the next question, action, or hypothesis. That adaptability is difficult to reproduce with a predefined script.

What is automated testing?

Automated testing uses software to execute checks, prepare test conditions, compare results, and produce evidence with limited human intervention during each run.

It is not limited to browser automation. Automated checks may operate at several levels:

  • unit;

  • component;

  • API;

  • integration;

  • database;

  • UI and end-to-end;

  • visual regression;

  • performance;

  • compatibility;

  • security scanning.

A well-designed automated test can run after every code change, across multiple configurations, or as part of a CI/CD pipeline. This makes automation particularly useful for fast feedback and regression protection.

However, automation does not decide what quality means. People still need to identify risks, design the checks, define expected results, maintain the suite, investigate failures, and decide whether the available evidence is sufficient for release.

An automated test can pass because the product works. It can also pass because the test checks the wrong thing.

Manual vs automated testing: Key differences

Criterion
Manual testing
Automated testing

Execution

Performed directly by a person

Performed by scripts and tools

Initial setup

Usually lower

Usually higher

Cost per repeated run

Remains significant

Usually decreases after implementation

Execution speed

Limited by available human time

Fast and often parallel

Repeatability

May vary between executions

High when tests and environments are reliable

Adaptability

Tester can change direction immediately

Requires code, data, or configuration changes

Human judgment

A central strength

Limited to programmed expectations

Exploratory capability

High

Can support exploration but cannot fully replace it

CI/CD integration

Limited

One of the main use cases

Scalability

Requires additional people or time

Can scale across data and configurations

Maintenance

Test cases, knowledge, and documentation

Test code, infrastructure, data, and environments

Failure analysis

Often happens during execution

Usually requires later review of logs, traces, and reports

Best suited for

New, ambiguous, or experience-heavy areas

Frequent, stable, and deterministic checks

Main risk

Slow, inconsistent, or incomplete repeated execution

Flakiness, maintenance burden, and false confidence

The most important cost difference appears over time. A manual check can be faster and cheaper to perform once. The same check may become a strong automation candidate if the team expects to run it hundreds of times.

Advantages of manual testing

1. Human observation and judgment

A person can recognize that a technically correct result is confusing, misleading, or difficult to use. A script may verify that a button exists and responds to a click, while a tester notices that it is hard to find, overlaps another element, or uses an unclear label.

2. Adaptability

Manual testers can adjust their approach as they learn. If an error appears after changing a setting, the tester can investigate related states, permissions, or workflows without waiting for a new script.

3. Effective exploration

Exploratory testing combines learning, test design, and execution. It is useful when risks are unknown or requirements do not describe every meaningful behavior.

4. Fast start for new functionality

A tester can begin evaluating a new feature before the interface and requirements are stable enough to justify automation.

5. Better evaluation of user experience

Usability, clarity, visual hierarchy, trust, and emotional response cannot be reduced to simple pass/fail rules. Tools can gather data and identify some violations, but people still need to interpret the experience.

6. Lower setup effort for one-time checks

If a scenario will be tested only once, implementing and maintaining automation may cost more than executing it manually.

Limitations of manual testing

1. Repeated execution consumes time

Running the same regression checks before every release creates an ongoing cost. As the product grows, the regression cycle may become a delivery bottleneck.

2. Limited scalability

It is difficult to manually repeat the same scenarios across many browsers, devices, roles, configurations, and datasets.

3. Inconsistent execution

People may interpret instructions differently, follow slightly different paths, or miss a step during repetitive work. Clear test cases and session charters reduce this risk but do not eliminate it.

4. Slow feedback

A large manual regression suite may provide results hours or days after a change was made. By then, developers have moved to other work and the context is less fresh.

5. Poor fit for continuous release gates

A delivery pipeline needs repeatable evidence without waiting for a person to execute the same checks after every commit.

These limitations do not make manual testing obsolete. They indicate that repetitive execution should not consume the time needed for investigation and risk analysis.

Advantages of automated testing

1. Fast, repeatable feedback

Automated checks can run after every relevant change and return results while the developer still remembers the code.

DORA’s guidance on test automation connects fast, reliable automated test suites in delivery pipelines with better software stability, less deployment pain, and lower team burnout.

2. Efficient regression coverage

Stable regression and smoke scenarios can be executed regularly without requiring a tester to repeat every step manually. This is one of the strongest use cases for test automation.

3. Parallel execution

Automation can test multiple configurations and datasets at the same time, reducing the total feedback cycle.

4. CI/CD integration

Unit, API, integration, security, and UI checks can be placed at appropriate stages of the delivery pipeline. A failed critical check can stop a risky change before deployment.

5. Consistent evidence

Automated tests perform the same programmed actions and produce logs, screenshots, traces, and reports that can support investigation and release decisions.

6. Coverage of data-heavy scenarios

Automation is effective when the same business rule must be evaluated against many inputs, boundaries, and combinations.

7. Earlier defect detection

Unit, component, and API checks can detect failures before a complete user interface is available. Fixing a problem at this stage is usually easier than finding it during release regression.

Limitations of automated testing

1. Implementation and maintenance costs

Automation requires more than writing the first script. Teams also need to maintain:

  • frameworks and dependencies;

  • test data;

  • environments;

  • integrations;

  • selectors and contracts;

  • CI/CD infrastructure;

  • reports and dashboards.

These costs continue throughout the life of the product.

2. Flaky tests

An automated test is flaky when it sometimes passes and sometimes fails without a relevant change in the product. Common causes include shared data, timing assumptions, unstable environments, external services, and dependencies between tests.

Once a suite becomes noisy, teams may ignore failures or rerun tests until they pass. At that point, automation stops being reliable evidence.

3. Limited interpretation

A script can compare an observed result with a programmed expectation. It does not automatically understand whether that expectation is incomplete, outdated, or harmful to the user.

4. False confidence

A large number of passing tests may create the impression that the product is safe to release. The suite may still miss incorrect assumptions, untested integrations, usability problems, or risks nobody anticipated.

5. Dependence on test data and environments

The World Quality Report finding that 60% of organizations struggle with secure, scalable test data is significant here. A test can be perfectly coded and still produce weak evidence because its data or environment does not represent the required conditions.

6. Failure investigation still requires people

An automated test reports a symptom. A person usually needs to determine whether the failure comes from the product, test code, environment, data, or an external dependency.

Which tests should be automated?

A test is usually a good automation candidate when several of the following are true:

  • it is executed frequently;

  • the expected result is clear and deterministic;

  • it protects a critical business flow;

  • it needs to run after many code changes;

  • it uses multiple datasets or configurations;

  • manual execution is slow or error-prone;

  • it should run in parallel;

  • it will remain relevant long enough to justify maintenance;

  • the environment and data can be prepared reliably;

  • quick feedback changes what the team does next.

Common examples include:

  • authentication and authorization checks;

  • checkout and payment workflows;

  • smoke tests;

  • stable regression scenarios;

  • API contracts;

  • business calculations;

  • data validation;

  • permissions;

  • repetitive cross-browser checks;

  • performance workloads;

  • build and deployment verification.

A critical scenario should not automatically be automated at the UI level. The team should first ask where the behavior can be checked most quickly and reliably. An API or component test may provide better feedback than a slow end-to-end script.

Which tests should remain manual?

Human-led testing is usually more valuable when:

  • the feature is new and changing rapidly;

  • the team is still learning how the feature should behave;

  • the expected result is subjective or ambiguous;

  • the evaluation depends on perception or experience;

  • the scenario will be executed only once;

  • automation would require disproportionate setup;

  • the tester needs to react to unexpected behavior;

  • a business stakeholder must judge fitness for use;

  • the product risk is not yet well understood.

Examples include:

  • exploratory testing of new functionality;

  • usability evaluation;

  • early prototypes;

  • assessment of onboarding clarity;

  • stakeholder acceptance testing;

  • unusual edge cases;

  • one-time migration investigations;

  • visual and interaction reviews;

  • investigating an escaped production defect.

Some of these activities can be supported by automation. Test data may be prepared automatically, accounts may be created through APIs, and exploratory sessions may use automated monitoring. The investigation itself remains human-led.

Decision matrix: Manual, automated, or both?

Testing situation
Recommended approach
Reason

Stable checkout regression run every day

Automated

Critical, frequent, and repeatable

New checkout redesign

Both

Explore behavior first, then protect stable flows

API contract validation

Automated

Inputs and expected outputs are clear

First-time user onboarding

Manual

Requires observation and usability judgment

Accessibility testing

Both

Scanners find some issues; human checks remain necessary

Performance testing

Primarily automated

Requires controlled workloads and repeatable measurements

Security testing

Both

Automated scanning and checks plus expert investigation

Visual regression

Both

Tools detect differences; people decide whether they matter

User acceptance testing

Primarily manual

Business stakeholders evaluate fitness for use

One-time data migration

Both

Automated reconciliation plus investigation of anomalies

Compatibility across many browser versions

Both

Automate repeatable flows and manually inspect meaningful differences

Recovery after a third-party outage

Both

Automate predictable states and explore unexpected interactions

Example: Testing saved payment methods

Consider a release that allows customers to store a payment method and use it during future purchases.

A weak strategy would be either to automate every test case or to test the feature entirely by hand. A better strategy allocates work according to risk.

Good automation candidates

  • associating a payment token with the correct account;

  • rejecting unauthorized access to another user’s token;

  • preventing duplicate charges after retries;

  • processing valid, declined, and expired cards;

  • preserving existing guest checkout behavior;

  • validating payment API responses;

  • running daily smoke tests;

  • checking stable flows across supported browsers.

These scenarios have clear expected results and need regular regression protection.

Human-led testing

  • whether payment choices are understandable;

  • whether error messages help the user recover;

  • how the flow feels after interruptions;

  • whether trust and security information is displayed clearly;

  • exploratory testing around changing accounts, sessions, and devices;

  • unexpected paths discovered during testing.

Combined testing

Accessibility can begin with automated scans but should include keyboard navigation and assistive-technology checks. Visual regression can identify changed screens, while a tester decides whether the change is a defect. Automated scripts can create complex payment states, leaving the tester more time to investigate behavior.

This division gives automation the repeatable work and people the uncertain work.

How to calculate whether automation is worth it

Automation ROI cannot be estimated from execution speed alone.

A simple break-even calculation is:

Initial automation effort ÷ (manual effort per run − automated operating effort per run)

Suppose a regression scenario takes 30 minutes to execute manually. Automating it takes eight hours, while reviewing each automated run requires five minutes.

The approximate break-even point is:

8 hours ÷ (0.5 hours − 0.083 hours) = about 19 runs

After approximately 19 runs, the execution savings begin to exceed the initial implementation effort.

This calculation is useful but incomplete. The automated operating cost should also include:

  • maintenance;

  • failure triage;

  • framework upgrades;

  • infrastructure;

  • test data;

  • environment preparation;

  • reporting;

  • time lost to flaky results.

Automation may still be valuable before it produces direct labor savings. A critical test that runs on every code change can prevent a costly defect or reduce the feedback cycle from days to minutes.

Likewise, a test with an attractive theoretical ROI may be a poor investment if it is unstable and generates more investigation than useful feedback.

How manual and automated testing work together

A balanced workflow may look like this:

1.

Developers create unit, component, and integration checks while implementing the change.

2.

QA analyzes risk and explores the new functionality.

3.

Manual testing reveals edge cases and incorrect assumptions.

4.

Stable, valuable scenarios become automation candidates.

5.

Automated suites run in CI/CD and provide regression feedback.

6.

QA investigates failures and performs targeted exploratory testing.

7.

Production issues and user feedback reveal gaps in the existing coverage.

8.

The team adds, improves, or removes tests based on what it learns.

Automation does not remove testing work. It shifts human effort away from routine execution and toward investigation, test design, and risk management.

Choosing the right balance

Automate checks that gain value from speed, repetition, and consistency. Keep people focused on uncertainty, investigation, and product experience.

That balance will change as the product matures. New features may begin with exploratory testing and later gain automated regression coverage. Some automated checks will become obsolete. New production risks will require new forms of testing.

A healthy strategy reviews those decisions continuously instead of pursuing a fixed automation target.

If your regression cycle is slowing releases – or your current test suite produces more noise than confidence – DeviQA’s test automation consultants can assess your process and create a risk-based roadmap for manual and automated coverage.

Curious how your QA could scale?

Frequently asked questions

What is the main difference between manual and automated testing?

Manual testing involves a person directly investigating and evaluating software. Automated testing uses scripts and tools to perform predefined checks. Manual testing is adaptive and judgment-driven, while automation provides fast, repeatable execution.

Is automated testing better than manual testing?

Neither is universally better. Automation is more effective for frequent and deterministic checks. Manual testing is more effective for exploration, usability, changing functionality, and situations requiring human interpretation.

Can automation completely replace manual testing?

No. Automation can substantially reduce repetitive manual execution, but it cannot fully replace exploratory testing, usability evaluation, risk analysis, or human interpretation of unexpected behavior.

Which tests should be automated first?

Begin with stable, business-critical scenarios that run frequently and have clear expected results. Smoke tests, APIs, core business rules, and high-value regression checks are common starting points.

Which tests should not be automated?

Avoid or postpone automation for one-time checks, rapidly changing features, ambiguous requirements, subjective evaluations, and scenarios whose maintenance cost will exceed their expected value.

Is manual testing still relevant?

Yes. Katalon’s 2025 survey found that 82% of testers still used manual testing in their daily work. Its role is moving away from repetitive execution and toward exploration, investigation, product understanding, and user experience.

Is automation always cheaper?

No. Automation has implementation, maintenance, infrastructure, data, and investigation costs. It becomes economically attractive when valuable checks are repeated often enough or when faster feedback reduces delivery risk.

What percentage of tests should be automated?

There is no universal target. The appropriate level depends on architecture, release frequency, product risk, testability, and maintenance capacity. Coverage of critical risks is more informative than an overall automation percentage.

Does automation testing require coding?

Many automation approaches require programming or scripting knowledge. Low-code tools can reduce the barrier for some scenarios, but reliable automation still requires technical understanding of data, environments, application behavior, debugging, and maintenance.

How does AI affect manual and automated testing?

AI can help generate test ideas, data, scripts, and reports or analyze failures. It does not remove the need to review expected results, prioritize risks, investigate behavior, and maintain reproducible release evidence.

When should a startup introduce test automation?

A startup should consider automation when critical flows become stable, releases become frequent, and manual regression begins slowing delivery. Starting with a small API or smoke suite is usually more sustainable than attempting to automate the entire product.

Ievgen Ievdokymov

About the author

Ievgen Ievdokymov

Senior AQA engineer

Ievgen Ievdokymov is a Senior AQA Engineer at DeviQA, focused on building efficient, scalable testing processes for modern software products.