Responsive

Leveraging Testkube for Complex System Testing

Published
July 22, 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 21, 2025
Bruno Lopes
Product Leader
Testkube
Share on X
Share on LinkedIn
Share on Reddit
Share on HackerNews
Copy URL

Table of Contents

Testkube System Testing TL;DR

TL;DR

Testkube System Testing Essentials

  • 1
    Testing distributed applications is complex - Modern apps span multiple servers requiring coordinated functional, load, API, and UI tests running simultaneously, which is difficult to manage without proper tools
  • 2
    Testkube is a Kubernetes-native testing framework that orchestrates complex testing workflows using different tools (k6, Cypress, Postman) from a single UI, executing tests directly within Kubernetes clusters
  • 3
    You can combine multiple test workflows to run sequentially or in parallel - for example, starting with a cURL authentication test, then running Cypress, k6, and Postman tests simultaneously
  • 4
    Tests can share data between steps - the framework allows passing outputs from one test (like authentication tokens) as inputs to subsequent tests through config variables and file storage
  • 5
    Benefits include better resource optimization, simplified orchestration, and production-like testing environments while reducing implementation time compared to CI/CD or DIY solutions

Applications today span multiple servers and services which requires a multifaceted approach to ensure reliability and performance. Testing such distributed applications has its own challenges due to their inherent complexity. 

To perform comprehensive testing of such applications, you must run various functional and non-functional tests. Moreover, different load, API, and UI tests should preferably be executed simultaneously to ensure consistent system behavior under complex usage scenarios and provide a thorough validation of your system before it goes into production.

However, without proper tools, managing multiple tests simultaneously can be difficult. Coordinating with different types of tests, analyzing their results, and maintaining consistency is difficult. 

This learn article will show how Testkube can help you create custom Test Workflows combining multiple tests for seamless system testing.

Challenges With System Testing

Performing a system test for your application is crucial to ensure it always works as expected. This often involves running different tests, including unit, functional, and non-functional tests. Managing these tests and integrating multiple tools to replicate a real-world scenario is challenging. Let us look at some other challenges with system testing.

  • Complexity: As the number of tests and their types increases, managing and analyzing them becomes complex. Furthermore, when each test is to be performed by a different tool, it is even more complex and demands advanced tools.
  • Resource Optimization: Running multiple tests simultaneously means increased resource usage and requires careful orchestration of tests and allocation of resources. 
  • Logs & Analysis: With so many tests running simultaneously, getting a complete picture of the test outcome can be difficult. Teams struggle to collate results from different tests and environments without proper tools. This inefficiency can lead to missed bugs and affect the application quality. 

You need a versatile tool to orchestrate and manage multiple tests to overcome the challenges of performing comprehensive system testing with different tests. Enter Testkube.

System Testing with Testkube

Testkube is a Kubernetes-native testing framework that makes end-to-end testing in Kubernetes a breeze. Using Testkube, you can orchestrate and automate complex testing workflows using different testing tools, all from a single intuitive UI. 

Benefits of Using Testkube For System Testing

Testkube enhances system testing by integrating seamlessly with Kubernetes, allowing teams to leverage its full potential for running your tests: 

  • Orchestrate Complex Test Workflow: Test Workflows allow you to define complex workflows that enable sequential and parallel test executions to mimic real-world scenarios. Testkube does so without complex scripting and facilitates the creation of detailed test workflows, allowing for better control and customization of test executions.
  • In-Cluster Test Execution: Unlike other testing frameworks and tools, Testkube executes your tests within the Kubernetes clusters, ensuring a secure and production-like environment and thus improving the reliability of your test outcomes.
  • Leverage your own infrastructure: You can run Testkube on your existing infrastructure, which helps maintain consistency across test and production environments and decreases infrastructure costs.
  • Integration with Testing Tools: Testkube integrates with all popular testing tools, including k6, Cypress, and Postman, to name a few. Furthermore, Testkube allows you to combine tests for any of these tools in any way required to perform your system tests.

With these out-of-the-box benefits, Testkube simplifies the orchestration of complex system testing scenarios with a drastically shorter implementation time than other approaches like CI/CD-based solutions or DIY frameworks.

Building A System Test Workflow Using Testkube

With Testkube, you can not only create standalone test workflows but also combine different test workflows that use different tools to run sequentially or in parallel. To put it simply, you can run a system test, load test, and API test all at the same time.

Let’s have a look at how this can be done with Testkube. We’ll create a similar scenario where we’ll have a cURL test to login a user as the first step. The test fetches the access token and passes it on to the next step. Next, we configure Cypress, k6, and Postman tests to run parallelly. All these tests will use the token to perform the tests.

