Author End-to-End Tests in Natural Language with KaneAI

Plan, Author, and Evolve E2E Tests for Web and Mobile Apps in Natural Language.

Automation

What Is End-to-End (E2E) Testing?

End-to-end testing checks a full user journey across UI, APIs and data. Learn how E2E testing works, see examples you can run, and where AI agents fit.

Last Updated on:

End-to-end (E2E) testing checks that a complete user journey works across every layer of an application: the interface, the APIs behind it, the database, and any third-party service the journey touches. An E2E test drives the running application the way a user would and passes only when the whole flow completes.

The Playwright suite built further down this page runs one guest checkout on a live demo store. Its four tests passed on November 16, 2026, and each took between 11 and 17 seconds, which is why most teams keep only a few tests at this level.

TL;DR

End-to-end testing runs the whole application and checks a full user journey from the first screen to the stored result. It sits at the top of the test pyramid, above integration and unit tests.

  • What it covers: a full journey through the UI, APIs, database and third-party services.
  • Two types: horizontal E2E follows a user across screens and applications, and vertical E2E follows one transaction down through the layers of a single system.
  • How many to write: Google's testing blog suggests about 10% of a suite as a first guess, spent on the journeys where a failure costs the most.
  • How to write one: script the journey in Playwright, Cypress or Selenium, or describe it to an AI testing agent.

What Is End-to-End Testing?

End-to-end testing is a software testing method that runs an application with all of its real parts connected and checks that a user journey works from the first step to the last. E2E is the common abbreviation, and the two names mean the same thing.

