What Is End-to-End Testing? A Plain Guide With One Real Example

What is end-to-end testing? A plain definition and one real example, an order in a shop app, followed from the first click to a test that runs on every build.

By Ait Nohaila, Business Development Representative 10 min read

End-to-end testing checks a whole workflow of an application through its real screen, from the user's first click to the final result, with every part behind it working together. It proves the user gets what they came for.

Every team agrees these are the tests that matter most, and most teams have very few of them. Written as code, an end-to-end test is slow to write and breaks at every redesign, so the workflows the business lives on are still checked by hand before each release, or not at all.

What is end-to-end testing?

Definition

End-to-end testing, often written E2E testing, is testing an application the way its users use it: one whole workflow, through the real screen, from start to finish.

  • The test clicks, types and reads what is shown, as a person would.
  • Everything behind the screen takes part: the servers, the database and the outside services the workflow calls.

The test passes only when the user's final result is right.

The two ends in the name are the user's first action and the user's final result.What lies between them is the whole application.The end-to-end testing page shows the kinds of apps this covers, from web apps to Windows desktop apps and phones.

An end-to-end testing example: one order in a shop app

This article follows one example all the way: a customer of an online shop orders a desk lamp. It is four screens long, and it is the workflow the shop cannot afford to lose.

1

Sign in

Types the email and the password.

The account name appears.

2

Add to cart

Opens the desk lamp and adds it.

The cart shows one item and its price.

3

Pay

Types the card and clicks Pay.

No error message appears.

4

Confirmation

Reads the confirmation page.

The total and an order number are shown.

Behind the screen, all of this has to work

Sign-in serviceProduct cataloguePayment providerOrder databaseConfirmation email
One end-to-end test: four screens, a check on each, and every part behind them exercised on the way.

A person testing this by hand does exactly that: sign in, add the lamp, pay with a test card, and read the confirmation. An end-to-end test does the same, in the same order, and checks the same things on the way.

What an end-to-end test covers that smaller tests cannot

Smaller tests look at one part at a time: a function, a service, a screen. They are fast and precise, and they are right about their own part. What they cannot see is the handover from one part to the next, as the customer lives it.

Each part, tested on its own

Sign-in
Cart
Payment
Orders

The whole order, through the screen

The confirmation page shows no order number.

Every part passed its own tests. Only the test that followed the order to its last screen saw what the customer would see.

An end-to-end test of the order covers what no smaller test does.

  • It proves the sign-in really leads to the shop, with the right account.
  • It proves the item added on one screen is the item charged on the next.
  • It proves the payment that succeeded produces a confirmation the customer can read.
  • It proves all of it on the screen, where a right value drawn in the wrong place is still a bug.

How the same bug looks through a test of the parts and through a test of the screen is the subject of end-to-end testing vs integration testing.A test of one function alone, such as a discount code field, is explained in what is functional testing.

What to check at each step of the workflow

An end-to-end test that clicks through four screens and checks nothing only proves the app did not crash. Each step ends on something the user would look at.

StepWhat the test checksWith which check
Sign inThe account name appears at the top of the page.A Text Assert, which reads the words.
Add to cartThe cart shows one item, the lamp's picture and its price.A Text Assert for the price, a Visual Assert for the picture.
PayThe waiting spinner goes away and no error message appears.A Visual Absent Assert and a Text Absent Assert.
ConfirmationThe thank-you message, the total paid and the order number.Text Asserts, and a Dynamic Text Assert for the number.

The order number deserves a closer look, because it is where many end-to-end tests go wrong. It is different at every run, so a check that expects the number seen during the recording fails the very next day.

A check that expects the recorded number

Run 1ORD-20418
Run 2ORD-20419
Run 3ORD-20420
A broken buildORD-

It fails every order after the first, although nothing is broken.

A Dynamic Text Assert that expects the shape

Run 1ORD-20418
Run 2ORD-20419
Run 3ORD-20420
A broken buildORD-

