E2E testing is that final piece of a puzzle. Every tests have passed, now it's time to bring everything together in one single test to see if your application holds up as a singular entity. One test (suite) to rule them all!

In this article, we'll explore the concept of E2E testing, also known as end-to-end testing in great depth.

What is End-to-End Testing?

End-to-end testing (E2E testing) checks the system's behavior as a comprehensive whole. It's done after integration testing and before user acceptance testing to catch system-wide issues early.

When To Do E2E Tests?

What sets end-to-end apart from other testing type is its scope. To understand this, let's look at the test pyramid.

Testing pyramid detailed explanation

A comprehensive test strategy should include 3 layers of tests:

Unit tests (base of the pyramid): These tests focus on individual components, like functions or methods, ensuring that each small piece of the system works correctly in isolation. Unit tests are simple, fast, and cover the most ground in a test suite. Developers typically write them while coding or shortly after, as they’re easy to automate and provide quick feedback.
Integration tests (middle layer): Once individual components work, it’s time to check if they function properly together. Individual components that passed unit tests can totally break when they are integrated, usually due to data miscommunication. Integration tests ensure that data flows correctly between modules and that interfaces are solid. They offer a good mix of speed and coverage but need more setup than unit tests.
E2E tests/system tests (top of the pyramid): End-to-end tests validate the entire application, from the user interface to the back-end, ensuring the system works as a whole. These tests give high confidence in meeting business requirements, but they’re slower and more complex. Because of this, they should be limited to critical workflows to avoid flakiness.

As you can see, while unit testing is only concerned with ‘Is this specific module working well individually’, integration testing is concerned with ‘Are these modules working well together?’, the goal of end-to-end tests is much more comprehensive: is everything working well together?

In a good test strategy, end-to-end tests should only account for 5-10% of the total number of tests. This figure is around 15-20% for integration tests and 70-80% for unit tests.

Benefits of End-to-End Testing

End-to-end testing has become essential for a few key reasons:

Real-World Confidence: By mimicking real user journeys from start to finish, E2E testing gives you confidence that core features—like logins or transactions—will work smoothly in real life.
Smooth Component Integration: Today’s apps rely on multiple services and integrations. E2E testing ensures these parts communicate well and handle data properly, catching issues before they impact users.
Regression Protection: With E2E tests in place, you’re less likely to introduce bugs from new code changes. It’s like a safety net, keeping things steady as your app evolves.
Consistent Experience Across Devices: E2E testing checks that your app looks and feels the same on all browsers and devices, so users enjoy a seamless experience, no matter what they’re using.

Challenges of E2E Testing

Test Flakiness: E2E tests fail inconsistently due to network issues or timing problems, causing unreliable results. Resolve this by using explicit waits, isolated environments, and mocking external services.
Long Execution Times: E2E tests are slow as they cover full workflows, delaying feedback. Speed up by prioritizing critical tests, running tests in parallel, and simplifying steps.
Complex Test Data Management: Tests often require specific data states, which are hard to manage. Use pre-seeded datasets, data generation, or database snapshots to keep data consistent.
Dependency on External Systems: Third-party APIs or services can cause test failures when unreliable. Mock external services for stability, and run key tests on live services at scheduled times.
High Maintenance Effort: Frequent UI or workflow changes lead to high test upkeep. Use stable locators, modular functions, and frameworks that simplify updates to reduce maintenance.

End-to-End Testing Best Practices

Prioritize Critical Workflows: Start with the most critical parts of your application that users rely on. Break these workflows into smaller steps to create focused, effective tests without getting bogged down by less essential paths.
Skip Exception Testing in E2E: E2E testing isn’t ideal for testing error-handling or exceptional cases. These tests may detect that an error occurred but don’t reveal its root cause or potential impact on the system.
Minimize UI Flakiness: E2E tests often involve the UI, which can be prone to flaky failures due to network lags or server delays. Use strategies like Smart Wait (e.g., in Katalon) to wait until all UI elements load fully, reducing false positives and improving test stability.
Leverage Automation: Automate E2E tests to handle the complexity of verifying user scenarios, integrations, and workflows. Automation ensures coverage across multiple scenarios and helps keep tests efficient and repeatable.

End-to-End Testing vs Integration Testing

End to end testing is quite similar to integration testing, and indeed they do overlap in several aspects. Here are some major differences between them:

Aspect	Integration Testing	End-to-End Testing
Perspective	Technical team’s point of view	Final user’s point of view
Goal	Ensure that application components work together	Ensure that the User Experience is consistent
Scope	Multiple components within in one applications	The scope may span across the entire technology stack of the application
Cost	Less expensive to implement	More expensive to implement due to the hardware - software needed to best simulate real-world scenarios
Time needed	Faster than E2E testing (about less than 1 hour for 200 tests)	Longer than Integration testing (may take up to 4 - 8 hours)

A quick example: let's say you have an application with the UI, API, and the backend. The goal of E2E testing is to check the entire flow from the UI to the backend to the database, while the goal of integration testing is only to check the flow from the UI to the backend, or from the backend to the database. In other words, the scope of integration testing is more limited than the scope of end-to-end testing.