Key facts (checked November 2026)

  • End-to-end (E2E) testing checks that a complete user journey works across the interface, APIs, database and third-party services.
  • In this guide's Playwright example (run November 16, 2026), four guest checkout tests took 11 to 17 seconds each; the suite took 28.0 seconds on four workers and 53.9 seconds on one.
  • Teams keep E2E tests few and cover the rest with unit and integration tests (the 70/20/10 split comes from Google's testing blog).

For a quick visual walkthrough of this concept, watch the video below from TestMu AI.

Youtube thumbnail

Subscribe to the TestMu AI YouTube channel for more tutorials on testing and automation.

The name describes the scope. Unit testing checks one function. Integration testing checks that two or three parts talk to each other correctly. An end-to-end test starts where the user starts, in a browser or a mobile app, and follows the request through the front end, the API, the database and outside services such as a payment provider. It then checks what the user sees at the end.

E2E tests usually run last, after unit and integration tests have passed, against a staging or preview environment that mirrors production. They can be run by hand, and most teams automate the journeys they repeat on every release.

How Does End-to-End Testing Work?

An automated E2E test has three parts: a test runner, a real browser or device, and the application deployed with its real dependencies. The runner sends user actions to the browser, the application handles them the same way it would in production, and the test checks the result after each step.

A test runner drives a real browser1. Log inLogin form, auth API, users table2. SearchSearch box, search API, product catalog3. Add to cartProduct page, cart API, session store4. Check outCheckout form, order API, payment provider5. ConfirmConfirmation page, orders table, email serviceThe test passes only if every step passes
One end-to-end test. Each step of the journey exercises a different set of layers.

In that journey, logging in exercises the login form, the auth API and the users table. Checking out adds the order API and a payment provider that your team does not own. A defect in any one of those layers fails the test, so E2E testing catches faults that no single-layer test sees, and a failure takes longer to diagnose than a failed unit test.

How far you can trust the result depends on the environment. The tests need a deployed build, seeded data such as a known user and a product in stock, and either real third-party services in sandbox mode or stubs for the ones you cannot call.

What Does an End-to-End Testing Example Look Like?

An end-to-end testing example follows one user journey through the application and checks the result at every step. The journey here is a returning customer buying one product from an online store: log in, search, add to cart, check out.

The test scenario is a registered customer who logs in, searches for a phone, adds it to the cart, pays, and sees an order confirmation. The objective is to prove that the whole purchase works on a deployed build.

End-to-End Test Cases for the Checkout Journey

StepUser actionExpected resultLayers exercised
1. Log inEnter a valid email and password, then submitThe account page opens and shows the customer's nameLogin form, auth API, users table
2. SearchType the product name in the search box and submitThe results list includes the product with its priceSearch box, search API, product catalog
3. Add to cartOpen the product and select Add to CartThe cart count goes from 0 to 1 and the cart lists the productProduct page, cart API, session store
4. Check outOpen the cart, go to checkout, enter the address and payment details, place the orderThe order is accepted and the payment is authorizedCheckout form, order API, payment provider
5. ConfirmRead the confirmation page and open the order historyThe page shows an order number, the order appears in the history, and a confirmation email arrivesConfirmation page, orders table, email service

The table works as a template for your own journeys. Each row is one test case, with an action a user can perform and a result a test can check. A row whose expected result reads "works correctly" cannot be automated, because it gives the test nothing to assert.

To turn each row into a test case your team can track and rerun, add the fields below. The test case template guide lists the remaining fields, such as actual result, status and postconditions, with filled examples you can copy.

Field to addWhat to recordExample for step 4, Check out
Test case IDA unique ID that links the row to a requirement and to its run resultsE2E-CHECKOUT-04
PreconditionsThe state the application must be in before the step startsThe customer is logged in and the cart holds one phone
Test dataThe accounts, addresses and payment details the step usesA registered test account, a delivery address and a sandbox test card from the payment provider

Keep negative cases, such as a declined card or an empty required field, out of this journey. Each one is cheaper to check at the integration or unit level, where the test can call the payment or validation code directly.

E2E vs Integration vs Unit Testing: What Is the Difference?

The three levels differ in how much of the application is running when the test executes. A unit test runs one function, an integration test runs a few connected parts, and an end-to-end test runs the whole deployed application.

Unit testIntegration testEnd-to-end test
What runsOne function or class, with dependencies replaced by mocksTwo or more modules or services, sometimes with a real databaseThe whole deployed application in a real browser or on a device
Defects it findsWrong logic inside one unitBroken contracts, data formats and queries between partsBroken user journeys, including faults in configuration and third-party services
SpeedFastestSlowerSlowest: 11 to 17 seconds each for the sample tests on this page
When it failsPoints to one functionPoints to one interfaceCould be any layer, the test script or the environment
Share of the suite70%20%10%
Usual ownerDevelopersDevelopersQA engineers, SDETs and developers

The 70/20/10 split in the table comes from Google's testing blog, which offers it as a good first guess and adds that the exact mix will be different for each team.

For the two upper levels side by side, including one behavior automated both ways and timed, see end-to-end vs integration testing.

What Are the Types of End-to-End Testing?

End-to-end testing has two types. Horizontal E2E testing follows a user across the screens and applications of a workflow, and vertical E2E testing follows one transaction down through the layers of a single system.

Horizontal tests are the common kind. The checkout journey is one: it moves from login to search to cart to payment the way a customer does, and it may cross into other systems such as an inventory service or a shipping provider. Business users can read and agree on these tests, because each step is something a person does.

Vertical tests take one action, such as placing an order, and check each layer it passes through in turn: the UI, the API response, the row written to the database, the message put on a queue. They need access below the UI, so developers usually write them, and they overlap with integration testing more than horizontal tests do.

Is End-to-End Testing Worth It? When to Use It

Yes, for a small set of journeys that make or lose money, such as sign-up, login and checkout. No, as the main safety net: E2E tests are the slowest and most fragile layer, so cover logic with unit and integration tests.

An E2E test earns its place when:

  • The journey makes money or protects accounts: sign-up, login, checkout, payment, password reset.
  • The journey crosses a boundary that lower-level tests mock, such as a payment provider, a single sign-on service or a message queue.
  • A past incident got through unit and integration tests because each part worked alone and the combination did not.
  • Someone repeats the same manual check before every release.

It is the wrong tool for checking every validation rule, every permutation of input, or logic that lives in one function. Those cases multiply quickly, and each E2E test added to cover them makes the suite slower and more likely to fail for reasons unrelated to the product.

Each E2E test also costs more than a lower-level one. It is slow: the four sample tests on this page took 11 to 17 seconds each. It needs a deployed environment with test data. When it fails, the cause could be the product, the test or the environment, so someone has to investigate before the team knows whether a defect exists.

Note

Note: Run your end-to-end suite on 3,000+ browser and OS combinations in the TestMu AI cloud, with no test infrastructure to maintain. Start testing on TestMu AI free

How Do You Write End-to-End Tests?

To write an end-to-end test, pick one journey, prepare an environment with known test data, script the user's actions with a browser automation framework, assert on the result of each step, and run the test in CI on every merge.

  • Pick one journey. Start with the flow whose failure would hurt most, and write it down as steps with expected results, as in the checkout test cases.
  • Prepare the environment and test data. Deploy the build to staging or a preview environment and seed what the journey needs: a user account, a product in stock, a payment sandbox.
  • Script the user's actions. Find elements the way a user does, by role, label or visible text. Selectors tied to CSS classes break when the markup changes.
  • Assert on the result of each step. Check what the user would check: the cart shows the product, the URL is the checkout page, the confirmation has an order number.
  • Run it in CI. Trigger the test on every merge to the main branch, after unit and integration tests pass, and publish the test report where the team will see a failure. For the common blockers and a worked pipeline setup, read about integrating E2E testing in CI/CD pipelines.

The rest of this section turns that outline into a small Playwright Test suite in TypeScript for one guest purchase on the TestMu AI ecommerce playground, a public demo store: search for an iPod Nano, add it to the cart, check the cart totals and fill in a guest checkout. Every file ran on November 16, 2026 with Playwright Test 1.65.1, TypeScript 7.0.2 and Node.js 25.5.0, in Chrome 157 on Windows 11, and every console block is real output from those runs.

The journey stops at the confirm step. When the suite ran, the store had no payment method set up for guest checkout: its API answered "No Payment options are available" and the Confirm Order button stayed disabled, so the test asserts that state and never places an order. Store settings can change. If the payment step offers a method when you run the suite, the last step fails, and it should select the method, click Confirm Order and check the success page instead.

Set Up a Playwright Test Project in TypeScript

In an empty folder, install the test runner and TypeScript as development dependencies. These are the commands from the run:

$ npm init -y
$ npm i -D @playwright/test typescript
$ npm i -D @types/node
$ npx playwright --version
Version 1.65.1

Without a version number, npm installs the latest releases, so yours may be newer than 1.65.1. Playwright runs TypeScript test files directly, so the compiler is only a type check, and @types/node lets it read process.env in the config. Save the runner settings as playwright.config.ts in the project root:

import { defineConfig } from '@playwright/test';

export default defineConfig({
  testDir: './tests',
  fullyParallel: true,
  forbidOnly: !!process.env.CI,
  retries: process.env.CI ? 2 : 1,
  workers: process.env.CI ? 2 : undefined,
  reporter: [['list'], ['html', { open: 'never' }]],
  use: {
    baseURL: 'https://ecommerce-playground.lambdatest.io',
    channel: 'chrome',
    testIdAttribute: 'id',
    trace: 'on-first-retry',
    screenshot: 'only-on-failure',
  },
});
  • baseURL. Tests call page.goto('/') or a path, so pointing the suite at a staging copy of the store is a one-line change.
  • channel. Set to chrome, it drives the Google Chrome already installed on the machine, so the local run needed no Playwright browser download.
  • testIdAttribute. The store ships no data-testid attributes, but its markup carries stable ids such as button-cart and checkout-confirm, so this setting lets getByTestId use them. On your own app, add data-testid and keep the default.
  • retries and trace. Playwright does not retry a failing test by default. This config retries once locally and twice on CI, and records a trace only when a failed test runs again, so passing runs carry no tracing cost.
  • reporter. The list reporter prints one line per test, and the HTML reporter writes playwright-report/index.html without opening a browser.

Wrap Each Store Page in a Page Object

A page object is a class that owns the locators and actions of one page, so a markup change is fixed in one place and the tests read like the journey. The suite has four: StorePage opens the store and runs a search, and ProductPage, CartPage and CheckoutPage cover the rest. ProductPage shows the pattern. It returns what the cart API said, because the result of adding to the cart lives on the server:

import { type Page } from '@playwright/test';

export class ProductPage {
  constructor(private readonly page: Page) {}

  async addToCart() {
    const added = this.page.waitForResponse((res) =>
      res.url().includes('route=checkout/cart.add'),
    );
    await this.page.getByTestId('button-cart').click();
    const response = await added;
    const body = await response.json();
    return { status: response.status(), body };
  }
}

The waitForResponse promise is created before the click and awaited after it. Awaiting it before the click would wait for a request that has not started, and creating it after the click can miss a fast response. Page objects act and locate, and the tests decide what passing means. For base classes and component objects in a larger app, see the Playwright page object model chapter.

Share Page Objects and Test Data Through a Fixture

A fixture hands each test ready-made page objects and its own data. tests/fixtures.ts extends Playwright's base test once, and every spec imports test and expect from it instead of from @playwright/test:

import { test as base, expect } from '@playwright/test';
import { StorePage } from './pages/StorePage';
import { ProductPage } from './pages/ProductPage';
import { CartPage } from './pages/CartPage';
import { CheckoutPage } from './pages/CheckoutPage';
import { makeShopper, type Shopper } from './data/store';

type StoreFixtures = {
  store: StorePage;
  productPage: ProductPage;
  cart: CartPage;
  checkout: CheckoutPage;
  shopper: Shopper;
};

export const test = base.extend<StoreFixtures>({
  store: async ({ page }, use) => {
    await use(new StorePage(page));
  },
  productPage: async ({ page }, use) => {
    await use(new ProductPage(page));
  },
  cart: async ({ page }, use) => {
    await use(new CartPage(page));
  },
  checkout: async ({ page }, use) => {
    await use(new CheckoutPage(page));
  },
  shopper: async ({}, use, testInfo) => {
    const runId = `${testInfo.workerIndex}-${Date.now()}`;
    await use(makeShopper(runId));
  },
});

export { expect };

Fixtures are isolated between tests and set up on demand, so a test that never asks for checkout never builds a CheckoutPage. The shopper fixture builds the email address from the worker index and the current time, so two tests that save guest details at the same moment never send the same address. The expected values live in tests/data/store.ts: the product (iPod Nano, model Product 9), the cart totals ($100.00 sub-total and $122.00 total) and makeShopper, which returns a guest with an example.com address.

Write the Guest Checkout Journey With an API Check

tests/checkout.spec.ts holds four tests in a describe block named guest purchase journey. Three are short: search finds the product, cart API confirms the add, and cart lists the item and totals. The fourth walks the whole journey in named steps, which appear as sections in the HTML report and the trace:

import { test, expect } from './fixtures';
import { product, cartTotals } from './data/store';

test('guest checkout reaches the confirm step', async ({
  store,
  productPage,
  cart,
  checkout,
  shopper,
  page,
}) => {
  await test.step('find and add the product', async () => {
    await store.open();
    await store.search(product.name);
    await store.openResult(product.name);
    const res = await productPage.addToCart();
    expect(res.body.success).toContain(product.name);
  });

  await test.step('check the cart', async () => {
    await cart.open();
    await expect(cart.itemRow(product.name)).toBeVisible();
    await cart.checkout();
    await expect(page).toHaveURL(/route=checkout\/checkout/);
  });

  await test.step('save guest details', async () => {
    await checkout.fillGuestDetails(shopper);
    const saved = await checkout.saveGuestDetails();
    expect(saved.success).toContain('guest account');
    await expect(checkout.orderSummary())
      .toContainText(cartTotals.total);
  });

  await test.step('reach the confirm step', async () => {
    const methods = await checkout.choosePaymentMethod();
    expect(methods.error).toContain('No Payment options');
    await expect(checkout.paymentError()).toBeVisible();
    await expect(checkout.confirmButton()).toBeDisabled();
  });
});

Each step checks the page and the server. The cart.add response carried a success message naming the product, register.save answered "Success: Your guest account information has been saved!", and payment_method.getMethods returned an error that starts "No Payment options are available". The UI assertions retry until their condition holds or the timeout ends, so the suite has no fixed sleep.

npx playwright test runs the suite headless by default. In this output the test file path is shortened to three dots, the describe title is left out, and long lines wrap:

$ npx playwright test

Running 4 tests using 4 workers

  ok 3 ...:5:3 › search finds the product @smoke
       (11.1s)
  ok 1 ...:17:3 › cart API confirms the add @smoke
       (11.5s)
  ok 2 ...:29:3 › cart lists the item and totals
       (13.1s)
  ok 4 ...:47:3 › guest checkout reaches the confirm
       step (17.2s)

  4 passed (28.0s)

Add --headed to watch Chrome go through the steps, and --grep with part of a test title to run only the test you are working on.

Read a Real Failure in the Trace and HTML Report

The first run of this suite failed. CartPage.totalRow first found the totals row by its text, with getByText and an exact match on "Total", and the cart test failed on the first attempt and again on the retry:

$ npx playwright test

Running 4 tests using 4 workers

  ok 2 ...:5:3 › search finds the product @smoke
       (10.5s)
  ok 4 ...:17:3 › cart API confirms the add @smoke
       (10.6s)
  x  1 ...:29:3 › cart lists the item and totals
       (12.4s)
  ok 3 ...:47:3 › guest checkout reaches the confirm
       step (15.7s)
  x  5 ...:29:3 › cart lists the item and totals
       (retry #1) (12.8s)

  1) ...:29:3 › cart lists the item and totals

    Error: expect(locator).toContainText(expected)
    failed

    Locator: getByRole('row').filter({ has:
      getByText('Total', { exact: true }) })
    Expected substring: "$122.00"
    Error: strict mode violation: ... resolved to
    2 elements:
      1) <tr>…</tr> aka getByRole('row',
         { name: 'Image Product Quantity Unit' })
      2) <tr>…</tr> aka getByRole('row',
         { name: 'Total $122.00' })

    attachment #3: trace (application/zip)
    test-results\checkout-guest-purchase-jo-b912d-
    t-lists-the-item-and-totals-retry1\trace.zip

  1 failed
    ...:29:3 › cart lists the item and totals
  3 passed (31.9s)
  • Read the error. Strict mode found two rows: the totals row and the header row, whose TOTAL column header also has the text "Total".
  • Open the trace. The retry ran with tracing on and saved trace.zip. npx playwright show-trace with the path of that file opens it in the trace viewer, with DOM snapshots before and after each action and the network log.
  • Open the report. playwright-report/index.html lists the failed test with its error, screenshot and trace, and npx playwright show-report serves it locally.
  • Fix the locator. The header cell has the columnheader role and body cells have the cell role, so matching a cell named exactly "Total" picks one row.
