
How to Convert Manual Test Cases Into Automated Tests With AI (2026)
Liviu Lupei
Founder & Solutions Architect, Endtest · November 17, 2026
From Excel spreadsheets and test management tools to reliable, readable automation, without turning your test suite into a pile of generated code.
By Liviu Lupei, Founder of Endtest
Published November 17, 2026 · Last updated November 17, 2026
Key takeaways
- Yes, AI can convert manual test cases into automated tests. The useful output isn't just working code. It's a test your team can understand, review, reuse, and maintain.
- A spreadsheet full of manual instructions is a starting point, not a complete specification. Vague expected results, missing test data, and undocumented dependencies still need attention.
- Claude, ChatGPT, and other coding assistants can generate Playwright or Selenium scripts, but they don't automatically give you a maintainable test framework or the infrastructure to run complex end-to-end scenarios.
- Endtest's AI Test Creation Agent works with the actual web application and generates regular, editable Endtest steps, rather than leaving you with generated Playwright code or an AI prompt that must be interpreted on every run.
- AI remains optional after creation. Standard Endtest steps can be reviewed, edited, reused, and executed without AI. You can still use AI for failure analysis, specialized assertions, and maintenance when it helps.
- Disclosure: Endtest publishes this article. The workflow examples below are illustrative, not the results of a benchmark. Features and prices were checked against public documentation on November 17, 2026.
There's probably a spreadsheet somewhere in your company with a few hundred manual test cases in it.
Maybe the tests live in TestRail, Zephyr, Jira, or a collection of Google Sheets. A few were written years ago. Some still reference buttons that no longer exist. Others are perfectly good descriptions of business processes that people keep repeating every release.
A typical test might say:
- Open the application.
- Enter a valid username and password.
- Click Login.
- Open Account Settings.
- Change the display name.
- Click Save.
- Verify the new name appears.
A human tester can execute that without much trouble. The trouble is doing it again tomorrow, then next week, then on three browsers after every release.
Now that AI can write code and operate browsers, converting those instructions into automated tests seems straightforward. Upload the spreadsheet to an AI assistant, ask for Playwright scripts, and you're finished.
Well, you might be finished creating the scripts.
You haven't necessarily created a testing system anyone can maintain.
Can AI convert manual test cases into automated tests?
Yes. AI can read plain-English test cases from Excel, CSV files, and test management exports and turn them into automated test actions and assertions. Some tools only generate source code. Others, including Endtest's AI Test Creation Agent, interact with the application itself and produce editable test steps.
A good conversion process should do five things:
- Interpret the intent. Understand what the tester wants to accomplish, not just the words in a spreadsheet cell.
- Inspect the application. Identify the correct controls, pages, and transitions instead of guessing selectors.
- Create reliable actions and assertions. Use appropriate locators, waits, and checks for the expected result.
- Reuse shared workflows. Keep login, navigation, and setup logic in common components rather than copying them everywhere.
- Leave behind understandable tests. Someone other than the person who generated them should be able to read and change them.
The fifth point is the one I'd spend the most time evaluating.
What does a manual-to-automated test conversion look like?
Consider a fictional SaaS application. Its manual tests are stored in Excel with columns for Test case, Step, Instruction, and Expected result.
| Test case | Step | Manual instruction | Expected result |
|---|---|---|---|
| Update profile | 1 | Log in with a valid test account | Dashboard is visible |
| Update profile | 2 | Open Account Settings | Settings page is displayed |
| Update profile | 3 | Enter "Sample Tester" as the display name | Field contains the new name |
| Update profile | 4 | Click Save | Success message is displayed |
| Update profile | 5 | Refresh the page | Updated name is still displayed |
The last step matters. Without it, you might verify that a success message appeared while missing the fact that the change wasn't actually saved.
A well-converted automated test might look like this:
| Automated step | Purpose |
|---|---|
| Import Test Case: Login | Reuse the existing authentication workflow |
| Click: Account Settings | Navigate to the right page |
Write Text: Display Name → Sample Tester | Enter the new value |
| Click: Save | Submit the change |
| Assert: Success message is visible | Verify immediate feedback |
| Refresh page | Check persistence |
Assert: Display Name equals Sample Tester | Verify the change was actually stored |
Illustrative mapping, not a screenshot or output from a measured Endtest run. The actual generated actions and locators depend on the application.
You should be able to open a generated test and see which action it performs, which element it targets, and what it verifies. A generic instruction such as "check that the settings work" isn't enough. The expected result needs to be specific.
That's why I'd clean up unclear manual tests before attempting a large migration. AI can make reasonable guesses. It can't know whether those guesses match an undocumented business requirement.
Three ways to convert manual tests into automation
There isn't one method that makes sense for every team. These are the main options.
| Approach | What you get | Who maintains it | Best fit |
|---|---|---|---|
| Write Selenium or Playwright tests manually | Source code with explicit actions and assertions | Developers or test automation engineers | Engineering-led teams that want full control |
| Use ChatGPT, Claude, or a coding agent to generate Playwright/Selenium | Generated source code, often with helper functions | Someone who understands and owns that codebase | Teams that already have a framework, code review, and engineering capacity |
| Use Endtest's AI Test Creation Agent | Native, human-readable test steps in a no-code editor | Testers, QA engineers, and other team members | Teams converting existing manual tests without wanting to own a custom code framework |
These aren't mutually exclusive approaches. A mature QA team might use both coded unit or integration tests and no-code end-to-end tests.
What matters is who will own the result six months after the migration.
Why dumping an Excel file into Claude can create spaghetti Playwright tests
Imagine importing 600 manual test cases into a coding assistant and asking it to produce a Playwright suite.
The first batch looks promising. The generated scripts click the right buttons, enter values, and pass on the developer's laptop.
Then someone changes the login page.
A few tests use getByRole(). Others use CSS classes. Some have their own login() helper. Several repeat the login steps directly. One script waits three seconds because the generated code couldn't figure out when the page was ready.
Now 80 tests fail for different reasons.
You ask AI to repair them. It changes some locators, adds another helper, and renames a fixture. The tests pass again, except for the ones that don't.
You've traded a library of readable manual instructions for a codebase that the original testing team may not be equipped to maintain.
I call that spaghetti Playwright. Not because Playwright is inherently messy, but because generating lots of scripts is much easier than establishing consistent engineering practices.
To be fair, Playwright is an excellent framework. Its locators, auto-waiting, fixtures, traces, and page object patterns can be used to build very maintainable tests. Playwright's own documentation describes reusable page object models. Good teams use them successfully.
But somebody still has to design and maintain the framework, review code, manage dependencies, and decide how tests are organized. AI doesn't remove that responsibility.
For a wider explanation of this failure mode, read Why Playwright and Selenium Projects Fail.
For organizations whose starting point is a library of instructions written by manual testers, a more natural destination is often another library of human-readable steps that actually execute.
How to convert manual tests using Endtest's AI Test Creation Agent
This is where Endtest takes a different approach.
Instead of using a general-purpose model solely to generate browser automation code, the AI Test Creation Agent works inside a complete testing platform. It can navigate the actual web application, interpret the requested workflow, and generate regular Endtest test steps.
Those steps are then visible in the same editor used to create and maintain tests manually.
1. Prepare the manual instructions
Start with a small group of test cases from Excel, TestRail, Jira, or another test management system.
Export to a convenient format, such as CSV or text, and make sure each case includes the prerequisites, steps, test data, and expected results. The agent can also use files attached to its prompt as supporting context. If you're migrating scripts exported from an existing automation tool, Endtest has a separate AI Test Import feature for structured exports.
Don't paste real passwords or customer data into the instructions. Use dedicated test accounts and secure secret handling.
2. Start the agent against your application
In Endtest, go to Web Tests → New Test Suite → Use AI. Provide the starting URL and instructions. The agent needs access to the application, whether that's a reachable staging URL or an appropriately configured restricted environment.
You can work in Granular mode, where instructions are specific, or High-Level mode, where you describe the broader journey.
For an existing manual test library, I'd start with Granular mode. You already have the steps. Let the agent automate them before asking it to make broader decisions.
3. Let the agent inspect the page and generate steps
The agent interacts with the actual interface. When a manual instruction says "Click Save," it can inspect the page, identify the relevant control, and create a step with a locator.
That's more useful than asking a text-only assistant to invent selectors for a page it hasn't inspected.
It's still important to review the result. A locator can be valid today and fragile tomorrow. Prefer stable identifiers and meaningful element attributes when available; avoid selectors that depend on incidental layout or changing element positions.
4. Review the output in the no-code editor
The generated result consists of standard Endtest actions and assertions, not a Playwright codebase.
You can inspect each action, modify a locator, change a value, add an assertion, or remove an unnecessary step without opening a code editor or asking another AI model.
This is the key difference: AI helps build the test, but it doesn't become the language you need to speak to understand the test.
5. Reuse login and other common workflows
Suppose 200 of your manual tests begin with the same sign-in procedure.
You shouldn't generate 200 independent copies of it. Build a shared Login test case and reuse it with Endtest's Import Test Case action.
The agent can also continue from a specific point in an existing test, which is useful when the setup and login have already been created. You don't have to regenerate those earlier steps every time you expand coverage.
Reusable logic matters more than the speed of the initial conversion. When authentication changes, you want one shared workflow to update, not hundreds of nearly identical copies.
6. Run the resulting test without AI
Once the generated test consists of regular Endtest steps, it can execute through the normal test runner.
A click remains a click. A fixed assertion remains a fixed assertion. Endtest does not need to call a general-purpose AI model to interpret every routine action on every run.
You can still use AI where it adds value:
- Analyze Failures with AI can examine errors, screenshots, page source, and step details to suggest likely causes and fixes.
- AI Assertions can evaluate fuzzy conditions, such as whether a page appears to be in the right language or whether a complex visual condition is met. Those particular steps do use AI at runtime.
- AI Variables can help extract or transform information using natural-language instructions.
- Self-healing can help with certain locator changes, while people retain control over the test steps.
AI is useful. Making every ordinary test action depend on AI is a design choice, not a requirement.
What makes a converted test reliable?
Readable output is essential, but readable tests can still be bad tests.
I'd review every converted test against a short checklist:
| Check | What good looks like |
|---|---|
| Locator quality | Targets meaningful attributes or stable identifiers, not brittle positional selectors |
| Assertions | Checks business outcomes, not just whether a button was clicked |
| Synchronization | Waits for the actual condition, not a guessed fixed delay |
| Test data | Uses dedicated accounts and repeatable, isolated test records |
| Reuse | Common login, setup, and cleanup steps are shared |
| Debuggability | Someone can find the failing step and understand why it failed |
| Independence | Tests don't silently depend on another test having run first |
| Cross-browser coverage | Critical scenarios run on the browsers customers actually use |
The first version of a generated test is a draft. Review it, run it repeatedly, and improve it. That's the same standard I'd apply to code written by a person.
Good technical support matters during a test automation migration
When you're converting hundreds of manual test cases, you're going to run into edge cases. An authentication flow might behave differently than expected. A third-party component may be difficult to automate. Or a test might fail only on a particular browser.
At that point, helpful technical support can be just as important as another AI feature. You want someone who understands test automation and can help you figure out what's actually going wrong.
It's an area where Endtest gets a lot of positive feedback. Endtest has 60 reviews and a 4.6/5 rating on G2 as of November 2026. Customer support is a recurring theme in those reviews, and G2's own summary specifically highlights how frequently users praise the team's responsiveness and helpfulness. Reviewers describe getting useful answers and help resolving difficult issues.
That matters during a migration. AI can create the first version of a test, but access to experienced people when a tricky scenario fails can save a team hours of trial and error.
Complex manual tests involve more than clicking buttons
A manual tester may have a test case like this:
- Create a new account.
- Open the confirmation email and activate it.
- Log in and receive an SMS verification code.
- Enter the code.
- Choose a subscription plan.
- Complete payment through a third-party provider.
- Check that the account has the correct subscription status.
A coding assistant may generate browser code for these instructions. But a complete, reliable test also needs mailboxes, SMS access, API capabilities, and a browser environment that can handle redirects, new tabs, and embedded payment fields.
That's not an exotic scenario. It's a fairly ordinary SaaS onboarding flow.
Email and SMS. You need a way to receive messages, extract activation links or one-time codes, and verify the contents. Endtest includes email and SMS testing capabilities, so these don't have to be separately assembled from unrelated services.
API requests. Sometimes the best way to prepare a test is to create a record through an API, then verify the result through the user interface. Other times you want to check an API response after the browser workflow completes. Endtest supports API requests as part of testing workflows.
Multiple tabs and nested iframes. Payment providers and authentication systems frequently introduce new tabs, redirects, or iframe-based forms. A useful automated test has to follow the user's real path through those components. Skipping them just to make the test easier can remove the very coverage the manual test provided.
Files and database checks. Some flows involve uploading a document, checking a downloaded PDF, or verifying that the correct record was created in a database. Those capabilities are part of the broader platform rather than something the AI must improvise from a prompt.
When comparing tools, give vendors a difficult test from your own system, not just a login demo.
Why Safari matters when converting manual tests
Here's an easy way to accidentally lose coverage during the migration.
Your manual testing team runs critical flows in Chrome, Firefox, Edge, and Safari. The new automation team moves everything to Playwright and checks Chromium, Firefox, and WebKit. The migration report says all four browsers are covered.
Except WebKit is not the actual Safari browser.
Playwright's browser documentation explains that its WebKit build is based on upstream WebKit sources and that Playwright doesn't automate the branded Safari browser. WebKit testing is useful, but it's not a replacement for checking an important flow in Safari on macOS.
Safari-specific issues can show up in authentication, downloads, payment flows, file handling, rendering, and interactions with third-party components.
Endtest runs tests on real browsers on Windows and macOS, including real Safari. The steps created by its AI agent can be executed in those environments without rewriting the test in a different language.
Selenium can also drive real Safari using SafariDriver. The difference is that a self-managed Selenium setup still needs access to compatible macOS machines and the related maintenance.
We covered the distinction in detail in Real Safari vs WebKit: Which Tools Automate Real Safari?.
Isn't Playwright free? What's the actual cost of converting manual tests?
The Playwright framework is free. Selenium is free too.
That is a real advantage. And if you have engineers who enjoy building and maintaining automation infrastructure, using an open-source framework can be a sensible choice.
But a framework is only one part of a production testing system.
| Cost area | Typical code-first setup | Endtest approach |
|---|---|---|
| Test authoring | Engineering time; optional AI coding assistant and model usage | AI Test Creation Agent plus no-code editor |
| Browser execution | Local machines, CI runners, or a cloud browser provider | Managed browser execution in the platform |
| Real Safari | Compatible macOS machine or a provider offering real Safari | Real Safari on macOS through Endtest |
| Email verification | Mailbox infrastructure or an email-testing service | Email testing capabilities in the platform |
| SMS verification | Phone numbers, messaging provider, or testing integration | SMS testing capabilities in the platform |
| API and test data | Custom helpers and integrations | Built-in actions and integrations |
| Failure investigations | Engineers reviewing traces and logs; optional AI tools | Results and optional AI failure analysis |
| Maintenance | Review and update code, dependencies, locators, helpers, CI | Edit regular steps; reuse cases; optional AI assistance |
This is a comparison of operational responsibilities, not a priced benchmark. Particular integrations, environments, and features depend on the chosen plan and configuration.
For example, Endtest's published pricing currently starts at $175 per month for Starter and $225 per month for Pro. The published plans list unlimited test executions, unlimited test creation, and unlimited AI usage. Parallel execution is limited by the number of slots in the plan, and enterprise requirements may need a custom plan.
A code-first setup may cost less if your organization already owns the machines, integrations, and engineering time. But when you add paid browser infrastructure, real Safari capacity, email and SMS testing, AI usage, artifact storage, and ongoing maintenance, the total cost can exceed an Endtest subscription.
I wouldn't evaluate this on framework license price alone. I'd calculate what the entire testing system costs to operate over a year.
Is it secure to upload manual tests to AI?
Manual test files sometimes contain things that shouldn't be casually uploaded to a general-purpose AI service: internal application URLs, real credentials, customer names, API tokens, screenshots, and descriptions of systems behind a firewall.
The risk isn't limited to the initial file upload. A browser agent may also process page source, screenshots, cookies, logs, or data returned by the application.
Before using any AI-powered testing service, ask:
- What data is sent to the AI model, and for which features?
- Can tests run with synthetic data and dedicated low-privilege accounts?
- Where do screenshots, logs, recordings, and uploaded files go?
- What are the retention, access-control, and deletion policies?
- Can the test environment be reached without exposing internal systems unnecessarily?
- Can the organization review or restrict optional AI features?
Endtest has received ISO/IEC 27001 certification, based on the internationally recognized standard for information security management. That's meaningful evidence of a formal security management program, not a promise that every possible customer configuration is automatically secure.
For organizations with stricter requirements, Endtest also offers on-premises and customer-hosted deployment options. The deployment and AI configuration should be reviewed against the organization's own security requirements.
Treat the conversion project like any other software project with access to test environments and credentials. Use synthetic data by default, avoid copying production secrets into prompts, and give the agent only the access it needs. OWASP's secrets management guidance is a useful starting point.
For a deeper discussion of the risks of combining automation frameworks, browser agents, and AI services, see Is Playwright Secure?.
How to migrate hundreds or thousands of manual test cases
I'd avoid starting with "convert all 2,000 cases by Friday." You can generate a lot of automation quickly and still end up with poor coverage.
A better migration plan looks like this:
- Inventory the manual tests. Export them from Excel or the test management system. Identify duplicates, outdated instructions, and cases that still need human judgment.
- Prioritize business-critical workflows. Login, checkout, account creation, billing, permissions, and other revenue- or security-sensitive flows are usually a better starting point than low-value UI checks.
- Improve ambiguous cases. Every test should define prerequisites, inputs, actions, and expected outcomes. Clarify phrases like "verify everything works."
- Convert 10–20 representative cases first. Include simple flows and difficult ones involving email, SMS, iframes, APIs, or multiple tabs. This is a pilot, not a benchmark.
- Review locators and assertions. Check that the generated steps test the right behavior. Refactor login, setup, and other repeated actions into reusable components.
- Run the tests repeatedly and across relevant browsers. A single successful run doesn't establish reliability. Investigate failures and confirm that the test gives useful evidence when the application is wrong.
- Expand in batches, with an owner and review process. Track which manual cases were converted, which were retired, which still require human testing, and who maintains the automated versions.
Keep the old test case identifiers during the migration if you can. That makes it easier to trace a failed automated test back to the original business requirement and to show stakeholders what has actually been covered.
A sensible completion metric isn't "number of scripts generated." It's number of important scenarios that run reliably, catch real failures, and can be maintained by the team.
Frequently asked questions
Can AI convert an Excel spreadsheet of manual test cases into automated tests?
Yes. AI tools can interpret the instructions and expected results in Excel or CSV files and turn them into automated actions. Endtest's AI Test Creation Agent can use files as context while working with the application; CSV and other exported formats can also be used in migration workflows. Review the generated tests before adding them to CI or scheduled runs.
Can ChatGPT or Claude generate Playwright tests from manual instructions?
Yes. They can generate Playwright or Selenium code from natural-language test cases. The generated scripts still need code review, testing, framework integration, and ongoing maintenance. If the team doesn't want to maintain a codebase, a no-code platform may be a better fit.
What is the best AI tool for converting manual tests into automated tests?
Endtest is our recommendation for teams starting with human-readable manual tests and wanting human-readable automated tests afterward. Its AI Test Creation Agent produces editable native steps, while the platform handles execution and many common end-to-end integrations. Playwright or Selenium may be preferable for developer-led teams that want source-code ownership and full framework control.
Can I convert TestRail, Jira, or Zephyr test cases into automation?
Yes, provided you can export or copy the relevant instructions and expected results into a usable format. Confirm that any field mappings, attachments, test data, and prerequisites carry over. A test case management export doesn't necessarily contain enough detail to generate a reliable automated assertion without review.
Can manual tests be automated without knowing how to code?
Yes. Endtest lets teams generate and maintain tests through an AI-assisted, no-code editor. You'll still need to understand the application and its expected behavior, but you don't need to write Playwright or Selenium scripts for ordinary test maintenance.
Do Endtest tests need AI every time they run?
No. The AI Test Creation Agent generates regular Endtest steps that can execute without AI interpreting each routine action. Optional AI Assertions and some other AI features use AI when invoked, so whether a particular test calls AI depends on the steps you choose.
Can converted tests reuse existing login steps?
Yes. Endtest supports reusable test cases through Import Test Case. You can maintain login once and reference it from other tests. The AI Test Creation Agent can also continue from a point in an existing test, rather than creating the earlier workflow again.
Can manual tests involving emails, SMS, APIs, and payment iframes be automated?
Yes. They require more than basic click-and-type automation, but a complete testing platform can handle these flows. Endtest supports email and SMS testing, API requests, multiple tabs, iframe interactions, and other components of end-to-end testing. Review the specific requirements of your payment provider and test environment.
Is WebKit the same as Safari for cross-browser testing?
No. WebKit is the engine behind Safari, but Playwright's WebKit build isn't the branded Safari browser. For critical Safari coverage, use real Safari on macOS. Endtest offers real Safari execution; Selenium can also automate Safari through SafariDriver on suitable Macs.
How long does it take to convert 1,000 manual tests?
There isn't a reliable universal estimate. It depends on test quality, workflow complexity, access to the application, the number of shared components, and how much review is needed. Start with a representative pilot, measure review and repair effort, then estimate the remaining migration using your own results.
Is Endtest cheaper than Playwright?
Playwright is free software; Endtest is a subscription service. If a team already has automation engineers and infrastructure, Playwright can be economical. If it needs paid browser capacity, email and SMS integrations, AI services, and ongoing framework maintenance, the full code-first stack may cost more. Compare total operating cost, not just licensing.
Is converting manual test cases with AI secure?
It can be, if the organization controls test data, credentials, access, AI processing, and artifact retention. Avoid uploading production secrets or personal data without a security review. Endtest holds ISO/IEC 27001 certification and offers deployment options for organizations with additional requirements, but each team should assess its own configuration.
The bottom line
AI makes it easier than ever to turn a spreadsheet of manual instructions into executable tests.
That's good news. Manual testers shouldn't have to repeat the same registration, billing, and account settings flows every week just because automating them used to require a developer.
But I wouldn't celebrate generating 1,000 Playwright files if nobody on the testing team could confidently change them next month.
The better outcome is automation that preserves what made the original manual tests useful: they're easy to read, easy to review, and organized around real business behavior.
Use AI to inspect the application and create the first version. Keep the resulting tests structured and reusable. Run them through a predictable execution system. Bring AI back when a fuzzy assertion or complicated failure actually needs it.
That's the idea behind the Endtest AI Test Creation Agent.
If you have manual tests sitting in Excel or a test management tool, try converting a few with Endtest. Start with one of the difficult ones. A login form is easy to automate. A full customer journey is a much better test of the platform.
Related reading
- Why Playwright and Selenium Projects Fail
- Is Playwright Secure? Vulnerabilities, MCP Risks, and Alternatives
- Real Safari vs WebKit: Which Tools Automate Real Safari?
- What Is the Fastest Way to Automate Tests?
- HIPAA-Compliant Test Automation With AI
Sources and further reading
- Endtest: AI Test Creation Agent documentation
- Endtest: AI Test Import
- Endtest: Importing Test Cases
- Endtest: Email and SMS Testing
- Endtest: Cross-Browser Testing
- Endtest: Pricing
- Endtest: Security and ISO 27001
- G2: Endtest reviews and customer feedback
- Playwright: Browsers
- Playwright: Page Object Models
- Selenium: SafariDriver
- ISO: ISO/IEC 27001
- OWASP: Secrets Management Cheat Sheet
About the author
Liviu Lupei founded Endtest, a test automation platform launched in 2016. He has worked across software testing, test automation, engineering, and product development, including building tools for AI-assisted test creation and cross-browser testing.
Last updated: November 17, 2026.