It passes every real order number, and still fails a broken one.

A value that changes at every run is checked by its shape: here, the letters ORD, a dash and five digits.

When to write an end-to-end test, and how many

Write an end-to-end test when a workflow is one the business cannot lose.

  • It involves money, personal data or signing in.
  • It crosses several parts of the application or an outside service.
  • A bug in it would stop customers or colleagues from doing their work.

How many is a short answer: few. Start with one, the workflow whose failure would hurt most, and add the others it cannot lose. Most applications are well protected by five to fifteen of them, run on every build.

Do

  • One whole workflow per test, from the first click to the result
  • A check of what the user would look at on each screen
  • A test environment, a test account and a test payment card

Avoid

  • An end-to-end test for every option of every screen
  • A test that clicks through the workflow and verifies nothing
  • A test that depends on data left by yesterday's run

The options of one screen belong to shorter tests of one function each.And once you have several end-to-end tests, smoke vs sanity vs regression testing shows which of them to run at each build and which at night.

Why E2E tests are hard to keep alive when written as code

In a coded framework such as Playwright, Selenium or Cypress, the order test is a program. Writing it once is the small part. Keeping it alive is the cost.

What the order test needsIn a coded frameworkIn GUI Test Studio
Finding each field and buttonA selector for each one, written and repaired by hand.Found through the app's accessibility information first, and by sight when the app says nothing.
Waiting for each screenWait code for every page and spinner, or fixed pauses.Every check waits by itself and passes the moment the element is there.
The order numberA pattern written in code.A Dynamic Text Assert: mark the number, and its shape is recognised.
A redesign of the checkoutScripts repaired by a programmer, one selector at a time.The new look accepted in the report in one click, after a review.
Who can create itSomeone who programs.Anyone who can do the workflow by hand.
An end-to-end test is only worth what it costs to keep. Take the code away, and the cost goes with it.

Two of those rows cause most of the failures on a working app: finding an element and waiting for it.Fixed sleeps in tests shows why a pause of a fixed length never fits, and flaky tests and false positives what the noise costs a team.

How to create this end-to-end test without code, step by step

GUI Test Studio automates end-to-end tests of any app without code. Here is the order test of this article, from nothing to a test that runs by itself. Most of the work is doing the order once.

  1. 1

    Prepare the starting point

    Use a test environment, with a test account and a test payment card. For a web app, the test opens the page itself in a clean browser window at every run, so every run starts signed out, like a new visitor.

  2. 2

    Record the order once

    Click Record in GUI Test Runner-Recorder, choose a web app and type the shop's address. Sign in, add the desk lamp to the cart, pay, wait for the confirmation page, then press Esc to stop.

    Do it at a normal pace, and wait for each page to finish loading before you act on it.You can also describe the workflow in a prompt to Claude, to ChatGPT with Codex, or to a local AI model that we provide or that you bring: see Create a test from a prompt.

  3. 3

    Choose what the test verifies

    The question What should this test verify decides which checks the test gets by itself. Leave Verify Visual Elements and Verify What Appears switched on, switch on Verify Text so words are checked as words, then click Save the Test.

    Asked once the recording is over: the checks a careful tester would make, chosen in one window.
  4. 4

    Give the order number a Dynamic Text Assert

    Open the test in GUI Test Studio. Drag a Dynamic Text Assert from the Assertions palette to the moment the confirmation shows, and mark the order number on the frame. The editor picks the shape of the value, and a format of your own is described once with a pattern.

    A Dynamic Text Assert in its editor, here on an amount: the value is marked, its shape is chosen, and the editor says at once whether a run would find it.
  5. 5

    Run it and read the Confidence Report

    Click Run Test and keep your hands off the mouse and the keyboard. When the run ends, the report gives the verdict, then every step and every check, with what was expected beside what was found.

    The Confidence Report of a run that passed: the verdict at the top, every step and check under it, the run's video along the bottom.
  6. 6

    Run it on every build

    On the build machine, gtr-cli runs the test after each build. A failed order fails the build, and the report, the video and the pictures of the run are kept.