// before: the TOTAL column header matched too
.filter({ has: this.page.getByText(label, { exact: true }) });

// after: only body cells can match
.filter({
  has: this.page.getByRole('cell', {
    name: label,
    exact: true,
  }),
});

With the fix in CartPage, all four tests passed in the run shown above. The Playwright trace viewer article walks through each panel of the viewer.

Tag a Smoke Subset and Run Tests in Parallel

The search test and the cart API test carry the tag @smoke through the tag option of test(). Tags must start with the @ symbol:

test('search finds the product', { tag: '@smoke' }, async ({
  store,
  page,
}) => {
  await store.open();
  await store.search(product.name);
  await expect(store.resultsHeading(product.name)).toBeVisible();
  await store.openResult(product.name);
  await expect(page.getByRole('heading', { level: 1 }))
    .toHaveText(product.name);
});

--grep @smoke runs only that subset, and --grep-invert @smoke runs the other two tests:

$ npx playwright test --grep @smoke

Running 2 tests using 2 workers

  ok 1 ...:17:3 › cart API confirms the add @smoke
       (10.1s)
  ok 2 ...:5:3 › search finds the product @smoke
       (10.1s)

  2 passed (14.8s)

fullyParallel: true lets tests in the same file run at the same time, each in its own browser context with its own session and cart. With one worker, the same four tests took 53.9 seconds, against 28.0 seconds on four workers:

