Responsive

Scaling Cypress Tests: Parallelize E2E Tests

Published
July 20, 2025
Bruno Lopes
Product Leader
Testkube

Table of Contents

Unlock Better Testing Workflows in Kubernetes — Try Testkube for Free

Subscribe to our monthly newsletter to stay up to date with all-things Testkube.

You have successfully subscribed to the Testkube newsletter.
You have successfully subscribed to the Testkube newsletter.
Oops! Something went wrong while submitting the form.
Last updated
July 19, 2025
Bruno Lopes
Product Leader
Testkube
Share on X
Share on LinkedIn
Share on Reddit
Share on HackerNews
Copy URL

Table of Contents

Cypress Testing TL;DR

TL;DR

Cypress Testing & Parallelization

  • 1
    Cypress test parallelization speeds up testing by running multiple tests simultaneously instead of sequentially, reducing execution time and providing faster feedback for large applications
  • 2
    Cypress Cloud offers built-in parallelization with features like multi-browser testing, CI integration, and a dashboard, but has limitations in the free tier and can be complex to manage
  • 3
    Testkube provides a Kubernetes-native alternative that integrates with Cypress without dependency on Cypress-specific libraries, offering container-based execution and unlimited parallelization
  • 4
    Third-party solutions are becoming obsolete - starting with Cypress v12, the platform blocked third-party services like SorryCypress and Currents.dev, disrupting many teams' workflows
  • 5
    Testkube offers uninterrupted testing by bypassing Cypress's restrictions while providing advanced test orchestration, custom workflows, and integration with existing CI/CD pipelines

Users today want applications that are snappier and have an intuitive interface. Building and shipping such applications require thorough testing features to ensure they work as expected. 

One of the most popular end-to-end testing tools for this is Cypress. Its rich feature set and developer-friendly APIs make testing your entire application easy. However, running tests in sequence is time-consuming for large, complex applications. 

Hence, teams turn to test parallelization, which allows them to run multiple tests simultaneously. In this blog post, we’ll look at how test parallelization works in Cypress. We’ll also explain why parallelization is critical for end-to-end testing and how Testkube helps with test parallelization for Cypress, providing an example. 

The Need For Parallelization In Testing

Test parallelization runs multiple tests simultaneously across different environments. Instead of executing tests sequentially, one after another, parallel testing divides the test suite into smaller groups that can be run concurrently.

Here’s why parallelization in testing is necessary:

  • Faster Results: Test parallelization reduces the time taken to execute all the tests, thus reducing the overall execution time and allowing teams to get faster feedback. 
  • Resource Efficiency: By running tests in parallel across different environments, you can optimize your resource utilization and better use the available resources.

Test Parallelization in Cypress

As mentioned earlier, Cypress has become a popular choice for end-to-end testing. To enhance its capabilities, Cypress provides Cypress Cloud with an intuitive dashboard with additional functionalities like test parallelization and result analytics. These features allow developers to speed up test execution.

Below are some salient features of running tests in parallel in Cypress

  • Multi-browser Testing: Cypress allows tests to be run concurrently across different browsers, enhancing cross-browser coverage.
  • CI Integration: Cypress easily integrates with CI tools and allows you to execute tests on different environments in an automated manner.
  • Dashboard Service: Cypress provides a dashboard that helps you manage and visualize parallel test runs.

Having said that, running tests in Parallel in Cypress can be complex. Managing test data, environment setup, and teardown across parallel instances can be difficult. Further, in their free tier, the limit on the number of tests you can execute in parallel and the results you can collect is relatively low.

Cypress With Testkube

Testkube is a Kubernetes-native testing framework that allows you to create testing workflows in a declarative, version-controlled manner. It allows you to plug in any testing tool and leverage the power of Kubernetes.

Key benefits

  • Simplified Test Workflow Creation: Without complex scripting, Testkube facilitates the creation of detailed Test workflows that allows for better control and customization of your Test Executions. Refer to our Test Workflows documentation to learn more. 
  • Scales your Testing Tools by leveraging Kubernetes: Testkube integrates with any testing tool, including Cypress and Playwright, and allows you to leverage your own infrastructure to run tests at scale!
  • Single Pane of Glass: Testkube gives you a simple dashboard that allows you to observe and troubleshoot all of your tests.

Further, Testkube integrates with existing CI/CD pipelines, enhancing end-to-end testing capabilities. Furthermore, it provides a straightforward process for incorporating custom testing tools, enabling native execution on Kubernetes with minimal setup. Read more about Testkube.

Key advantages of Testkube for Cypress test parallelization:

  1. No dependency on Cypress libraries: It doesn't rely on any Cypress-specific libraries that could be subject to blocking or restrictions.
  2. Flexibility: Testkube allows users to run tests without being tied to specific versions of Cypress or worrying about compatibility issues.
  3. Container-based execution: Testkube runs tests inside containers, providing isolation and consistency.

Thus, Testkube provides stable and reliable options for teams looking to parallelize their Cypress tests.

Cypress Test Workflow using Testkube

