# Automated test script development: your test cases turned into automated tests

> Automated Test Script Development Services | Zapple.Tech. Canonical page: <https://zapple.tech/services/automated-scripts-development/>

You have a backlog of manual test cases, user stories and bugs that keep coming back, and no automated tests for them. With automated test script development, we turn them into automated tests in your framework and your repository, starting with the cases that are run most often and carry the most risk. AI agents draft the routine parts, and an engineer checks every test in a pull request before it is merged, so each one tests the business rule and can fail. A one-week audit comes first, with a ranked list of what to automate.

## What you can order

- **Manual test cases turned into automated tests**: The core of the service. Your cases, stories and recurring bugs become automated tests in your framework.
- **Tests for new features as they are built**: New features get their tests while they are built, so the gap does not grow again behind you.
- **[Tests at the API level](https://zapple.tech/services/api-server-side-test-automation/)**: Where the product has an API worth testing directly, tests can sit next to the UI tests.
- **[Test data and fixtures the tests need](https://zapple.tech/services/custom-framework-development/)**: Tests need data they can rely on. When this turns into framework work, it is scoped as such.

## Which test cases to automate first

Not every test case should become a test. We rank them by two things: how much it costs you if the case fails in
production, and how often someone runs it by hand. The cases that are high on both go first.

Some work stays manual:

- one-off checks that will not be repeated,
- checks that need human judgement, such as whether a page looks right,
- exploratory testing, where a person looks for what nobody wrote down.

That work is covered by [manual and exploratory testing](/services/manual-testing/).

You may be in one of three situations. You repeat the same manual checks before every release. You have considered
automation but never started. Or you automated the easy cases, and the complex ones are stuck. The audit starts from
whichever it is.

## Test case automation: from test case to automated test

Test case automation follows the same steps for every case:

1. **Read the case or the story** and agree the expected result with someone who knows the business rule.
2. **An agent drafts the test** from the case, in your framework.
3. **An engineer completes it** and checks that the assertion is the business rule, not just that the page loaded.
4. **Pull request review** in your repository. Nothing is merged without it.
5. **The test runs in your CI.** How often it runs is agreed with you: heavier tests on a build or on a schedule,
   lighter ones more often.

For tests that run as part of your pipeline, see [CI/CD test automation](/services/tools-integration/).

## Your framework, or one chosen with you

In test automation development the framework comes first, because tests follow their framework and cannot be
moved freely to another one. If you have one, we write in it. If you have none, the audit compares options for your stack, for example Playwright and
CodeceptJS, and the report records the choice with the reason. If you need a framework built or reworked first, see
[custom test framework development](/services/custom-framework-development/).

Zapple.Tech was founded by the founders of CodeceptJS and Codeception, open-source testing frameworks, and of
Testomat.io and Testomat.ai. So the conventions your new tests follow come from a company whose founders build test
frameworks and test management. If one of those tools is an option for your stack, the audit says so and judges it
by the same criteria as the others.

## What makes an automated test worth keeping

A test earns its place when the next engineer can read it, trust it and change it. The tests we write follow a few
rules:

- **One behaviour per test.** When it fails, you know what broke.
- **Test data is not hard-coded.** The test creates or loads what it needs, so it does not depend on what a
  previous run left behind.
- **Names say what is checked.** A failing test name should tell a developer the rule that failed.
- **Locators are stable.** Tests use identifiers that survive a change of layout, agreed with the developers where
  the product needs them.
- **A test can fail.** A test that cannot fail is not done.

## The agent writes the draft, the engineer writes the assertion

An agent is quick at the routine part: a first draft of a test from a case, filling in the steps. It is poor at
knowing which business rule the case stands for. A test that passes while checking the wrong thing is worse than no
test, because people trust it.

So an agent drafts, an engineer decides what the test must prove, and each test is reviewed in a pull request
before it is merged. The agent-driven way of writing browser journeys is described under [end-to-end testing with AI agents](/services/agentic-e2e-testing/).

## What the work covers

Automated test scripts are written for the platform you ship on: [web application testing](/services/web-test-automation/),
[API test automation](/services/api-server-side-test-automation/) and the rest of the platform pages under
[test automation and QA testing services](/services/). Regression suites are a test type with their own page:
[regression testing](/services/regression-automation-testing/).

## When test script development is the wrong choice

- **You want the whole automation project handed over,** from strategy to a running suite. See
  [test automation outsourcing](/services/automated-qa-outsourcing/).
- **Your existing tests keep breaking.** Repair is a different job from writing new tests. See
  [test automation maintenance](/services/automated-testing-maintenance/).
- **You have no framework and no idea which one.** Start with the [automation audit](/services/audit-and-assessment/).
- **You want engineers inside your team,** not tests delivered. See
  [hire test automation engineers](/services/hire-test-automation-engineers/).

## What automated test scripts do not solve

Writing a test turns a known check into code. Knowing which checks matter stays with you.

- A test checks what its test case says, so a vague case gives a weak test. Someone who knows the business rule confirms each expected result.
- Not every case is worth automating. One-off checks, visual judgement and exploratory testing stay with people.
- Unstable environments and shared test data make tests fail whoever wrote them.
- Tests need upkeep as the product changes. Writing them and keeping them current are separate jobs.
- An agent-drafted test can pass while checking the wrong thing, which is why every one is reviewed.

## Which test cases are automated first and which stay with people.

| Kind of check | Automate or keep manual | Why |
| --- | --- | --- |
| Cases that are run most often and carry the most risk | Automate first | Ranked by what a production failure costs and how often someone runs the case by hand |
| One-off checks | Keep manual | They will not be repeated |
| Checks that need human judgement, such as whether a page looks right | Keep manual | The check is a person's judgement |
| Exploratory testing | Keep manual | A person looks for what nobody wrote down |

## How the work runs

1. **Automation audit** (About one week): We read your manual test cases, stories and existing tests, and the framework they would go into, and decide with you what to automate first.
2. **Pilot** (Two to six weeks): The top of the ranked list is automated first, in your repository and CI. You read the pull requests and watch the tests run before more cases follow.
3. **Ongoing** (Monthly): Further batches follow release by release, together with tests for new features. You decide after each step whether to continue.

## FAQ

### What is automated test script development?

It is the work of writing automated tests that run a test case without a person, in a test framework, in your repository. It is also called test automation development or automation script development. The tests are ordinary code, so your engineers can read, change and run them.

### How do you create an automated test script?

Case by case. We agree the expected result with someone who knows the business rule, an agent drafts the test in your framework, an engineer completes the assertion and checks that the test fails when the rule is broken, and the test goes through a pull request before it joins your CI runs.

### Which test cases should be automated first?

The cases that are run most often and carry the most risk. The audit ranks them. One-off checks, checks that need human judgement and exploratory testing stay manual; see manual and exploratory testing.

### Who writes the automated test scripts?

Zapple.Tech test automation engineers write them. Your QA engineers and developers can extend them afterwards, because they are code in your repository.

### Which frameworks and languages do you write tests in?

In the framework your team already uses, in its language. A test written for one framework does not run in another, so the audit starts from yours and says in writing whether it fits. If you have none, the audit compares options for your stack, for example Playwright and CodeceptJS, and writes down the choice with its reason. If the framework itself needs building first, see custom test framework development.

### Do AI agents write the tests?

Agents draft the routine parts. An engineer reviews each test in a pull request before it is merged and checks that it asserts the business rule and can fail. Only tools you approve are used, and nothing leaves your environment if your rules say so.

### Who maintains the tests after they are written?

They are ordinary code in your repository, so your team can, or we can. Upkeep as the product changes is described under test automation maintenance.

### How fast can you automate our test cases?

There is no figure. The pilot covers the first batch in two to six weeks. The number of cases, the state of the test data and the environments decide where in that range it lands.

### How much does it cost?

Prices are not published. The quote depends on the number of cases, the platforms, the state of the framework and the test data. Describe what you have and you get a scoped quote within one business day.

[Request an audit quote](https://zapple.tech/services/automated-scripts-development/#start)