$ npx playwright test --workers=1

Running 4 tests using 1 worker

  ok 1 ...:5:3 › search finds the product @smoke
       (8.0s)
  ok 2 ...:17:3 › cart API confirms the add @smoke
       (15.1s)
  ok 3 ...:29:3 › cart lists the item and totals
       (13.0s)
  ok 4 ...:47:3 › guest checkout reaches the confirm
       step (15.9s)

  4 passed (53.9s)

Parallel runs stay safe only while tests share no state. Tests that log in as one shared account or edit the same record need separate data per worker first. To split a suite across machines, see Playwright parallel testing.

For more on Playwright journeys, see Playwright end-to-end testing; for other frameworks, see Cypress end to end testing and the Selenium tutorial.

To run a journey like this from a terminal, see end-to-end testing from the command line.

How Is AI Changing End-to-End Testing?

An AI testing agent takes the journey as a goal written in natural language, such as "buy one phone as a returning customer", and works out the steps itself. It opens a real browser or device, performs the actions, checks the outcome, and reports a pass or fail. When a button moves or a label changes, the agent can find the element again from the goal, where a scripted test would stop on a missing selector.

KaneAI is TestMu AI's end-to-end testing agent. Kane CLI brings it to the terminal so developers and coding agents can verify changes. You author a KaneAI test in natural language, and when the UI shifts and locators change, KaneAI updates the affected steps and shows the diff for review. Kane CLI runs each change in a real browser and reads back a pass or fail. Agents suit journeys that change often, and a hand-written script still fits where every step has to be fixed and reviewed in code. Testing an AI agent itself is a separate job, covered in end to end agent testing.