To summarize, we have created the following test workflows: 

  • cURL - to authenticate a user, fetch the access token, and save it in a file.
  • Cypress - to perform end-to-end testing of the application.
  • Postman - to perform API testing for the application.

Pre-requisites

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

This video below provides a visual guide to the concepts we'll be exploring in the following sections.

Creating a System Test Workflow

Login to Testkube, navigate to the Test Workflows tab for your local environment, and click the “Add a new test workflow” button.

This will provide you with four options:

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

We’ll choose the “Combine existing workflows” option to create this custom workflow and choose the existing test workflows we’ve created. 

In the new tab, provide the name for the test workflow and click on the “Add the first workflow” button. Testkube provides an easy-to-use and intuitive interface for creating test workflows. This will give you a list of test workflows that you have already created, and you can choose one from the list. We’ll choose a cURL test workflow that we created, which tests login. 

After adding your first test workflow, Testkube will allow you to add more test workflows to execute in sequence or parallel. You can click the “+” buttons on either side of the current test workflow to add a new test workflow. Let us add a “cypress-workflow.”

Similarly, let’s add “distributed-k6” and “postman-example” test workflow, but parallelly so that we have cypress, k6, and postman test workflows execute in parallel.

Finally, you’ll have something like this - a cURL test followed by cypress, k6, and postman that will run parallelly. Click on the “Next” button to view the spec file it generates. 

Passing Parameters Between Tests

A common need in System testing is to reuse output from one test as input to other tests. In this case, our initial test authenticates a user. The resulting authentication token is then passed to all subsequent tests to ensure those are all running as the same user account. 

Let’s do just that in our generated Workflow: we will modify the spec generated and add an initial cURL test step that adds “token” as the config variable that will be passed by the cURL test to the other tests. Below is the updated spec file.

kind: TestWorkflow
apiVersion: testworkflows.testkube.io/v1
metadata:
 name: end-to-end-test-workflow
 namespace: testkube
