Glossary

Agentic AI tools are AI systems that autonomously plan and execute multi-step tasks across tools, such as running tests, analyzing logs, and proposing fixes.

The agentic SDLC is a software development lifecycle where AI coding agents write code, write tests, and open pull requests, while people set direction, review changes, and approve releases.

AI-enhanced development is the practice of using AI tools to accelerate every phase of software creation, from autocomplete and code generation to agentic task execution.

AI-powered testing applies machine learning and large language models to the work around tests, such as log analysis, configuration generation, and failure triage.

AI testing tools use machine learning, natural language processing, and computer vision to write, repair, prioritize, and analyze software tests with less manual effort.

An annotation is a key-value pair of non-identifying metadata attached to a Kubernetes object, such as a Pod or Deployment, for use by tools and automation.

API testing validates that application programming interfaces return correct responses, perform under load, and enforce security, authentication, and data format rules.

An application is software designed to perform specific functions or services for users or other systems, from simple web services to distributed microservice platforms.

ArgoCD is a Kubernetes-native GitOps continuous delivery tool that automatically syncs clusters with the desired state defined in a Git repository.

An artifact is a file produced by a build, test, or deployment process, such as a binary, container image, log, report, or screenshot.

Artillery is an open-source load testing framework that simulates realistic traffic against HTTP, WebSocket, and Socket.io services to measure performance and reliability.

An assertion is a check inside a test that compares an actual result with an expected result and marks that test step as passed or failed.

Bitbucket is a Git hosting service from Atlassian that provides source code repositories, pull request reviews, Jira integration, and built-in CI/CD through Bitbucket Pipelines.

Canary testing is a progressive release strategy that deploys a change to a small subset of users or servers first, so teams can catch problems before a full rollout.

Centralized test observability is the practice of collecting test results, logs, and metrics from every tool and environment in one place to analyze and debug quality.

Change failure rate (CFR) is the percentage of production deployments or changes that cause an incident, degradation, or rollback requiring remediation.

Change impact testing selects and runs only the tests affected by the code, configuration, or dependency changes in a commit or pull request.

Chaos engineering is the discipline of deliberately injecting controlled failures into a system to see how it behaves under stress and confirm it can recover.

CI/CD-agnostic testing runs automated tests independently of any single CI/CD tool, so execution is not tied to Jenkins, GitHub Actions, GitLab CI, or one pipeline.

CI/CD integration is the practice of building automated tests into continuous integration and delivery pipelines so every code change is validated before it ships.

CircleCI is a continuous integration and delivery platform that automates building, testing, and deploying software through workflows defined in configuration files.

A Kubernetes cluster is a group of machines, called nodes, that work together under a control plane to run and manage containerized applications.

Cluster validation is the process of verifying that a Kubernetes cluster is correctly configured, healthy, and ready to run workloads before deployments or tests begin.

A command line interface (CLI) is a text-based tool that lets users control a computer system or application by typing commands in a terminal.

A ConfigMap is a Kubernetes object that stores non-confidential configuration data as key-value pairs, keeping settings separate from container images.

Configuration is the set of parameters and settings that control how software behaves in a given environment, kept separate from the application code itself.

A container is a lightweight, portable software unit that packages an application with its libraries, runtime, and settings so it runs the same everywhere.

A container image is an immutable, packaged file containing application code, libraries, runtime, and configuration needed to start a container.

A continuous feedback loop is an automated cycle of testing, observation, and improvement that sends quality results back to developers after every code change.

Continuous integration (CI) is a software development practice that automatically builds and tests code each time a developer commits a change to a shared repository.

Continuous load testing is the practice of running automated performance and scalability tests on an ongoing basis, not just once before release.

Continuous quality governance is the ongoing, automated enforcement of testing standards, compliance policies, and quality controls across teams, clusters, and environments.

Continuous testing is the practice of running automated tests at every stage of the software delivery pipeline to give fast, ongoing feedback on quality.

A continuous testing platform is software that automates, orchestrates, and reports on testing across tools, environments, and pipelines throughout the delivery lifecycle.