E2E testing agents, scripted frameworks and record-and-playback tools compared on how they create and maintain end-to-end tests:

E2E testing agentScripted framework (Playwright, Cypress, Selenium)Record-and-playback tool
How a test is createdA goal written in plain EnglishCode an engineer writesClicks recorded in a browser
What each step binds toThe intent of the step, found on the live pageSelectors and waits in the codeSelectors captured while recording
When the UI changesThe agent finds the element again from the goalAn engineer updates the selectorsSomeone re-records the step
Logic and dataBranches and checks described in plain EnglishA full programming languageLinear flows; branching usually needs a script
Best fitJourneys that change oftenSteps that must be fixed and reviewed in codeShort, stable flows

In the TestMu Conf 2026 session The Last Manual Handoff: Redesigning End-to-End Testing in the Age of AI, Sachin Sharma looks at why E2E testing still feels manual after teams have automated execution, regression, reporting, data creation and test design.

Youtube thumbnail

To bring an agent into a team's release gates, the 30-day agentic E2E testing playbook splits the rollout into four one-week phases.

Automate web and mobile tests with KaneAI by TestMu AI

What Are End-to-End Testing Best Practices?

Good end-to-end tests are few, independent of each other, and stable enough that a failure means a defect. Most of the practices here exist to prevent flaky tests, which pass and fail on the same code.

  • Test journeys and leave edge cases to lower levels. Cover the common path through each business-critical flow. Input validation and error branches belong in unit and integration tests.
  • Wait for conditions, never for time. A fixed sleep is too short on a slow day and wasted on a fast one. Wait for a URL, an element or a network response, as the page objects on this page do.
  • Use locators a user would recognize. Roles, labels and visible text survive a redesign better than generated class names. Make each locator match one element: the cart test on this page failed until its total-row locator stopped matching the header row.
  • Give every test its own data. A test that depends on an order created by another test fails when the two run in parallel or in a different sequence. Create what the test needs at the start, through the API where possible.
  • Pair E2E with API tests. When a journey fails, API testing on the same endpoint tells you whether the fault is in the front end or behind it.
  • Run on the browsers and devices your users have. A journey that passes in Chrome can fail in Safari or on a small Android screen. Running the suite in parallel in a cloud keeps that coverage from slowing the pipeline.
  • Quarantine a flaky test the day it flakes. Move it out of the blocking suite, fix the cause, then put it back. Once people rerun a failed pipeline out of habit, real failures get rerun too.