Let's see how we can run Cypress tests in parallel using Testkube. We’ll create a Test workflow for Cypress tests and configure it to run in parallel. 

Pre-requisites

  • A Testkube account, either on prem or in the cloud.
  • Kubernetes cluster - we’re using a local Minikube cluster.
  • Testkube Agent configured on the cluster.

Once the prerequisites are in place, you should have a target Kubernetes cluster ready with a Testkube agent configured. 

Creating a Test Workflow

Navigate to the Test Workflows tab and click on “Add a new test workflow”

This will provide you with three options:

  • Create from scratch - use the wizard to create a Test Workflow.
  • Start from an example - use existing k6, cypress, and playwright examples
  • Import from yaml - import your own Test Workflow.

We’ll choose the “Import from yaml” option to create this workflow. Below is the yaml file used to create the Test workflow for running Cypress tests in parallel.

apiVersion: testworkflows.testkube.io/v1
kind: TestWorkflow
metadata:
  name: cypress
  namespace: testkube

spec:
  content:
    git:
      uri: https://github.com/kubeshop/testkube
      revision: main
      paths:
      - test/cypress/executor-tests/cypress-13

  container:
    image: cypress/included:13.6.4
    workingDir: /data/repo/test/cypress/executor-tests/cypress-13

  steps:
  - name: Run tests
    parallel:
      maxCount: 3
      
      shards:
        testFiles: 'glob("cypress/e2e/**/*.js")'

      description: '{{ join(map(shard.testFiles, "relpath(_.value, \"cypress/e2e\")"), ", ") }}'

      transfer:
      - from: /data/repo

      fetch:
      - from: /data/artifacts

      container:
        resources:
          requests:
            cpu: 1
            memory: 1Gi

      run:

        args:
        - --env
        - NON_CYPRESS_ENV=NON_CYPRESS_ENV_value
        - --config
        - '{"video":true,"screenshotsFolder":"/data/artifacts/screenshots","videosFolder":"/data/artifacts/videos"}'
        - --spec
        - '{{ join(shard.testFiles, ",") }}'

        env:
        - name: CYPRESS_CUSTOM_ENV
          value: CYPRESS_CUSTOM_ENV_value

    artifacts:
      workingDir: /data/artifacts
      paths:
      - '**/*'

The above file creates a Cypress Test workflow and configures it to run 3 tests in parallel, specifying other details like resource requirements and artifacts folders.

Paste the yaml file's contents and click Create & Run to create and run the test workflow.  This will trigger the Test workflow, which you’ll see on the dashboard.

After the Test workflow has finished, it will update the status and give you a link to view the artifacts, such as logs, screenshots, and videos.

In this case, it has generated logs and videos. Clicking on any artifacts will open a new tab/window to view them.

This was a simple demo of creating and running Cypress tests in parallel using Testkube. To take advantage of test workflows more, you can create custom workflows and import them to Testkube.

Cypress & Its Alternatives

Cypress offers features like test parallelization and analytics that help teams quicken their testing process. While initially expensive, it now has a free tier with limitations on the number of parallel tests you can run. 

To overcome this barrier, open-source alternatives like SorryCypress and managed solutions like Currents.dev emerged, offering unlimited parallelization and features previously exclusive to Cypress's enterprise plans.

However, starting with version 12, Cypress blocked projects using the 'cypress-cloud' module, impacting these third-party services. SorryCypress now only works with older Cypress versions, while Currents.dev has ended its official support for Cypress. This change has disrupted many teams' testing workflows.

However, with Testkube, you can still run your Cypress tests in parallel without worrying about Cypress blocking Testkube. 

Summary

To summarize, Cypress is a versatile and feature-rich tool for end-to-end testing. With Testkube, you can run Cypress tests in parallel and leverage its advanced test orchestration capabilities to perform end-to-end testing.

Further, third-party services like SorryCypress and Currents.dev are no longer helpful as they don’t work with the latest version of Cypress or are forcing their users to use Playwright. But with Testkube, you’re guaranteed an uninterrupted testing experience.

Check out the Testkube website to learn more about Cypress or other testing tools you can integrate and get started with Testkube today. Feel free to post a note in our active Slack community if you struggle with anything.

Top 5 Most Important Cypress Parallel Testing FAQs

Cypress Parallel Testing FAQs

Essential questions about parallelizing end-to-end tests

Running Cypress tests in parallel involves splitting your test suite into smaller shards and executing them simultaneously across multiple machines or containers. This approach significantly reduces overall test execution time and accelerates feedback in CI/CD pipelines.

Common approaches for parallel execution include:

  • CI environment parallelization: Use your CI/CD platform's built-in parallel job capabilities to run test shards across multiple runners
  • Cypress Cloud dashboard: Leverage Cypress's official parallelization service for automatic load balancing and intelligent test distribution
  • Container orchestration: Deploy Cypress tests in multiple containers using Docker or Kubernetes for scalable parallel execution
  • Third-party orchestrators: Use tools like Testkube to manage parallel test execution within Kubernetes clusters
  • Custom scripting: Implement custom solutions using tools like cypress-split or manual test file distribution

