Kubernetes has tests for cluster conformance, but operators still have to assess application workloads themselves before upgrades and maintenance. The new Workload Conformance Working Group aims to close that gap with a shared specification and repeatable tests for how workloads behave at runtime. That distinction matters: a cluster can satisfy Kubernetes requirements while an application running on it still fails under ordinary operating conditions.
Why workload behavior needs a baseline
Certified Kubernetes checks clusters, while Kubernetes AI Conformance checks whether clusters can run AI and machine learning workloads. Neither establishes whether an individual workload behaves reliably on Kubernetes. The gap sits between what a cluster supports and what an application actually expects from it.
That leaves cluster teams to discover compatibility problems one application at a time. A node drain can expose an application that cannot handle disruption; an upgrade can reveal reliance on a removed API version. Operators may also encounter workloads requesting unnecessary privileges or reserving resources they don't use. Each issue can require investigation across application configuration, cluster policy and operational history, making repeated manual reviews costly and hard to compare.
Kubernetes guidance already covers topics such as security and disruption handling. The missing piece is a common way to evaluate workload behavior against that guidance. A shared specification could reduce repeated assessments for operators and give application maintainers a consistent baseline across environments. It would also make gaps easier to discuss: teams could point to a defined requirement and a test result instead of relying only on local checklists.
Requirements must be testable
The working group's charter calls for three outputs: a workload behavior specification for each Kubernetes minor version, a way to test each requirement against a running workload, and upstream tooling that runs those tests. Together, those outputs are intended to connect written expectations to observable behavior, with versioning giving teams a way to understand which specification applies to a given Kubernetes release.
The group is still deciding which workloads and behaviors to cover. Areas under consideration include security, disruption resilience, resource use, networking, storage, API usage and observability. The breadth creates a real scoping challenge: a requirement has to matter across enough workloads to justify inclusion, while remaining specific enough to test consistently.
Each requirement will need an objective check that a test binary can run, keeping subjective judgments out of the specification. That constraint is practical, but it may also leave some valuable operational advice outside the conformance test if it can't be expressed as a repeatable check. A test can identify a condition; teams will still need to interpret what that condition means for their own service.
The scope is runtime behavior, not application purpose or logic. The test binary won't repeat checks already covered by Certified Kubernetes, mandate a packaging format, or require a particular vendor tool such as a policy engine or security scanner. That boundary should keep the effort focused on workload compatibility across Kubernetes environments. This is more significant than it looks: avoiding a required vendor tool could make the tests easier to adopt across organizations with different operating practices.
SIGs will guide the work
SIG Architecture will own the specification and tooling through a subproject, to be created after the working group proposes its first artifacts. SIG Apps will contribute the application perspective. When requirements touch areas such as node behavior or networking, the group plans to consult the relevant SIGs.
The working group gives SIGs a place to shape the specification while it's being written. That involvement can help keep requirements aligned with existing Kubernetes guidance, though coordination across groups will take time and careful review. Its target is a stable first specification and working tests within two to three Kubernetes release cycles. The target sets a useful pace, but the substance of the requirements will matter more than hitting a schedule.
Contribute examples, tests and review
Real operating experience will help determine which requirements matter. Cluster operators can share how they assess workloads today and what failed during upgrades or maintenance. Application maintainers can explain what their workloads need from a cluster and where current guidance leaves unanswered questions. Those accounts can help distinguish recurring compatibility problems from edge cases that don't belong in a shared baseline.
The group is also seeking reviewers for proposed requirements, contributors to build tests and tooling, and early testers who can run the binary against their workloads. Comparing results across runs and environments will help expose unclear requirements or inconsistent checks. If you're working in this space, early testing offers a chance to show where a rule is difficult to measure or where a passing result doesn't reflect the operational risk teams care about.
SIG members can review requirements that touch their areas, and the project will need long-term maintainers as it moves beyond the working group. The maintenance question is easy to overlook (and this is the part most people overlook): specifications and test binaries need ongoing attention as Kubernetes versions and workload practices change. A baseline that stops being maintained can become misleading rather than useful.
Join the discussion in #wg-workload-conformance on Kubernetes Slack; invitations are available at slack.k8s.io. The mailing list carries updates, and meetings take place every other Wednesday at 15:00 UTC. The meeting notes include the Zoom link and agenda; joining the list usually adds the invite to your calendar. There are several ways to follow the work, so prospective contributors can review discussions before taking on a task.
What a shared baseline could change
The group's usefulness will depend on whether its requirements reflect real workloads and produce repeatable results. A common test could give operators a clearer starting point when evaluating applications, while maintainers could use failures to identify behavior that needs attention before deployment or an upgrade. That would make workload readiness easier to explain across teams.
And yet, a passing result won't guarantee that a workload is appropriate for every cluster or operating environment. The specification can establish a shared floor for selected behaviors; local policies and service needs will still shape the final decision. The first version will therefore be a measure of the group's priorities as much as a technical checklist.
For now, the most useful contribution is evidence from actual operations: requirements that map to recurring problems, tests that behave consistently, and clear explanations when a workload fails. If the group can bring those pieces together, operators and maintainers will have a baseline they can discuss and improve. A starting point, not a verdict.