Which Tools Do You Need for End-to-End Testing?

You need a framework such as Playwright, Cypress or Selenium to drive the browser, and a cloud such as TestMu AI to run it across real browsers and devices. When a coding agent like Claude Code writes the change, Kane CLI runs the end-to-end check from the terminal, which makes it the best E2E testing tool for Claude Code.

For a wider field, the end-to-end testing tools chapter compares open-source frameworks, cloud platforms and AI testing agents, with advice on choosing among them.

Two framework chapters apply these ideas to a real app: React end-to-end testing with Cypress and Jest, and Angular E2E testing with Cypress and Playwright.

Where Should You Start With End-to-End Testing?

Start with one journey: the flow that would cost the most if it broke tonight. Write its test cases as a table, automate it with the framework your team already knows, and run it on every merge. Add a second journey once the first has stopped producing false failures.

Testing web or mobile apps without writing code? KaneAI by TestMu AI turns plain-English instructions into tests.

To run your first test, start free, or
for a full walkthrough of the product.

End-to-End Testing Guide: All Chapters

The chapters run from how E2E compares with integration testing to running suites from the terminal and in CI/CD pipelines, then an agentic testing playbook, a tools comparison and framework guides for React and Angular.

Author

...

Salman Khan

Blogs: 136

  • Twitter
  • Linkedin