Why run both? Integration tests are quicker to execute and provide faster, more targeted feedback. When they fail, it’s easier to pinpoint the issue since it’s isolated to specific components, excluding UI concerns. Test layers are designed to systematically narrow down potential problems in your codebase or configuration.

In some cases, E2E tests can simulate machine-to-machine interactions, where the “user” is another system rather than a human, ensuring seamless communication between systems.

End-to-end Testing vs Functional Testing

End-to-end tests are not just several unit tests and functional tests strung together – they are more complex and carry more risks. We’ve listed the main differences between functional and E2E tests to illustrate this further.

Aspect	Functional Tests	End-to-End Tests
Scope	Testing is limited to one single piece of code or application.	Testing crosses multiple applications and user groups.
Goal	Ensures the tested software meets acceptance criteria.	Ensures a process continues to work after changes are made.
Test Method	Tests the way a single user engages with the application.	Tests the way multiple users work across applications.
What To Validate	Validate the result of each test for inputs and outputs.	Validate that each step in the process is completed.

Types of End-to-End Testing

1. Horizontal E2E test

Horizontal end to end testing

Horizontal end to end testing is what the end user thinks of when they hear “end-to-end testing”. In this approach, testers focus on ensuring that each individual workflow in the application works correctly.

Scope: Focuses on testing the full user journey across all modules of an application from start to finish.
Goal: Ensures that a system behaves as expected across various modules in a single workflow.
Example: Testing the entire checkout process in an e-commerce platform, from logging in to selecting items, applying a discount, and completing the purchase.
Benefits: Validates end-user experiences and ensures each component integrates smoothly with others, giving confidence that the overall workflow functions correctly.

2. Vertical E2E test

Vertical End to End Testing

Vertical E2E testing is a more technical approach. This is what the tester thinks when they hear end-to-end testing. Unlike end users who only experience the frontend, testers also work with the backend, and they want to make sure that the right data is transferred to the right place, at the right time, so that all background processes keeping the application running can be smoothly executed.

Scope: Tests each individual layer or module of the application in-depth, focusing on the internal behavior and functionality.
Goal: Ensures that specific parts of the application, such as APIs, databases, and microservices, work correctly and efficiently, even if they are not part of a full user journey.
Example: Testing just the payment processing API in an e-commerce platform, verifying the payment methods, and ensuring transactions are securely processed.
Benefits: Ensures robustness in isolated components, making it easier to troubleshoot and debug specific parts of an application without needing to test the entire flow.

End-to-End Test Automation with Katalon Studio

Katalon logo

Katalon is an excellent software quality management platform that can make your end-to-end tests less complicated. With Katalon, software teams can have an end-to-end perspective of their testing activities, from collaboration for test planning, test authoring, test execution, test artifact management, to test analytics and reporting.

Demo speaks louder than words. Here's a sneak peek of how Katalon works:

Katalon supports a wide range of testing types, and both developers and manual testers can easily automate UI or functional testing for web, API, desktop, and mobile applications, all in 1 place. Tools used across the software testing life cycle can natively integrate with Katalon, giving you a comprehensive testing experience. (your existing CI/CD pipeline and test management tools).

Katalon has several noticeable features to support your E2E testing activities:

1. On-cloud Test Execution

Mobile Testing A Leap Forward with Katalon TestCloud

Performing end-to-end testing across multiple browsers and operating systems can be a daunting task, especially when it comes to setting up physical machines to execute tests. This process can be time-consuming and resource-intensive, leading to delays in the end-to-end testing process.

By leveraging Katalon, you can easily run tests on the cloud, on a wide range of multiple browsers, devices, and operating systems simultaneously, ensuring comprehensive test coverage. This feature helps organizations save time and resources while improving the quality of their web applications.

2. Katalon Recorder

Different use cases are often mixed together in different orders and variations. But we can call each grouping of use cases a user journey. Technically, a user journey is a collection of steps in which each step corresponds to a user action. Collectively, they represent a typical user session.

Katalon offers the Recorder feature on the web to help you accomplish the task of creating user journeys without any hassle. The Recorder essentially watches and records all your movements on the application so that you can focus on creating the journey itself.

3. Built-in keywords

built-in keywords in Katalon Studio for keyword-driven testing

A user journey usually consists of hundreds of steps. When a test case – which represents a user journey – fails, it may be easy to pinpoint superficial causes (e.g. a change in a Web element’s property). However, it is harder to diagnose the actual cause solely based on the fact that the test has failed. It could have been because the current page is not the same page that was recorded because at some points the test case went off the right track.

To ensure that the user journey has to go through certain milestones, test oracles are necessary. Test oracle refers to a mechanism to ensure that the test case is being executed as expected. In Katalon, a set of built-in keywords that implement this concept is provided. You can assert or verify a web element against certain text that you expect it to contain, or its properties against some expected properties and many other types of expectations.

4. Custom keywords

Depending on the business logic of your application, there may be behaviors that occur across different pages but differ only in some known characteristics. In such cases, it is a best practice to capture these behaviors in a behavior template that can be filled with specific information when necessary.

In Katalon, a custom keyword can be defined to represent such a behavior template. Once defined, it can be reused in different test cases and even in different test projects. You can even share your custom keyword as a plug-in through Katalon Store so that others can benefit from it.