Repository: kubernetes-sigs/kueue
Pull request #187 (2022-04-07 19:09:18)

Rename QueuedWorkload to Workload
## What type of PR is this?

/kind cleanup

/kind api-change

#### What this PR does / why we need it:

Initially we named it QueuedWorkload for lack of a better name. Now we are close to the release and:
- we didn't find a better name.
- we already referring to them as workloads in the documentation, and it works well.

#### Which issue(s) this PR fixes:

Fixes #

#### Special notes for your reviewer:



k8s-ci-robot: [APPROVALNOTIFIER] This PR is **APPROVED**

This pull-request has been approved by: *<a href="https://github.com/kubernetes-sigs/kueue/pull/187#" title="Author self-approved">alculquicondor</a>*

The full list of commands accepted by this bot can be found [here](https://go.k8s.io/bot-commands?repo=kubernetes-sigs%2Fkueue).

The pull request process is described [here](https://git.k8s.io/community/contributors/guide/owners.md#the-code-review-process)

<details >
Needs approval from an approver in each of these files:

- ~~[OWNERS](https://github.com/kubernetes-sigs/kueue/blob/main/OWNERS)~~ [alculquicondor]

Approvers can indicate their approval by writing `/approve` in a comment
Approvers can cancel approval by writing `/approve cancel` in a comment
</details>
<!-- META={"approvers":[]} -->
alculquicondor: /hold
to prevent premature merge
alculquicondor: FYI @Huang-Wei. I think you wanted this name at some point :)
ahg-g: /lgtm

Patch:
diff --git a/PROJECT b/PROJECT
index af89701cd..2f1aaf7c5 100644
--- a/PROJECT
+++ b/PROJECT
@@ -28,7 +28,7 @@ resources:
   controller: true
   domain: x-k8s.io
   group: kueue
-  kind: QueuedWorkload
+  kind: Workload
   path: sigs.k8s.io/kueue/api/v1alpha1
   version: v1alpha1
 - api:
diff --git a/README.md b/README.md
index 35267f6a1..5c69ba539 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,6 @@
 # Kueue
 
-Kueue is a set of APIs and controller for [job](docs/concepts/queued_workload.md)
+Kueue is a set of APIs and controller for [job](docs/concepts/workload.md)
 [queueing](docs/concepts#queueing). It is a job-level manager that decides when
 a job should be [admitted](docs/concepts#admission) to start (as in pods can be
 created) and when it should stop (as in active pods should be deleted).
diff --git a/api/v1alpha1/queuedworkload_types.go b/api/v1alpha1/workload_types.go
similarity index 73%
rename from api/v1alpha1/queuedworkload_types.go
rename to api/v1alpha1/workload_types.go
index 81253c338..a6e36f178 100644
--- a/api/v1alpha1/queuedworkload_types.go
+++ b/api/v1alpha1/workload_types.go
@@ -21,8 +21,8 @@ import (
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 )
 
-// QueuedWorkloadSpec defines the desired state of QueuedWorkload
-type QueuedWorkloadSpec struct {
+// WorkloadSpec defines the desired state of Workload
+type WorkloadSpec struct {
 	// pods is a list of sets of homogeneous pods, each described by a Pod spec
 	// and a count.
 	//
@@ -30,17 +30,17 @@ type QueuedWorkloadSpec struct {
 	// +listMapKey=name
 	PodSets []PodSet `json:"pods,omitempty"`
 
-	// queueName is the name of the queue the QueuedWorkload is associated with.
+	// queueName is the name of the queue the Workload is associated with.
 	QueueName string `json:"queueName"`
 
 	// admission holds the parameters of the admission of the workload by a ClusterQueue.
 	Admission *Admission `json:"admission,omitempty"`
 
-	// If specified, indicates the queuedWorkload's priority.
+	// If specified, indicates the workload's priority.
 	// "system-node-critical" and "system-cluster-critical" are two special
 	// keywords which indicate the highest priorities with the former being
 	// the highest priority. Any other name must be defined by creating a
-	// PriorityClass object with that name. If not specified, the queuedWorkload
+	// PriorityClass object with that name. If not specified, the workload
 	// priority will be default or zero if there is no default.
 	PriorityClassName string `json:"priorityClassName,omitempty"`
 
@@ -82,23 +82,23 @@ type PodSet struct {
 	Count int32 `json:"count"`
 }
 
-// QueuedWorkloadStatus defines the observed state of QueuedWorkload
-type QueuedWorkloadStatus struct {
-	// conditions hold the latest available observations of the QueuedWorkload
+// WorkloadStatus defines the observed state of Workload
+type WorkloadStatus struct {
+	// conditions hold the latest available observations of the Workload
 	// current state.
 	// +optional
 	// +listType=map
 	// +listMapKey=type
-	Conditions []QueuedWorkloadCondition `json:"conditions,omitempty"`
+	Conditions []WorkloadCondition `json:"conditions,omitempty"`
 }
 
-type QueuedWorkloadCondition struct {
+type WorkloadCondition struct {
 	// type of condition could be:
 	//
-	// Admitted: the QueuedWorkload was admitted through a ClusterQueue.
+	// Admitted: the Workload was admitted through a ClusterQueue.
 	//
 	// Finished: the associated workload finished running (failed or succeeded).
-	Type QueuedWorkloadConditionType `json:"type"`
+	Type WorkloadConditionType `json:"type"`
 
 	// status could be True, False or Unknown.
 	Status corev1.ConditionStatus `json:"status"`
@@ -122,42 +122,41 @@ type QueuedWorkloadCondition struct {
 	Message string `json:"message,omitempty"`
 }
 
-type QueuedWorkloadConditionType string
+type WorkloadConditionType string
 
 const (
-	// QueuedWorkloadAdmitted means that the QueuedWorkload was admitted by a ClusterQueue.
-	QueuedWorkloadAdmitted QueuedWorkloadConditionType = "Admitted"
+	// WorkloadAdmitted means that the Workload was admitted by a ClusterQueue.
+	WorkloadAdmitted WorkloadConditionType = "Admitted"
 
-	// QueuedWorkloadFinished means that the workload associated to the
+	// WorkloadFinished means that the workload associated to the
 	// ResourceClaim finished running (failed or succeeded).
-	QueuedWorkloadFinished QueuedWorkloadConditionType = "Finished"
+	WorkloadFinished WorkloadConditionType = "Finished"
 )
 
 //+kubebuilder:object:root=true
-//+kubebuilder:resource:shortName={workload,workloads,qw}
 //+kubebuilder:subresource:status
 //+kubebuilder:printcolumn:name="Queue",JSONPath=".spec.queueName",type=string,description="Name of the queue this workload was submitted to"
 //+kubebuilder:printcolumn:name="Admitted by",JSONPath=".spec.admission.clusterQueue",type=string,description="Name of the ClusterQueue that admitted this workload"
 //+kubebuilder:printcolumn:name="Age",JSONPath=".metadata.creationTimestamp",type=date,description="Time this workload was created"
 
-// QueuedWorkload is the Schema for the queuedworkloads API
-type QueuedWorkload struct {
+// Workload is the Schema for the workloads API
+type Workload struct {
 	metav1.TypeMeta   `json:",inline"`
 	metav1.ObjectMeta `json:"metadata,omitempty"`
 
-	Spec   QueuedWorkloadSpec   `json:"spec,omitempty"`
-	Status QueuedWorkloadStatus `json:"status,omitempty"`
+	Spec   WorkloadSpec   `json:"spec,omitempty"`
+	Status WorkloadStatus `json:"status,omitempty"`
 }
 
 //+kubebuilder:object:root=true
 
-// QueuedWorkloadList contains a list of ResourceClaim
-type QueuedWorkloadList struct {
+// WorkloadList contains a list of ResourceClaim
+type WorkloadList struct {
 	metav1.TypeMeta `json:",inline"`
 	metav1.ListMeta `json:"metadata,omitempty"`
-	Items           []QueuedWorkload `json:"items"`
+	Items           []Workload `json:"items"`
 }
 
 func init() {
-	SchemeBuilder.Register(&QueuedWorkload{}, &QueuedWorkloadList{})
+	SchemeBuilder.Register(&Workload{}, &WorkloadList{})
 }
diff --git a/api/v1alpha1/zz_generated.deepcopy.go b/api/v1alpha1/zz_generated.deepcopy.go
index 148a2e888..56ee144e6 100644
--- a/api/v1alpha1/zz_generated.deepcopy.go
+++ b/api/v1alpha1/zz_generated.deepcopy.go
@@ -310,136 +310,6 @@ func (in *QueueStatus) DeepCopy() *QueueStatus {
 	return out
 }
 
-// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
-func (in *QueuedWorkload) DeepCopyInto(out *QueuedWorkload) {
-	*out = *in
-	out.TypeMeta = in.TypeMeta
-	in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
-	in.Spec.DeepCopyInto(&out.Spec)
-	in.Status.DeepCopyInto(&out.Status)
-}
-
-// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new QueuedWorkload.
-func (in *QueuedWorkload) DeepCopy() *QueuedWorkload {
-	if in == nil {
-		return nil
-	}
-	out := new(QueuedWorkload)
-	in.DeepCopyInto(out)
-	return out
-}
-
-// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
-func (in *QueuedWorkload) DeepCopyObject() runtime.Object {
-	if c := in.DeepCopy(); c != nil {
-		return c
-	}
-	return nil
-}
-
-// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
-func (in *QueuedWorkloadCondition) DeepCopyInto(out *QueuedWorkloadCondition) {
-	*out = *in
-	in.LastProbeTime.DeepCopyInto(&out.LastProbeTime)
-	in.LastTransitionTime.DeepCopyInto(&out.LastTransitionTime)
-}
-
-// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new QueuedWorkloadCondition.
-func (in *QueuedWorkloadCondition) DeepCopy() *QueuedWorkloadCondition {
-	if in == nil {
-		return nil
-	}
-	out := new(QueuedWorkloadCondition)
-	in.DeepCopyInto(out)
-	return out
-}
-
-// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
-func (in *QueuedWorkloadList) DeepCopyInto(out *QueuedWorkloadList) {
-	*out = *in
-	out.TypeMeta = in.TypeMeta
-	in.ListMeta.DeepCopyInto(&out.ListMeta)
-	if in.Items != nil {
-		in, out := &in.Items, &out.Items
-		*out = make([]QueuedWorkload, len(*in))
-		for i := range *in {
-			(*in)[i].DeepCopyInto(&(*out)[i])
-		}
-	}
-}
-
-// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new QueuedWorkloadList.
-func (in *QueuedWorkloadList) DeepCopy() *QueuedWorkloadList {
-	if in == nil {
-		return nil
-	}
-	out := new(QueuedWorkloadList)
-	in.DeepCopyInto(out)
-	return out
-}
-
-// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
-func (in *QueuedWorkloadList) DeepCopyObject() runtime.Object {
-	if c := in.DeepCopy(); c != nil {
-		return c
-	}
-	return nil
-}
-
-// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
-func (in *QueuedWorkloadSpec) DeepCopyInto(out *QueuedWorkloadSpec) {
-	*out = *in
-	if in.PodSets != nil {
-		in, out := &in.PodSets, &out.PodSets
-		*out = make([]PodSet, len(*in))
-		for i := range *in {
-			(*in)[i].DeepCopyInto(&(*out)[i])
-		}
-	}
-	if in.Admission != nil {
-		in, out := &in.Admission, &out.Admission
-		*out = new(Admission)
-		(*in).DeepCopyInto(*out)
-	}
-	if in.Priority != nil {
-		in, out := &in.Priority, &out.Priority
-		*out = new(int32)
-		**out = **in
-	}
-}
-
-// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new QueuedWorkloadSpec.
-func (in *QueuedWorkloadSpec) DeepCopy() *QueuedWorkloadSpec {
-	if in == nil {
-		return nil
-	}
-	out := new(QueuedWorkloadSpec)
-	in.DeepCopyInto(out)
-	return out
-}
-
-// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
-func (in *QueuedWorkloadStatus) DeepCopyInto(out *QueuedWorkloadStatus) {
-	*out = *in
-	if in.Conditions != nil {
-		in, out := &in.Conditions, &out.Conditions
-		*out = make([]QueuedWorkloadCondition, len(*in))
-		for i := range *in {
-			(*in)[i].DeepCopyInto(&(*out)[i])
-		}
-	}
-}
-
-// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new QueuedWorkloadStatus.
-func (in *QueuedWorkloadStatus) DeepCopy() *QueuedWorkloadStatus {
-	if in == nil {
-		return nil
-	}
-	out := new(QueuedWorkloadStatus)
-	in.DeepCopyInto(out)
-	return out
-}
-
 // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
 func (in *Quota) DeepCopyInto(out *Quota) {
 	*out = *in
@@ -609,3 +479,133 @@ func (in UsedResources) DeepCopy() UsedResources {
 	in.DeepCopyInto(out)
 	return *out
 }
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *Workload) DeepCopyInto(out *Workload) {
+	*out = *in
+	out.TypeMeta = in.TypeMeta
+	in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
+	in.Spec.DeepCopyInto(&out.Spec)
+	in.Status.DeepCopyInto(&out.Status)
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Workload.
+func (in *Workload) DeepCopy() *Workload {
+	if in == nil {
+		return nil
+	}
+	out := new(Workload)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
+func (in *Workload) DeepCopyObject() runtime.Object {
+	if c := in.DeepCopy(); c != nil {
+		return c
+	}
+	return nil
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *WorkloadCondition) DeepCopyInto(out *WorkloadCondition) {
+	*out = *in
+	in.LastProbeTime.DeepCopyInto(&out.LastProbeTime)
+	in.LastTransitionTime.DeepCopyInto(&out.LastTransitionTime)
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new WorkloadCondition.
+func (in *WorkloadCondition) DeepCopy() *WorkloadCondition {
+	if in == nil {
+		return nil
+	}
+	out := new(WorkloadCondition)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *WorkloadList) DeepCopyInto(out *WorkloadList) {
+	*out = *in
+	out.TypeMeta = in.TypeMeta
+	in.ListMeta.DeepCopyInto(&out.ListMeta)
+	if in.Items != nil {
+		in, out := &in.Items, &out.Items
+		*out = make([]Workload, len(*in))
+		for i := range *in {
+			(*in)[i].DeepCopyInto(&(*out)[i])
+		}
+	}
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new WorkloadList.
+func (in *WorkloadList) DeepCopy() *WorkloadList {
+	if in == nil {
+		return nil
+	}
+	out := new(WorkloadList)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
+func (in *WorkloadList) DeepCopyObject() runtime.Object {
+	if c := in.DeepCopy(); c != nil {
+		return c
+	}
+	return nil
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *WorkloadSpec) DeepCopyInto(out *WorkloadSpec) {
+	*out = *in
+	if in.PodSets != nil {
+		in, out := &in.PodSets, &out.PodSets
+		*out = make([]PodSet, len(*in))
+		for i := range *in {
+			(*in)[i].DeepCopyInto(&(*out)[i])
+		}
+	}
+	if in.Admission != nil {
+		in, out := &in.Admission, &out.Admission
+		*out = new(Admission)
+		(*in).DeepCopyInto(*out)
+	}
+	if in.Priority != nil {
+		in, out := &in.Priority, &out.Priority
+		*out = new(int32)
+		**out = **in
+	}
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new WorkloadSpec.
+func (in *WorkloadSpec) DeepCopy() *WorkloadSpec {
+	if in == nil {
+		return nil
+	}
+	out := new(WorkloadSpec)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *WorkloadStatus) DeepCopyInto(out *WorkloadStatus) {
+	*out = *in
+	if in.Conditions != nil {
+		in, out := &in.Conditions, &out.Conditions
+		*out = make([]WorkloadCondition, len(*in))
+		for i := range *in {
+			(*in)[i].DeepCopyInto(&(*out)[i])
+		}
+	}
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new WorkloadStatus.
+func (in *WorkloadStatus) DeepCopy() *WorkloadStatus {
+	if in == nil {
+		return nil
+	}
+	out := new(WorkloadStatus)
+	in.DeepCopyInto(out)
+	return out
+}
diff --git a/config/crd/bases/kueue.x-k8s.io_queuedworkloads.yaml b/config/crd/bases/kueue.x-k8s.io_workloads.yaml
similarity index 99%
rename from config/crd/bases/kueue.x-k8s.io_queuedworkloads.yaml
rename to config/crd/bases/kueue.x-k8s.io_workloads.yaml
index 66abd5fbe..7c3cd12ff 100644
--- a/config/crd/bases/kueue.x-k8s.io_queuedworkloads.yaml
+++ b/config/crd/bases/kueue.x-k8s.io_workloads.yaml
@@ -5,18 +5,14 @@ metadata:
   annotations:
     controller-gen.kubebuilder.io/version: v0.8.0
   creationTimestamp: null
-  name: queuedworkloads.kueue.x-k8s.io
+  name: workloads.kueue.x-k8s.io
 spec:
   group: kueue.x-k8s.io
   names:
-    kind: QueuedWorkload
-    listKind: QueuedWorkloadList
-    plural: queuedworkloads
-    shortNames:
-    - workload
-    - workloads
-    - qw
-    singular: queuedworkload
+    kind: Workload
+    listKind: WorkloadList
+    plural: workloads
+    singular: workload
   scope: Namespaced
   versions:
   - additionalPrinterColumns:
@@ -35,7 +31,7 @@ spec:
     name: v1alpha1
     schema:
       openAPIV3Schema:
-        description: QueuedWorkload is the Schema for the queuedworkloads API
+        description: Workload is the Schema for the workloads API
         properties:
           apiVersion:
             description: 'APIVersion defines the versioned schema of this representation
@@ -50,7 +46,7 @@ spec:
           metadata:
             type: object
           spec:
-            description: QueuedWorkloadSpec defines the desired state of QueuedWorkload
+            description: WorkloadSpec defines the desired state of Workload
             properties:
               admission:
                 description: admission holds the parameters of the admission of the
@@ -7322,26 +7318,26 @@ spec:
                 format: int32
                 type: integer
               priorityClassName:
-                description: If specified, indicates the queuedWorkload's priority.
-                  "system-node-critical" and "system-cluster-critical" are two special
-                  keywords which indicate the highest priorities with the former being
-                  the highest priority. Any other name must be defined by creating
-                  a PriorityClass object with that name. If not specified, the queuedWorkload
-                  priority will be default or zero if there is no default.
+                description: If specified, indicates the workload's priority. "system-node-critical"
+                  and "system-cluster-critical" are two special keywords which indicate
+                  the highest priorities with the former being the highest priority.
+                  Any other name must be defined by creating a PriorityClass object
+                  with that name. If not specified, the workload priority will be
+                  default or zero if there is no default.
                 type: string
               queueName:
-                description: queueName is the name of the queue the QueuedWorkload
-                  is associated with.
+                description: queueName is the name of the queue the Workload is associated
+                  with.
                 type: string
             required:
             - queueName
             type: object
           status:
-            description: QueuedWorkloadStatus defines the observed state of QueuedWorkload
+            description: WorkloadStatus defines the observed state of Workload
             properties:
               conditions:
                 description: conditions hold the latest available observations of
-                  the QueuedWorkload current state.
+                  the Workload current state.
                 items:
                   properties:
                     lastProbeTime:
@@ -7366,7 +7362,7 @@ spec:
                       description: status could be True, False or Unknown.
                       type: string
                     type:
-                      description: "type of condition could be: \n Admitted: the QueuedWorkload
+                      description: "type of condition could be: \n Admitted: the Workload
                         was admitted through a ClusterQueue. \n Finished: the associated
                         workload finished running (failed or succeeded)."
                       type: string
diff --git a/config/crd/kustomization.yaml b/config/crd/kustomization.yaml
index c460a41c4..ff523c320 100644
--- a/config/crd/kustomization.yaml
+++ b/config/crd/kustomization.yaml
@@ -4,7 +4,7 @@
 resources:
 - bases/kueue.x-k8s.io_queues.yaml
 - bases/kueue.x-k8s.io_clusterqueues.yaml
-- bases/kueue.x-k8s.io_queuedworkloads.yaml
+- bases/kueue.x-k8s.io_workloads.yaml
 - bases/kueue.x-k8s.io_resourceflavors.yaml
 #+kubebuilder:scaffold:crdkustomizeresource
 
@@ -13,7 +13,7 @@ patchesStrategicMerge:
 # patches here are for enabling the conversion webhook for each CRD
 #- patches/webhook_in_queues.yaml
 #- patches/webhook_in_clusterqueues.yaml
-#- patches/webhook_in_queuedworkloads.yaml
+#- patches/webhook_in_workloads.yaml
 #- patches/webhook_in_resourceflavors.yaml
 #+kubebuilder:scaffold:crdkustomizewebhookpatch
 
@@ -21,7 +21,7 @@ patchesStrategicMerge:
 # patches here are for enabling the CA injection for each CRD
 #- patches/cainjection_in_queues.yaml
 #- patches/cainjection_in_clusterqueues.yaml
-#- patches/cainjection_in_queuedworkloads.yaml
+#- patches/cainjection_in_workloads.yaml
 #- patches/cainjection_in_resourceflavors.yaml
 #+kubebuilder:scaffold:crdkustomizecainjectionpatch
 
diff --git a/config/crd/patches/cainjection_in_queuedworkloads.yaml b/config/crd/patches/cainjection_in_workloads.yaml
similarity index 86%
rename from config/crd/patches/cainjection_in_queuedworkloads.yaml
rename to config/crd/patches/cainjection_in_workloads.yaml
index 07e84ce82..ff55f2f64 100644
--- a/config/crd/patches/cainjection_in_queuedworkloads.yaml
+++ b/config/crd/patches/cainjection_in_workloads.yaml
@@ -4,4 +4,4 @@ kind: CustomResourceDefinition
 metadata:
   annotations:
     cert-manager.io/inject-ca-from: $(CERTIFICATE_NAMESPACE)/$(CERTIFICATE_NAME)
-  name: queuedworkloads.kueue.x-k8s.io
+  name: workloads.kueue.x-k8s.io
diff --git a/config/crd/patches/webhook_in_queuedworkloads.yaml b/config/crd/patches/webhook_in_workloads.yaml
similarity index 90%
rename from config/crd/patches/webhook_in_queuedworkloads.yaml
rename to config/crd/patches/webhook_in_workloads.yaml
index d1ef1faef..2d69269b9 100644
--- a/config/crd/patches/webhook_in_queuedworkloads.yaml
+++ b/config/crd/patches/webhook_in_workloads.yaml
@@ -2,7 +2,7 @@
 apiVersion: apiextensions.k8s.io/v1
 kind: CustomResourceDefinition
 metadata:
-  name: queuedworkloads.kueue.x-k8s.io
+  name: workloads.kueue.x-k8s.io
 spec:
   conversion:
     strategy: Webhook
diff --git a/config/rbac/kustomization.yaml b/config/rbac/kustomization.yaml
index a7fd6720c..1f4c41094 100644
--- a/config/rbac/kustomization.yaml
+++ b/config/rbac/kustomization.yaml
@@ -25,7 +25,7 @@ resources:
 - job_viewer_role.yaml
 - queue_editor_role.yaml
 - queue_viewer_role.yaml
-- queuedworkload_editor_role.yaml
-- queuedworkload_viewer_role.yaml
+- workload_editor_role.yaml
+- workload_viewer_role.yaml
 - resourceflavor_editor_role.yaml
 - resourceflavor_viewer_role.yaml
diff --git a/config/rbac/role.yaml b/config/rbac/role.yaml
index 7d719eb8e..ed60c0ab1 100644
--- a/config/rbac/role.yaml
+++ b/config/rbac/role.yaml
@@ -66,7 +66,7 @@ rules:
 - apiGroups:
   - kueue.x-k8s.io
   resources:
-  - queuedworkloads
+  - queues
   verbs:
   - create
   - delete
@@ -78,13 +78,13 @@ rules:
 - apiGroups:
   - kueue.x-k8s.io
   resources:
-  - queuedworkloads/finalizers
+  - queues/finalizers
   verbs:
   - update
 - apiGroups:
   - kueue.x-k8s.io
   resources:
-  - queuedworkloads/status
+  - queues/status
   verbs:
   - get
   - patch
@@ -92,7 +92,15 @@ rules:
 - apiGroups:
   - kueue.x-k8s.io
   resources:
-  - queues
+  - resourceflavors
+  verbs:
+  - get
+  - list
+  - watch
+- apiGroups:
+  - kueue.x-k8s.io
+  resources:
+  - workloads
   verbs:
   - create
   - delete
@@ -104,25 +112,17 @@ rules:
 - apiGroups:
   - kueue.x-k8s.io
   resources:
-  - queues/finalizers
+  - workloads/finalizers
   verbs:
   - update
 - apiGroups:
   - kueue.x-k8s.io
   resources:
-  - queues/status
+  - workloads/status
   verbs:
   - get
   - patch
   - update
-- apiGroups:
-  - kueue.x-k8s.io
-  resources:
-  - resourceflavors
-  verbs:
-  - get
-  - list
-  - watch
 - apiGroups:
   - scheduling.k8s.io
   resources:
diff --git a/config/rbac/queuedworkload_editor_role.yaml b/config/rbac/workload_editor_role.yaml
similarity index 70%
rename from config/rbac/queuedworkload_editor_role.yaml
rename to config/rbac/workload_editor_role.yaml
index a40534d2f..61e6cfe23 100644
--- a/config/rbac/queuedworkload_editor_role.yaml
+++ b/config/rbac/workload_editor_role.yaml
@@ -1,15 +1,15 @@
-# permissions for end users to edit queuedworkloads.
+# permissions for end users to edit workloads.
 apiVersion: rbac.authorization.k8s.io/v1
 kind: ClusterRole
 metadata:
-  name: queuedworkload-editor-role
+  name: workload-editor-role
   labels:
     rbac.kueue.x-k8s.io/batch-admin: "true"
 rules:
 - apiGroups:
   - kueue.x-k8s.io
   resources:
-  - queuedworkloads
+  - workloads
   verbs:
   - create
   - delete
@@ -21,6 +21,6 @@ rules:
 - apiGroups:
   - kueue.x-k8s.io
   resources:
-  - queuedworkloads/status
+  - workloads/status
   verbs:
   - get
diff --git a/config/rbac/queuedworkload_viewer_role.yaml b/config/rbac/workload_viewer_role.yaml
similarity index 70%
rename from config/rbac/queuedworkload_viewer_role.yaml
rename to config/rbac/workload_viewer_role.yaml
index 4236c5df0..9f02c6783 100644
--- a/config/rbac/queuedworkload_viewer_role.yaml
+++ b/config/rbac/workload_viewer_role.yaml
@@ -1,8 +1,8 @@
-# permissions for end users to view queuedworkloads.
+# permissions for end users to view workloads.
 apiVersion: rbac.authorization.k8s.io/v1
 kind: ClusterRole
 metadata:
-  name: queuedworkload-viewer-role
+  name: workload-viewer-role
   labels:
     rbac.kueue.x-k8s.io/batch-admin: "true"
     rbac.kueue.x-k8s.io/batch-user: "true"
@@ -10,7 +10,7 @@ rules:
 - apiGroups:
   - kueue.x-k8s.io
   resources:
-  - queuedworkloads
+  - workloads
   verbs:
   - get
   - list
@@ -18,6 +18,6 @@ rules:
 - apiGroups:
   - kueue.x-k8s.io
   resources:
-  - queuedworkloads/status
+  - workloads/status
   verbs:
   - get
diff --git a/docs/concepts/README.md b/docs/concepts/README.md
index 9093f26d7..50e7adf52 100644
--- a/docs/concepts/README.md
+++ b/docs/concepts/README.md
@@ -15,7 +15,7 @@ limits and fair sharing rules.
 A namespaced resource that groups closely related workloads belonging to a
 single tenant.
 
-### [Queued Workload](queued_workload.md)
+### [Workload](workload.md)
 
 An application that will run to completion. It is the unit of _admission_ in
 Kueue. Sometimes referred to as _job_.
diff --git a/docs/concepts/cluster_queue.md b/docs/concepts/cluster_queue.md
index 6d2cd2193..e62d78383 100644
--- a/docs/concepts/cluster_queue.md
+++ b/docs/concepts/cluster_queue.md
@@ -29,7 +29,7 @@ spec:
         guaranteed: 36Gi
 ```
 
-This ClusterQueue admits [workloads](queued_workload.md) if and only if:
+This ClusterQueue admits [workloads](workload.md) if and only if:
 - The sum of the CPU requests is less than or equal to 9.
 - The sum of the memory requests is less than or equal to 36Gi.
 
@@ -64,7 +64,7 @@ are ordered in the ClusterQueue and how they are re-queued after an unsuccessful
 
 The following are the supported queueing strategies:
 
-- `StrictFIFO`: Workloads are ordered first by [priority](queued_workload.md#priority)
+- `StrictFIFO`: Workloads are ordered first by [priority](workload.md#priority)
   and then by `.metadata.creationTimestamp`. Older workloads that can't be
   admitted will block newer workloads, even if the newer workloads fit in the
   available quota.
@@ -105,8 +105,8 @@ taints:
 You can use the `.metadata.name` to reference a flavor from a ClusterQueue in
 the `.spec.requestableResources[*].flavors[*].resourceFlavor` field.
 
-For each resource of each [pod set](queued_workload.md#pod-sets) in a
-QueuedWorkload, Kueue assigns the first flavor in the `.spec.requestableResources[*].resources.flavors`
+For each resource of each [pod set](workload.md#pod-sets) in a Workload, Kueue
+assigns the first flavor in the `.spec.requestableResources[*].resources.flavors`
 list that has enough unused quota in the ClusterQueue or the ClusterQueue's
 [cohort](#cohort).
 
@@ -125,7 +125,7 @@ steps:
 1. When admitting a workload, Kueue evaluates the
    [`.nodeSelector`](https://kubernetes.io/docs/concepts/scheduling-eviction/assign-pod-node/#nodeselector)
    and [`.affinity.nodeAffinity.requiredDuringSchedulingIgnoredDuringExecution`](https://kubernetes.io/docs/concepts/scheduling-eviction/assign-pod-node/#node-affinity)
-   fields in the PodSpecs of your [QueuedWorkloads](queued_workload.md) against the
+   fields in the PodSpecs of your [Workload](workload.md) against the
    ResourceFlavor labels.
 2. Once the workload is admitted, Kueue adds the ResourceFlavor labels to the
   `.nodeSelector` of the underlying workload Pod templates, if the workload
diff --git a/docs/concepts/queued_workload.md b/docs/concepts/workload.md
similarity index 51%
rename from docs/concepts/queued_workload.md
rename to docs/concepts/workload.md
index 37696672a..5cb582221 100644
--- a/docs/concepts/queued_workload.md
+++ b/docs/concepts/workload.md
@@ -1,25 +1,24 @@
-# Queued Workload
+# Workload
 
-A _queued workload_ (or simply _workload_) is an application that will run to
-completion. It can be composed by one or multiple Pods that, loosely or tightly
-coupled, that, as a whole, complete a task. A workload is the unit of [admission](.#admission)
-in Kueue.
+A _workload_ is an application that will run to completion. It can be composed
+by one or multiple Pods that, loosely or tightly coupled, that, as a whole,
+complete a task. A workload is the unit of [admission](.#admission) in Kueue.
 
 The prototypical workload can be represented with a
 [Kubernetes `batch/v1.Job`](https://kubernetes.io/docs/concepts/workloads/controllers/job/).
 For this reason, we sometimes use the word _job_ to refer to any workload, and
-`Job` when we refer specifically to the Kubernetes API.
+Job when we refer specifically to the Kubernetes API.
 
-However, Kueue does not directly manipulate Job objects. Instead, Kueue
-manages QueuedWorkload objects that represent the resource requirements
-of an arbitrary workload. Kueue automatically creates a QueuedWorkload for
-each Job object and syncs the decisions and statuses.
+However, Kueue does not directly manipulate Job objects. Instead, Kueue manages
+Workload objects that represent the resource requirements of an arbitrary
+workload. Kueue automatically creates a Workload for each Job object and syncs
+the decisions and statuses.
 
-The manifest for a QueuedWorkload looks like the following:
+The manifest for a Workload looks like the following:
 
 ```yaml
 apiVersion: kueue.x-k8s.io/v1alpha1
-kind: QueuedWorkload
+kind: Workload
 metadata:
   name: sample-job
   namespace: default
@@ -42,22 +41,21 @@ spec:
 
 ## Pod sets
 
-A QueuedWorkload represents a workload composed of multiple Pods with different
-pod specs.
+A Workload might be composed of multiple Pods with different pod specs.
 
 Each item of the `.spec.pods` list represents a set of homogeneous Pods and has
 the following fields:
 - `spec` describes the pods using a [`v1/core.PodSpec`](https://kubernetes.io/docs/reference/kubernetes-api/workload-resources/pod-v1/#PodSpec).
 - `count` is the number of pods that use the same `spec`.
-- `name` is a human-readable identifier for the group of pods. You can use the
-  role of the Pods in the workload, like `driver`, `worker`, `parameter-server`, etc.
+- `name` is a human-readable identifier for the pod set. You can use the role of
+  the Pods in the workload, like `driver`, `worker`, `parameter-server`, etc.
 
 ## Priority
 
-QueuedWorkloads have a priority that influences the [order in which they are admitted by a ClusterQueue](cluster_queue.md#queueing-strategy).
-You can see the priority of the QueuedWorkload in the field `.spec.priority`.
+Workloads have a priority that influences the [order in which they are admitted by a ClusterQueue](cluster_queue.md#queueing-strategy).
+You can see the priority of the Workload in the field `.spec.priority`.
 
-For a `batch/v1.Job`, Kueue sets the priority of the QueuedWorkload based on the
+For a `batch/v1.Job`, Kueue sets the priority of the Workload based on the
 [pod priority](https://kubernetes.io/docs/concepts/scheduling-eviction/pod-priority-preemption/)
 of the Job's pod template.
 
@@ -65,4 +63,4 @@ of the Job's pod template.
 
 As described previously, Kueue has built-in support for workloads created with
 the Job API. But any custom workload API can integrate with Kueue by
-creating a corresponding `QueuedWorkload` object for it.
\ No newline at end of file
+creating a corresponding Workload object for it.
\ No newline at end of file
diff --git a/docs/tasks/README.md b/docs/tasks/README.md
index e903b21bf..23ff0560f 100644
--- a/docs/tasks/README.md
+++ b/docs/tasks/README.md
@@ -16,7 +16,7 @@ quotas and queues.
 
 ## Batch user
 
-A _batch user_ runs [workloads](/docs/concepts/queued_workload.md). A typical
+A _batch user_ runs [workloads](/docs/concepts/workload.md). A typical
 batch user is a researcher, AI/ML engineer, data scientist, among others.
 
 - As a batch user, you can learn how to [run a Job on a cluster](run_jobs.md)
diff --git a/docs/tasks/administer_cluster_quotas.md b/docs/tasks/administer_cluster_quotas.md
index 2cb526c9e..5741d791d 100644
--- a/docs/tasks/administer_cluster_quotas.md
+++ b/docs/tasks/administer_cluster_quotas.md
@@ -95,7 +95,7 @@ field in the ClusterQueue.
 
 ### 3. Create [Queues](/docs/concepts/queue.md)
 
-Users cannot directly send [workloads](/docs/concepts/queued_workload.md) to
+Users cannot directly send [workloads](/docs/concepts/workload.md) to
 ClusterQueues. Instead, users need to send their workloads to a Queue in their
 namespace.
 Thus, for the queuing system to be complete, you need to create a Queue in
diff --git a/docs/tasks/run_jobs.md b/docs/tasks/run_jobs.md
index 47262f99f..411985c27 100644
--- a/docs/tasks/run_jobs.md
+++ b/docs/tasks/run_jobs.md
@@ -78,7 +78,7 @@ You can run the Job with the following command:
 kubectl create -f sample-job.yaml
 ```
 
-Internally, Kueue will create a corresponding [QueuedWorkload](/docs/concepts/queued_workload.md)
+Internally, Kueue will create a corresponding [Workload](/docs/concepts/workload.md)
 for this Job with a matching name.
 
 ```shell
@@ -104,12 +104,12 @@ If the ClusterQueue doesn't have enough quota to run the workload, the output
 will be similar to the following:
 
 ```
-Name:         sample-job-jtz5f                                                                                                                                       
-Namespace:    default                                                                                                                                                
-Labels:       <none>                                                                                                                                                 
-Annotations:  <none>                                                                                                                                                 
-API Version:  kueue.x-k8s.io/v1alpha1                                                                                                                                
-Kind:         QueuedWorkload                                                                                                                                         
+Name:         sample-job-jtz5f
+Namespace:    default
+Labels:       <none>
+Annotations:  <none>
+API Version:  kueue.x-k8s.io/v1alpha1
+Kind:         Workload
 Metadata:
   ...
 Spec:
@@ -196,16 +196,16 @@ Pods Statuses:    0 Active / 3 Succeeded / 0 Failed
 Pod Template:
   ...
 Events:
-  Type    Reason                 Age   From                  Message
-  ----    ------                 ----  ----                  -------
-  Normal  Suspended              22m   job-controller        Job suspended
-  Normal  CreatedQueuedWorkload  22m   kueue-job-controller  Created QueuedWorkload: default/sample-job-rxb6q
-  Normal  SuccessfulCreate       19m   job-controller        Created pod: sample-job-rxb6q-7bqld
-  Normal  Started                19m   kueue-job-controller  Admitted by clusterQueue cluster-total
-  Normal  SuccessfulCreate       19m   job-controller        Created pod: sample-job-rxb6q-7jw4z
-  Normal  SuccessfulCreate       19m   job-controller        Created pod: sample-job-rxb6q-m7wgm
-  Normal  Resumed                19m   job-controller        Job resumed
-  Normal  Completed              18m   job-controller        Job completed
+  Type    Reason            Age   From                  Message
+  ----    ------            ----  ----                  -------
+  Normal  Suspended         22m   job-controller        Job suspended
+  Normal  CreatedWorkload   22m   kueue-job-controller  Created Workload: default/sample-job-rxb6q
+  Normal  SuccessfulCreate  19m   job-controller        Created pod: sample-job-rxb6q-7bqld
+  Normal  Started           19m   kueue-job-controller  Admitted by clusterQueue cluster-total
+  Normal  SuccessfulCreate  19m   job-controller        Created pod: sample-job-rxb6q-7jw4z
+  Normal  SuccessfulCreate  19m   job-controller        Created pod: sample-job-rxb6q-m7wgm
+  Normal  Resumed           19m   job-controller        Job resumed
+  Normal  Completed         18m   job-controller        Job completed
 ```
 
 Since events have a timestamp with a resolution of seconds, the events might
diff --git a/docs/tasks/setup_rbac.md b/docs/tasks/setup_rbac.md
index 1d24a9685..85dd4e0b5 100644
--- a/docs/tasks/setup_rbac.md
+++ b/docs/tasks/setup_rbac.md
@@ -21,9 +21,9 @@ When you install Kueue, the following set of ClusterRoles are created for the
 two main personas that we assume will interact with Kueue:
 
 - `kueue-batch-admin-role` includes the permissions to manage ClusterQueues,
-  Queues, QueuedWorkloads, and ResourceFlavors.
+  Queues, Workloads, and ResourceFlavors.
 - `kueue-batch-user-role` includes the permissions to manage [Jobs](https://kubernetes.io/docs/concepts/workloads/controllers/job/)
-  and to view Queues and QueuedWorkloads.
+  and to view Queues and Workloads.
 
 ## Giving permissions to a batch administrator
 
@@ -62,7 +62,7 @@ kubectl apply -f batch-admin-role-binding.yaml
 A batch user typically requires permissions to:
 - Create and view Jobs in their namespace.
 - View the queues available in their namespace.
-- View the status of their [workloads](/docs/concepts/queued_workload.md) in their namespace.
+- View the status of their [workloads](/docs/concepts/workload.md) in their namespace.
 
 To give these permissions to a group of users `team-a@example.com` for the
 namespace `team-a`, create a RoleBinding with a manifest similar to the
diff --git a/pkg/cache/cache.go b/pkg/cache/cache.go
index a5e46e9d4..7c0b3e80e 100644
--- a/pkg/cache/cache.go
+++ b/pkg/cache/cache.go
@@ -37,8 +37,7 @@ const workloadClusterQueueKey = "spec.admission.clusterQueue"
 
 var errCqNotFound = errors.New("cluster queue not found")
 
-// Cache keeps track of the QueuedWorkloads that got admitted through
-// ClusterQueues.
+// Cache keeps track of the Workloads that got admitted through ClusterQueues.
 type Cache struct {
 	sync.RWMutex
 
@@ -168,7 +167,7 @@ func (c *ClusterQueue) UpdateLabelKeys(flavors map[string]*kueue.ResourceFlavor)
 	}
 }
 
-func (c *ClusterQueue) addWorkload(w *kueue.QueuedWorkload) error {
+func (c *ClusterQueue) addWorkload(w *kueue.Workload) error {
 	k := workload.Key(w)
 	if _, exist := c.Workloads[k]; exist {
 		return fmt.Errorf("workload already exists in ClusterQueue")
@@ -179,7 +178,7 @@ func (c *ClusterQueue) addWorkload(w *kueue.QueuedWorkload) error {
 	return nil
 }
 
-func (c *ClusterQueue) deleteWorkload(w *kueue.QueuedWorkload) {
+func (c *ClusterQueue) deleteWorkload(w *kueue.Workload) {
 	k := workload.Key(w)
 	wi, exist := c.Workloads[k]
 	if !exist {
@@ -237,7 +236,7 @@ func (c *Cache) AddClusterQueue(ctx context.Context, cq *kueue.ClusterQueue) err
 
 	// On controller restart, an add ClusterQueue event may come after
 	// add workload events, and so here we explicitly list and add existing workloads.
-	var workloads kueue.QueuedWorkloadList
+	var workloads kueue.WorkloadList
 	if err := c.client.List(ctx, &workloads, client.MatchingFields{workloadClusterQueueKey: cq.Name}); err != nil {
 		return fmt.Errorf("listing workloads that match the queue: %w", err)
 	}
@@ -284,13 +283,13 @@ func (c *Cache) DeleteClusterQueue(cq *kueue.ClusterQueue) {
 	delete(c.clusterQueues, cq.Name)
 }
 
-func (c *Cache) AddOrUpdateWorkload(w *kueue.QueuedWorkload) bool {
+func (c *Cache) AddOrUpdateWorkload(w *kueue.Workload) bool {
 	c.Lock()
 	defer c.Unlock()
 	return c.addOrUpdateWorkload(w)
 }
 
-func (c *Cache) addOrUpdateWorkload(w *kueue.QueuedWorkload) bool {
+func (c *Cache) addOrUpdateWorkload(w *kueue.Workload) bool {
 	if w.Spec.Admission == nil {
 		return false
 	}
@@ -309,7 +308,7 @@ func (c *Cache) addOrUpdateWorkload(w *kueue.QueuedWorkload) bool {
 	return clusterQueue.addWorkload(w) == nil
 }
 
-func (c *Cache) UpdateWorkload(oldWl, newWl *kueue.QueuedWorkload) error {
+func (c *Cache) UpdateWorkload(oldWl, newWl *kueue.Workload) error {
 	c.Lock()
 	defer c.Unlock()
 	if oldWl.Spec.Admission != nil {
@@ -331,7 +330,7 @@ func (c *Cache) UpdateWorkload(oldWl, newWl *kueue.QueuedWorkload) error {
 	return cq.addWorkload(newWl)
 }
 
-func (c *Cache) DeleteWorkload(w *kueue.QueuedWorkload) error {
+func (c *Cache) DeleteWorkload(w *kueue.Workload) error {
 	c.Lock()
 	defer c.Unlock()
 	if w.Spec.Admission == nil {
@@ -349,7 +348,7 @@ func (c *Cache) DeleteWorkload(w *kueue.QueuedWorkload) error {
 	return nil
 }
 
-func (c *Cache) AssumeWorkload(w *kueue.QueuedWorkload) error {
+func (c *Cache) AssumeWorkload(w *kueue.Workload) error {
 	c.Lock()
 	defer c.Unlock()
 
@@ -375,7 +374,7 @@ func (c *Cache) AssumeWorkload(w *kueue.QueuedWorkload) error {
 	return nil
 }
 
-func (c *Cache) ForgetWorkload(w *kueue.QueuedWorkload) error {
+func (c *Cache) ForgetWorkload(w *kueue.Workload) error {
 	c.Lock()
 	defer c.Unlock()
 
@@ -425,7 +424,7 @@ func (c *Cache) Usage(cqObj *kueue.ClusterQueue) (kueue.UsedResources, int, erro
 	return usage, len(cq.Workloads), nil
 }
 
-func (c *Cache) cleanupAssumedState(w *kueue.QueuedWorkload) {
+func (c *Cache) cleanupAssumedState(w *kueue.Workload) {
 	k := workload.Key(w)
 	assumedCQName, assumed := c.assumedWorkloads[k]
 	if assumed {
@@ -486,8 +485,8 @@ func resourceLimitsByName(in []kueue.Resource) map[corev1.ResourceName][]FlavorL
 }
 
 func SetupIndexes(indexer client.FieldIndexer) error {
-	return indexer.IndexField(context.Background(), &kueue.QueuedWorkload{}, workloadClusterQueueKey, func(o client.Object) []string {
-		wl := o.(*kueue.QueuedWorkload)
+	return indexer.IndexField(context.Background(), &kueue.Workload{}, workloadClusterQueueKey, func(o client.Object) []string {
+		wl := o.(*kueue.Workload)
 		if wl.Spec.Admission == nil {
 			return nil
 		}
diff --git a/pkg/constants/constants.go b/pkg/constants/constants.go
index 59b7612bc..a06266b32 100644
--- a/pkg/constants/constants.go
+++ b/pkg/constants/constants.go
@@ -27,8 +27,8 @@ const (
 	ManagerName       = "kueue-manager"
 	JobControllerName = "kueue-job-controller"
 
-	// UpdatesBatchPeriod is the batch period to hold queuedworkload updates
-	// before syncing a Queue and CLusterQueue onbjects.
+	// UpdatesBatchPeriod is the batch period to hold workload updates
+	// before syncing a Queue and ClusterQueue objects.
 	UpdatesBatchPeriod = time.Second
 
 	// DefaultPriority is used to set priority of workloads
diff --git a/pkg/controller/core/clusterqueue_controller.go b/pkg/controller/core/clusterqueue_controller.go
index cc6492619..9371fc0f0 100644
--- a/pkg/controller/core/clusterqueue_controller.go
+++ b/pkg/controller/core/clusterqueue_controller.go
@@ -37,7 +37,7 @@ import (
 	"sigs.k8s.io/kueue/pkg/cache"
 )
 
-const qwUpdateBuffer = 10
+const wlUpdateChBuffer = 10
 
 // ClusterQueueReconciler reconciles a ClusterQueue object
 type ClusterQueueReconciler struct {
@@ -45,7 +45,7 @@ type ClusterQueueReconciler struct {
 	log        logr.Logger
 	qManager   *queue.Manager
 	cache      *cache.Cache
-	qwUpdateCh chan event.GenericEvent
+	wlUpdateCh chan event.GenericEvent
 }
 
 func NewClusterQueueReconciler(client client.Client, qMgr *queue.Manager, cache *cache.Cache) *ClusterQueueReconciler {
@@ -54,7 +54,7 @@ func NewClusterQueueReconciler(client client.Client, qMgr *queue.Manager, cache
 		log:        ctrl.Log.WithName("cluster-queue-reconciler"),
 		qManager:   qMgr,
 		cache:      cache,
-		qwUpdateCh: make(chan event.GenericEvent, qwUpdateBuffer),
+		wlUpdateCh: make(chan event.GenericEvent, wlUpdateChBuffer),
 	}
 }
 
@@ -89,8 +89,8 @@ func (r *ClusterQueueReconciler) Reconcile(ctx context.Context, req ctrl.Request
 	return ctrl.Result{}, nil
 }
 
-func (r *ClusterQueueReconciler) NotifyQueuedWorkloadUpdate(w *kueue.QueuedWorkload) {
-	r.qwUpdateCh <- event.GenericEvent{Object: w}
+func (r *ClusterQueueReconciler) NotifyWorkloadUpdate(w *kueue.Workload) {
+	r.wlUpdateCh <- event.GenericEvent{Object: w}
 }
 
 // Event handlers return true to signal the controller to reconcile the
@@ -144,7 +144,7 @@ func (r *ClusterQueueReconciler) Update(e event.UpdateEvent) bool {
 }
 
 func (r *ClusterQueueReconciler) Generic(e event.GenericEvent) bool {
-	r.log.V(3).Info("Got QueuedWorkload event", "queuedWorkload", klog.KObj(e.Object))
+	r.log.V(3).Info("Got Workload event", "workload", klog.KObj(e.Object))
 	return true
 }
 
@@ -166,14 +166,14 @@ func (h *cqWorkloadHandler) Delete(event.DeleteEvent, workqueue.RateLimitingInte
 }
 
 func (h *cqWorkloadHandler) Generic(e event.GenericEvent, q workqueue.RateLimitingInterface) {
-	w := e.Object.(*kueue.QueuedWorkload)
+	w := e.Object.(*kueue.Workload)
 	req := h.requestForWorkloadClusterQueue(w)
 	if req != nil {
 		q.AddAfter(*req, constants.UpdatesBatchPeriod)
 	}
 }
 
-func (h *cqWorkloadHandler) requestForWorkloadClusterQueue(w *kueue.QueuedWorkload) *reconcile.Request {
+func (h *cqWorkloadHandler) requestForWorkloadClusterQueue(w *kueue.Workload) *reconcile.Request {
 	var name string
 	if w.Spec.Admission != nil {
 		name = string(w.Spec.Admission.ClusterQueue)
@@ -198,7 +198,7 @@ func (r *ClusterQueueReconciler) SetupWithManager(mgr ctrl.Manager) error {
 	}
 	return ctrl.NewControllerManagedBy(mgr).
 		For(&kueue.ClusterQueue{}).
-		Watches(&source.Channel{Source: r.qwUpdateCh}, &wHandler).
+		Watches(&source.Channel{Source: r.wlUpdateCh}, &wHandler).
 		WithEventFilter(r).
 		Complete(r)
 }
diff --git a/pkg/controller/core/core.go b/pkg/controller/core/core.go
index 4896dd7c9..27845b655 100644
--- a/pkg/controller/core/core.go
+++ b/pkg/controller/core/core.go
@@ -33,8 +33,8 @@ func SetupControllers(mgr ctrl.Manager, qManager *queue.Manager, cc *cache.Cache
 	if err := cqRec.SetupWithManager(mgr); err != nil {
 		return "ClusterQueue", err
 	}
-	if err := NewQueuedWorkloadReconciler(mgr.GetClient(), qManager, cc, qRec, cqRec).SetupWithManager(mgr); err != nil {
-		return "QueuedWorkload", err
+	if err := NewWorkloadReconciler(mgr.GetClient(), qManager, cc, qRec, cqRec).SetupWithManager(mgr); err != nil {
+		return "Workload", err
 	}
 	if err := NewResourceFlavorReconciler(cc).SetupWithManager(mgr); err != nil {
 		return "ResourceFlavor", err
diff --git a/pkg/controller/core/queue_controller.go b/pkg/controller/core/queue_controller.go
index 5c825ef95..04d1c5b65 100644
--- a/pkg/controller/core/queue_controller.go
+++ b/pkg/controller/core/queue_controller.go
@@ -40,7 +40,7 @@ type QueueReconciler struct {
 	client     client.Client
 	log        logr.Logger
 	queues     *queue.Manager
-	qwUpdateCh chan event.GenericEvent
+	wlUpdateCh chan event.GenericEvent
 }
 
 func NewQueueReconciler(client client.Client, queues *queue.Manager) *QueueReconciler {
@@ -48,12 +48,12 @@ func NewQueueReconciler(client client.Client, queues *queue.Manager) *QueueRecon
 		log:        ctrl.Log.WithName("queue-reconciler"),
 		queues:     queues,
 		client:     client,
-		qwUpdateCh: make(chan event.GenericEvent, qwUpdateBuffer),
+		wlUpdateCh: make(chan event.GenericEvent, wlUpdateChBuffer),
 	}
 }
 
-func (r *QueueReconciler) NotifyQueuedWorkloadUpdate(w *kueue.QueuedWorkload) {
-	r.qwUpdateCh <- event.GenericEvent{Object: w}
+func (r *QueueReconciler) NotifyWorkloadUpdate(w *kueue.Workload) {
+	r.wlUpdateCh <- event.GenericEvent{Object: w}
 }
 
 //+kubebuilder:rbac:groups="",resources=events,verbs=create;watch;update
@@ -129,7 +129,7 @@ func (r *QueueReconciler) Update(e event.UpdateEvent) bool {
 }
 
 func (r *QueueReconciler) Generic(e event.GenericEvent) bool {
-	r.log.V(3).Info("Got QueuedWorkload event", "queuedWorkload", klog.KObj(e.Object))
+	r.log.V(3).Info("Got Workload event", "workload", klog.KObj(e.Object))
 	return true
 }
 
@@ -149,7 +149,7 @@ func (h *qWorkloadHandler) Delete(event.DeleteEvent, workqueue.RateLimitingInter
 }
 
 func (h *qWorkloadHandler) Generic(e event.GenericEvent, q workqueue.RateLimitingInterface) {
-	w := e.Object.(*kueue.QueuedWorkload)
+	w := e.Object.(*kueue.Workload)
 	if w.Name == "" {
 		return
 	}
@@ -166,7 +166,7 @@ func (h *qWorkloadHandler) Generic(e event.GenericEvent, q workqueue.RateLimitin
 func (r *QueueReconciler) SetupWithManager(mgr ctrl.Manager) error {
 	return ctrl.NewControllerManagedBy(mgr).
 		For(&kueue.Queue{}).
-		Watches(&source.Channel{Source: r.qwUpdateCh}, &qWorkloadHandler{}).
+		Watches(&source.Channel{Source: r.wlUpdateCh}, &qWorkloadHandler{}).
 		WithEventFilter(r).
 		Complete(r)
 }
diff --git a/pkg/controller/core/queuedworkload_controller.go b/pkg/controller/core/workload_controller.go
similarity index 71%
rename from pkg/controller/core/queuedworkload_controller.go
rename to pkg/controller/core/workload_controller.go
index a652ab175..a12bda39b 100644
--- a/pkg/controller/core/queuedworkload_controller.go
+++ b/pkg/controller/core/workload_controller.go
@@ -40,22 +40,22 @@ const (
 	finished = "finished"
 )
 
-type QWUpdateWatcher interface {
-	NotifyQueuedWorkloadUpdate(*kueue.QueuedWorkload)
+type WorkloadUpdateWatcher interface {
+	NotifyWorkloadUpdate(*kueue.Workload)
 }
 
-// QueuedWorkloadReconciler reconciles a QueuedWorkload object
-type QueuedWorkloadReconciler struct {
+// WorkloadReconciler reconciles a Workload object
+type WorkloadReconciler struct {
 	log      logr.Logger
 	queues   *queue.Manager
 	cache    *cache.Cache
 	client   client.Client
-	watchers []QWUpdateWatcher
+	watchers []WorkloadUpdateWatcher
 }
 
-func NewQueuedWorkloadReconciler(client client.Client, queues *queue.Manager, cache *cache.Cache, watchers ...QWUpdateWatcher) *QueuedWorkloadReconciler {
-	return &QueuedWorkloadReconciler{
-		log:      ctrl.Log.WithName("queued-workload-reconciler"),
+func NewWorkloadReconciler(client client.Client, queues *queue.Manager, cache *cache.Cache, watchers ...WorkloadUpdateWatcher) *WorkloadReconciler {
+	return &WorkloadReconciler{
+		log:      ctrl.Log.WithName("workload-reconciler"),
 		client:   client,
 		queues:   queues,
 		cache:    cache,
@@ -64,29 +64,29 @@ func NewQueuedWorkloadReconciler(client client.Client, queues *queue.Manager, ca
 }
 
 //+kubebuilder:rbac:groups="",resources=events,verbs=create;watch;update
-//+kubebuilder:rbac:groups=kueue.x-k8s.io,resources=queuedworkloads,verbs=get;list;watch;create;update;patch;delete
-//+kubebuilder:rbac:groups=kueue.x-k8s.io,resources=queuedworkloads/status,verbs=get;update;patch
-//+kubebuilder:rbac:groups=kueue.x-k8s.io,resources=queuedworkloads/finalizers,verbs=update
+//+kubebuilder:rbac:groups=kueue.x-k8s.io,resources=workloads,verbs=get;list;watch;create;update;patch;delete
+//+kubebuilder:rbac:groups=kueue.x-k8s.io,resources=workloads/status,verbs=get;update;patch
+//+kubebuilder:rbac:groups=kueue.x-k8s.io,resources=workloads/finalizers,verbs=update
 
-func (r *QueuedWorkloadReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {
-	var wl kueue.QueuedWorkload
+func (r *WorkloadReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {
+	var wl kueue.Workload
 	if err := r.client.Get(ctx, req.NamespacedName, &wl); err != nil {
 		// we'll ignore not-found errors, since there is nothing to do.
 		return ctrl.Result{}, client.IgnoreNotFound(err)
 	}
-	log := ctrl.LoggerFrom(ctx).WithValues("queuedWorkload", klog.KObj(&wl))
+	log := ctrl.LoggerFrom(ctx).WithValues("workload", klog.KObj(&wl))
 	ctx = ctrl.LoggerInto(ctx, log)
-	log.V(2).Info("Reconciling QueuedWorkload")
+	log.V(2).Info("Reconciling Workload")
 
 	status := workloadStatus(&wl)
 	if status == pending && !r.queues.QueueForWorkloadExists(&wl) {
-		err := workload.UpdateWorkloadStatusIfChanged(ctx, r.client, &wl, kueue.QueuedWorkloadAdmitted, corev1.ConditionFalse,
+		err := workload.UpdateWorkloadStatusIfChanged(ctx, r.client, &wl, kueue.WorkloadAdmitted, corev1.ConditionFalse,
 			"Inadmissible", fmt.Sprintf("Queue %s doesn't exist", wl.Spec.QueueName))
 		return ctrl.Result{}, client.IgnoreNotFound(err)
 	}
 	cqName, cqOk := r.queues.ClusterQueueForWorkload(&wl)
 	if status == pending && !cqOk {
-		err := workload.UpdateWorkloadStatusIfChanged(ctx, r.client, &wl, kueue.QueuedWorkloadAdmitted, corev1.ConditionFalse,
+		err := workload.UpdateWorkloadStatusIfChanged(ctx, r.client, &wl, kueue.WorkloadAdmitted, corev1.ConditionFalse,
 			"Inadmissible", fmt.Sprintf("ClusterQueue %s doesn't exist", cqName))
 		return ctrl.Result{}, client.IgnoreNotFound(err)
 	}
@@ -94,12 +94,12 @@ func (r *QueuedWorkloadReconciler) Reconcile(ctx context.Context, req ctrl.Reque
 	return ctrl.Result{}, nil
 }
 
-func (r *QueuedWorkloadReconciler) Create(e event.CreateEvent) bool {
-	wl := e.Object.(*kueue.QueuedWorkload)
+func (r *WorkloadReconciler) Create(e event.CreateEvent) bool {
+	wl := e.Object.(*kueue.Workload)
 	defer r.notifyWatchers(wl)
 	status := workloadStatus(wl)
-	log := r.log.WithValues("queuedWorkload", klog.KObj(wl), "queue", wl.Spec.QueueName, "status", status)
-	log.V(2).Info("QueuedWorkload create event")
+	log := r.log.WithValues("workload", klog.KObj(wl), "queue", wl.Spec.QueueName, "status", status)
+	log.V(2).Info("Workload create event")
 
 	if status == finished {
 		return true
@@ -118,15 +118,15 @@ func (r *QueuedWorkloadReconciler) Create(e event.CreateEvent) bool {
 	return true
 }
 
-func (r *QueuedWorkloadReconciler) Delete(e event.DeleteEvent) bool {
-	wl := e.Object.(*kueue.QueuedWorkload)
+func (r *WorkloadReconciler) Delete(e event.DeleteEvent) bool {
+	wl := e.Object.(*kueue.Workload)
 	defer r.notifyWatchers(wl)
 	status := "unknown"
 	if !e.DeleteStateUnknown {
 		status = workloadStatus(wl)
 	}
-	log := r.log.WithValues("queuedWorkload", klog.KObj(wl), "queue", wl.Spec.QueueName, "status", status)
-	log.V(2).Info("QueuedWorkload delete event")
+	log := r.log.WithValues("workload", klog.KObj(wl), "queue", wl.Spec.QueueName, "status", status)
+	log.V(2).Info("Workload delete event")
 	// When assigning a clusterQueue to a workload, we assume it in the cache. If
 	// the state is unknown, the workload could have been assumed and we need
 	// to clear it from the cache.
@@ -149,13 +149,13 @@ func (r *QueuedWorkloadReconciler) Delete(e event.DeleteEvent) bool {
 	return true
 }
 
-func (r *QueuedWorkloadReconciler) Update(e event.UpdateEvent) bool {
-	oldWl := e.ObjectOld.(*kueue.QueuedWorkload)
-	wl := e.ObjectNew.(*kueue.QueuedWorkload)
+func (r *WorkloadReconciler) Update(e event.UpdateEvent) bool {
+	oldWl := e.ObjectOld.(*kueue.Workload)
+	wl := e.ObjectNew.(*kueue.Workload)
 	defer r.notifyWatchers(oldWl)
 	defer r.notifyWatchers(wl)
 	status := workloadStatus(wl)
-	log := r.log.WithValues("queuedWorkload", klog.KObj(wl), "queue", wl.Spec.QueueName, "status", status)
+	log := r.log.WithValues("workload", klog.KObj(wl), "queue", wl.Spec.QueueName, "status", status)
 	prevQueue := oldWl.Spec.QueueName
 	if prevQueue != wl.Spec.QueueName {
 		log = log.WithValues("prevQueue", prevQueue)
@@ -170,7 +170,7 @@ func (r *QueuedWorkloadReconciler) Update(e event.UpdateEvent) bool {
 	if oldWl.Spec.Admission != nil && (wl.Spec.Admission == nil || wl.Spec.Admission.ClusterQueue != oldWl.Spec.Admission.ClusterQueue) {
 		log = log.WithValues("prevClusterQueue", oldWl.Spec.Admission.ClusterQueue)
 	}
-	log.V(2).Info("QueuedWorkload update event")
+	log.V(2).Info("Workload update event")
 
 	switch {
 	case status == finished:
@@ -215,26 +215,26 @@ func (r *QueuedWorkloadReconciler) Update(e event.UpdateEvent) bool {
 	return true
 }
 
-func (r *QueuedWorkloadReconciler) Generic(e event.GenericEvent) bool {
+func (r *WorkloadReconciler) Generic(e event.GenericEvent) bool {
 	r.log.V(3).Info("Ignore generic event", "obj", klog.KObj(e.Object), "kind", e.Object.GetObjectKind().GroupVersionKind())
 	return false
 }
 
-func (r *QueuedWorkloadReconciler) notifyWatchers(wl *kueue.QueuedWorkload) {
+func (r *WorkloadReconciler) notifyWatchers(wl *kueue.Workload) {
 	for _, w := range r.watchers {
-		w.NotifyQueuedWorkloadUpdate(wl)
+		w.NotifyWorkloadUpdate(wl)
 	}
 }
 
 // SetupWithManager sets up the controller with the Manager.
-func (r *QueuedWorkloadReconciler) SetupWithManager(mgr ctrl.Manager) error {
+func (r *WorkloadReconciler) SetupWithManager(mgr ctrl.Manager) error {
 	return ctrl.NewControllerManagedBy(mgr).
-		For(&kueue.QueuedWorkload{}).
+		For(&kueue.Workload{}).
 		WithEventFilter(r).
 		Complete(r)
 }
 
-func workloadStatus(w *kueue.QueuedWorkload) string {
+func workloadStatus(w *kueue.Workload) string {
 	if workloadFinished(w) {
 		return finished
 	}
@@ -244,9 +244,9 @@ func workloadStatus(w *kueue.QueuedWorkload) string {
 	return pending
 }
 
-func workloadFinished(w *kueue.QueuedWorkload) bool {
+func workloadFinished(w *kueue.Workload) bool {
 	for _, c := range w.Status.Conditions {
-		if c.Type == kueue.QueuedWorkloadFinished {
+		if c.Type == kueue.WorkloadFinished {
 			return c.Status == corev1.ConditionTrue
 		}
 	}
diff --git a/pkg/controller/workload/job/job_controller.go b/pkg/controller/workload/job/job_controller.go
index 76822b0d4..e943cc068 100644
--- a/pkg/controller/workload/job/job_controller.go
+++ b/pkg/controller/workload/job/job_controller.go
@@ -62,10 +62,10 @@ func NewReconciler(scheme *runtime.Scheme, client client.Client, record record.E
 // SetupWithManager sets up the controller with the Manager. It indexes workloads
 // based on the owning jobs.
 func (r *JobReconciler) SetupWithManager(mgr ctrl.Manager) error {
-	if err := mgr.GetFieldIndexer().IndexField(context.Background(), &kueue.QueuedWorkload{}, ownerKey, func(rawObj client.Object) []string {
-		// grab the QueuedWorkload object, extract the owner...
-		qw := rawObj.(*kueue.QueuedWorkload)
-		owner := metav1.GetControllerOf(qw)
+	if err := mgr.GetFieldIndexer().IndexField(context.Background(), &kueue.Workload{}, ownerKey, func(rawObj client.Object) []string {
+		// grab the Workload object, extract the owner...
+		wl := rawObj.(*kueue.Workload)
+		owner := metav1.GetControllerOf(wl)
 		if owner == nil {
 			return nil
 		}
@@ -82,7 +82,7 @@ func (r *JobReconciler) SetupWithManager(mgr ctrl.Manager) error {
 
 	return ctrl.NewControllerManagedBy(mgr).
 		For(&batchv1.Job{}).
-		Owns(&kueue.QueuedWorkload{}).
+		Owns(&kueue.Workload{}).
 		Complete(r)
 }
 
@@ -90,9 +90,9 @@ func (r *JobReconciler) SetupWithManager(mgr ctrl.Manager) error {
 //+kubebuilder:rbac:groups="",resources=events,verbs=create;watch;update
 //+kubebuilder:rbac:groups=batch,resources=jobs,verbs=get;list;watch;update;patch
 //+kubebuilder:rbac:groups=batch,resources=jobs/status,verbs=get
-//+kubebuilder:rbac:groups=kueue.x-k8s.io,resources=queuedworkloads,verbs=get;list;watch;create;update;patch;delete
-//+kubebuilder:rbac:groups=kueue.x-k8s.io,resources=queuedworkloads/status,verbs=get;update;patch
-//+kubebuilder:rbac:groups=kueue.x-k8s.io,resources=queuedworkloads/finalizers,verbs=update
+//+kubebuilder:rbac:groups=kueue.x-k8s.io,resources=workloads,verbs=get;list;watch;create;update;patch;delete
+//+kubebuilder:rbac:groups=kueue.x-k8s.io,resources=workloads/status,verbs=get;update;patch
+//+kubebuilder:rbac:groups=kueue.x-k8s.io,resources=workloads/finalizers,verbs=update
 //+kubebuilder:rbac:groups=kueue.x-k8s.io,resources=resourceflavors,verbs=get;list;watch
 
 func (r *JobReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {
@@ -106,7 +106,7 @@ func (r *JobReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.R
 	ctx = ctrl.LoggerInto(ctx, log)
 	log.V(2).Info("Reconciling Job")
 
-	var childWorkloads kueue.QueuedWorkloadList
+	var childWorkloads kueue.WorkloadList
 	if err := r.client.List(ctx, &childWorkloads, client.InNamespace(req.Namespace),
 		client.MatchingFields{ownerKey: req.Name}); err != nil {
 		log.Error(err, "Unable to list child workloads")
@@ -194,7 +194,7 @@ func (r *JobReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.R
 // stopJob sends updates to suspend the job, reset the startTime so we can update the scheduling directives
 // later when unsuspending and resets the nodeSelector to its previous state based on what is available in
 // the workload (which should include the original affinities that the job had).
-func (r *JobReconciler) stopJob(ctx context.Context, w *kueue.QueuedWorkload,
+func (r *JobReconciler) stopJob(ctx context.Context, w *kueue.Workload,
 	job *batchv1.Job, eventMsg string) error {
 	job.Spec.Suspend = pointer.BoolPtr(true)
 	if err := r.client.Update(ctx, job); err != nil {
@@ -222,7 +222,7 @@ func (r *JobReconciler) stopJob(ctx context.Context, w *kueue.QueuedWorkload,
 	return nil
 }
 
-func (r *JobReconciler) startJob(ctx context.Context, w *kueue.QueuedWorkload, job *batchv1.Job) error {
+func (r *JobReconciler) startJob(ctx context.Context, w *kueue.Workload, job *batchv1.Job) error {
 	log := ctrl.LoggerFrom(ctx)
 
 	if len(w.Spec.PodSets) != 1 {
@@ -255,7 +255,7 @@ func (r *JobReconciler) startJob(ctx context.Context, w *kueue.QueuedWorkload, j
 	return nil
 }
 
-func (r *JobReconciler) getNodeSelectors(ctx context.Context, w *kueue.QueuedWorkload) (map[string]string, error) {
+func (r *JobReconciler) getNodeSelectors(ctx context.Context, w *kueue.Workload) (map[string]string, error) {
 	if len(w.Spec.Admission.PodSetFlavors[0].Flavors) == 0 {
 		return nil, nil
 	}
@@ -297,18 +297,18 @@ func (r *JobReconciler) handleJobWithNoWorkload(ctx context.Context, job *batchv
 		return err
 	}
 
-	r.record.Eventf(job, corev1.EventTypeNormal, "CreatedQueuedWorkload",
-		"Created QueuedWorkload: %v", workload.Key(wl))
+	r.record.Eventf(job, corev1.EventTypeNormal, "CreatedWorkload",
+		"Created Workload: %v", workload.Key(wl))
 	return nil
 }
 
 // ensureAtmostoneworkload finds a matching workload and deletes redundant ones.
-func (r *JobReconciler) ensureAtMostOneWorkload(ctx context.Context, job *batchv1.Job, workloads kueue.QueuedWorkloadList) (*kueue.QueuedWorkload, error) {
+func (r *JobReconciler) ensureAtMostOneWorkload(ctx context.Context, job *batchv1.Job, workloads kueue.WorkloadList) (*kueue.Workload, error) {
 	log := ctrl.LoggerFrom(ctx)
 
 	// Find a matching workload first if there is one.
-	var toDelete []*kueue.QueuedWorkload
-	var match *kueue.QueuedWorkload
+	var toDelete []*kueue.Workload
+	var match *kueue.Workload
 	for i := range workloads.Items {
 		w := &workloads.Items[i]
 		owner := metav1.GetControllerOf(w)
@@ -327,14 +327,14 @@ func (r *JobReconciler) ensureAtMostOneWorkload(ctx context.Context, job *batchv
 	// If there is no matching workload and the job is running, suspend it.
 	if match == nil && !jobSuspended(job) {
 		log.V(2).Info("job with no matching workload, suspending")
-		var w *kueue.QueuedWorkload
+		var w *kueue.Workload
 		if len(workloads.Items) == 1 {
 			// The job may have been modified and hence the existing workload
 			// doesn't match the job anymore. All bets are off if there are more
 			// than one workload...
 			w = &workloads.Items[0]
 		}
-		if err := r.stopJob(ctx, w, job, "No matching QueuedWorkload"); err != nil {
+		if err := r.stopJob(ctx, w, job, "No matching Workload"); err != nil {
 			log.Error(err, "stopping job")
 		}
 	}
@@ -350,8 +350,8 @@ func (r *JobReconciler) ensureAtMostOneWorkload(ctx context.Context, job *batchv
 			log.Error(err, "Failed to delete workload")
 		}
 		if err == nil {
-			r.record.Eventf(job, corev1.EventTypeNormal, "DeletedQueuedWorkload",
-				"Deleted not matching QueuedWorkload: %v", workload.Key(toDelete[i]))
+			r.record.Eventf(job, corev1.EventTypeNormal, "DeletedWorkload",
+				"Deleted not matching Workload: %v", workload.Key(toDelete[i]))
 		}
 	}
 
@@ -366,13 +366,13 @@ func (r *JobReconciler) ensureAtMostOneWorkload(ctx context.Context, job *batchv
 }
 
 func ConstructWorkloadFor(ctx context.Context, client client.Client,
-	job *batchv1.Job, scheme *runtime.Scheme) (*kueue.QueuedWorkload, error) {
-	w := &kueue.QueuedWorkload{
+	job *batchv1.Job, scheme *runtime.Scheme) (*kueue.Workload, error) {
+	w := &kueue.Workload{
 		ObjectMeta: metav1.ObjectMeta{
 			Name:      job.Name,
 			Namespace: job.Namespace,
 		},
-		Spec: kueue.QueuedWorkloadSpec{
+		Spec: kueue.WorkloadSpec{
 			PodSets: []kueue.PodSet{
 				{
 					Spec:  *job.Spec.Template.Spec.DeepCopy(),
@@ -399,9 +399,9 @@ func ConstructWorkloadFor(ctx context.Context, client client.Client,
 	return w, nil
 }
 
-func appendFinishedConditionIfNotExists(conds []kueue.QueuedWorkloadCondition, jobStatus batchv1.JobConditionType) ([]kueue.QueuedWorkloadCondition, bool) {
+func appendFinishedConditionIfNotExists(conds []kueue.WorkloadCondition, jobStatus batchv1.JobConditionType) ([]kueue.WorkloadCondition, bool) {
 	for i, c := range conds {
-		if c.Type == kueue.QueuedWorkloadFinished {
+		if c.Type == kueue.WorkloadFinished {
 			if c.Status == corev1.ConditionTrue {
 				return conds, false
 			}
@@ -414,8 +414,8 @@ func appendFinishedConditionIfNotExists(conds []kueue.QueuedWorkloadCondition, j
 		message = "Job failed"
 	}
 	now := metav1.Now()
-	conds = append(conds, kueue.QueuedWorkloadCondition{
-		Type:               kueue.QueuedWorkloadFinished,
+	conds = append(conds, kueue.WorkloadCondition{
+		Type:               kueue.WorkloadFinished,
 		Status:             corev1.ConditionTrue,
 		LastProbeTime:      now,
 		LastTransitionTime: now,
@@ -440,7 +440,7 @@ func jobSuspended(j *batchv1.Job) bool {
 
 }
 
-func jobAndWorkloadEqual(job *batchv1.Job, wl *kueue.QueuedWorkload) bool {
+func jobAndWorkloadEqual(job *batchv1.Job, wl *kueue.Workload) bool {
 	if len(wl.Spec.PodSets) != 1 {
 		return false
 	}
diff --git a/pkg/queue/cluster_queue_best_effort_fifo.go b/pkg/queue/cluster_queue_best_effort_fifo.go
index 4f9d7862c..95a8469e6 100644
--- a/pkg/queue/cluster_queue_best_effort_fifo.go
+++ b/pkg/queue/cluster_queue_best_effort_fifo.go
@@ -53,7 +53,7 @@ func newClusterQueueBestEffortFIFO(cq *kueue.ClusterQueue) (ClusterQueue, error)
 	return cqBE, nil
 }
 
-func (cq *ClusterQueueBestEffortFIFO) PushOrUpdate(w *kueue.QueuedWorkload) {
+func (cq *ClusterQueueBestEffortFIFO) PushOrUpdate(w *kueue.Workload) {
 	key := workload.Key(w)
 	oldInfo := cq.inadmissibleWorkloads[key]
 	if oldInfo != nil {
@@ -70,7 +70,7 @@ func (cq *ClusterQueueBestEffortFIFO) PushOrUpdate(w *kueue.QueuedWorkload) {
 	cq.ClusterQueueImpl.PushOrUpdate(w)
 }
 
-func (cq *ClusterQueueBestEffortFIFO) Delete(w *kueue.QueuedWorkload) {
+func (cq *ClusterQueueBestEffortFIFO) Delete(w *kueue.Workload) {
 	delete(cq.inadmissibleWorkloads, workload.Key(w))
 	cq.ClusterQueueImpl.Delete(w)
 }
diff --git a/pkg/queue/cluster_queue_impl.go b/pkg/queue/cluster_queue_impl.go
index 733328a0a..691ba5c03 100644
--- a/pkg/queue/cluster_queue_impl.go
+++ b/pkg/queue/cluster_queue_impl.go
@@ -74,7 +74,7 @@ func (c *ClusterQueueImpl) pushIfNotPresent(info *workload.Info) bool {
 	return true
 }
 
-func (c *ClusterQueueImpl) PushOrUpdate(w *kueue.QueuedWorkload) {
+func (c *ClusterQueueImpl) PushOrUpdate(w *kueue.Workload) {
 	item := c.heap.items[workload.Key(w)]
 	info := *workload.NewInfo(w)
 	if item == nil {
@@ -85,7 +85,7 @@ func (c *ClusterQueueImpl) PushOrUpdate(w *kueue.QueuedWorkload) {
 	heap.Fix(&c.heap, item.index)
 }
 
-func (c *ClusterQueueImpl) Delete(w *kueue.QueuedWorkload) {
+func (c *ClusterQueueImpl) Delete(w *kueue.Workload) {
 	item := c.heap.items[workload.Key(w)]
 	if item != nil {
 		heap.Remove(&c.heap, item.index)
diff --git a/pkg/queue/cluster_queue_interface.go b/pkg/queue/cluster_queue_interface.go
index 31959515d..b17442400 100644
--- a/pkg/queue/cluster_queue_interface.go
+++ b/pkg/queue/cluster_queue_interface.go
@@ -42,9 +42,9 @@ type ClusterQueue interface {
 
 	// PushOrUpdate pushes the workload to ClusterQueue.
 	// If the workload is already present, updates with the new one.
-	PushOrUpdate(*kueue.QueuedWorkload)
+	PushOrUpdate(*kueue.Workload)
 	// Delete removes the workload from ClusterQueue.
-	Delete(*kueue.QueuedWorkload)
+	Delete(*kueue.Workload)
 	// Pop removes the head of the queue and returns it. It returns nil if the
 	// queue is empty.
 	Pop() *workload.Info
diff --git a/pkg/queue/manager.go b/pkg/queue/manager.go
index 7c0692af0..af3d39545 100644
--- a/pkg/queue/manager.go
+++ b/pkg/queue/manager.go
@@ -162,7 +162,7 @@ func (m *Manager) AddQueue(ctx context.Context, q *kueue.Queue) error {
 	m.queues[key] = qImpl
 	// Iterate through existing workloads, as workloads corresponding to this
 	// queue might have been added earlier.
-	var workloads kueue.QueuedWorkloadList
+	var workloads kueue.WorkloadList
 	if err := m.client.List(ctx, &workloads, client.MatchingFields{workloadQueueKey: q.Name}, client.InNamespace(q.Namespace)); err != nil {
 		return fmt.Errorf("listing workloads that match the queue: %w", err)
 	}
@@ -235,7 +235,7 @@ func (m *Manager) Pending(cq *kueue.ClusterQueue) int32 {
 	return m.clusterQueues[cq.Name].Pending()
 }
 
-func (m *Manager) QueueForWorkloadExists(wl *kueue.QueuedWorkload) bool {
+func (m *Manager) QueueForWorkloadExists(wl *kueue.Workload) bool {
 	m.RLock()
 	defer m.RUnlock()
 	_, ok := m.queues[queueKeyForWorkload(wl)]
@@ -246,7 +246,7 @@ func (m *Manager) QueueForWorkloadExists(wl *kueue.QueuedWorkload) bool {
 // ClusterQueueForWorkload returns the name of the ClusterQueue where the
 // workload should be queued and whether it exists.
 // Returns empty string if the queue doesn't exist.
-func (m *Manager) ClusterQueueForWorkload(wl *kueue.QueuedWorkload) (string, bool) {
+func (m *Manager) ClusterQueueForWorkload(wl *kueue.Workload) (string, bool) {
 	m.RLock()
 	defer m.RUnlock()
 	q, ok := m.queues[queueKeyForWorkload(wl)]
@@ -259,13 +259,13 @@ func (m *Manager) ClusterQueueForWorkload(wl *kueue.QueuedWorkload) (string, boo
 
 // AddOrUpdateWorkload adds or updates workload to the corresponding queue.
 // Returns whether the queue existed.
-func (m *Manager) AddOrUpdateWorkload(w *kueue.QueuedWorkload) bool {
+func (m *Manager) AddOrUpdateWorkload(w *kueue.Workload) bool {
 	m.Lock()
 	defer m.Unlock()
 	return m.addOrUpdateWorkload(w)
 }
 
-func (m *Manager) addOrUpdateWorkload(w *kueue.QueuedWorkload) bool {
+func (m *Manager) addOrUpdateWorkload(w *kueue.Workload) bool {
 	qKey := queueKeyForWorkload(w)
 	q := m.queues[qKey]
 	if q == nil {
@@ -293,7 +293,7 @@ func (m *Manager) RequeueWorkload(ctx context.Context, info *workload.Info) bool
 		return false
 	}
 
-	var w kueue.QueuedWorkload
+	var w kueue.Workload
 	err := m.client.Get(ctx, client.ObjectKeyFromObject(info.Obj), &w)
 	// Since the client is cached, the only possible error is NotFound
 	if apierrors.IsNotFound(err) || w.Spec.Admission != nil {
@@ -313,13 +313,13 @@ func (m *Manager) RequeueWorkload(ctx context.Context, info *workload.Info) bool
 	return added
 }
 
-func (m *Manager) DeleteWorkload(w *kueue.QueuedWorkload) {
+func (m *Manager) DeleteWorkload(w *kueue.Workload) {
 	m.Lock()
 	m.deleteWorkloadFromQueueAndClusterQueue(w, queueKeyForWorkload(w))
 	m.Unlock()
 }
 
-func (m *Manager) deleteWorkloadFromQueueAndClusterQueue(w *kueue.QueuedWorkload, qKey string) {
+func (m *Manager) deleteWorkloadFromQueueAndClusterQueue(w *kueue.Workload, qKey string) {
 	q := m.queues[qKey]
 	if q == nil {
 		return
@@ -334,7 +334,7 @@ func (m *Manager) deleteWorkloadFromQueueAndClusterQueue(w *kueue.QueuedWorkload
 // QueueAssociatedInadmissibleWorkloads moves all associated workloads from
 // inadmissibleWorkloads to heap. If at least one workload is moved,
 // returns true. Otherwise returns false.
-func (m *Manager) QueueAssociatedInadmissibleWorkloads(w *kueue.QueuedWorkload) {
+func (m *Manager) QueueAssociatedInadmissibleWorkloads(w *kueue.Workload) {
 	m.Lock()
 	defer m.Unlock()
 
@@ -380,7 +380,7 @@ func (m *Manager) queueAllInadmissibleWorkloadsInCohort(cq ClusterQueue) bool {
 
 // UpdateWorkload updates the workload to the corresponding queue or adds it if
 // it didn't exist. Returns whether the queue existed.
-func (m *Manager) UpdateWorkload(oldW, w *kueue.QueuedWorkload) bool {
+func (m *Manager) UpdateWorkload(oldW, w *kueue.Workload) bool {
 	m.Lock()
 	defer m.Unlock()
 	if oldW.Spec.QueueName != w.Spec.QueueName {
@@ -476,12 +476,12 @@ func (m *Manager) updateCohort(oldCohort string, newCohort string, cqName string
 }
 
 func SetupIndexes(indexer client.FieldIndexer) error {
-	err := indexer.IndexField(context.Background(), &kueue.QueuedWorkload{}, workloadQueueKey, func(o client.Object) []string {
-		wl := o.(*kueue.QueuedWorkload)
+	err := indexer.IndexField(context.Background(), &kueue.Workload{}, workloadQueueKey, func(o client.Object) []string {
+		wl := o.(*kueue.Workload)
 		return []string{wl.Spec.QueueName}
 	})
 	if err != nil {
-		return fmt.Errorf("setting index on queue for QueuedWorkload: %w", err)
+		return fmt.Errorf("setting index on queue for Workload: %w", err)
 	}
 	err = indexer.IndexField(context.Background(), &kueue.Queue{}, queueClusterQueueKey, func(o client.Object) []string {
 		q := o.(*kueue.Queue)
diff --git a/pkg/queue/queue.go b/pkg/queue/queue.go
index 037f19d0b..eac31aa0c 100644
--- a/pkg/queue/queue.go
+++ b/pkg/queue/queue.go
@@ -29,7 +29,7 @@ func Key(q *kueue.Queue) string {
 }
 
 // queueKeyForWorkload is the key to find the queue for the workload in the index.
-func queueKeyForWorkload(w *kueue.QueuedWorkload) string {
+func queueKeyForWorkload(w *kueue.Workload) string {
 	return fmt.Sprintf("%s/%s", w.Namespace, w.Spec.QueueName)
 }
 
@@ -52,7 +52,7 @@ func (q *Queue) update(apiQueue *kueue.Queue) {
 	q.ClusterQueue = string(apiQueue.Spec.ClusterQueue)
 }
 
-func (q *Queue) AddOrUpdate(w *kueue.QueuedWorkload) {
+func (q *Queue) AddOrUpdate(w *kueue.Workload) {
 	key := workload.Key(w)
 	q.items[key] = workload.NewInfo(w)
 }
diff --git a/pkg/scheduler/scheduler.go b/pkg/scheduler/scheduler.go
index 1b47b1516..8040b2d1a 100644
--- a/pkg/scheduler/scheduler.go
+++ b/pkg/scheduler/scheduler.go
@@ -115,15 +115,15 @@ func (s *Scheduler) schedule(ctx context.Context) {
 			e.inadmissibleReason = "cohort used in this cycle"
 			continue
 		}
-		log := log.WithValues("queuedWorkload", klog.KObj(e.Obj), "clusterQueue", klog.KRef("", e.ClusterQueue))
+		log := log.WithValues("workload", klog.KObj(e.Obj), "clusterQueue", klog.KRef("", e.ClusterQueue))
 		if err := s.admit(ctrl.LoggerInto(ctx, log), e); err == nil {
 			e.status = assumed
 		} else {
 			log.Error(err, "Failed to admit workload")
 			e.inadmissibleReason = fmt.Sprintf("Failed to admit workload: %v", err)
-			err := workload.UpdateStatus(ctx, s.client, e.Obj, kueue.QueuedWorkloadAdmitted, corev1.ConditionFalse, "Pending", err.Error())
+			err := workload.UpdateStatus(ctx, s.client, e.Obj, kueue.WorkloadAdmitted, corev1.ConditionFalse, "Pending", err.Error())
 			if err != nil {
-				log.Error(err, "Updating QueuedWorkload status")
+				log.Error(err, "Updating Workload status")
 			}
 		}
 		// Even if there was a failure, we shouldn't admit other workloads to this
@@ -135,8 +135,11 @@ func (s *Scheduler) schedule(ctx context.Context) {
 
 	// 6. Requeue the heads that were not scheduled.
 	for _, e := range entries {
-		log := log.WithValues("queuedWorkload", klog.KObj(e.Obj), "clusterQueue", klog.KRef("", e.ClusterQueue))
-		log.V(3).Info("Workload evaluated for admission", "status", e.status, "reason", e.inadmissibleReason)
+		log.V(3).Info("Workload evaluated for admission",
+			"workload", klog.KObj(e.Obj),
+			"clusterQueue", klog.KRef("", e.ClusterQueue),
+			"status", e.status,
+			"reason", e.inadmissibleReason)
 		if e.status != assumed {
 			s.requeueAndUpdate(log, ctx, &e.Info, e.inadmissibleReason)
 			s.recorder.Eventf(e.Obj, corev1.EventTypeNormal, "Pending", e.inadmissibleReason)
@@ -173,7 +176,7 @@ func (s *Scheduler) nominate(ctx context.Context, workloads []workload.Info, sna
 	log := ctrl.LoggerFrom(ctx)
 	entries := make([]entry, 0, len(workloads))
 	for _, w := range workloads {
-		log := log.WithValues("queuedWorkload", klog.KObj(w.Obj), "clusterQueue", klog.KRef("", w.ClusterQueue))
+		log := log.WithValues("workload", klog.KObj(w.Obj), "clusterQueue", klog.KRef("", w.ClusterQueue))
 		cq := snap.ClusterQueues[w.ClusterQueue]
 		ns := corev1.Namespace{}
 		e := entry{Info: w}
@@ -422,9 +425,9 @@ func (e entryOrdering) Less(i, j int) bool {
 
 func (s *Scheduler) requeueAndUpdate(log logr.Logger, ctx context.Context, w *workload.Info, message string) {
 	added := s.queues.RequeueWorkload(ctx, w)
-	log.V(2).Info("Workload re-queued", "queuedWorkload", klog.KObj(w.Obj), "queue", klog.KRef(w.Obj.Namespace, w.Obj.Spec.QueueName), "added", added)
-	err := workload.UpdateStatus(ctx, s.client, w.Obj, kueue.QueuedWorkloadAdmitted, corev1.ConditionFalse, "Pending", message)
+	log.V(2).Info("Workload re-queued", "workload", klog.KObj(w.Obj), "queue", klog.KRef(w.Obj.Namespace, w.Obj.Spec.QueueName), "added", added)
+	err := workload.UpdateStatus(ctx, s.client, w.Obj, kueue.WorkloadAdmitted, corev1.ConditionFalse, "Pending", message)
 	if err != nil {
-		log.Error(err, "Could not update QueuedWorkload status")
+		log.Error(err, "Could not update Workload status")
 	}
 }
diff --git a/pkg/util/priority/priority.go b/pkg/util/priority/priority.go
index 22e732c4d..12dacee0a 100644
--- a/pkg/util/priority/priority.go
+++ b/pkg/util/priority/priority.go
@@ -28,7 +28,7 @@ import (
 )
 
 // Priority returns priority of the given workload.
-func Priority(w *kueue.QueuedWorkload) int32 {
+func Priority(w *kueue.Workload) int32 {
 	if w.Spec.Priority != nil {
 		return *w.Spec.Priority
 	}
diff --git a/pkg/workload/workload.go b/pkg/workload/workload.go
index 9a661d176..b3320d852 100644
--- a/pkg/workload/workload.go
+++ b/pkg/workload/workload.go
@@ -29,9 +29,9 @@ import (
 	kueue "sigs.k8s.io/kueue/api/v1alpha1"
 )
 
-// Info holds a QueuedWorkload object and some pre-processing.
+// Info holds a Workload object and some pre-processing.
 type Info struct {
-	Obj *kueue.QueuedWorkload
+	Obj *kueue.Workload
 	// list of total resources requested by the podsets.
 	TotalRequests []PodSetResources
 	// Populated from queue.
@@ -44,18 +44,18 @@ type PodSetResources struct {
 	Flavors  map[corev1.ResourceName]string
 }
 
-func NewInfo(w *kueue.QueuedWorkload) *Info {
+func NewInfo(w *kueue.Workload) *Info {
 	return &Info{
 		Obj:           w,
 		TotalRequests: totalRequests(&w.Spec),
 	}
 }
 
-func Key(w *kueue.QueuedWorkload) string {
+func Key(w *kueue.Workload) string {
 	return fmt.Sprintf("%s/%s", w.Namespace, w.Name)
 }
 
-func totalRequests(spec *kueue.QueuedWorkloadSpec) []PodSetResources {
+func totalRequests(spec *kueue.WorkloadSpec) []PodSetResources {
 	if len(spec.PodSets) == 0 {
 		return nil
 	}
@@ -161,7 +161,7 @@ func max(v1, v2 int64) int64 {
 
 // FindConditionIndex finds the provided condition from the given status and returns the index.
 // Returns -1 if the condition is not present.
-func FindConditionIndex(status *kueue.QueuedWorkloadStatus, conditionType kueue.QueuedWorkloadConditionType) int {
+func FindConditionIndex(status *kueue.WorkloadStatus, conditionType kueue.WorkloadConditionType) int {
 	if status == nil {
 		return -1
 	}
@@ -179,14 +179,14 @@ func FindConditionIndex(status *kueue.QueuedWorkloadStatus, conditionType kueue.
 // UpdateStatus updates the condition of a workload.
 func UpdateStatus(ctx context.Context,
 	c client.Client,
-	wl *kueue.QueuedWorkload,
-	conditionType kueue.QueuedWorkloadConditionType,
+	wl *kueue.Workload,
+	conditionType kueue.WorkloadConditionType,
 	conditionStatus corev1.ConditionStatus,
 	reason, message string) error {
 	conditionIndex := FindConditionIndex(&wl.Status, conditionType)
 
 	now := metav1.Now()
-	condition := kueue.QueuedWorkloadCondition{
+	condition := kueue.WorkloadCondition{
 		Type:               conditionType,
 		Status:             conditionStatus,
 		LastProbeTime:      now,
@@ -209,8 +209,8 @@ func UpdateStatus(ctx context.Context,
 
 func UpdateWorkloadStatusIfChanged(ctx context.Context,
 	c client.Client,
-	wl *kueue.QueuedWorkload,
-	conditionType kueue.QueuedWorkloadConditionType,
+	wl *kueue.Workload,
+	conditionType kueue.WorkloadConditionType,
 	conditionStatus corev1.ConditionStatus,
 	reason, message string) error {
 	i := FindConditionIndex(&wl.Status, conditionType)


Test patch:
diff --git a/pkg/cache/cache_test.go b/pkg/cache/cache_test.go
index adcfe542d..15fcae135 100644
--- a/pkg/cache/cache_test.go
+++ b/pkg/cache/cache_test.go
@@ -399,9 +399,9 @@ func TestCacheWorkloadOperations(t *testing.T) {
 		t.Fatalf("Failed adding kueue scheme: %v", err)
 	}
 	client := fake.NewClientBuilder().WithScheme(scheme).WithObjects(
-		&kueue.QueuedWorkload{
+		&kueue.Workload{
 			ObjectMeta: metav1.ObjectMeta{Name: "a"},
-			Spec: kueue.QueuedWorkloadSpec{
+			Spec: kueue.WorkloadSpec{
 				PodSets: podSets,
 				Admission: &kueue.Admission{
 					ClusterQueue:  "one",
@@ -409,15 +409,15 @@ func TestCacheWorkloadOperations(t *testing.T) {
 				},
 			},
 		},
-		&kueue.QueuedWorkload{
+		&kueue.Workload{
 			ObjectMeta: metav1.ObjectMeta{Name: "c"},
-			Spec: kueue.QueuedWorkloadSpec{
+			Spec: kueue.WorkloadSpec{
 				Admission: &kueue.Admission{ClusterQueue: "one"},
 			},
 		},
-		&kueue.QueuedWorkload{
+		&kueue.Workload{
 			ObjectMeta: metav1.ObjectMeta{Name: "d"},
-			Spec: kueue.QueuedWorkloadSpec{
+			Spec: kueue.WorkloadSpec{
 				Admission: &kueue.Admission{ClusterQueue: "two"},
 			},
 		},
@@ -445,10 +445,10 @@ func TestCacheWorkloadOperations(t *testing.T) {
 		{
 			name: "add",
 			operation: func() error {
-				workloads := []kueue.QueuedWorkload{
+				workloads := []kueue.Workload{
 					{
 						ObjectMeta: metav1.ObjectMeta{Name: "a"},
-						Spec: kueue.QueuedWorkloadSpec{
+						Spec: kueue.WorkloadSpec{
 							PodSets: podSets,
 							Admission: &kueue.Admission{
 								ClusterQueue:  "one",
@@ -458,7 +458,7 @@ func TestCacheWorkloadOperations(t *testing.T) {
 					},
 					{
 						ObjectMeta: metav1.ObjectMeta{Name: "b"},
-						Spec: kueue.QueuedWorkloadSpec{
+						Spec: kueue.WorkloadSpec{
 							Admission: &kueue.Admission{ClusterQueue: "two"},
 						},
 					},
@@ -484,9 +484,9 @@ func TestCacheWorkloadOperations(t *testing.T) {
 		{
 			name: "add error no clusterQueue",
 			operation: func() error {
-				w := kueue.QueuedWorkload{
+				w := kueue.Workload{
 					ObjectMeta: metav1.ObjectMeta{Name: "a"},
-					Spec: kueue.QueuedWorkloadSpec{
+					Spec: kueue.WorkloadSpec{
 						Admission: &kueue.Admission{ClusterQueue: "three"},
 					},
 				}
@@ -510,9 +510,9 @@ func TestCacheWorkloadOperations(t *testing.T) {
 		{
 			name: "add already exists",
 			operation: func() error {
-				w := kueue.QueuedWorkload{
+				w := kueue.Workload{
 					ObjectMeta: metav1.ObjectMeta{Name: "c"},
-					Spec: kueue.QueuedWorkloadSpec{
+					Spec: kueue.WorkloadSpec{
 						Admission: &kueue.Admission{ClusterQueue: "one"},
 					},
 				}
@@ -535,15 +535,15 @@ func TestCacheWorkloadOperations(t *testing.T) {
 		{
 			name: "update",
 			operation: func() error {
-				old := kueue.QueuedWorkload{
+				old := kueue.Workload{
 					ObjectMeta: metav1.ObjectMeta{Name: "a"},
-					Spec: kueue.QueuedWorkloadSpec{
+					Spec: kueue.WorkloadSpec{
 						Admission: &kueue.Admission{ClusterQueue: "one"},
 					},
 				}
-				latest := kueue.QueuedWorkload{
+				latest := kueue.Workload{
 					ObjectMeta: metav1.ObjectMeta{Name: "a"},
-					Spec: kueue.QueuedWorkloadSpec{
+					Spec: kueue.WorkloadSpec{
 						PodSets: podSets,
 						Admission: &kueue.Admission{
 							ClusterQueue:  "two",
@@ -567,15 +567,15 @@ func TestCacheWorkloadOperations(t *testing.T) {
 		{
 			name: "update old doesn't exist",
 			operation: func() error {
-				old := kueue.QueuedWorkload{
+				old := kueue.Workload{
 					ObjectMeta: metav1.ObjectMeta{Name: "e"},
-					Spec: kueue.QueuedWorkloadSpec{
+					Spec: kueue.WorkloadSpec{
 						Admission: &kueue.Admission{ClusterQueue: "one"},
 					},
 				}
-				latest := kueue.QueuedWorkload{
+				latest := kueue.Workload{
 					ObjectMeta: metav1.ObjectMeta{Name: "e"},
-					Spec: kueue.QueuedWorkloadSpec{
+					Spec: kueue.WorkloadSpec{
 						Admission: &kueue.Admission{ClusterQueue: "two"},
 					},
 				}
@@ -595,9 +595,9 @@ func TestCacheWorkloadOperations(t *testing.T) {
 		{
 			name: "delete",
 			operation: func() error {
-				w := kueue.QueuedWorkload{
+				w := kueue.Workload{
 					ObjectMeta: metav1.ObjectMeta{Name: "a"},
-					Spec: kueue.QueuedWorkloadSpec{
+					Spec: kueue.WorkloadSpec{
 						Admission: &kueue.Admission{ClusterQueue: "two"},
 					},
 				}
@@ -617,9 +617,9 @@ func TestCacheWorkloadOperations(t *testing.T) {
 		{
 			name: "delete error clusterQueue doesn't exist",
 			operation: func() error {
-				w := kueue.QueuedWorkload{
+				w := kueue.Workload{
 					ObjectMeta: metav1.ObjectMeta{Name: "a"},
-					Spec: kueue.QueuedWorkloadSpec{
+					Spec: kueue.WorkloadSpec{
 						Admission: &kueue.Admission{ClusterQueue: "three"},
 					},
 				}
@@ -640,9 +640,9 @@ func TestCacheWorkloadOperations(t *testing.T) {
 		{
 			name: "delete workload doesn't exist",
 			operation: func() error {
-				w := kueue.QueuedWorkload{
+				w := kueue.Workload{
 					ObjectMeta: metav1.ObjectMeta{Name: "f"},
-					Spec: kueue.QueuedWorkloadSpec{
+					Spec: kueue.WorkloadSpec{
 						Admission: &kueue.Admission{ClusterQueue: "one"},
 					},
 				}
@@ -662,10 +662,10 @@ func TestCacheWorkloadOperations(t *testing.T) {
 		{
 			name: "assume",
 			operation: func() error {
-				workloads := []kueue.QueuedWorkload{
+				workloads := []kueue.Workload{
 					{
 						ObjectMeta: metav1.ObjectMeta{Name: "a"},
-						Spec: kueue.QueuedWorkloadSpec{
+						Spec: kueue.WorkloadSpec{
 							PodSets: podSets,
 							Admission: &kueue.Admission{
 								ClusterQueue:  "one",
@@ -675,7 +675,7 @@ func TestCacheWorkloadOperations(t *testing.T) {
 					},
 					{
 						ObjectMeta: metav1.ObjectMeta{Name: "f"},
-						Spec: kueue.QueuedWorkloadSpec{
+						Spec: kueue.WorkloadSpec{
 							PodSets: podSets,
 							Admission: &kueue.Admission{
 								ClusterQueue:  "two",
@@ -709,9 +709,9 @@ func TestCacheWorkloadOperations(t *testing.T) {
 		{
 			name: "forget",
 			operation: func() error {
-				w := kueue.QueuedWorkload{
+				w := kueue.Workload{
 					ObjectMeta: metav1.ObjectMeta{Name: "a"},
-					Spec: kueue.QueuedWorkloadSpec{
+					Spec: kueue.WorkloadSpec{
 						PodSets: podSets,
 						Admission: &kueue.Admission{
 							ClusterQueue:  "one",
@@ -738,9 +738,9 @@ func TestCacheWorkloadOperations(t *testing.T) {
 		{
 			name: "add assumed workload",
 			operation: func() error {
-				w := kueue.QueuedWorkload{
+				w := kueue.Workload{
 					ObjectMeta: metav1.ObjectMeta{Name: "f"},
-					Spec: kueue.QueuedWorkloadSpec{
+					Spec: kueue.WorkloadSpec{
 						PodSets: podSets,
 						Admission: &kueue.Admission{
 							ClusterQueue:  "two",
@@ -831,10 +831,10 @@ func TestClusterQueueUsage(t *testing.T) {
 			},
 		},
 	}
-	workloads := []kueue.QueuedWorkload{
+	workloads := []kueue.Workload{
 		{
 			ObjectMeta: metav1.ObjectMeta{Name: "one"},
-			Spec: kueue.QueuedWorkloadSpec{
+			Spec: kueue.WorkloadSpec{
 				PodSets: []kueue.PodSet{
 					{
 						Name:  "main",
@@ -861,7 +861,7 @@ func TestClusterQueueUsage(t *testing.T) {
 		},
 		{
 			ObjectMeta: metav1.ObjectMeta{Name: "two"},
-			Spec: kueue.QueuedWorkloadSpec{
+			Spec: kueue.WorkloadSpec{
 				PodSets: []kueue.PodSet{
 					{
 						Name:  "main",
@@ -888,7 +888,7 @@ func TestClusterQueueUsage(t *testing.T) {
 		},
 	}
 	cases := map[string]struct {
-		workloads         []kueue.QueuedWorkload
+		workloads         []kueue.Workload
 		wantUsedResources kueue.UsedResources
 		wantWorkloads     int
 	}{
diff --git a/pkg/cache/snapshot_test.go b/pkg/cache/snapshot_test.go
index b5b6b862a..55fceb6f0 100644
--- a/pkg/cache/snapshot_test.go
+++ b/pkg/cache/snapshot_test.go
@@ -142,10 +142,10 @@ func TestSnapshot(t *testing.T) {
 	for i := range flavors {
 		cache.AddOrUpdateResourceFlavor(&flavors[i])
 	}
-	workloads := []kueue.QueuedWorkload{
+	workloads := []kueue.Workload{
 		{
 			ObjectMeta: metav1.ObjectMeta{Name: "alpha"},
-			Spec: kueue.QueuedWorkloadSpec{
+			Spec: kueue.WorkloadSpec{
 				PodSets: []kueue.PodSet{
 					{
 						Name:  "main",
@@ -170,7 +170,7 @@ func TestSnapshot(t *testing.T) {
 		},
 		{
 			ObjectMeta: metav1.ObjectMeta{Name: "beta"},
-			Spec: kueue.QueuedWorkloadSpec{
+			Spec: kueue.WorkloadSpec{
 				PodSets: []kueue.PodSet{
 					{
 						Name:  "main",
@@ -197,7 +197,7 @@ func TestSnapshot(t *testing.T) {
 		},
 		{
 			ObjectMeta: metav1.ObjectMeta{Name: "gamma"},
-			Spec: kueue.QueuedWorkloadSpec{
+			Spec: kueue.WorkloadSpec{
 				PodSets: []kueue.PodSet{
 					{
 						Name:  "main",
diff --git a/pkg/queue/cluster_queue_best_effort_fifo_test.go b/pkg/queue/cluster_queue_best_effort_fifo_test.go
index c75c5ab46..702cf1a0d 100644
--- a/pkg/queue/cluster_queue_best_effort_fifo_test.go
+++ b/pkg/queue/cluster_queue_best_effort_fifo_test.go
@@ -30,11 +30,11 @@ import (
 func TestClusterQueueBestEffortFIFO(t *testing.T) {
 	clusterQueue := utiltesting.MakeClusterQueue("cq").QueueingStrategy(
 		kueue.BestEffortFIFO).Obj()
-	var workloads = []*kueue.QueuedWorkload{
-		utiltesting.MakeQueuedWorkload("w1", "ns1").Queue("q1").Obj(),
-		utiltesting.MakeQueuedWorkload("w2", "ns2").Queue("q2").Obj(),
+	var workloads = []*kueue.Workload{
+		utiltesting.MakeWorkload("w1", "ns1").Queue("q1").Obj(),
+		utiltesting.MakeWorkload("w2", "ns2").Queue("q2").Obj(),
 	}
-	var updatedWorkloads = make([]*kueue.QueuedWorkload, len(workloads))
+	var updatedWorkloads = make([]*kueue.Workload, len(workloads))
 
 	updatedWorkloads[0] = workloads[0].DeepCopy()
 	updatedWorkloads[0].Spec.QueueName = "q2"
@@ -43,46 +43,46 @@ func TestClusterQueueBestEffortFIFO(t *testing.T) {
 
 	tests := []struct {
 		name                       string
-		workloadsToAdd             []*kueue.QueuedWorkload
+		workloadsToAdd             []*kueue.Workload
 		inadmissibleWorkloadsToAdd []*workload.Info
-		workloadsToUpdate          []*kueue.QueuedWorkload
-		workloadsToDelete          []*kueue.QueuedWorkload
+		workloadsToUpdate          []*kueue.Workload
+		workloadsToDelete          []*kueue.Workload
 		queueInadmissibleWorkloads bool
 		wantWorkloads              sets.String
 	}{
 		{
 			name:                       "add, update, delete workload",
-			workloadsToAdd:             []*kueue.QueuedWorkload{workloads[0], workloads[1]},
+			workloadsToAdd:             []*kueue.Workload{workloads[0], workloads[1]},
 			inadmissibleWorkloadsToAdd: []*workload.Info{},
-			workloadsToUpdate:          []*kueue.QueuedWorkload{updatedWorkloads[0]},
-			workloadsToDelete:          []*kueue.QueuedWorkload{workloads[0]},
+			workloadsToUpdate:          []*kueue.Workload{updatedWorkloads[0]},
+			workloadsToDelete:          []*kueue.Workload{workloads[0]},
 			queueInadmissibleWorkloads: false,
 			wantWorkloads:              sets.NewString(workloads[1].Name),
 		},
 		{
 			name:                       "update inadmissible workload",
-			workloadsToAdd:             []*kueue.QueuedWorkload{workloads[0]},
+			workloadsToAdd:             []*kueue.Workload{workloads[0]},
 			inadmissibleWorkloadsToAdd: []*workload.Info{workload.NewInfo(workloads[1])},
-			workloadsToUpdate:          []*kueue.QueuedWorkload{updatedWorkloads[1]},
-			workloadsToDelete:          []*kueue.QueuedWorkload{},
+			workloadsToUpdate:          []*kueue.Workload{updatedWorkloads[1]},
+			workloadsToDelete:          []*kueue.Workload{},
 			queueInadmissibleWorkloads: false,
 			wantWorkloads:              sets.NewString(workloads[0].Name, workloads[1].Name),
 		},
 		{
 			name:                       "re-queue inadmissible workload",
-			workloadsToAdd:             []*kueue.QueuedWorkload{workloads[0]},
+			workloadsToAdd:             []*kueue.Workload{workloads[0]},
 			inadmissibleWorkloadsToAdd: []*workload.Info{workload.NewInfo(workloads[1])},
-			workloadsToUpdate:          []*kueue.QueuedWorkload{},
-			workloadsToDelete:          []*kueue.QueuedWorkload{},
+			workloadsToUpdate:          []*kueue.Workload{},
+			workloadsToDelete:          []*kueue.Workload{},
 			queueInadmissibleWorkloads: true,
 			wantWorkloads:              sets.NewString(workloads[0].Name, workloads[1].Name),
 		},
 		{
 			name:                       "delete inadmissible workload",
-			workloadsToAdd:             []*kueue.QueuedWorkload{workloads[0]},
+			workloadsToAdd:             []*kueue.Workload{workloads[0]},
 			inadmissibleWorkloadsToAdd: []*workload.Info{workload.NewInfo(workloads[1])},
-			workloadsToUpdate:          []*kueue.QueuedWorkload{},
-			workloadsToDelete:          []*kueue.QueuedWorkload{workloads[1]},
+			workloadsToUpdate:          []*kueue.Workload{},
+			workloadsToDelete:          []*kueue.Workload{workloads[1]},
 			queueInadmissibleWorkloads: true,
 			wantWorkloads:              sets.NewString(workloads[0].Name),
 		},
diff --git a/pkg/queue/cluster_queue_strict_fifo_test.go b/pkg/queue/cluster_queue_strict_fifo_test.go
index 938b0009d..c1f1ac8cc 100644
--- a/pkg/queue/cluster_queue_strict_fifo_test.go
+++ b/pkg/queue/cluster_queue_strict_fifo_test.go
@@ -41,7 +41,7 @@ func TestFIFOClusterQueue(t *testing.T) {
 		t.Fatalf("Failed creating ClusterQueue %v", err)
 	}
 	now := metav1.Now()
-	ws := []*kueue.QueuedWorkload{
+	ws := []*kueue.Workload{
 		{
 			ObjectMeta: metav1.ObjectMeta{
 				Name:              "now",
@@ -71,7 +71,7 @@ func TestFIFOClusterQueue(t *testing.T) {
 	if got.Obj.Name != "before" {
 		t.Errorf("Popped workload %q want %q", got.Obj.Name, "before")
 	}
-	q.PushOrUpdate(&kueue.QueuedWorkload{
+	q.PushOrUpdate(&kueue.Workload{
 		ObjectMeta: metav1.ObjectMeta{
 			Name:              "after",
 			CreationTimestamp: metav1.NewTime(now.Add(-time.Minute)),
@@ -85,7 +85,7 @@ func TestFIFOClusterQueue(t *testing.T) {
 		t.Errorf("Popped workload %q want %q", got.Obj.Name, "after")
 	}
 
-	q.Delete(&kueue.QueuedWorkload{
+	q.Delete(&kueue.Workload{
 		ObjectMeta: metav1.ObjectMeta{Name: "now"},
 	})
 	got = q.Pop()
@@ -99,28 +99,28 @@ func TestStrictFIFO(t *testing.T) {
 	t2 := t1.Add(time.Second)
 	for _, tt := range []struct {
 		name     string
-		w1       *kueue.QueuedWorkload
-		w2       *kueue.QueuedWorkload
+		w1       *kueue.Workload
+		w2       *kueue.Workload
 		expected string
 	}{
 		{
 			name: "w1.priority is higher than w2.priority",
-			w1: &kueue.QueuedWorkload{
+			w1: &kueue.Workload{
 				ObjectMeta: metav1.ObjectMeta{
 					Name:              "w1",
 					CreationTimestamp: metav1.NewTime(t1),
 				},
-				Spec: kueue.QueuedWorkloadSpec{
+				Spec: kueue.WorkloadSpec{
 					PriorityClassName: "highPriority",
 					Priority:          pointer.Int32(highPriority),
 				},
 			},
-			w2: &kueue.QueuedWorkload{
+			w2: &kueue.Workload{
 				ObjectMeta: metav1.ObjectMeta{
 					Name:              "w2",
 					CreationTimestamp: metav1.NewTime(t2),
 				},
-				Spec: kueue.QueuedWorkloadSpec{
+				Spec: kueue.WorkloadSpec{
 					PriorityClassName: "lowPriority",
 					Priority:          pointer.Int32(lowPriority),
 				},
@@ -129,13 +129,13 @@ func TestStrictFIFO(t *testing.T) {
 		},
 		{
 			name: "w1.priority equals w2.priority and w1.create time is earlier than w2.create time",
-			w1: &kueue.QueuedWorkload{
+			w1: &kueue.Workload{
 				ObjectMeta: metav1.ObjectMeta{
 					Name:              "w1",
 					CreationTimestamp: metav1.NewTime(t1),
 				},
 			},
-			w2: &kueue.QueuedWorkload{
+			w2: &kueue.Workload{
 				ObjectMeta: metav1.ObjectMeta{
 					Name:              "w2",
 					CreationTimestamp: metav1.NewTime(t2),
@@ -145,22 +145,22 @@ func TestStrictFIFO(t *testing.T) {
 		},
 		{
 			name: "p1.priority is lower than p2.priority and w1.create time is earlier than w2.create time",
-			w1: &kueue.QueuedWorkload{
+			w1: &kueue.Workload{
 				ObjectMeta: metav1.ObjectMeta{
 					Name:              "w1",
 					CreationTimestamp: metav1.NewTime(t1),
 				},
-				Spec: kueue.QueuedWorkloadSpec{
+				Spec: kueue.WorkloadSpec{
 					PriorityClassName: "lowPriority",
 					Priority:          pointer.Int32(lowPriority),
 				},
 			},
-			w2: &kueue.QueuedWorkload{
+			w2: &kueue.Workload{
 				ObjectMeta: metav1.ObjectMeta{
 					Name:              "w2",
 					CreationTimestamp: metav1.NewTime(t2),
 				},
-				Spec: kueue.QueuedWorkloadSpec{
+				Spec: kueue.WorkloadSpec{
 					PriorityClassName: "highPriority",
 					Priority:          pointer.Int32(highPriority),
 				},
diff --git a/pkg/queue/manager_test.go b/pkg/queue/manager_test.go
index 8a85f1643..d350a2ab9 100644
--- a/pkg/queue/manager_test.go
+++ b/pkg/queue/manager_test.go
@@ -43,12 +43,12 @@ func TestAddQueueOrphans(t *testing.T) {
 		t.Fatalf("Failed adding kueue scheme: %s", err)
 	}
 	kClient := fake.NewClientBuilder().WithScheme(scheme).WithObjects(
-		utiltesting.MakeQueuedWorkload("a", "earth").Queue("foo").Obj(),
-		utiltesting.MakeQueuedWorkload("b", "earth").Queue("bar").Obj(),
-		utiltesting.MakeQueuedWorkload("c", "earth").Queue("foo").Obj(),
-		utiltesting.MakeQueuedWorkload("d", "earth").Queue("foo").
+		utiltesting.MakeWorkload("a", "earth").Queue("foo").Obj(),
+		utiltesting.MakeWorkload("b", "earth").Queue("bar").Obj(),
+		utiltesting.MakeWorkload("c", "earth").Queue("foo").Obj(),
+		utiltesting.MakeWorkload("d", "earth").Queue("foo").
 			Admit(utiltesting.MakeAdmission("cq").Obj()).Obj(),
-		utiltesting.MakeQueuedWorkload("a", "moon").Queue("foo").Obj(),
+		utiltesting.MakeWorkload("a", "moon").Queue("foo").Obj(),
 	).Build()
 	manager := NewManager(kClient)
 	q := utiltesting.MakeQueue("foo", "earth").Obj()
@@ -75,11 +75,11 @@ func TestAddClusterQueueOrphans(t *testing.T) {
 		utiltesting.MakeQueue("bar", "").ClusterQueue("cq").Obj(),
 	}
 	kClient := fake.NewClientBuilder().WithScheme(scheme).WithObjects(
-		utiltesting.MakeQueuedWorkload("a", "").Queue("foo").Creation(now.Add(time.Second)).Obj(),
-		utiltesting.MakeQueuedWorkload("b", "").Queue("bar").Creation(now).Obj(),
-		utiltesting.MakeQueuedWorkload("c", "").Queue("foo").
+		utiltesting.MakeWorkload("a", "").Queue("foo").Creation(now.Add(time.Second)).Obj(),
+		utiltesting.MakeWorkload("b", "").Queue("bar").Creation(now).Obj(),
+		utiltesting.MakeWorkload("c", "").Queue("foo").
 			Admit(utiltesting.MakeAdmission("cq").Obj()).Obj(),
-		utiltesting.MakeQueuedWorkload("d", "").Queue("baz").Obj(),
+		utiltesting.MakeWorkload("d", "").Queue("baz").Obj(),
 		queues[0],
 		queues[1],
 	).Build()
@@ -113,9 +113,9 @@ func TestUpdateQueue(t *testing.T) {
 		utiltesting.MakeQueue("bar", "").ClusterQueue("cq2").Obj(),
 	}
 	now := time.Now()
-	workloads := []*kueue.QueuedWorkload{
-		utiltesting.MakeQueuedWorkload("a", "").Queue("foo").Creation(now.Add(time.Second)).Obj(),
-		utiltesting.MakeQueuedWorkload("b", "").Queue("bar").Creation(now).Obj(),
+	workloads := []*kueue.Workload{
+		utiltesting.MakeWorkload("a", "").Queue("foo").Creation(now.Add(time.Second)).Obj(),
+		utiltesting.MakeWorkload("b", "").Queue("bar").Creation(now).Obj(),
 	}
 	// Setup.
 	scheme := runtime.NewScheme()
@@ -178,44 +178,44 @@ func TestAddWorkload(t *testing.T) {
 		}
 	}
 	cases := []struct {
-		workload  *kueue.QueuedWorkload
+		workload  *kueue.Workload
 		wantAdded bool
 	}{
 		{
-			workload: &kueue.QueuedWorkload{
+			workload: &kueue.Workload{
 				ObjectMeta: metav1.ObjectMeta{
 					Namespace: "earth",
 					Name:      "existing_queue",
 				},
-				Spec: kueue.QueuedWorkloadSpec{QueueName: "foo"},
+				Spec: kueue.WorkloadSpec{QueueName: "foo"},
 			},
 			wantAdded: true,
 		},
 		{
-			workload: &kueue.QueuedWorkload{
+			workload: &kueue.Workload{
 				ObjectMeta: metav1.ObjectMeta{
 					Namespace: "earth",
 					Name:      "non_existing_queue",
 				},
-				Spec: kueue.QueuedWorkloadSpec{QueueName: "baz"},
+				Spec: kueue.WorkloadSpec{QueueName: "baz"},
 			},
 		},
 		{
-			workload: &kueue.QueuedWorkload{
+			workload: &kueue.Workload{
 				ObjectMeta: metav1.ObjectMeta{
 					Namespace: "mars",
 					Name:      "non_existing_cluster_queue",
 				},
-				Spec: kueue.QueuedWorkloadSpec{QueueName: "bar"},
+				Spec: kueue.WorkloadSpec{QueueName: "bar"},
 			},
 		},
 		{
-			workload: &kueue.QueuedWorkload{
+			workload: &kueue.Workload{
 				ObjectMeta: metav1.ObjectMeta{
 					Namespace: "mars",
 					Name:      "wrong_namespace",
 				},
-				Spec: kueue.QueuedWorkloadSpec{QueueName: "foo"},
+				Spec: kueue.WorkloadSpec{QueueName: "foo"},
 			},
 		},
 	}
@@ -250,34 +250,34 @@ func TestStatus(t *testing.T) {
 			},
 		},
 	}
-	workloads := []kueue.QueuedWorkload{
+	workloads := []kueue.Workload{
 		{
 			ObjectMeta: metav1.ObjectMeta{
 				Name:              "a",
 				CreationTimestamp: metav1.NewTime(now.Add(time.Hour)),
 			},
-			Spec: kueue.QueuedWorkloadSpec{QueueName: "foo"},
+			Spec: kueue.WorkloadSpec{QueueName: "foo"},
 		},
 		{
 			ObjectMeta: metav1.ObjectMeta{
 				Name:              "b",
 				CreationTimestamp: metav1.NewTime(now),
 			},
-			Spec: kueue.QueuedWorkloadSpec{QueueName: "bar"},
+			Spec: kueue.WorkloadSpec{QueueName: "bar"},
 		},
 		{
 			ObjectMeta: metav1.ObjectMeta{
 				Name:              "c",
 				CreationTimestamp: metav1.NewTime(now),
 			},
-			Spec: kueue.QueuedWorkloadSpec{QueueName: "foo"},
+			Spec: kueue.WorkloadSpec{QueueName: "foo"},
 		},
 		{
 			ObjectMeta: metav1.ObjectMeta{
 				Name:              "d",
 				CreationTimestamp: metav1.NewTime(now),
 			},
-			Spec: kueue.QueuedWorkloadSpec{QueueName: "foo"},
+			Spec: kueue.WorkloadSpec{QueueName: "foo"},
 		},
 	}
 
@@ -337,51 +337,51 @@ func TestRequeueWorkload(t *testing.T) {
 		utiltesting.MakeQueue("bar", "").Obj(),
 	}
 	cases := []struct {
-		workload     *kueue.QueuedWorkload
+		workload     *kueue.Workload
 		inClient     bool
 		inQueue      bool
 		wantRequeued bool
 	}{
 		{
-			workload: &kueue.QueuedWorkload{
+			workload: &kueue.Workload{
 				ObjectMeta: metav1.ObjectMeta{Name: "existing_queue_and_obj"},
-				Spec:       kueue.QueuedWorkloadSpec{QueueName: "foo"},
+				Spec:       kueue.WorkloadSpec{QueueName: "foo"},
 			},
 			inClient:     true,
 			wantRequeued: true,
 		},
 		{
-			workload: &kueue.QueuedWorkload{
+			workload: &kueue.Workload{
 				ObjectMeta: metav1.ObjectMeta{Name: "non_existing_queue"},
-				Spec:       kueue.QueuedWorkloadSpec{QueueName: "baz"},
+				Spec:       kueue.WorkloadSpec{QueueName: "baz"},
 			},
 			inClient: true,
 		},
 		{
-			workload: &kueue.QueuedWorkload{
+			workload: &kueue.Workload{
 				ObjectMeta: metav1.ObjectMeta{Name: "non_existing_cluster_queue"},
-				Spec:       kueue.QueuedWorkloadSpec{QueueName: "bar"},
+				Spec:       kueue.WorkloadSpec{QueueName: "bar"},
 			},
 			inClient: true,
 		},
 		{
-			workload: &kueue.QueuedWorkload{
+			workload: &kueue.Workload{
 				ObjectMeta: metav1.ObjectMeta{Name: "not_in_client"},
-				Spec:       kueue.QueuedWorkloadSpec{QueueName: "foo"},
+				Spec:       kueue.WorkloadSpec{QueueName: "foo"},
 			},
 		},
 		{
-			workload: &kueue.QueuedWorkload{
+			workload: &kueue.Workload{
 				ObjectMeta: metav1.ObjectMeta{Name: "already_in_queue"},
-				Spec:       kueue.QueuedWorkloadSpec{QueueName: "foo"},
+				Spec:       kueue.WorkloadSpec{QueueName: "foo"},
 			},
 			inClient: true,
 			inQueue:  true,
 		},
 		{
-			workload: &kueue.QueuedWorkload{
+			workload: &kueue.Workload{
 				ObjectMeta: metav1.ObjectMeta{Name: "already_admitted"},
-				Spec: kueue.QueuedWorkloadSpec{
+				Spec: kueue.WorkloadSpec{
 					QueueName: "foo",
 					Admission: &kueue.Admission{},
 				},
@@ -430,8 +430,8 @@ func TestUpdateWorkload(t *testing.T) {
 	cases := map[string]struct {
 		clusterQueues    []*kueue.ClusterQueue
 		queues           []*kueue.Queue
-		workloads        []*kueue.QueuedWorkload
-		update           func(*kueue.QueuedWorkload)
+		workloads        []*kueue.Workload
+		update           func(*kueue.Workload)
 		wantUpdated      bool
 		wantQueueOrder   map[string][]string
 		wantQueueMembers map[string]sets.String
@@ -443,11 +443,11 @@ func TestUpdateWorkload(t *testing.T) {
 			queues: []*kueue.Queue{
 				utiltesting.MakeQueue("foo", "").ClusterQueue("cq").Obj(),
 			},
-			workloads: []*kueue.QueuedWorkload{
-				utiltesting.MakeQueuedWorkload("a", "").Queue("foo").Creation(now).Obj(),
-				utiltesting.MakeQueuedWorkload("b", "").Queue("foo").Creation(now.Add(time.Second)).Obj(),
+			workloads: []*kueue.Workload{
+				utiltesting.MakeWorkload("a", "").Queue("foo").Creation(now).Obj(),
+				utiltesting.MakeWorkload("b", "").Queue("foo").Creation(now.Add(time.Second)).Obj(),
 			},
-			update: func(w *kueue.QueuedWorkload) {
+			update: func(w *kueue.Workload) {
 				w.CreationTimestamp = metav1.NewTime(now.Add(time.Minute))
 			},
 			wantUpdated: true,
@@ -466,10 +466,10 @@ func TestUpdateWorkload(t *testing.T) {
 				utiltesting.MakeQueue("foo", "").ClusterQueue("cq").Obj(),
 				utiltesting.MakeQueue("bar", "").ClusterQueue("cq").Obj(),
 			},
-			workloads: []*kueue.QueuedWorkload{
-				utiltesting.MakeQueuedWorkload("a", "").Queue("foo").Obj(),
+			workloads: []*kueue.Workload{
+				utiltesting.MakeWorkload("a", "").Queue("foo").Obj(),
 			},
-			update: func(w *kueue.QueuedWorkload) {
+			update: func(w *kueue.Workload) {
 				w.Spec.QueueName = "bar"
 			},
 			wantUpdated: true,
@@ -490,10 +490,10 @@ func TestUpdateWorkload(t *testing.T) {
 				utiltesting.MakeQueue("foo", "").ClusterQueue("cq1").Obj(),
 				utiltesting.MakeQueue("bar", "").ClusterQueue("cq2").Obj(),
 			},
-			workloads: []*kueue.QueuedWorkload{
-				utiltesting.MakeQueuedWorkload("a", "").Queue("foo").Obj(),
+			workloads: []*kueue.Workload{
+				utiltesting.MakeWorkload("a", "").Queue("foo").Obj(),
 			},
-			update: func(w *kueue.QueuedWorkload) {
+			update: func(w *kueue.Workload) {
 				w.Spec.QueueName = "bar"
 			},
 			wantUpdated: true,
@@ -513,10 +513,10 @@ func TestUpdateWorkload(t *testing.T) {
 			queues: []*kueue.Queue{
 				utiltesting.MakeQueue("foo", "").ClusterQueue("cq").Obj(),
 			},
-			workloads: []*kueue.QueuedWorkload{
-				utiltesting.MakeQueuedWorkload("a", "").Queue("foo").Obj(),
+			workloads: []*kueue.Workload{
+				utiltesting.MakeWorkload("a", "").Queue("foo").Obj(),
 			},
-			update: func(w *kueue.QueuedWorkload) {
+			update: func(w *kueue.Workload) {
 				w.Spec.QueueName = "bar"
 			},
 			wantQueueOrder: map[string][]string{
@@ -533,10 +533,10 @@ func TestUpdateWorkload(t *testing.T) {
 			queues: []*kueue.Queue{
 				utiltesting.MakeQueue("foo", "").ClusterQueue("cq").Obj(),
 			},
-			workloads: []*kueue.QueuedWorkload{
-				utiltesting.MakeQueuedWorkload("a", "").Queue("bar").Obj(),
+			workloads: []*kueue.Workload{
+				utiltesting.MakeWorkload("a", "").Queue("bar").Obj(),
 			},
-			update: func(w *kueue.QueuedWorkload) {
+			update: func(w *kueue.Workload) {
 				w.Spec.QueueName = "foo"
 			},
 			wantUpdated: true,
@@ -640,27 +640,27 @@ func TestHeads(t *testing.T) {
 			},
 		},
 	}
-	workloads := []kueue.QueuedWorkload{
+	workloads := []kueue.Workload{
 		{
 			ObjectMeta: metav1.ObjectMeta{
 				Name:              "a",
 				CreationTimestamp: metav1.NewTime(now.Add(time.Hour)),
 			},
-			Spec: kueue.QueuedWorkloadSpec{QueueName: "foo"},
+			Spec: kueue.WorkloadSpec{QueueName: "foo"},
 		},
 		{
 			ObjectMeta: metav1.ObjectMeta{
 				Name:              "b",
 				CreationTimestamp: metav1.NewTime(now),
 			},
-			Spec: kueue.QueuedWorkloadSpec{QueueName: "bar"},
+			Spec: kueue.WorkloadSpec{QueueName: "bar"},
 		},
 		{
 			ObjectMeta: metav1.ObjectMeta{
 				Name:              "c",
 				CreationTimestamp: metav1.NewTime(now),
 			},
-			Spec: kueue.QueuedWorkloadSpec{QueueName: "foo"},
+			Spec: kueue.WorkloadSpec{QueueName: "foo"},
 		},
 	}
 	manager := NewManager(fake.NewClientBuilder().WithScheme(scheme).Build())
@@ -708,12 +708,12 @@ func TestHeadsAsync(t *testing.T) {
 	}
 	now := time.Now().Truncate(time.Second)
 	cq := utiltesting.MakeClusterQueue("fooCq").Obj()
-	wl := kueue.QueuedWorkload{
+	wl := kueue.Workload{
 		ObjectMeta: metav1.ObjectMeta{
 			Name:              "a",
 			CreationTimestamp: metav1.NewTime(now),
 		},
-		Spec: kueue.QueuedWorkloadSpec{QueueName: "foo"},
+		Spec: kueue.WorkloadSpec{QueueName: "foo"},
 	}
 	q := kueue.Queue{
 		ObjectMeta: metav1.ObjectMeta{Name: "foo"},
diff --git a/pkg/scheduler/scheduler_test.go b/pkg/scheduler/scheduler_test.go
index 6f44f0a92..741c965dc 100644
--- a/pkg/scheduler/scheduler_test.go
+++ b/pkg/scheduler/scheduler_test.go
@@ -212,7 +212,7 @@ func TestSchedule(t *testing.T) {
 		},
 	}
 	cases := map[string]struct {
-		workloads []kueue.QueuedWorkload
+		workloads []kueue.Workload
 		// wantAssignments is a summary of all the admissions in the cache after this cycle.
 		wantAssignments map[string]kueue.Admission
 		// wantScheduled is the subset of workloads that got scheduled/admitted in this cycle.
@@ -221,13 +221,13 @@ func TestSchedule(t *testing.T) {
 		wantLeft map[string]sets.String
 	}{
 		"workload fits in single clusterQueue": {
-			workloads: []kueue.QueuedWorkload{
+			workloads: []kueue.Workload{
 				{
 					ObjectMeta: metav1.ObjectMeta{
 						Namespace: "sales",
 						Name:      "foo",
 					},
-					Spec: kueue.QueuedWorkloadSpec{
+					Spec: kueue.WorkloadSpec{
 						QueueName: "main",
 						PodSets: []kueue.PodSet{
 							{
@@ -257,13 +257,13 @@ func TestSchedule(t *testing.T) {
 			wantScheduled: []string{"sales/foo"},
 		},
 		"single clusterQueue full": {
-			workloads: []kueue.QueuedWorkload{
+			workloads: []kueue.Workload{
 				{
 					ObjectMeta: metav1.ObjectMeta{
 						Namespace: "sales",
 						Name:      "new",
 					},
-					Spec: kueue.QueuedWorkloadSpec{
+					Spec: kueue.WorkloadSpec{
 						QueueName: "main",
 						PodSets: []kueue.PodSet{
 							{
@@ -281,7 +281,7 @@ func TestSchedule(t *testing.T) {
 						Namespace: "sales",
 						Name:      "assigned",
 					},
-					Spec: kueue.QueuedWorkloadSpec{
+					Spec: kueue.WorkloadSpec{
 						PodSets: []kueue.PodSet{
 							{
 								Name:  "one",
@@ -323,13 +323,13 @@ func TestSchedule(t *testing.T) {
 			},
 		},
 		"failed to match clusterQueue selector": {
-			workloads: []kueue.QueuedWorkload{
+			workloads: []kueue.Workload{
 				{
 					ObjectMeta: metav1.ObjectMeta{
 						Namespace: "sales",
 						Name:      "new",
 					},
-					Spec: kueue.QueuedWorkloadSpec{
+					Spec: kueue.WorkloadSpec{
 						QueueName: "blocked",
 						PodSets: []kueue.PodSet{
 							{
@@ -348,13 +348,13 @@ func TestSchedule(t *testing.T) {
 			},
 		},
 		"assign to different cohorts": {
-			workloads: []kueue.QueuedWorkload{
+			workloads: []kueue.Workload{
 				{
 					ObjectMeta: metav1.ObjectMeta{
 						Namespace: "sales",
 						Name:      "new",
 					},
-					Spec: kueue.QueuedWorkloadSpec{
+					Spec: kueue.WorkloadSpec{
 						QueueName: "main",
 						PodSets: []kueue.PodSet{
 							{
@@ -372,7 +372,7 @@ func TestSchedule(t *testing.T) {
 						Namespace: "eng-alpha",
 						Name:      "new",
 					},
-					Spec: kueue.QueuedWorkloadSpec{
+					Spec: kueue.WorkloadSpec{
 						QueueName: "main",
 						PodSets: []kueue.PodSet{
 							{
@@ -413,13 +413,13 @@ func TestSchedule(t *testing.T) {
 			wantScheduled: []string{"sales/new", "eng-alpha/new"},
 		},
 		"assign to same cohort no borrowing": {
-			workloads: []kueue.QueuedWorkload{
+			workloads: []kueue.Workload{
 				{
 					ObjectMeta: metav1.ObjectMeta{
 						Namespace: "eng-alpha",
 						Name:      "new",
 					},
-					Spec: kueue.QueuedWorkloadSpec{
+					Spec: kueue.WorkloadSpec{
 						QueueName: "main",
 						PodSets: []kueue.PodSet{
 							{
@@ -437,7 +437,7 @@ func TestSchedule(t *testing.T) {
 						Namespace: "eng-beta",
 						Name:      "new",
 					},
-					Spec: kueue.QueuedWorkloadSpec{
+					Spec: kueue.WorkloadSpec{
 						QueueName: "main",
 						PodSets: []kueue.PodSet{
 							{
@@ -478,13 +478,13 @@ func TestSchedule(t *testing.T) {
 			wantScheduled: []string{"eng-alpha/new", "eng-beta/new"},
 		},
 		"assign multiple resources and flavors": {
-			workloads: []kueue.QueuedWorkload{
+			workloads: []kueue.Workload{
 				{
 					ObjectMeta: metav1.ObjectMeta{
 						Namespace: "eng-beta",
 						Name:      "new",
 					},
-					Spec: kueue.QueuedWorkloadSpec{
+					Spec: kueue.WorkloadSpec{
 						QueueName: "main",
 						PodSets: []kueue.PodSet{
 							{
@@ -529,13 +529,13 @@ func TestSchedule(t *testing.T) {
 			wantScheduled: []string{"eng-beta/new"},
 		},
 		"cannot borrow if cohort was assigned": {
-			workloads: []kueue.QueuedWorkload{
+			workloads: []kueue.Workload{
 				{
 					ObjectMeta: metav1.ObjectMeta{
 						Namespace: "eng-alpha",
 						Name:      "new",
 					},
-					Spec: kueue.QueuedWorkloadSpec{
+					Spec: kueue.WorkloadSpec{
 						QueueName: "main",
 						PodSets: []kueue.PodSet{
 							{
@@ -553,7 +553,7 @@ func TestSchedule(t *testing.T) {
 						Namespace: "eng-beta",
 						Name:      "new",
 					},
-					Spec: kueue.QueuedWorkloadSpec{
+					Spec: kueue.WorkloadSpec{
 						QueueName: "main",
 						PodSets: []kueue.PodSet{
 							{
@@ -586,13 +586,13 @@ func TestSchedule(t *testing.T) {
 			},
 		},
 		"cannot borrow resource not listed in clusterQueue": {
-			workloads: []kueue.QueuedWorkload{
+			workloads: []kueue.Workload{
 				{
 					ObjectMeta: metav1.ObjectMeta{
 						Namespace: "eng-alpha",
 						Name:      "new",
 					},
-					Spec: kueue.QueuedWorkloadSpec{
+					Spec: kueue.WorkloadSpec{
 						QueueName: "main",
 						PodSets: []kueue.PodSet{
 							{
@@ -611,13 +611,13 @@ func TestSchedule(t *testing.T) {
 			},
 		},
 		"not enough resources to borrow, fallback to next flavor": {
-			workloads: []kueue.QueuedWorkload{
+			workloads: []kueue.Workload{
 				{
 					ObjectMeta: metav1.ObjectMeta{
 						Namespace: "eng-alpha",
 						Name:      "new",
 					},
-					Spec: kueue.QueuedWorkloadSpec{
+					Spec: kueue.WorkloadSpec{
 						QueueName: "main",
 						PodSets: []kueue.PodSet{
 							{
@@ -635,7 +635,7 @@ func TestSchedule(t *testing.T) {
 						Namespace: "eng-beta",
 						Name:      "existing",
 					},
-					Spec: kueue.QueuedWorkloadSpec{
+					Spec: kueue.WorkloadSpec{
 						PodSets: []kueue.PodSet{
 							{
 								Name:  "one",
@@ -700,7 +700,7 @@ func TestSchedule(t *testing.T) {
 				t.Fatalf("Failed adding kueue scheme: %v", err)
 			}
 			clientBuilder := fake.NewClientBuilder().WithScheme(scheme).
-				WithLists(&kueue.QueuedWorkloadList{Items: tc.workloads}, &kueue.QueueList{Items: queues}).
+				WithLists(&kueue.WorkloadList{Items: tc.workloads}, &kueue.QueueList{Items: queues}).
 				WithObjects(
 					&corev1.Namespace{ObjectMeta: metav1.ObjectMeta{Name: "eng-alpha", Labels: map[string]string{"dep": "eng"}}},
 					&corev1.Namespace{ObjectMeta: metav1.ObjectMeta{Name: "eng-beta", Labels: map[string]string{"dep": "eng"}}},
@@ -729,7 +729,7 @@ func TestSchedule(t *testing.T) {
 			for i := range resourceFlavors {
 				cqCache.AddOrUpdateResourceFlavor(resourceFlavors[i])
 			}
-			workloadWatch, err := cl.Watch(ctx, &kueue.QueuedWorkloadList{})
+			workloadWatch, err := cl.Watch(ctx, &kueue.WorkloadList{})
 			if err != nil {
 				t.Fatalf("Failed setting up watch: %v", err)
 			}
@@ -751,15 +751,15 @@ func TestSchedule(t *testing.T) {
 			for !timedOut && len(gotScheduled) < len(tc.wantScheduled) {
 				select {
 				case evt := <-workloadWatch.ResultChan():
-					w, ok := evt.Object.(*kueue.QueuedWorkload)
+					w, ok := evt.Object.(*kueue.Workload)
 					if !ok {
-						t.Fatalf("Received update for %T, want QueuedWorkload", evt.Object)
+						t.Fatalf("Received update for %T, want Workload", evt.Object)
 					}
 					if w.Spec.Admission != nil {
 						gotScheduled[workload.Key(w)] = *w.Spec.Admission
 					}
 				case <-time.After(watchTimeout):
-					t.Errorf("Timed out waiting for QueuedWorkload updates")
+					t.Errorf("Timed out waiting for Workload updates")
 					timedOut = true
 				}
 			}
@@ -1395,8 +1395,8 @@ func TestEntryAssignFlavors(t *testing.T) {
 				Verbosity: 2,
 			})
 			e := entry{
-				Info: *workload.NewInfo(&kueue.QueuedWorkload{
-					Spec: kueue.QueuedWorkloadSpec{
+				Info: *workload.NewInfo(&kueue.Workload{
+					Spec: kueue.WorkloadSpec{
 						PodSets: tc.wlPods,
 					},
 				}),
@@ -1428,7 +1428,7 @@ func TestEntryOrdering(t *testing.T) {
 	input := []entry{
 		{
 			Info: workload.Info{
-				Obj: &kueue.QueuedWorkload{ObjectMeta: metav1.ObjectMeta{
+				Obj: &kueue.Workload{ObjectMeta: metav1.ObjectMeta{
 					Name:              "alpha",
 					CreationTimestamp: metav1.NewTime(now),
 				}},
@@ -1439,7 +1439,7 @@ func TestEntryOrdering(t *testing.T) {
 		},
 		{
 			Info: workload.Info{
-				Obj: &kueue.QueuedWorkload{ObjectMeta: metav1.ObjectMeta{
+				Obj: &kueue.Workload{ObjectMeta: metav1.ObjectMeta{
 					Name:              "beta",
 					CreationTimestamp: metav1.NewTime(now.Add(time.Second)),
 				}},
@@ -1447,7 +1447,7 @@ func TestEntryOrdering(t *testing.T) {
 		},
 		{
 			Info: workload.Info{
-				Obj: &kueue.QueuedWorkload{ObjectMeta: metav1.ObjectMeta{
+				Obj: &kueue.Workload{ObjectMeta: metav1.ObjectMeta{
 					Name:              "gamma",
 					CreationTimestamp: metav1.NewTime(now.Add(2 * time.Second)),
 				}},
@@ -1455,7 +1455,7 @@ func TestEntryOrdering(t *testing.T) {
 		},
 		{
 			Info: workload.Info{
-				Obj: &kueue.QueuedWorkload{ObjectMeta: metav1.ObjectMeta{
+				Obj: &kueue.Workload{ObjectMeta: metav1.ObjectMeta{
 					Name:              "delta",
 					CreationTimestamp: metav1.NewTime(now.Add(time.Second)),
 				}},
diff --git a/pkg/util/testing/wrappers.go b/pkg/util/testing/wrappers.go
index bf48e11d2..05e3f0e39 100644
--- a/pkg/util/testing/wrappers.go
+++ b/pkg/util/testing/wrappers.go
@@ -134,14 +134,14 @@ func (p *PriorityClassWrapper) Obj() *schedulingv1.PriorityClass {
 	return &p.PriorityClass
 }
 
-type QueuedWorkloadWrapper struct{ kueue.QueuedWorkload }
+type WorkloadWrapper struct{ kueue.Workload }
 
-// MakeQueuedWorkload creates a wrapper for a QueuedWorkload with a single
+// MakeWorkload creates a wrapper for a Workload with a single
 // pod with a single container.
-func MakeQueuedWorkload(name, ns string) *QueuedWorkloadWrapper {
-	return &QueuedWorkloadWrapper{kueue.QueuedWorkload{
+func MakeWorkload(name, ns string) *WorkloadWrapper {
+	return &WorkloadWrapper{kueue.Workload{
 		ObjectMeta: metav1.ObjectMeta{Name: name, Namespace: ns},
-		Spec: kueue.QueuedWorkloadSpec{
+		Spec: kueue.WorkloadSpec{
 			PodSets: []kueue.PodSet{
 				{
 					Name:  "main",
@@ -162,31 +162,31 @@ func MakeQueuedWorkload(name, ns string) *QueuedWorkloadWrapper {
 	}}
 }
 
-func (w *QueuedWorkloadWrapper) Obj() *kueue.QueuedWorkload {
-	return &w.QueuedWorkload
+func (w *WorkloadWrapper) Obj() *kueue.Workload {
+	return &w.Workload
 }
 
-func (w *QueuedWorkloadWrapper) Request(r corev1.ResourceName, q string) *QueuedWorkloadWrapper {
+func (w *WorkloadWrapper) Request(r corev1.ResourceName, q string) *WorkloadWrapper {
 	w.Spec.PodSets[0].Spec.Containers[0].Resources.Requests[r] = resource.MustParse(q)
 	return w
 }
 
-func (w *QueuedWorkloadWrapper) Queue(q string) *QueuedWorkloadWrapper {
+func (w *WorkloadWrapper) Queue(q string) *WorkloadWrapper {
 	w.Spec.QueueName = q
 	return w
 }
 
-func (w *QueuedWorkloadWrapper) Admit(a *kueue.Admission) *QueuedWorkloadWrapper {
+func (w *WorkloadWrapper) Admit(a *kueue.Admission) *WorkloadWrapper {
 	w.Spec.Admission = a
 	return w
 }
 
-func (w *QueuedWorkloadWrapper) Creation(t time.Time) *QueuedWorkloadWrapper {
+func (w *WorkloadWrapper) Creation(t time.Time) *WorkloadWrapper {
 	w.CreationTimestamp = metav1.NewTime(t)
 	return w
 }
 
-func (w *QueuedWorkloadWrapper) PriorityClass(priorityClassName string) *QueuedWorkloadWrapper {
+func (w *WorkloadWrapper) PriorityClass(priorityClassName string) *WorkloadWrapper {
 	w.Spec.PriorityClassName = priorityClassName
 	return w
 }
diff --git a/pkg/workload/workload_test.go b/pkg/workload/workload_test.go
index 4ede46da1..9b853263e 100644
--- a/pkg/workload/workload_test.go
+++ b/pkg/workload/workload_test.go
@@ -105,8 +105,8 @@ func TestPodRequests(t *testing.T) {
 }
 
 func TestNewInfo(t *testing.T) {
-	qw := &kueue.QueuedWorkload{
-		Spec: kueue.QueuedWorkloadSpec{
+	wl := &kueue.Workload{
+		Spec: kueue.WorkloadSpec{
 			PodSets: []kueue.PodSet{
 				{
 					Name: "driver",
@@ -144,7 +144,7 @@ func TestNewInfo(t *testing.T) {
 			},
 		},
 	}
-	info := NewInfo(qw)
+	info := NewInfo(wl)
 	wantRequests := []PodSetResources{
 		{
 			Name: "driver",
@@ -170,26 +170,26 @@ func TestNewInfo(t *testing.T) {
 	}
 }
 
-var ignoreConditionTimestamps = cmpopts.IgnoreFields(kueue.QueuedWorkloadCondition{}, "LastProbeTime", "LastTransitionTime")
+var ignoreConditionTimestamps = cmpopts.IgnoreFields(kueue.WorkloadCondition{}, "LastProbeTime", "LastTransitionTime")
 
 func TestUpdateWorkloadStatus(t *testing.T) {
 	cases := map[string]struct {
-		oldStatus  kueue.QueuedWorkloadStatus
-		condType   kueue.QueuedWorkloadConditionType
+		oldStatus  kueue.WorkloadStatus
+		condType   kueue.WorkloadConditionType
 		condStatus corev1.ConditionStatus
 		reason     string
 		message    string
-		wantStatus kueue.QueuedWorkloadStatus
+		wantStatus kueue.WorkloadStatus
 	}{
 		"initial empty": {
-			condType:   kueue.QueuedWorkloadAdmitted,
+			condType:   kueue.WorkloadAdmitted,
 			condStatus: corev1.ConditionFalse,
 			reason:     "Pending",
 			message:    "didn't fit",
-			wantStatus: kueue.QueuedWorkloadStatus{
-				Conditions: []kueue.QueuedWorkloadCondition{
+			wantStatus: kueue.WorkloadStatus{
+				Conditions: []kueue.WorkloadCondition{
 					{
-						Type:    kueue.QueuedWorkloadAdmitted,
+						Type:    kueue.WorkloadAdmitted,
 						Status:  corev1.ConditionFalse,
 						Reason:  "Pending",
 						Message: "didn't fit",
@@ -198,23 +198,23 @@ func TestUpdateWorkloadStatus(t *testing.T) {
 			},
 		},
 		"same condition type": {
-			oldStatus: kueue.QueuedWorkloadStatus{
-				Conditions: []kueue.QueuedWorkloadCondition{
+			oldStatus: kueue.WorkloadStatus{
+				Conditions: []kueue.WorkloadCondition{
 					{
-						Type:    kueue.QueuedWorkloadAdmitted,
+						Type:    kueue.WorkloadAdmitted,
 						Status:  corev1.ConditionFalse,
 						Reason:  "Pending",
 						Message: "didn't fit",
 					},
 				},
 			},
-			condType:   kueue.QueuedWorkloadAdmitted,
+			condType:   kueue.WorkloadAdmitted,
 			condStatus: corev1.ConditionTrue,
 			reason:     "Admitted",
-			wantStatus: kueue.QueuedWorkloadStatus{
-				Conditions: []kueue.QueuedWorkloadCondition{
+			wantStatus: kueue.WorkloadStatus{
+				Conditions: []kueue.WorkloadCondition{
 					{
-						Type:   kueue.QueuedWorkloadAdmitted,
+						Type:   kueue.WorkloadAdmitted,
 						Status: corev1.ConditionTrue,
 						Reason: "Admitted",
 					},
@@ -222,24 +222,24 @@ func TestUpdateWorkloadStatus(t *testing.T) {
 			},
 		},
 		"different condition type": {
-			oldStatus: kueue.QueuedWorkloadStatus{
-				Conditions: []kueue.QueuedWorkloadCondition{
+			oldStatus: kueue.WorkloadStatus{
+				Conditions: []kueue.WorkloadCondition{
 					{
-						Type:   kueue.QueuedWorkloadAdmitted,
+						Type:   kueue.WorkloadAdmitted,
 						Status: corev1.ConditionTrue,
 					},
 				},
 			},
-			condType:   kueue.QueuedWorkloadFinished,
+			condType:   kueue.WorkloadFinished,
 			condStatus: corev1.ConditionTrue,
-			wantStatus: kueue.QueuedWorkloadStatus{
-				Conditions: []kueue.QueuedWorkloadCondition{
+			wantStatus: kueue.WorkloadStatus{
+				Conditions: []kueue.WorkloadCondition{
 					{
-						Type:   kueue.QueuedWorkloadAdmitted,
+						Type:   kueue.WorkloadAdmitted,
 						Status: corev1.ConditionTrue,
 					},
 					{
-						Type:   kueue.QueuedWorkloadFinished,
+						Type:   kueue.WorkloadFinished,
 						Status: corev1.ConditionTrue,
 					},
 				},
@@ -252,7 +252,7 @@ func TestUpdateWorkloadStatus(t *testing.T) {
 			if err := kueue.AddToScheme(scheme); err != nil {
 				t.Fatalf("Failed to add kueue scheme: %v", err)
 			}
-			workload := utiltesting.MakeQueuedWorkload("foo", "bar").Obj()
+			workload := utiltesting.MakeWorkload("foo", "bar").Obj()
 			workload.Status = tc.oldStatus
 			cl := fake.NewClientBuilder().WithScheme(scheme).WithObjects(workload).Build()
 			ctx := context.Background()
@@ -260,11 +260,11 @@ func TestUpdateWorkloadStatus(t *testing.T) {
 			if err != nil {
 				t.Fatalf("Failed updating status: %v", err)
 			}
-			var updatedQW kueue.QueuedWorkload
-			if err := cl.Get(ctx, client.ObjectKeyFromObject(workload), &updatedQW); err != nil {
+			var updatedWl kueue.Workload
+			if err := cl.Get(ctx, client.ObjectKeyFromObject(workload), &updatedWl); err != nil {
 				t.Fatalf("Failed obtaining updated object: %v", err)
 			}
-			if diff := cmp.Diff(tc.wantStatus, updatedQW.Status, ignoreConditionTimestamps); diff != "" {
+			if diff := cmp.Diff(tc.wantStatus, updatedWl.Status, ignoreConditionTimestamps); diff != "" {
 				t.Errorf("Unexpected status after updating (-want,+got):\n%s", diff)
 			}
 		})
diff --git a/test/integration/controller/core/clusterqueue_controller_test.go b/test/integration/controller/core/clusterqueue_controller_test.go
index e39b60ca8..d0710facf 100644
--- a/test/integration/controller/core/clusterqueue_controller_test.go
+++ b/test/integration/controller/core/clusterqueue_controller_test.go
@@ -89,18 +89,18 @@ var _ = ginkgo.Describe("ClusterQueue controller", func() {
 	})
 
 	ginkgo.It("Should update status when workloads are assigned and finish", func() {
-		workloads := []*kueue.QueuedWorkload{
-			testing.MakeQueuedWorkload("one", ns.Name).Queue(queue.Name).
+		workloads := []*kueue.Workload{
+			testing.MakeWorkload("one", ns.Name).Queue(queue.Name).
 				Request(corev1.ResourceCPU, "2").Request(resourceGPU, "2").Obj(),
-			testing.MakeQueuedWorkload("two", ns.Name).Queue(queue.Name).
+			testing.MakeWorkload("two", ns.Name).Queue(queue.Name).
 				Request(corev1.ResourceCPU, "3").Request(resourceGPU, "3").Obj(),
-			testing.MakeQueuedWorkload("three", ns.Name).Queue(queue.Name).
+			testing.MakeWorkload("three", ns.Name).Queue(queue.Name).
 				Request(corev1.ResourceCPU, "1").Request(resourceGPU, "1").Obj(),
-			testing.MakeQueuedWorkload("four", ns.Name).Queue(queue.Name).
+			testing.MakeWorkload("four", ns.Name).Queue(queue.Name).
 				Request(corev1.ResourceCPU, "1").Request(resourceGPU, "1").Obj(),
-			testing.MakeQueuedWorkload("five", ns.Name).Queue("other").
+			testing.MakeWorkload("five", ns.Name).Queue("other").
 				Request(corev1.ResourceCPU, "1").Request(resourceGPU, "1").Obj(),
-			testing.MakeQueuedWorkload("six", ns.Name).Queue(queue.Name).
+			testing.MakeWorkload("six", ns.Name).Queue(queue.Name).
 				Request(corev1.ResourceCPU, "1").Request(resourceGPU, "1").Obj(),
 		}
 
@@ -133,7 +133,7 @@ var _ = ginkgo.Describe("ClusterQueue controller", func() {
 		}
 		for i, w := range workloads {
 			gomega.Eventually(func() error {
-				var newWL kueue.QueuedWorkload
+				var newWL kueue.Workload
 				gomega.Expect(k8sClient.Get(ctx, client.ObjectKeyFromObject(w), &newWL)).To(gomega.Succeed())
 				newWL.Spec.Admission = admissions[i]
 				return k8sClient.Update(ctx, &newWL)
@@ -170,10 +170,10 @@ var _ = ginkgo.Describe("ClusterQueue controller", func() {
 		ginkgo.By("Finishing workloads")
 		for _, w := range workloads {
 			gomega.Eventually(func() error {
-				var newWL kueue.QueuedWorkload
+				var newWL kueue.Workload
 				gomega.Expect(k8sClient.Get(ctx, client.ObjectKeyFromObject(w), &newWL)).To(gomega.Succeed())
-				newWL.Status.Conditions = append(newWL.Status.Conditions, kueue.QueuedWorkloadCondition{
-					Type:   kueue.QueuedWorkloadFinished,
+				newWL.Status.Conditions = append(newWL.Status.Conditions, kueue.WorkloadCondition{
+					Type:   kueue.WorkloadFinished,
 					Status: corev1.ConditionTrue,
 				})
 				return k8sClient.Status().Update(ctx, &newWL)
diff --git a/test/integration/controller/core/queue_controller_test.go b/test/integration/controller/core/queue_controller_test.go
index 270020a76..830dc5395 100644
--- a/test/integration/controller/core/queue_controller_test.go
+++ b/test/integration/controller/core/queue_controller_test.go
@@ -61,14 +61,14 @@ var _ = ginkgo.Describe("Queue controller", func() {
 	})
 
 	ginkgo.It("Should update status when workloads are created", func() {
-		workloads := []*kueue.QueuedWorkload{
-			testing.MakeQueuedWorkload("one", ns.Name).
+		workloads := []*kueue.Workload{
+			testing.MakeWorkload("one", ns.Name).
 				Queue(queue.Name).
 				Request(corev1.ResourceCPU, "2").Obj(),
-			testing.MakeQueuedWorkload("two", ns.Name).
+			testing.MakeWorkload("two", ns.Name).
 				Queue(queue.Name).
 				Request(corev1.ResourceCPU, "3").Obj(),
-			testing.MakeQueuedWorkload("three", ns.Name).
+			testing.MakeWorkload("three", ns.Name).
 				Queue(queue.Name).
 				Request(corev1.ResourceCPU, "1").Obj(),
 		}
@@ -86,7 +86,7 @@ var _ = ginkgo.Describe("Queue controller", func() {
 		ginkgo.By("Admitting workloads")
 		for _, w := range workloads {
 			gomega.Eventually(func() error {
-				var newWL kueue.QueuedWorkload
+				var newWL kueue.Workload
 				gomega.Expect(k8sClient.Get(ctx, client.ObjectKeyFromObject(w), &newWL)).To(gomega.Succeed())
 				newWL.Spec.Admission = testing.MakeAdmission(clusterQueue.Name).
 					Flavor(corev1.ResourceCPU, flavorOnDemand).Obj()
@@ -102,10 +102,10 @@ var _ = ginkgo.Describe("Queue controller", func() {
 		ginkgo.By("Finishing workloads")
 		for _, w := range workloads {
 			gomega.Eventually(func() error {
-				var newWL kueue.QueuedWorkload
+				var newWL kueue.Workload
 				gomega.Expect(k8sClient.Get(ctx, client.ObjectKeyFromObject(w), &newWL)).To(gomega.Succeed())
-				newWL.Status.Conditions = append(w.Status.Conditions, kueue.QueuedWorkloadCondition{
-					Type:   kueue.QueuedWorkloadFinished,
+				newWL.Status.Conditions = append(w.Status.Conditions, kueue.WorkloadCondition{
+					Type:   kueue.WorkloadFinished,
 					Status: corev1.ConditionTrue,
 				})
 				return k8sClient.Status().Update(ctx, &newWL)
diff --git a/test/integration/controller/core/queuedworkload_controller_test.go b/test/integration/controller/core/workload_controller_test.go
similarity index 83%
rename from test/integration/controller/core/queuedworkload_controller_test.go
rename to test/integration/controller/core/workload_controller_test.go
index 071a660e6..9b0460172 100644
--- a/test/integration/controller/core/queuedworkload_controller_test.go
+++ b/test/integration/controller/core/workload_controller_test.go
@@ -32,19 +32,19 @@ import (
 
 // +kubebuilder:docs-gen:collapse=Imports
 
-var _ = ginkgo.Describe("QueuedWorkload controller", func() {
+var _ = ginkgo.Describe("Workload controller", func() {
 	var (
 		ns                   *corev1.Namespace
-		updatedQueueWorkload kueue.QueuedWorkload
+		updatedQueueWorkload kueue.Workload
 		queue                *kueue.Queue
-		wl                   *kueue.QueuedWorkload
+		wl                   *kueue.Workload
 		message              string
 	)
 
 	ginkgo.BeforeEach(func() {
 		ns = &corev1.Namespace{
 			ObjectMeta: metav1.ObjectMeta{
-				GenerateName: "core-queuedworkload-",
+				GenerateName: "core-workload-",
 			},
 		}
 		gomega.Expect(k8sClient.Create(ctx, ns)).To(gomega.Succeed())
@@ -52,11 +52,11 @@ var _ = ginkgo.Describe("QueuedWorkload controller", func() {
 
 	ginkgo.When("the queue is not defined in the workload", func() {
 		ginkgo.AfterEach(func() {
-			updatedQueueWorkload = kueue.QueuedWorkload{}
+			updatedQueueWorkload = kueue.Workload{}
 			gomega.Expect(framework.DeleteNamespace(ctx, k8sClient, ns)).To(gomega.Succeed())
 		})
 		ginkgo.It("Should update status when workloads are created", func() {
-			wl = testing.MakeQueuedWorkload("one", ns.Name).Request(corev1.ResourceCPU, "1").Obj()
+			wl = testing.MakeWorkload("one", ns.Name).Request(corev1.ResourceCPU, "1").Obj()
 			message = fmt.Sprintf("Queue %s doesn't exist", "")
 			gomega.Expect(k8sClient.Create(ctx, wl)).To(gomega.Succeed())
 			gomega.Eventually(func() int {
@@ -69,11 +69,11 @@ var _ = ginkgo.Describe("QueuedWorkload controller", func() {
 
 	ginkgo.When("the queue doesn't exist", func() {
 		ginkgo.AfterEach(func() {
-			updatedQueueWorkload = kueue.QueuedWorkload{}
+			updatedQueueWorkload = kueue.Workload{}
 			gomega.Expect(framework.DeleteNamespace(ctx, k8sClient, ns)).To(gomega.Succeed())
 		})
 		ginkgo.It("Should update status when workloads are created", func() {
-			wl = testing.MakeQueuedWorkload("two", ns.Name).Queue("nonCreatedQueue").Request(corev1.ResourceCPU, "1").Obj()
+			wl = testing.MakeWorkload("two", ns.Name).Queue("nonCreatedQueue").Request(corev1.ResourceCPU, "1").Obj()
 			message = fmt.Sprintf("Queue %s doesn't exist", "nonCreatedQueue")
 			gomega.Expect(k8sClient.Create(ctx, wl)).To(gomega.Succeed())
 			gomega.Eventually(func() int {
@@ -92,13 +92,13 @@ var _ = ginkgo.Describe("QueuedWorkload controller", func() {
 		ginkgo.AfterEach(func() {
 			gomega.Expect(framework.DeleteQueue(ctx, k8sClient, queue)).To(gomega.Succeed())
 			gomega.Expect(framework.DeleteNamespace(ctx, k8sClient, ns)).To(gomega.Succeed())
-			updatedQueueWorkload = kueue.QueuedWorkload{}
+			updatedQueueWorkload = kueue.Workload{}
 		})
 		ginkgo.It("Should update status when workloads are created", func() {
-			wl = testing.MakeQueuedWorkload("three", ns.Name).Queue(queue.Name).Request(corev1.ResourceCPU, "1").Obj()
+			wl = testing.MakeWorkload("three", ns.Name).Queue(queue.Name).Request(corev1.ResourceCPU, "1").Obj()
 			message = fmt.Sprintf("ClusterQueue %s doesn't exist", "fooclusterqueue")
 			gomega.Expect(k8sClient.Create(ctx, wl)).To(gomega.Succeed())
-			gomega.Eventually(func() []kueue.QueuedWorkloadCondition {
+			gomega.Eventually(func() []kueue.WorkloadCondition {
 				gomega.Expect(k8sClient.Get(ctx, client.ObjectKeyFromObject(wl), &updatedQueueWorkload)).To(gomega.Succeed())
 				return updatedQueueWorkload.Status.Conditions
 			}, framework.Timeout, framework.Interval).ShouldNot(gomega.BeNil())
diff --git a/test/integration/controller/job/job_controller_test.go b/test/integration/controller/job/job_controller_test.go
index 44131c4f4..5fc7db083 100644
--- a/test/integration/controller/job/job_controller_test.go
+++ b/test/integration/controller/job/job_controller_test.go
@@ -66,13 +66,13 @@ var _ = ginkgo.Describe("Job controller", func() {
 		}, framework.Timeout, framework.Interval).Should(gomega.BeTrue())
 
 		ginkgo.By("checking the workload is created without queue assigned")
-		createdWorkload := &kueue.QueuedWorkload{}
+		createdWorkload := &kueue.Workload{}
 		gomega.Eventually(func() bool {
 			err := k8sClient.Get(ctx, lookupKey, createdWorkload)
 			return err == nil
 		}, framework.Timeout, framework.Interval).Should(gomega.BeTrue())
-		gomega.Expect(createdWorkload.Spec.QueueName).Should(gomega.Equal(""), "The QueuedWorkload shouldn't have .spec.queueName set")
-		gomega.Expect(metav1.IsControlledBy(createdWorkload, job)).To(gomega.BeTrue(), "The QueuedWorkload should be owned by the Job")
+		gomega.Expect(createdWorkload.Spec.QueueName).Should(gomega.Equal(""), "The Workload shouldn't have .spec.queueName set")
+		gomega.Expect(metav1.IsControlledBy(createdWorkload, job)).To(gomega.BeTrue(), "The Workload should be owned by the Job")
 
 		ginkgo.By("checking the workload is created with priority and priorityName")
 		gomega.Expect(createdWorkload.Spec.PriorityClassName).Should(gomega.Equal(priorityClassName))
@@ -95,7 +95,7 @@ var _ = ginkgo.Describe("Job controller", func() {
 		secondWl.Spec.PodSets[0].Count = parallelism + 1
 		gomega.Expect(k8sClient.Create(ctx, secondWl)).Should(gomega.Succeed())
 		gomega.Eventually(func() bool {
-			wl := &kueue.QueuedWorkload{}
+			wl := &kueue.Workload{}
 			key := types.NamespacedName{Name: secondWl.Name, Namespace: secondWl.Namespace}
 			if err := k8sClient.Get(ctx, key, wl); err != nil && apierrors.IsNotFound(err) {
 				return true
@@ -108,7 +108,7 @@ var _ = ginkgo.Describe("Job controller", func() {
 			return err == nil
 		}, framework.ConsistentDuration, framework.Interval).Should(gomega.BeTrue())
 		gomega.Eventually(func() bool {
-			ok, _ := testing.CheckLatestEvent(ctx, k8sClient, "DeletedQueuedWorkload", corev1.EventTypeNormal, fmt.Sprintf("Deleted not matching QueuedWorkload: %v", workload.Key(secondWl)))
+			ok, _ := testing.CheckLatestEvent(ctx, k8sClient, "DeletedWorkload", corev1.EventTypeNormal, fmt.Sprintf("Deleted not matching Workload: %v", workload.Key(secondWl)))
 			return ok
 		}, framework.Timeout, framework.Interval).Should(gomega.BeTrue())
 
@@ -163,7 +163,7 @@ var _ = ginkgo.Describe("Job controller", func() {
 				len(createdJob.Spec.Template.Spec.NodeSelector) == 0
 		}, framework.Timeout, framework.Interval).Should(gomega.BeTrue())
 		gomega.Eventually(func() bool {
-			ok, _ := testing.CheckLatestEvent(ctx, k8sClient, "DeletedQueuedWorkload", corev1.EventTypeNormal, fmt.Sprintf("Deleted not matching QueuedWorkload: %v", jobKey))
+			ok, _ := testing.CheckLatestEvent(ctx, k8sClient, "DeletedWorkload", corev1.EventTypeNormal, fmt.Sprintf("Deleted not matching Workload: %v", jobKey))
 			return ok
 		}, framework.Timeout, framework.Interval).Should(gomega.BeTrue())
 
@@ -216,7 +216,7 @@ var _ = ginkgo.Describe("Job controller", func() {
 				return false
 			}
 
-			return createdWorkload.Status.Conditions[0].Type == kueue.QueuedWorkloadFinished &&
+			return createdWorkload.Status.Conditions[0].Type == kueue.WorkloadFinished &&
 				createdWorkload.Status.Conditions[0].Status == corev1.ConditionTrue
 		}, framework.Timeout, framework.Interval).Should(gomega.BeTrue())
 	})
diff --git a/test/integration/framework/framework.go b/test/integration/framework/framework.go
index 9ed780796..54ee52686 100644
--- a/test/integration/framework/framework.go
+++ b/test/integration/framework/framework.go
@@ -125,7 +125,7 @@ func DeleteNamespace(ctx context.Context, c client.Client, ns *corev1.Namespace)
 	if err := c.DeleteAllOf(ctx, &kueue.Queue{}, client.InNamespace(ns.Name)); err != nil && !apierrors.IsNotFound(err) {
 		return err
 	}
-	if err := c.DeleteAllOf(ctx, &kueue.QueuedWorkload{}, client.InNamespace(ns.Name)); err != nil && !apierrors.IsNotFound(err) {
+	if err := c.DeleteAllOf(ctx, &kueue.Workload{}, client.InNamespace(ns.Name)); err != nil && !apierrors.IsNotFound(err) {
 		return err
 	}
 	if err := c.Delete(ctx, ns); err != nil && !apierrors.IsNotFound(err) {
@@ -134,10 +134,10 @@ func DeleteNamespace(ctx context.Context, c client.Client, ns *corev1.Namespace)
 	return nil
 }
 
-func ExpectWorkloadsToBeAdmitted(ctx context.Context, k8sClient client.Client, cqName string, wls ...*kueue.QueuedWorkload) {
+func ExpectWorkloadsToBeAdmitted(ctx context.Context, k8sClient client.Client, cqName string, wls ...*kueue.Workload) {
 	gomega.EventuallyWithOffset(1, func() int {
 		admitted := 0
-		var updatedWorkload kueue.QueuedWorkload
+		var updatedWorkload kueue.Workload
 		for _, wl := range wls {
 			gomega.ExpectWithOffset(1, k8sClient.Get(ctx, client.ObjectKeyFromObject(wl), &updatedWorkload)).To(gomega.Succeed())
 			if updatedWorkload.Spec.Admission != nil && string(updatedWorkload.Spec.Admission.ClusterQueue) == cqName {
@@ -148,13 +148,13 @@ func ExpectWorkloadsToBeAdmitted(ctx context.Context, k8sClient client.Client, c
 	}).Should(gomega.Equal(len(wls)), "Not enough workloads were admitted")
 }
 
-func ExpectWorkloadsToBePending(ctx context.Context, k8sClient client.Client, wls ...*kueue.QueuedWorkload) {
+func ExpectWorkloadsToBePending(ctx context.Context, k8sClient client.Client, wls ...*kueue.Workload) {
 	gomega.EventuallyWithOffset(1, func() int {
 		pending := 0
-		var updatedWorkload kueue.QueuedWorkload
+		var updatedWorkload kueue.Workload
 		for _, wl := range wls {
 			gomega.ExpectWithOffset(1, k8sClient.Get(ctx, client.ObjectKeyFromObject(wl), &updatedWorkload)).To(gomega.Succeed())
-			idx := workload.FindConditionIndex(&updatedWorkload.Status, kueue.QueuedWorkloadAdmitted)
+			idx := workload.FindConditionIndex(&updatedWorkload.Status, kueue.WorkloadAdmitted)
 			if idx == -1 {
 				continue
 			}
@@ -167,9 +167,9 @@ func ExpectWorkloadsToBePending(ctx context.Context, k8sClient client.Client, wl
 	}).Should(gomega.Equal(len(wls)), "Not enough workloads are pending")
 }
 
-func UpdateWorkloadStatus(ctx context.Context, k8sClient client.Client, wl *kueue.QueuedWorkload, update func(*kueue.QueuedWorkload)) {
+func UpdateWorkloadStatus(ctx context.Context, k8sClient client.Client, wl *kueue.Workload, update func(*kueue.Workload)) {
 	gomega.EventuallyWithOffset(1, func() error {
-		var updatedWl kueue.QueuedWorkload
+		var updatedWl kueue.Workload
 		gomega.ExpectWithOffset(1, k8sClient.Get(ctx, client.ObjectKeyFromObject(wl), &updatedWl)).To(gomega.Succeed())
 		update(&updatedWl)
 		return k8sClient.Status().Update(ctx, &updatedWl)
diff --git a/test/integration/scheduler/scheduler_test.go b/test/integration/scheduler/scheduler_test.go
index 4ca51d644..bf555af2b 100644
--- a/test/integration/scheduler/scheduler_test.go
+++ b/test/integration/scheduler/scheduler_test.go
@@ -332,7 +332,7 @@ var _ = ginkgo.Describe("Scheduler", func() {
 		gomega.Expect(k8sClient.Create(ctx, jobHighPriority)).Should(gomega.Succeed())
 
 		ginkgo.By("checking that workload1 is created with priority and priorityName")
-		createdLowPriorityWorkload := &kueue.QueuedWorkload{}
+		createdLowPriorityWorkload := &kueue.Workload{}
 		gomega.Eventually(func() bool {
 			lookupKey := types.NamespacedName{Name: jobLowPriority.Name, Namespace: jobLowPriority.Namespace}
 			err := k8sClient.Get(ctx, lookupKey, createdLowPriorityWorkload)
@@ -342,7 +342,7 @@ var _ = ginkgo.Describe("Scheduler", func() {
 		gomega.Expect(*createdLowPriorityWorkload.Spec.Priority).Should(gomega.Equal(lowPriorityClass.Value))
 
 		ginkgo.By("checking that workload2 is created with priority and priorityName")
-		createdHighPriorityWorkload := &kueue.QueuedWorkload{}
+		createdHighPriorityWorkload := &kueue.Workload{}
 		gomega.Eventually(func() bool {
 			lookupKey := types.NamespacedName{Name: jobHighPriority.Name, Namespace: jobHighPriority.Namespace}
 			err := k8sClient.Get(ctx, lookupKey, createdHighPriorityWorkload)
@@ -404,7 +404,7 @@ var _ = ginkgo.Describe("Scheduler", func() {
 		gomega.Expect(k8sClient.Delete(ctx, job1)).Should(gomega.Succeed())
 		// Simulated deletion of workload by ownerReference of job1.
 		gomega.Expect(k8sClient.Delete(ctx,
-			&kueue.QueuedWorkload{ObjectMeta: metav1.ObjectMeta{
+			&kueue.Workload{ObjectMeta: metav1.ObjectMeta{
 				Name:      job1.Name,
 				Namespace: job1.Namespace,
 			}})).Should(gomega.Succeed())
@@ -452,7 +452,7 @@ var _ = ginkgo.Describe("Scheduler", func() {
 		gomega.Expect(k8sClient.Delete(ctx, job1, client.GracePeriodSeconds(-1))).Should(gomega.Succeed())
 		// Simulated deletion of workload by ownerReference of job1.
 		gomega.Expect(k8sClient.Delete(ctx,
-			&kueue.QueuedWorkload{ObjectMeta: metav1.ObjectMeta{
+			&kueue.Workload{ObjectMeta: metav1.ObjectMeta{
 				Name:      job1.Name,
 				Namespace: job1.Namespace,
 			}})).Should(gomega.Succeed())
@@ -514,14 +514,14 @@ var _ = ginkgo.Describe("Scheduler", func() {
 	})
 
 	ginkgo.It("Should admit two small workloads after a big one finishes", func() {
-		bigWl := testing.MakeQueuedWorkload("big-wl", ns.Name).Queue(prodQueue.Name).Request(corev1.ResourceCPU, "5").Obj()
+		bigWl := testing.MakeWorkload("big-wl", ns.Name).Queue(prodQueue.Name).Request(corev1.ResourceCPU, "5").Obj()
 		ginkgo.By("Creating big workload")
 		gomega.Expect(k8sClient.Create(ctx, bigWl)).Should(gomega.Succeed())
 
 		framework.ExpectWorkloadsToBeAdmitted(ctx, k8sClient, prodClusterQ.Name, bigWl)
 
-		smallWl1 := testing.MakeQueuedWorkload("small-wl-1", ns.Name).Queue(prodQueue.Name).Request(corev1.ResourceCPU, "2.5").Obj()
-		smallWl2 := testing.MakeQueuedWorkload("small-wl-2", ns.Name).Queue(prodQueue.Name).Request(corev1.ResourceCPU, "2.5").Obj()
+		smallWl1 := testing.MakeWorkload("small-wl-1", ns.Name).Queue(prodQueue.Name).Request(corev1.ResourceCPU, "2.5").Obj()
+		smallWl2 := testing.MakeWorkload("small-wl-2", ns.Name).Queue(prodQueue.Name).Request(corev1.ResourceCPU, "2.5").Obj()
 		ginkgo.By("Creating two small workloads")
 		gomega.Expect(k8sClient.Create(ctx, smallWl1)).Should(gomega.Succeed())
 		gomega.Expect(k8sClient.Create(ctx, smallWl2)).Should(gomega.Succeed())
@@ -529,9 +529,9 @@ var _ = ginkgo.Describe("Scheduler", func() {
 		framework.ExpectWorkloadsToBePending(ctx, k8sClient, smallWl1, smallWl2)
 
 		ginkgo.By("Marking the big workload as finished")
-		framework.UpdateWorkloadStatus(ctx, k8sClient, bigWl, func(wl *kueue.QueuedWorkload) {
-			wl.Status.Conditions = append(wl.Status.Conditions, kueue.QueuedWorkloadCondition{
-				Type:   kueue.QueuedWorkloadFinished,
+		framework.UpdateWorkloadStatus(ctx, k8sClient, bigWl, func(wl *kueue.Workload) {
+			wl.Status.Conditions = append(wl.Status.Conditions, kueue.WorkloadCondition{
+				Type:   kueue.WorkloadFinished,
 				Status: corev1.ConditionTrue,
 			})
 		})