Salman is a Test Automation Evangelist and Community Contributor at TestMu AI, with over 6 years of hands-on experience in software testing and automation. He has completed his Master of Technology in Computer Science and Engineering, demonstrating strong technical expertise in software development, testing, AI agents and LLMs. He is certified in KaneAI, Automation Testing, Selenium, Cypress, Playwright, and Appium, with deep experience in CI/CD pipelines, cross-browser testing, AI in testing, and mobile automation. Salman works closely with engineering teams to convert complex testing concepts into actionable, developer-first content. Salman has authored 120+ technical tutorials, guides, and documentation on test automation, web development, and related domains, making him a strong voice in the QA and testing community.

Reviewer

...

Srinivasan Sekar

Reviewer

  • Linkedin

Srinivasan Sekar is Director of Engineering at TestMu AI, where he leads engineering and open-source initiatives behind the Selenium and Appium automation grid and owns TestMu AI's MCP Server. A committer to Appium and a contributor to Selenium, WebdriverIO, Taiko, and AppiumTestDistribution, he brings over 15 years of experience in quality engineering and open-source technologies. He is the author of the Apress book 'The MCP Standard: A Developer's Guide to Building Universal AI Tools with the Model Context Protocol,' a Certified Kubernetes and Cloud Native Associate, and an international conference speaker. Before TestMu AI he spent over eight years at Thoughtworks as a Principal Consultant and Quality Architect. Srinivasan holds a B.Tech in Information Technology from Anna University.

End-to-End Testing FAQs

Did you find this page helpful?

More Related Learning Hubs

TestMu AI forEnterprise

Get access to solutions built on Enterprise
grade security, privacy, & compliance

  • Advanced access controls
  • Advanced data retention rules
  • Advanced Local Testing
  • Premium Support options
  • Early access to beta features
  • Private Slack Channel
  • Unlimited Manual Accessibility DevTools Tests