Continuous validation is the practice of running automated tests on an ongoing schedule or event basis to confirm system quality and reliability beyond CI/CD pipeline events.

Control plane orchestration is the centralized coordination of multiple Kubernetes clusters, environments, or workloads through a single control layer.

Coverage is a software testing metric that measures how much of an application’s source code a test suite executes, usually shown as a percentage.

A custom executor is a user-defined, containerized component that lets a test orchestration platform run tests with any tool, framework, or script beyond built-in options.

Cypress is an open-source JavaScript testing framework that runs end-to-end, integration, and component tests directly inside the browser to simulate real user interactions.

Decoupled testing is the practice of separating test execution from CI/CD pipelines so tests run independently through their own orchestration layer.

A Kubernetes Deployment is a controller that keeps a specified number of identical pod replicas running and manages their updates, rollbacks, and scaling.

Deployment frequency is a DORA metric that measures how often a team successfully releases code changes to production within a given time period.

Distributed load testing generates traffic from multiple machines, containers, or clusters at the same time to simulate real-world user load at scale.

Distributed test agents are lightweight components that run automated tests across multiple nodes, clusters, or environments in parallel and report results to a central controller.

Distributed testing runs test cases at the same time across multiple machines, nodes, or clusters instead of one after another on a single machine.

Docker is a platform for building, packaging, and running applications in containers, which bundle code with its dependencies so it runs the same everywhere.

End-to-end (E2E) testing validates a complete user workflow across every layer of an application, from the interface to backend services and data.

An environment is the context where software runs and is tested, defined by its configuration, infrastructure, dependencies, and runtime settings.

An ephemeral environment is a temporary, disposable environment that is created automatically to run tests or validate changes, then torn down.

An error is a failure encountered during a test or workflow execution, caused by the test script, the application under test, or its infrastructure.

A Kubernetes Event is a lightweight API object that records a notable change in the cluster, with a message, reason, type, and timestamp.

Event-driven testing automatically triggers test runs when system events happen, such as deployments, configuration changes, or Git commits.

An execution environment is the full runtime context around a test or application while it runs, including resources, configuration, dependencies, and credentials.

A test failure occurs when a test runs to completion but its actual results do not match the expected results.

A feedback loop is the cycle in which results from one stage of development or testing inform the next decision or iteration.

Flaky infrastructure is test instability caused by the systems that run the tests, such as clusters, nodes, or networks, rather than by test logic or application code.

A flaky test is a test that passes in one run and fails in another even though nothing in the code or test has changed.

Front-end testing tools are frameworks and platforms that verify the user interface of a web application behaves, renders, and performs correctly.

Functional service validation tests whether a deployed Kubernetes service behaves as intended, checking its business logic, APIs, and integrations rather than just availability.

Functional testing is a black-box testing method that checks whether an application performs its intended functions according to its requirements.

Git is a distributed version control system that tracks changes to code and files over time and gives every developer a full copy of the project history.

GitHub is a cloud-based platform built on Git that hosts repositories and adds collaboration, project management, security, and automation features.

GitLab is a DevOps platform that combines Git repositories, CI/CD pipelines, issue tracking, and code review in one application for the full software lifecycle.

GitOps is an operational model that uses Git repositories as the source of truth to manage infrastructure, applications, and configuration through automated reconciliation.

Grafana is an open-source platform for querying, visualizing, and alerting on metrics, logs, and traces from sources like Prometheus, Loki, and InfluxDB.

Helm is an open-source package manager for Kubernetes that uses charts to install, configure, upgrade, and roll back applications with single commands.

A hook is an automation mechanism that runs custom logic at a predefined event or lifecycle stage, such as before a test starts or after a deployment finishes.

Hybrid infrastructure testing validates applications that run across both virtual machines and Kubernetes clusters, checking consistency, reliability, and visibility between legacy and cloud-native environments.

An identifier is a unique label assigned to a resource, such as a test, test run, or workflow, so systems and people can track and reference it without ambiguity.

In-cluster test execution runs tests directly inside a Kubernetes cluster as native Jobs, so tests share the same network, configuration, and resources as the application under test.