The key is to ensure proper test isolation, avoid shared state dependencies, and implement effective load balancing to maximize the benefits of parallel execution while maintaining test reliability.

Cypress offers limited parallelization capabilities in its free tier through Cypress Cloud, but with significant restrictions that may impact larger teams and projects.

Free tier limitations include:

  • Limited parallel runs: Restricted number of concurrent test executions per month
  • Test run limits: Monthly caps on total test executions
  • Reduced analytics: Limited access to test insights, trends, and performance analytics
  • Basic reporting: Fewer dashboard features and historical data retention
  • No advanced features: Missing features like flaky test detection and smart orchestration

For teams requiring extensive parallel testing capabilities, upgrading to a paid plan provides:

  • Unlimited parallel runs and test executions
  • Advanced analytics and debugging tools
  • Longer data retention periods
  • Priority support and enhanced security features
  • Team collaboration features

Alternatively, teams can implement parallel testing using open-source solutions or Kubernetes-native platforms to avoid these limitations entirely.

The best alternative to Cypress Cloud is using a Kubernetes-native test orchestrator like Testkube, which provides comprehensive parallel testing capabilities without vendor lock-in or usage limitations.

Advantages of Kubernetes-native parallelization:

  • Full control: Complete ownership of test execution environment and infrastructure
  • No usage limits: Run unlimited parallel tests without monthly restrictions or cost concerns
  • Container isolation: Each test runs in isolated containers ensuring clean environments
  • Resource optimization: Leverage existing Kubernetes cluster resources efficiently
  • Custom scaling: Scale test execution based on available cluster capacity
  • Integration flexibility: Easy integration with existing CI/CD pipelines and monitoring tools

Other effective alternatives include:

  • CI/CD native solutions: Use GitHub Actions, GitLab CI, or Jenkins matrix builds for parallel execution
  • Docker Compose: Run multiple Cypress containers locally or in CI environments
  • Custom orchestration: Build solutions using tools like cypress-split or sorry-cypress
  • Cloud platforms: Leverage cloud-native solutions like AWS CodeBuild or Azure DevOps parallel jobs

Testkube stands out for its declarative approach, native Kubernetes integration, and comprehensive test workflow management capabilities.

Parallelization is crucial in end-to-end testing because E2E tests are inherently slower and more comprehensive than unit or integration tests, making execution time a significant bottleneck in development workflows.

Key benefits of parallel E2E testing:

  • Dramatically reduced execution time: Transform hours of sequential testing into minutes of parallel execution
  • Faster developer feedback: Quickly identify regressions and issues during development cycles
  • Accelerated CI/CD pipelines: Prevent testing from becoming the bottleneck in deployment processes
  • Improved developer productivity: Reduce wait times and enable more frequent testing iterations
  • Enhanced test coverage: Run comprehensive test suites more frequently without time penalties
  • Better resource utilization: Maximize infrastructure efficiency by utilizing multiple cores or machines

Impact on development workflows:

  • Continuous integration: Enable running full E2E suites on every commit without slowing down development
  • Pull request validation: Quickly validate changes before merging to main branches
  • Release confidence: Run extensive testing before production deployments
  • Regression prevention: Catch issues early when they're cheaper and easier to fix

Without parallelization, large E2E test suites can take hours to complete, making them impractical for frequent execution and reducing their effectiveness in catching issues early in the development process.

Testkube enables Cypress parallelization through its declarative Test Workflows feature, which orchestrates test execution across isolated containers within a Kubernetes cluster, providing complete control over parallel test execution.

Core parallelization capabilities:

  • Container isolation: Each test shard runs in separate containers, ensuring complete isolation and avoiding interference
  • Intelligent sharding: Automatically distribute test files across multiple parallel workers based on configured parallelism levels
  • Resource management: Fine-grained control over CPU, memory, and storage resources for each test container
  • Dynamic scaling: Scale test execution based on available cluster capacity and test suite size
  • Artifact management: Collect and aggregate test results, screenshots, videos, and reports from all parallel executions

Test Workflow features for parallelization:

  • Declarative configuration: Define parallel execution strategies using YAML-based workflow definitions
  • Flexible sharding strategies: Support for file-based, directory-based, or custom sharding approaches
  • Conditional execution: Run different test sets based on conditions or previous step results
  • Dependency management: Handle test dependencies and execution order across parallel workers
  • Failure handling: Configure retry strategies and failure tolerance for robust test execution

Independence from Cypress Cloud means teams can run unlimited parallel tests, maintain full control over test execution environments, integrate with existing monitoring and observability tools, and avoid vendor lock-in while achieving superior performance and scalability.

About Testkube

Testkube is a test execution and orchestration framework for Kubernetes that works with any CI/CD system and testing tool you need. It empowers teams to deliver on the promise of agile, efficient, and comprehensive testing programs by leveraging all the capabilities of K8s to eliminate CI/CD bottlenecks, perfecting your testing workflow. Get started with Testkube's free trial today.