spec:
 container:
   env:
   - name: USERNAME
     value: emilys
   - name: PASSWORD
     value: emilyspass
 steps:
 - name: curl-emilys
   run:
     image: curlimages/curl:8.7.1
     shell: |
       curl -s -X POST https://dummyjson.com/auth/login \
        -H "Content-Type: application/json" \
        -d '{
          "username":  "'"$USERNAME"'",
          "password":  "'"$PASSWORD"'",
          "expiresInMins": 30
        }' | grep -o '"token":"[^"]*"' | sed 's/"token":"\([^"]*\)"/\1/' > /data/http_output.txt
 - execute:
     workflows:
     - name: cypress-example
       config:
         token: '{{ file("/data/http_output.txt") }}'
     - name: postman-testkube
       config:
         token: '{{ file("/data/http_output.txt") }}'
     - name: distributed-k6
       config:
         token: '{{ file("/data/http_output.txt") }}'
status: {}

Let us understand what the above spec file does:

  • It configures the “USERNAME” and “PASSWORD” as environment variables for the user to perform authentication.
  • The cURL test defines the end point for authentication and stores the received token in a file named http_output.txt
  • Under workflows, we configure `token: '{{ file("/data/http_output.txt") }}' that takes the token from http_output and passes it as a variable to the other test workflows.

Executing a System Test Workflow

The spec file lists down all the test workflows that we chose from the UI and the order of their execution. Plus it now has the config parameters that we added. Click on the “Create and Run” button to create and execute the test workflow. You’ll see that your custom workflow has started executing. 

You can click on an individual workflow to see its status. For instance, we can check our cypress-example’s execution and see that it has fetched the token from the cURL test and executed the steps successfully.

Similarly, we can check the status and logs for each of the test workflows. Once the entire test workflow has finished executing, you’ll see the status in the UI. In this case, we had a failed Postman test workflow. 

That’s how you can create end-to-end system test workflows by combining multiple test workflows to reproduce a realistic, close-to-product scenario to test your application. 

Summary

One of the most difficult things in testing is to test in production-like environments. It’s difficult to create complex test scenarios that replicate a real-world scenario. Furthermore, if you use different testing tools, it’s nearly impossible to configure all of them to work in tandem and perform comprehensive system tests on your application. 

That’s where Testkube shines by allowing you to create your own test workflows through an intuitive UI and execute those workflows from inside your Kubernetes cluster(s). Irrespective of what testing tools your test workflows use, you can combine all of them to run sequentially or parallelly to perform system testing to test your application.

We would love to hear all about the custom test workflows that you created using Testkube. If you face any issues, remember that the entire Testkube team, plus a vibrant community of fellow Kubernetes testers, are on Slack. We’re just getting started in building the most comprehensive (and friendliest!) cloud-native testing framework for Kubernetes so feel free to follow us on Twitter @testkube_io.

Top 5 System Testing for Distributed Applications FAQs

System Testing for Distributed Applications FAQs

Essential questions about testing complex distributed systems

System testing validates the complete and integrated application to ensure it functions as expected in a production-like environment. For distributed applications, it ensures all interconnected services and components—like APIs, front-end UIs, and databases—work together reliably under real-world conditions.

Why it's crucial for distributed systems:

  • Inter-service communication validation: Ensures APIs, microservices, and databases communicate correctly
  • End-to-end workflow verification: Tests complete user journeys across multiple services
  • Environment consistency checking: Validates that the system works in production-like conditions
  • Integration bug detection: Catches issues that only appear when services work together
  • Performance under realistic load: Tests how the entire system performs with real traffic patterns

Without system testing, bugs from inter-service communication or environment mismatches can go undetected until production, leading to costly failures and poor user experiences.

Testing distributed systems presents unique challenges that don't exist in monolithic applications:

  • Complexity management: Coordinating multiple test types (unit, functional, load, UI) across different tools and frameworks
  • Resource orchestration: Efficiently running tests in parallel or sequence while managing computational resources
  • Environment inconsistencies: Ensuring test environments accurately mirror production configurations and dependencies
  • Log and result aggregation: Collating logs and test results from multiple sources to get a unified view of system health
  • Tool integration difficulties: Managing compatibility issues when different test frameworks need to work together
  • Service dependency management: Handling external service dependencies and ensuring proper test isolation
  • Data consistency: Managing test data across multiple databases and services
  • Network latency simulation: Accurately testing network conditions and failure scenarios

These challenges require specialized tools and strategies designed specifically for distributed system testing.

Testkube simplifies system testing by providing a comprehensive orchestration platform designed for distributed applications:

  • Custom test workflows: Create complex workflows that combine multiple test types and tools in a single execution pipeline
  • Flexible execution patterns: Support for both sequential and parallel test execution to optimize testing time and resource usage
  • Kubernetes-native testing: Run tests directly inside your Kubernetes clusters for realistic environment replication and true production parity
  • Extensive tool integration: Native support for popular testing tools including:
    • API testing with Postman and curl
    • Performance testing with k6 and JMeter
    • UI testing with Cypress and Playwright
    • Load testing and custom testing frameworks
  • Unified management interface: Provides both a user-friendly UI and YAML-based specifications for easy workflow definition and management
  • Real-time monitoring: Live test execution monitoring with detailed logging and result aggregation
  • CI/CD integration: Seamless integration with existing CI/CD pipelines for automated testing

Yes, Testkube provides robust parameter passing capabilities between test steps, enabling complex testing scenarios that require data sharing:

  • File-based token sharing: Store authentication tokens, session IDs, or other data in files that subsequent tests can access
  • Environment variable propagation: Pass variables between tests using environment variables and config parameters
  • Workflow parameter injection: Use YAML-based workflow specifications to define and pass parameters between different test steps
  • Common use cases:
    • Fetching authentication tokens in a curl test and using them in Postman collections
    • Creating test data in setup steps and passing IDs to subsequent validation tests
    • Sharing session cookies between UI tests and API tests
    • Propagating configuration values across different testing tools
  • Dynamic configuration: Configure test parameters at runtime based on previous test results

This capability enables sophisticated testing workflows where tests can build upon each other's results, creating more realistic and comprehensive system validation.

Setting up a comprehensive system test workflow in Testkube involves several key steps:

  • Infrastructure setup:
    • Set up your Kubernetes cluster with proper networking and security configurations
    • Install and configure the Testkube Agent in your cluster
    • Ensure proper RBAC permissions for test execution
  • Individual test creation:
    • Create separate test workflows for different tools (Postman, Cypress, k6)
    • Configure each test with appropriate parameters and environment variables
    • Validate individual tests work correctly in isolation
  • Workflow orchestration:
    • Use the "Combine existing workflows" option in the Testkube UI
    • Define execution order (sequential for dependent tests, parallel for independent ones)
    • Configure variable passing between tests using shared outputs and config parameters
  • Execution and monitoring:
    • Run the complete workflow and monitor execution in real-time
    • Review aggregated logs and results from the Testkube UI
    • Set up alerts and notifications for test failures
    • Integrate results with external monitoring and reporting systems

This approach provides a comprehensive testing strategy that validates your entire distributed system from multiple perspectives while maintaining efficiency and reliability.

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.