Infrastructure-as-Code (IaC) is the practice of defining servers, networks, and clusters in machine-readable, version-controlled files instead of configuring them by hand.

Kubernetes Ingress is an API resource that manages external HTTP and HTTPS access to services inside a cluster, routing requests by hostname or path through a single entry point.

An integration is a connection between two or more systems that lets them exchange data, trigger actions, and share results automatically, using APIs, webhooks, plugins, or configuration files.

Integration testing is a software testing method that validates how multiple components, modules, or services work together, catching data mismatches and broken connections that unit tests miss.

Intelligent test orchestration is the practice of deciding when, where, and how tests run across environments, using automation, real-time data, and AI to balance speed, cost, and reliability.

IT testing tools are software applications that automate, manage, and monitor testing activities in IT projects, helping teams ensure the quality, performance, and security of web, mobile, and API systems.

Jenkins is an open-source automation server that builds, tests, and deploys applications through pipelines, which are defined sequences of steps that run automatically on code changes or schedules.

Apache JMeter is an open-source load and performance testing tool that simulates many concurrent users to measure how web applications, APIs, and other services respond under load.

A job is a single unit of work that runs to completion, such as a CI/CD pipeline step or a Kubernetes Job resource that creates pods to carry out a defined task.

k6 is an open-source load testing tool that uses JavaScript scripts to simulate virtual users and measure the performance, reliability, and scalability of APIs and web services.

Kubernetes is an open-source container orchestration platform that automates the deployment, scaling, and management of containerized applications across clusters of machines.

Kubernetes migration testing is the process of validating applications, services, and infrastructure as they move from legacy environments, such as VMs or monoliths, to Kubernetes.

Kubernetes-native testing is an approach that runs tests directly inside Kubernetes clusters, using pods, Jobs, and native APIs, instead of on external machines or hosted testing services.

A Kubernetes sandbox environment is an isolated cluster, namespace, or virtual cluster where teams can safely deploy, test, and experiment without affecting production systems.

A Kubernetes label is a key-value pair attached to a resource, such as a pod, service, or Job, so tools and controllers can group, filter, and select related resources.

Load testing is a performance testing method that measures how an application or system behaves under expected levels of concurrent users and traffic.

Long feedback loops occur when developers receive test results long after making a code change, which slows debugging, delays releases, and lets regressions spread.

A Kubernetes manifest is a YAML or JSON configuration file that declares the desired state of one or more resources, such as Deployments, Services, or Jobs.

A mapping is a set of key-value pairs that associates each key with a value, used in YAML, JSON, and other configuration formats to structure settings, parameters, and secrets.

An MCP (Model Context Protocol) server is a service that exposes a system’s data and actions to AI agents through an open standard, so AI tools can query, run, and analyze work in that system.

Mean Time to Detect (MTTD) is a reliability metric that measures the average time between when an issue occurs and when a team discovers it through testing, monitoring, or alerts.

Mean Time to Repair (MTTR) is a reliability metric that measures the average time it takes to diagnose, fix, test, and redeploy a resolution after an issue is detected.

Metrics are numeric measurements collected over time, such as test duration, error rate, or CPU usage, that show the health, performance, and effectiveness of systems and processes.

Mocking is a testing technique that simulates the behavior of real dependencies, such as APIs, databases, or third-party services, so a component can be tested in isolation.

Multi-cluster is a Kubernetes architecture where workloads and services are deployed, managed, and tested across two or more clusters instead of a single cluster.

Multi-step problem solving is an AI system’s ability to break a complex goal into smaller tasks and chain tools, such as Testkube, GitHub, and Kubernetes, to complete them in sequence.

A Kubernetes namespace is a logical partition within a cluster that groups related resources, such as pods, services, and Jobs, so teams can isolate, name, and govern them separately.

A Kubernetes node is a physical or virtual machine in a cluster that provides the CPU, memory, and storage needed to run pods and their containers.

Observability is the practice of understanding the internal state of a system by analyzing the data it produces, mainly logs, metrics, and traces.

On-premise and air-gapped testing is the practice of running automated software tests entirely inside private or internet-disconnected networks, so test data never leaves the organization.