Run the end-to-end test on every build

An end-to-end test protects the order only if it runs after every change. On a build machine, gtr-cli runs it from any CI/CD tool and answers the way a pipeline expects.

The order test, after each build
gtr-cli run tests\Order.GTS --countdown 0 --junit results\order.xml --artifacts results\artifacts
  • A failed order fails the build through the exit code.
  • The results file fills your CI tool's test tab.
  • The artifacts folder keeps the run's video, its Confidence Report and the pictures of what failed.

When the order fails one morning, the report shows the step that failed, what was expected beside what was found, and the last run that passed.How to read a test report shows what to look at first, and Run tests in your pipeline has a ready-made example for each CI tool.

The same test on other browsers, devices and apps

The order was recorded once, in one browser.For a web app, GUI Test Runner-Recorder can generate the same test for Chrome, Edge and Firefox and for emulated phones and tablets: see cross-browser testing from one recording.

Nothing in this article is special to a shop or to the web.The same four moves, record, choose what to verify, run, read the report, make an end-to-end test of a Windows desktop app, an Android phone plugged into the computer or a game.Testing a Windows desktop app without writing code follows a desktop example.

What to know before you start

LimitWhat it means
The test really paysIt clicks Pay as a customer would. Run it against a test environment, with a test card.
The same starting pointA test replays from the state it was recorded in. For a desktop app, put the app back there before each run.
A run uses the real screenKeep your hands off during a run, or give the test a build machine. A web test can also run without a browser window.
A test checks what it was told to checkA screen with no check on it can change unnoticed. Each step ends on a check.

Key takeaways

  • 1End-to-end testing follows a whole workflow through the real screen, from the user's first click to the final result.
  • 2It covers the handovers between parts, which tests of one part at a time cannot see.
  • 3Each step ends on a check, and a value that changes, such as an order number, is checked by its shape.
  • 4Keep few of them: the workflows the business cannot lose, run on every build.
  • 5Without code, the cost of keeping them goes away. GUI Test Studio records the workflow once and replays it by itself.

Questions

What is end-to-end testing in simple words?

End-to-end testing checks a whole workflow of an application through its real screen, the way a user goes through it. The test starts at the first click and ends on the result the user came for, such as an order confirmation.

What is an example of an end-to-end test?

An order in a shop app is the classic example. The test signs in, adds an item to the cart, pays, and checks that the confirmation page shows the right total and an order number. It passes only if every part behind those screens worked together.

What is the difference between end-to-end testing and functional testing?

A functional test checks one function against what it should do, such as a discount code field. An end-to-end test follows a whole workflow that crosses many functions. An end-to-end test is a functional test at the widest scope.

What is the difference between end-to-end testing and integration testing?

Integration testing checks that two or more parts of an application work together, usually through code. End-to-end testing checks the whole application through its screen. An integration test can pass while the screen shows the wrong result.

How many end-to-end tests should a team have?

Few, and well chosen. Start with the one workflow whose failure would hurt the business most, then add the others it cannot lose. Most applications are well protected by five to fifteen of them, run on every build.

Is end-to-end testing the same as UI testing?

Not quite. UI testing checks the screen itself: that its elements are there and look right. End-to-end testing uses the screen to follow a whole workflow and check its result. An end-to-end test usually makes UI checks along the way.

Who writes end-to-end tests?

Traditionally developers or automation engineers, because the tests were code. When a test is recorded instead of coded, the testers and product owners who know the workflow can create it and keep it up themselves.

Can end-to-end tests be automated without writing code?

Yes. With GUI Test Studio, you do the workflow once in your application while it is recorded, and choose what the test verifies. The test then replays by itself on every build, and no test code is written or maintained.

Playwright, Selenium, Cypress, Claude, ChatGPT, Chrome, Edge, Firefox, Android and Windows are trademarks of their respective owners.

All articles