Repository: kubernetes-sigs/kueue

Issue:
Flaky test: LeaderWorkerSet integration when LeaderWorkerSet created should admit group with leader only
kind/flake

**What happened**:

test failed on unrelated branch: https://prow.k8s.io/view/gs/kubernetes-ci-logs/pr-logs/pull/kubernetes-sigs_kueue/4591/pull-kueue-test-e2e-main-1-29/1900594986903146496

**What you expected to happen**:

no failures

**How to reproduce it (as minimally and precisely as possible)**:

ci

**Anything else we need to know?**:

```
End To End Suite: kindest/node:v1.29.4: [It] LeaderWorkerSet integration when LeaderWorkerSet created should admit group with leader only expand_less	55s
{Timed out after 45.061s.
The function passed to Eventually failed at /home/prow/go/src/sigs.k8s.io/kueue/test/e2e/singlecluster/leaderworkerset_test.go:135 with:
Expected
    <[]v1.Pod | len:1, cap:1>: [
        {
            TypeMeta: {Kind: "", APIVersion: ""},
            ObjectMeta: {
                Name: "lws-0",
                GenerateName: "lws-",
                Namespace: "lws-e2e-gk29d",
                SelfLink: "",
                UID: "4148fde2-6141-4052-a4a5-55b40af71bb0",
                ResourceVersion: "3874",
                Generation: 0,
                CreationTimestamp: {
                    Time: 2025-03-14T17:22:10Z,
                },
                DeletionTimestamp: {
                    Time: 2025-03-14T17:22:42Z,
                },
                DeletionGracePeriodSeconds: 30,
                Labels: {
                    "kueue.x-k8s.io/queue-name": "lws-lq",
                    "leaderworkerset.sigs.k8s.io/name": "lws",
                    "leaderworkerset.sigs.k8s.io/template-revision-hash": "68c67c6876",
                    "kueue.x-k8s.io/podset": "main",
                    "kueue.x-k8s.io/prebuilt-workload-name": "leaderworkerset-lws-0-49423",
                    "leaderworkerset.sigs.k8s.io/group-index": "0",
                    "leaderworkerset.sigs.k8s.io/group-key": "3e238779391c8fd563d42eb5af19391bdcd7c130",
                    "leaderworkerset.sigs.k8s.io/worker-index": "0",
                    "statefulset.kubernetes.io/pod-name": "lws-0",
                    "apps.kubernetes.io/pod-index": "0",
                    "controller-revision-hash": "lws-86cf6f578b",
                    "kueue.x-k8s.io/managed": "true",
                    "kueue.x-k8s.io/pod-group-name": "leaderworkerset-lws-0-49423",
                },
                Annotations: {
                    "leaderworkerset.sigs.k8s.io/size": "1",
                    "kueue.x-k8s.io/pod-group-serving": "true",
                    "kueue.x-k8s.io/pod-group-total-count": "1",
                    "kueue.x-k8s.io/pod-suspending-parent": "leaderworkerset.x-k8s.io/leaderworkerset",
                    "kueue.x-k8s.io/role-hash": "main",
                    "kueue.x-k8s.io/workload": "leaderworkerset-lws-0-49423",
                },
                OwnerReferences: [
                    {
                        APIVersion: "apps/v1",
                        Kind: "StatefulSet",
                        Name: "lws",
                        UID: "bf05a26b-fc96-4867-943b-98d4889e8421",
                        Controller: true,
                        BlockOwnerDeletion: true,
                    },
                ],
                Finalizers: [
                    "kueue.x-k8s.io/managed",
                ],
                ManagedFields: [
                    {
                        Manager: "kube-controller-manager",
                        Operation: "Update",
                        APIVersion: "v1",
                        Time: {
                            Time: 2025-03-14T17:22:10Z,
                        },
                        FieldsType: "FieldsV1",
                        FieldsV1: {
                            Raw: "{\"f:metadata\":{\"f:annotations\":{\".\":{},\"f:kueue.x-k8s.io/pod-group-serving\":{},\"f:kueue.x-k8s.io/pod-suspending-parent\":{},\"f:leaderworkerset.sigs.k8s.io/size\":{}},\"f:generateName\":{},\"f:labels\":{\".\":{},\"f:apps.kubernetes.io/pod-index\":{},\"f:controller-revision-hash\":{},\"f:leaderworkerset.sigs.k8s.io/name\":{},\"f:leaderworkerset.sigs.k8s.io/template-revision-hash\":{},\"f:leaderworkerset.sigs.k8s.io/worker-index\":{},\"f:statefulset.kubernetes.io/pod-name\":{}},\"f:ownerReferences\":{\".\":{},\"k:{\\\"uid\\\":\\\"bf05a26b-fc96-4867-943b-98d4889e8421\\\"}\":{}}},\"f:spec\":{\"f:containers\":{\"k:{\\\"name\\\":\\\"c\\\"}\":{\".\":{},\"f:args\":{},\"f:image\":{},\"f:imagePullPolicy\":{},\"f:name\":{},\"f:resources\":{\".\":{},\"f:requests\":{\".\":{},\"f:cpu\":{}}},\"f:terminationMessagePath\":{},\"f:terminationMessagePolicy\":{}}},\"f:dnsPolicy\":{},\"f:enableServiceLinks\":{},\"f:hostname\":{},\"f:restartPolicy\":{},\"f:schedulerName\":{},\"f:securityContext\":{},\"f:subdomai...

Gomega truncated this representation as it exceeds 'format.MaxLength'.
Consider having the object provide a custom 'GomegaStringer' representation
or adjust the parameters in Gomega's 'format' package.

Learn more here: https://onsi.github.io/gomega/#adjusting-output

to be empty failed [FAILED] Timed out after 45.061s.
The function passed to Eventually failed at /home/prow/go/src/sigs.k8s.io/kueue/test/e2e/singlecluster/leaderworkerset_test.go:135 with:
Expected
    <[]v1.Pod | len:1, cap:1>: [
        {
            TypeMeta: {Kind: "", APIVersion: ""},
            ObjectMeta: {
                Name: "lws-0",
                GenerateName: "lws-",
                Namespace: "lws-e2e-gk29d",
                SelfLink: "",
                UID: "4148fde2-6141-4052-a4a5-55b40af71bb0",
                ResourceVersion: "3874",
                Generation: 0,
                CreationTimestamp: {
                    Time: 2025-03-14T17:22:10Z,
                },
                DeletionTimestamp: {
                    Time: 2025-03-14T17:22:42Z,
                },
                DeletionGracePeriodSeconds: 30,
                Labels: {
                    "kueue.x-k8s.io/queue-name": "lws-lq",
                    "leaderworkerset.sigs.k8s.io/name": "lws",
                    "leaderworkerset.sigs.k8s.io/template-revision-hash": "68c67c6876",
                    "kueue.x-k8s.io/podset": "main",
                    "kueue.x-k8s.io/prebuilt-workload-name": "leaderworkerset-lws-0-49423",
                    "leaderworkerset.sigs.k8s.io/group-index": "0",
                    "leaderworkerset.sigs.k8s.io/group-key": "3e238779391c8fd563d42eb5af19391bdcd7c130",
                    "leaderworkerset.sigs.k8s.io/worker-index": "0",
                    "statefulset.kubernetes.io/pod-name": "lws-0",
                    "apps.kubernetes.io/pod-index": "0",
                    "controller-revision-hash": "lws-86cf6f578b",
                    "kueue.x-k8s.io/managed": "true",
                    "kueue.x-k8s.io/pod-group-name": "leaderworkerset-lws-0-49423",
                },
                Annotations: {
                    "leaderworkerset.sigs.k8s.io/size": "1",
                    "kueue.x-k8s.io/pod-group-serving": "true",
                    "kueue.x-k8s.io/pod-group-total-count": "1",
                    "kueue.x-k8s.io/pod-suspending-parent": "leaderworkerset.x-k8s.io/leaderworkerset",
                    "kueue.x-k8s.io/role-hash": "main",
                    "kueue.x-k8s.io/workload": "leaderworkerset-lws-0-49423",
                },
                OwnerReferences: [
                    {
                        APIVersion: "apps/v1",
                        Kind: "StatefulSet",
                        Name: "lws",
                        UID: "bf05a26b-fc96-4867-943b-98d4889e8421",
                        Controller: true,
                        BlockOwnerDeletion: true,
                    },
                ],
                Finalizers: [
                    "kueue.x-k8s.io/managed",
                ],
                ManagedFields: [
                    {
                        Manager: "kube-controller-manager",
                        Operation: "Update",
                        APIVersion: "v1",
                        Time: {
                            Time: 2025-03-14T17:22:10Z,
                        },
                        FieldsType: "FieldsV1",
                        FieldsV1: {
                            Raw: "{\"f:metadata\":{\"f:annotations\":{\".\":{},\"f:kueue.x-k8s.io/pod-group-serving\":{},\"f:kueue.x-k8s.io/pod-suspending-parent\":{},\"f:leaderworkerset.sigs.k8s.io/size\":{}},\"f:generateName\":{},\"f:labels\":{\".\":{},\"f:apps.kubernetes.io/pod-index\":{},\"f:controller-revision-hash\":{},\"f:leaderworkerset.sigs.k8s.io/name\":{},\"f:leaderworkerset.sigs.k8s.io/template-revision-hash\":{},\"f:leaderworkerset.sigs.k8s.io/worker-index\":{},\"f:statefulset.kubernetes.io/pod-name\":{}},\"f:ownerReferences\":{\".\":{},\"k:{\\\"uid\\\":\\\"bf05a26b-fc96-4867-943b-98d4889e8421\\\"}\":{}}},\"f:spec\":{\"f:containers\":{\"k:{\\\"name\\\":\\\"c\\\"}\":{\".\":{},\"f:args\":{},\"f:image\":{},\"f:imagePullPolicy\":{},\"f:name\":{},\"f:resources\":{\".\":{},\"f:requests\":{\".\":{},\"f:cpu\":{}}},\"f:terminationMessagePath\":{},\"f:terminationMessagePolicy\":{}}},\"f:dnsPolicy\":{},\"f:enableServiceLinks\":{},\"f:hostname\":{},\"f:restartPolicy\":{},\"f:schedulerName\":{},\"f:securityContext\":{},\"f:subdomai...

Gomega truncated this representation as it exceeds 'format.MaxLength'.
Consider having the object provide a custom 'GomegaStringer' representation
or adjust the parameters in Gomega's 'format' package.

Learn more here: https://onsi.github.io/gomega/#adjusting-output

to be empty
In [It] at: /home/prow/go/src/sigs.k8s.io/kueue/test/e2e/singlecluster/leaderworkerset_test.go:136 @ 03/14/25 17:22:57.07
}
```

Hints from issue comments:
@k8s-triage-robot: The Kubernetes project currently lacks enough contributors to adequately respond to all issues.

This bot triages un-triaged issues according to the following rules:
- After 90d of inactivity, `lifecycle/stale` is applied
- After 30d of inactivity since `lifecycle/stale` was applied, `lifecycle/rotten` is applied
- After 30d of inactivity since `lifecycle/rotten` was applied, the issue is closed

You can:
- Mark this issue as fresh with `/remove-lifecycle stale`
- Close this issue with `/close`
- Offer to help out with [Issue Triage][1]

Please send feedback to sig-contributor-experience at [kubernetes/community](https://github.com/kubernetes/community).

/lifecycle stale

[1]: https://www.kubernetes.dev/docs/guide/issue-triage/@mbobrovskyi: /kind flake@k8s-triage-robot: The Kubernetes project currently lacks enough active contributors to adequately respond to all issues.

This bot triages un-triaged issues according to the following rules:
- After 90d of inactivity, `lifecycle/stale` is applied
- After 30d of inactivity since `lifecycle/stale` was applied, `lifecycle/rotten` is applied
- After 30d of inactivity since `lifecycle/rotten` was applied, the issue is closed

You can:
- Mark this issue as fresh with `/remove-lifecycle rotten`
- Close this issue with `/close`
- Offer to help out with [Issue Triage][1]

Please send feedback to sig-contributor-experience at [kubernetes/community](https://github.com/kubernetes/community).

/lifecycle rotten

[1]: https://www.kubernetes.dev/docs/guide/issue-triage/@mimowo: /close
This is likely already fixed (there were many LWS fixes + more resources for e2e tests for CI), let's reopen if it re-occurs.@k8s-ci-robot: @mimowo: Closing this issue.

<details>

In response to [this](https://github.com/kubernetes-sigs/kueue/issues/4623#issuecomment-3163084683):

>/close
>This is likely already fixed (there were many LWS fixes + more resources for e2e tests for CI), let's reopen if it re-occurs.


Instructions for interacting with me using PR comments are available [here](https://git.k8s.io/community/contributors/guide/pull-requests.md).  If you have questions or suggestions related to my behavior, please file an issue against the [kubernetes-sigs/prow](https://github.com/kubernetes-sigs/prow/issues/new?title=Prow%20issue:) repository.
</details>@mimowo: Note that it was reported before https://github.com/kubernetes/test-infra/commit/5d436c9eee155b6db46b2dd291dab0742b2e4863

Solution patch:
diff --git a/Makefile-test.mk b/Makefile-test.mk
index 77679b5a1..8d725b5b9 100644
--- a/Makefile-test.mk
+++ b/Makefile-test.mk
@@ -34,6 +34,8 @@ LD_FLAGS += -X '$(version_pkg).GitCommit=$(shell git rev-parse HEAD)'
 # ENVTEST_K8S_VERSION refers to the version of kubebuilder assets to be downloaded by envtest binary.
 ENVTEST_K8S_VERSION ?= 1.32
 
+TEST_LOG_LEVEL ?= -3
+
 # Number of processes to use during integration tests to run specs within a
 # suite in parallel. Suites still run sequentially. User may set this value to 1
 # to run without parallelism.
@@ -88,7 +90,7 @@ test-integration: gomod-download envtest ginkgo dep-crds kueuectl ginkgo-top ##
 	PROJECT_DIR=$(PROJECT_DIR)/ \
 	KUEUE_BIN=$(PROJECT_DIR)/bin \
 	ENVTEST_K8S_VERSION=$(ENVTEST_K8S_VERSION) \
-	API_LOG_LEVEL=$(INTEGRATION_API_LOG_LEVEL) \
+	TEST_LOG_LEVEL=$(TEST_LOG_LEVEL) API_LOG_LEVEL=$(INTEGRATION_API_LOG_LEVEL) \
 	$(GINKGO) $(INTEGRATION_FILTERS) $(GINKGO_ARGS) $(GOFLAGS) -procs=$(INTEGRATION_NPROCS) --race --junit-report=junit.xml --json-report=integration.json --output-dir=$(ARTIFACTS) -v $(INTEGRATION_TARGET)
 	$(PROJECT_DIR)/bin/ginkgo-top -i $(ARTIFACTS)/integration.json > $(ARTIFACTS)/integration-top.yaml
 
@@ -98,7 +100,7 @@ test-multikueue-integration: gomod-download envtest ginkgo dep-crds kueuectl gin
 	PROJECT_DIR=$(PROJECT_DIR)/ \
 	KUEUE_BIN=$(PROJECT_DIR)/bin \
 	ENVTEST_K8S_VERSION=$(ENVTEST_K8S_VERSION) \
-	API_LOG_LEVEL=$(INTEGRATION_API_LOG_LEVEL) \
+	TEST_LOG_LEVEL=$(TEST_LOG_LEVEL) API_LOG_LEVEL=$(INTEGRATION_API_LOG_LEVEL) \
 	$(GINKGO) $(INTEGRATION_FILTERS) $(GINKGO_ARGS) $(GOFLAGS) -procs=$(INTEGRATION_NPROCS_MULTIKUEUE) --race --junit-report=multikueue-junit.xml --json-report=multikueue-integration.json --output-dir=$(ARTIFACTS) -v $(INTEGRATION_TARGET_MULTIKUEUE)
 	$(PROJECT_DIR)/bin/ginkgo-top -i $(ARTIFACTS)/multikueue-integration.json > $(ARTIFACTS)/multikueue-integration-top.yaml
 
@@ -132,6 +134,7 @@ run-test-e2e-singlecluster-%: FORCE
 		JOBSET_VERSION=$(JOBSET_VERSION) \
 		LEADERWORKERSET_VERSION=$(LEADERWORKERSET_VERSION) \
 		KIND_CLUSTER_FILE="kind-cluster.yaml" E2E_TARGET_FOLDER="singlecluster" \
+		TEST_LOG_LEVEL=$(TEST_LOG_LEVEL) \
 		./hack/e2e-test.sh
 	$(PROJECT_DIR)/bin/ginkgo-top -i $(ARTIFACTS)/$@/e2e.json > $(ARTIFACTS)/$@/e2e-top.yaml
 
@@ -143,6 +146,7 @@ run-test-multikueue-e2e-%: FORCE
 		APPWRAPPER_VERSION=$(APPWRAPPER_VERSION) \
 		JOBSET_VERSION=$(JOBSET_VERSION) KUBEFLOW_VERSION=$(KUBEFLOW_VERSION) \
 		KUBEFLOW_MPI_VERSION=$(KUBEFLOW_MPI_VERSION) KUBERAY_VERSION=$(KUBERAY_VERSION) \
+		TEST_LOG_LEVEL=$(TEST_LOG_LEVEL) \
 		./hack/multikueue-e2e-test.sh
 	$(PROJECT_DIR)/bin/ginkgo-top -i $(ARTIFACTS)/$@/e2e.json > $(ARTIFACTS)/$@/e2e-top.yaml
 
@@ -156,6 +160,7 @@ run-test-tas-e2e-%: FORCE
 		LEADERWORKERSET_VERSION=$(LEADERWORKERSET_VERSION) \
 		KUBERAY_VERSION=$(KUBERAY_VERSION) \
 		KIND_CLUSTER_FILE="tas-kind-cluster.yaml" E2E_TARGET_FOLDER="tas" \
+		TEST_LOG_LEVEL=$(TEST_LOG_LEVEL) \
 		./hack/e2e-test.sh
 	$(PROJECT_DIR)/bin/ginkgo-top -i $(ARTIFACTS)/$@/e2e.json > $(ARTIFACTS)/$@/e2e-top.yaml
 
@@ -166,6 +171,7 @@ run-test-e2e-customconfigs-%: FORCE
 		ARTIFACTS="$(ARTIFACTS)/$@" IMAGE_TAG=$(IMAGE_TAG) GINKGO_ARGS="$(GINKGO_ARGS)" \
 		KIND_CLUSTER_FILE="kind-cluster.yaml" E2E_TARGET_FOLDER="customconfigs" \
 		JOBSET_VERSION=$(JOBSET_VERSION) APPWRAPPER_VERSION=$(APPWRAPPER_VERSION) \
+		TEST_LOG_LEVEL=$(TEST_LOG_LEVEL) \
 		./hack/e2e-test.sh
 	$(PROJECT_DIR)/bin/ginkgo-top -i $(ARTIFACTS)/$@/e2e.json > $(ARTIFACTS)/$@/e2e-top.yaml
 
diff --git a/charts/kueue/OWNERS b/charts/kueue/OWNERS
new file mode 100644
index 000000000..ef7abba9d
--- /dev/null
+++ b/charts/kueue/OWNERS
@@ -0,0 +1,5 @@
+# See the OWNERS docs at https://go.k8s.io/owners
+
+reviewers:
+- kannon92
+
diff --git a/config/OWNERS b/config/OWNERS
new file mode 100644
index 000000000..ef7abba9d
--- /dev/null
+++ b/config/OWNERS
@@ -0,0 +1,5 @@
+# See the OWNERS docs at https://go.k8s.io/owners
+
+reviewers:
+- kannon92
+
diff --git a/pkg/controller/core/admissioncheck_controller.go b/pkg/controller/core/admissioncheck_controller.go
index 31880cb5f..e79cddfd3 100644
--- a/pkg/controller/core/admissioncheck_controller.go
+++ b/pkg/controller/core/admissioncheck_controller.go
@@ -25,11 +25,14 @@ import (
 	"k8s.io/klog/v2"
 	"k8s.io/utils/ptr"
 	ctrl "sigs.k8s.io/controller-runtime"
+	"sigs.k8s.io/controller-runtime/pkg/builder"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 	"sigs.k8s.io/controller-runtime/pkg/controller"
 	"sigs.k8s.io/controller-runtime/pkg/controller/controllerutil"
 	"sigs.k8s.io/controller-runtime/pkg/event"
+	"sigs.k8s.io/controller-runtime/pkg/handler"
 	"sigs.k8s.io/controller-runtime/pkg/log"
+	"sigs.k8s.io/controller-runtime/pkg/predicate"
 	"sigs.k8s.io/controller-runtime/pkg/reconcile"
 	"sigs.k8s.io/controller-runtime/pkg/source"
 
@@ -54,6 +57,9 @@ type AdmissionCheckReconciler struct {
 	watchers   []AdmissionCheckUpdateWatcher
 }
 
+var _ reconcile.Reconciler = (*AdmissionCheckReconciler)(nil)
+var _ predicate.TypedPredicate[*kueue.AdmissionCheck] = (*AdmissionCheckReconciler)(nil)
+
 func NewAdmissionCheckReconciler(
 	client client.Client,
 	qMgr *queue.Manager,
@@ -119,55 +125,39 @@ func (r *AdmissionCheckReconciler) AddUpdateWatchers(watchers ...AdmissionCheckU
 	r.watchers = append(r.watchers, watchers...)
 }
 
-func (r *AdmissionCheckReconciler) Create(e event.CreateEvent) bool {
-	ac, isAc := e.Object.(*kueue.AdmissionCheck)
-	if !isAc {
-		return false
-	}
-	defer r.notifyWatchers(nil, ac)
-	r.log.WithValues("admissionCheck", klog.KObj(ac)).V(5).Info("Create event")
-	if cqNames := r.cache.AddOrUpdateAdmissionCheck(ac); len(cqNames) > 0 {
+func (r *AdmissionCheckReconciler) Create(e event.TypedCreateEvent[*kueue.AdmissionCheck]) bool {
+	defer r.notifyWatchers(nil, e.Object)
+	r.log.WithValues("admissionCheck", klog.KObj(e.Object)).V(5).Info("Create event")
+	if cqNames := r.cache.AddOrUpdateAdmissionCheck(e.Object); len(cqNames) > 0 {
 		r.qManager.QueueInadmissibleWorkloads(context.Background(), cqNames)
 	}
 	return true
 }
 
-func (r *AdmissionCheckReconciler) Update(e event.UpdateEvent) bool {
-	newAc, isAc := e.ObjectNew.(*kueue.AdmissionCheck)
-	if !isAc {
-		return false
-	}
-	oldAc, isAc := e.ObjectNew.(*kueue.AdmissionCheck)
-	if !isAc {
-		return false
-	}
-	defer r.notifyWatchers(oldAc, newAc)
-	r.log.WithValues("admissionCheck", klog.KObj(newAc)).V(5).Info("Update event")
-	if !newAc.DeletionTimestamp.IsZero() {
+func (r *AdmissionCheckReconciler) Update(e event.TypedUpdateEvent[*kueue.AdmissionCheck]) bool {
+	defer r.notifyWatchers(e.ObjectOld, e.ObjectNew)
+	r.log.WithValues("admissionCheck", klog.KObj(e.ObjectNew)).V(5).Info("Update event")
+	if !e.ObjectNew.DeletionTimestamp.IsZero() {
 		return true
 	}
-	if cqNames := r.cache.AddOrUpdateAdmissionCheck(newAc); len(cqNames) > 0 {
+	if cqNames := r.cache.AddOrUpdateAdmissionCheck(e.ObjectNew); len(cqNames) > 0 {
 		r.qManager.QueueInadmissibleWorkloads(context.Background(), cqNames)
 	}
 	return false
 }
 
-func (r *AdmissionCheckReconciler) Delete(e event.DeleteEvent) bool {
-	ac, isAc := e.Object.(*kueue.AdmissionCheck)
-	if !isAc {
-		return false
-	}
-	defer r.notifyWatchers(ac, nil)
-	r.log.WithValues("admissionCheck", klog.KObj(ac)).V(5).Info("Delete event")
+func (r *AdmissionCheckReconciler) Delete(e event.TypedDeleteEvent[*kueue.AdmissionCheck]) bool {
+	defer r.notifyWatchers(e.Object, nil)
+	r.log.WithValues("admissionCheck", klog.KObj(e.Object)).V(5).Info("Delete event")
 
-	if cqNames := r.cache.DeleteAdmissionCheck(ac); len(cqNames) > 0 {
+	if cqNames := r.cache.DeleteAdmissionCheck(e.Object); len(cqNames) > 0 {
 		r.qManager.QueueInadmissibleWorkloads(context.Background(), cqNames)
 	}
 	return true
 }
 
-func (r *AdmissionCheckReconciler) Generic(e event.GenericEvent) bool {
-	r.log.WithValues("object", klog.KObj(e.Object), "kind", e.Object.GetObjectKind().GroupVersionKind()).V(5).Info("Generic event")
+func (r *AdmissionCheckReconciler) Generic(e event.TypedGenericEvent[*kueue.AdmissionCheck]) bool {
+	r.log.WithValues("admissionCheck", klog.KObj(e.Object)).V(5).Info("AdmissionCheck Generic event")
 	return true
 }
 
@@ -220,13 +210,18 @@ func (h *acCqHandler) Generic(ctx context.Context, e event.GenericEvent, q workq
 
 // SetupWithManager sets up the controller with the Manager.
 func (r *AdmissionCheckReconciler) SetupWithManager(mgr ctrl.Manager, cfg *config.Configuration) error {
-	handler := acCqHandler{
+	h := acCqHandler{
 		cache: r.cache,
 	}
-	return ctrl.NewControllerManagedBy(mgr).
-		For(&kueue.AdmissionCheck{}).
+	return builder.TypedControllerManagedBy[reconcile.Request](mgr).
+		Named("admissioncheck_controller").
+		WatchesRawSource(source.TypedKind(
+			mgr.GetCache(),
+			&kueue.AdmissionCheck{},
+			&handler.TypedEnqueueRequestForObject[*kueue.AdmissionCheck]{},
+			r,
+		)).
 		WithOptions(controller.Options{NeedLeaderElection: ptr.To(false)}).
-		WatchesRawSource(source.Channel(r.cqUpdateCh, &handler)).
-		WithEventFilter(r).
+		WatchesRawSource(source.Channel(r.cqUpdateCh, &h)).
 		Complete(WithLeadingManager(mgr, r, &kueue.AdmissionCheck{}, cfg))
 }
diff --git a/pkg/controller/core/clusterqueue_controller.go b/pkg/controller/core/clusterqueue_controller.go
index 88e71f634..40ac271ea 100644
--- a/pkg/controller/core/clusterqueue_controller.go
+++ b/pkg/controller/core/clusterqueue_controller.go
@@ -18,6 +18,8 @@ package core
 
 import (
 	"context"
+	"iter"
+	"slices"
 	"time"
 
 	"github.com/go-logr/logr"
@@ -37,6 +39,7 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/controller"
 	"sigs.k8s.io/controller-runtime/pkg/controller/controllerutil"
 	"sigs.k8s.io/controller-runtime/pkg/event"
+	"sigs.k8s.io/controller-runtime/pkg/handler"
 	"sigs.k8s.io/controller-runtime/pkg/reconcile"
 	"sigs.k8s.io/controller-runtime/pkg/source"
 
@@ -49,7 +52,7 @@ import (
 	"sigs.k8s.io/kueue/pkg/metrics"
 	"sigs.k8s.io/kueue/pkg/queue"
 	"sigs.k8s.io/kueue/pkg/util/resource"
-	"sigs.k8s.io/kueue/pkg/util/slices"
+	utilslices "sigs.k8s.io/kueue/pkg/util/slices"
 	"sigs.k8s.io/kueue/pkg/workload"
 )
 
@@ -66,11 +69,8 @@ type ClusterQueueReconciler struct {
 	qManager                             *queue.Manager
 	cache                                *cache.Cache
 	snapshotsQueue                       workqueue.TypedInterface[kueue.ClusterQueueReference]
-	wlUpdateCh                           chan event.GenericEvent
-	rfUpdateCh                           chan event.GenericEvent
-	acUpdateCh                           chan event.GenericEvent
 	snapUpdateCh                         chan event.GenericEvent
-	topologyUpdateCh                     chan event.GenericEvent
+	nonCQObjectUpdateCh                  chan event.TypedGenericEvent[iter.Seq[kueue.ClusterQueueReference]]
 	watchers                             []ClusterQueueUpdateWatcher
 	reportResourceMetrics                bool
 	fairSharingEnabled                   bool
@@ -145,11 +145,8 @@ func NewClusterQueueReconciler(
 		qManager:                             qMgr,
 		cache:                                cache,
 		snapshotsQueue:                       workqueue.NewTyped[kueue.ClusterQueueReference](),
-		wlUpdateCh:                           make(chan event.GenericEvent, updateChBuffer),
-		rfUpdateCh:                           make(chan event.GenericEvent, updateChBuffer),
-		acUpdateCh:                           make(chan event.GenericEvent, updateChBuffer),
 		snapUpdateCh:                         make(chan event.GenericEvent, updateChBuffer),
-		topologyUpdateCh:                     make(chan event.GenericEvent, updateChBuffer),
+		nonCQObjectUpdateCh:                  make(chan event.TypedGenericEvent[iter.Seq[kueue.ClusterQueueReference]], updateChBuffer),
 		watchers:                             options.Watchers,
 		reportResourceMetrics:                options.ReportResourceMetrics,
 		fairSharingEnabled:                   options.FairSharingEnabled,
@@ -213,29 +210,60 @@ func (r *ClusterQueueReconciler) Reconcile(ctx context.Context, req ctrl.Request
 // NotifyTopologyUpdate triggers a topology update event only on creation or deletion,
 // as these are the only changes affecting the ClusterQueue's active state.
 func (r *ClusterQueueReconciler) NotifyTopologyUpdate(oldTopology, newTopology *kueuealpha.Topology) {
-	// if oldTopology is nil, it's a create event.
-	if oldTopology == nil {
-		r.topologyUpdateCh <- event.GenericEvent{Object: newTopology}
+	var topology *kueuealpha.Topology
+	switch {
+	case oldTopology == nil:
+		// Create Event.
+		topology = newTopology
+	case newTopology == nil:
+		// Delete Event.
+		topology = oldTopology
+	default:
 		return
 	}
-
-	// if newTopology is nil, it's a delete event.
-	if newTopology == nil {
-		r.topologyUpdateCh <- event.GenericEvent{Object: oldTopology}
-		return
+	r.nonCQObjectUpdateCh <- event.TypedGenericEvent[iter.Seq[kueue.ClusterQueueReference]]{
+		Object: slices.Values(r.cache.ClusterQueuesUsingTopology(kueue.TopologyReference(topology.Name))),
 	}
 }
 
+// NotifyWorkloadUpdate signals the controller to reconcile the ClusterQueue
+// associated to the workload in the event.
 func (r *ClusterQueueReconciler) NotifyWorkloadUpdate(oldWl, newWl *kueue.Workload) {
-	if oldWl != nil {
-		r.wlUpdateCh <- event.GenericEvent{Object: oldWl}
-		if newWl != nil && oldWl.Spec.QueueName != newWl.Spec.QueueName {
-			r.wlUpdateCh <- event.GenericEvent{Object: newWl}
+	var wls []*kueue.Workload
+	switch {
+	case oldWl != nil && newWl != nil:
+		// Update Event
+		wls = []*kueue.Workload{oldWl}
+		if oldWl.Spec.QueueName != newWl.Spec.QueueName {
+			wls = append(wls, newWl)
+		}
+	case oldWl == nil:
+		// Create Event
+		wls = []*kueue.Workload{newWl}
+	default:
+		// Delete Event
+		wls = []*kueue.Workload{oldWl}
+	}
+	r.nonCQObjectUpdateCh <- event.TypedGenericEvent[iter.Seq[kueue.ClusterQueueReference]]{
+		Object: r.requestCQForWL(wls),
+	}
+}
+
+func (r *ClusterQueueReconciler) requestCQForWL(wls []*kueue.Workload) iter.Seq[kueue.ClusterQueueReference] {
+	return func(yield func(kueue.ClusterQueueReference) bool) {
+		for _, wl := range wls {
+			var req kueue.ClusterQueueReference
+			if workload.HasQuotaReservation(wl) {
+				req = wl.Status.Admission.ClusterQueue
+			} else if cqName, ok := r.qManager.ClusterQueueForWorkload(wl); ok {
+				req = cqName
+			}
+			if len(req) > 0 {
+				if !yield(req) {
+					return
+				}
+			}
 		}
-		return
-	}
-	if newWl != nil {
-		r.wlUpdateCh <- event.GenericEvent{Object: newWl}
 	}
 }
 
@@ -247,25 +275,36 @@ func (r *ClusterQueueReconciler) notifyWatchers(oldCQ, newCQ *kueue.ClusterQueue
 
 // NotifyResourceFlavorUpdate ignores updates since they have no impact on the ClusterQueue's readiness.
 func (r *ClusterQueueReconciler) NotifyResourceFlavorUpdate(oldRF, newRF *kueue.ResourceFlavor) {
-	// if oldRF is nil, it's a create event.
-	if oldRF == nil {
-		r.rfUpdateCh <- event.GenericEvent{Object: newRF}
+	var rfName string
+	switch {
+	case oldRF == nil:
+		// Create Event.
+		rfName = newRF.Name
+	case newRF == nil:
+		// Delete Event.
+		rfName = oldRF.Name
+	default:
 		return
 	}
-
-	// if newRF is nil, it's a delete event.
-	if newRF == nil {
-		r.rfUpdateCh <- event.GenericEvent{Object: oldRF}
-		return
+	r.nonCQObjectUpdateCh <- event.TypedGenericEvent[iter.Seq[kueue.ClusterQueueReference]]{
+		Object: slices.Values(r.cache.ClusterQueuesUsingFlavor(kueue.ResourceFlavorReference(rfName))),
 	}
 }
 
 func (r *ClusterQueueReconciler) NotifyAdmissionCheckUpdate(oldAc, newAc *kueue.AdmissionCheck) {
+	var acName string
 	switch {
 	case oldAc != nil:
-		r.acUpdateCh <- event.GenericEvent{Object: oldAc}
+		// Delete or Update Event.
+		acName = oldAc.Name
 	case newAc != nil:
-		r.acUpdateCh <- event.GenericEvent{Object: newAc}
+		// Create Event.
+		acName = newAc.Name
+	default:
+		return
+	}
+	r.nonCQObjectUpdateCh <- event.TypedGenericEvent[iter.Seq[kueue.ClusterQueueReference]]{
+		Object: slices.Values(r.cache.ClusterQueuesUsingAdmissionCheck(acName)),
 	}
 }
 
@@ -404,7 +443,7 @@ func clearOldResourceQuotas(oldCq, newCq *kueue.ClusterQueue) {
 		oldRG := &oldCq.Spec.ResourceGroups[rgi]
 		newFlavors := map[kueue.ResourceFlavorReference]*kueue.FlavorQuotas{}
 		if rgi < len(newCq.Spec.ResourceGroups) && len(newCq.Spec.ResourceGroups[rgi].Flavors) > 0 {
-			newFlavors = slices.ToRefMap(newCq.Spec.ResourceGroups[rgi].Flavors, func(f *kueue.FlavorQuotas) kueue.ResourceFlavorReference { return f.Name })
+			newFlavors = utilslices.ToRefMap(newCq.Spec.ResourceGroups[rgi].Flavors, func(f *kueue.FlavorQuotas) kueue.ResourceFlavorReference { return f.Name })
 		}
 
 		for fi := range oldRG.Flavors {
@@ -413,7 +452,7 @@ func clearOldResourceQuotas(oldCq, newCq *kueue.ClusterQueue) {
 				metrics.ClearClusterQueueResourceQuotas(oldCq.Name, string(flavor.Name), "")
 			} else {
 				// check all resources
-				newResources := slices.ToRefMap(newFlavor.Resources, func(r *kueue.ResourceQuota) corev1.ResourceName { return r.Name })
+				newResources := utilslices.ToRefMap(newFlavor.Resources, func(r *kueue.ResourceQuota) corev1.ResourceName { return r.Name })
 				for ri := range flavor.Resources {
 					rname := flavor.Resources[ri].Name
 					if _, found := newResources[rname]; !found {
@@ -428,14 +467,14 @@ func clearOldResourceQuotas(oldCq, newCq *kueue.ClusterQueue) {
 	if len(oldCq.Status.FlavorsReservation) > 0 {
 		newFlavors := map[kueue.ResourceFlavorReference]*kueue.FlavorUsage{}
 		if len(newCq.Status.FlavorsReservation) > 0 {
-			newFlavors = slices.ToRefMap(newCq.Status.FlavorsReservation, func(f *kueue.FlavorUsage) kueue.ResourceFlavorReference { return f.Name })
+			newFlavors = utilslices.ToRefMap(newCq.Status.FlavorsReservation, func(f *kueue.FlavorUsage) kueue.ResourceFlavorReference { return f.Name })
 		}
 		for fi := range oldCq.Status.FlavorsReservation {
 			flavor := &oldCq.Status.FlavorsReservation[fi]
 			if newFlavor, found := newFlavors[flavor.Name]; !found || len(newFlavor.Resources) == 0 {
 				metrics.ClearClusterQueueResourceReservations(oldCq.Name, string(flavor.Name), "")
 			} else {
-				newResources := slices.ToRefMap(newFlavor.Resources, func(r *kueue.ResourceUsage) corev1.ResourceName { return r.Name })
+				newResources := utilslices.ToRefMap(newFlavor.Resources, func(r *kueue.ResourceUsage) corev1.ResourceName { return r.Name })
 				for ri := range flavor.Resources {
 					rname := flavor.Resources[ri].Name
 					if _, found := newResources[rname]; !found {
@@ -450,14 +489,14 @@ func clearOldResourceQuotas(oldCq, newCq *kueue.ClusterQueue) {
 	if len(oldCq.Status.FlavorsUsage) > 0 {
 		newFlavors := map[kueue.ResourceFlavorReference]*kueue.FlavorUsage{}
 		if len(newCq.Status.FlavorsUsage) > 0 {
-			newFlavors = slices.ToRefMap(newCq.Status.FlavorsUsage, func(f *kueue.FlavorUsage) kueue.ResourceFlavorReference { return f.Name })
+			newFlavors = utilslices.ToRefMap(newCq.Status.FlavorsUsage, func(f *kueue.FlavorUsage) kueue.ResourceFlavorReference { return f.Name })
 		}
 		for fi := range oldCq.Status.FlavorsUsage {
 			flavor := &oldCq.Status.FlavorsUsage[fi]
 			if newFlavor, found := newFlavors[flavor.Name]; !found || len(newFlavor.Resources) == 0 {
 				metrics.ClearClusterQueueResourceUsage(oldCq.Name, string(flavor.Name), "")
 			} else {
-				newResources := slices.ToRefMap(newFlavor.Resources, func(r *kueue.ResourceUsage) corev1.ResourceName { return r.Name })
+				newResources := utilslices.ToRefMap(newFlavor.Resources, func(r *kueue.ResourceUsage) corev1.ResourceName { return r.Name })
 				for ri := range flavor.Resources {
 					rname := flavor.Resources[ri].Name
 					if _, found := newResources[rname]; !found {
@@ -469,49 +508,6 @@ func clearOldResourceQuotas(oldCq, newCq *kueue.ClusterQueue) {
 	}
 }
 
-// cqWorkloadHandler signals the controller to reconcile the ClusterQueue
-// associated to the workload in the event.
-// Since the events come from a channel Source, only the Generic handler will
-// receive events.
-type cqWorkloadHandler struct {
-	qManager *queue.Manager
-}
-
-func (h *cqWorkloadHandler) Create(context.Context, event.CreateEvent, workqueue.TypedRateLimitingInterface[reconcile.Request]) {
-}
-
-func (h *cqWorkloadHandler) Update(context.Context, event.UpdateEvent, workqueue.TypedRateLimitingInterface[reconcile.Request]) {
-}
-
-func (h *cqWorkloadHandler) Delete(context.Context, event.DeleteEvent, workqueue.TypedRateLimitingInterface[reconcile.Request]) {
-}
-
-func (h *cqWorkloadHandler) Generic(_ context.Context, e event.GenericEvent, q workqueue.TypedRateLimitingInterface[reconcile.Request]) {
-	w := e.Object.(*kueue.Workload)
-	req := h.requestForWorkloadClusterQueue(w)
-	if req != nil {
-		q.AddAfter(*req, constants.UpdatesBatchPeriod)
-	}
-}
-
-func (h *cqWorkloadHandler) requestForWorkloadClusterQueue(w *kueue.Workload) *reconcile.Request {
-	var name kueue.ClusterQueueReference
-	if workload.HasQuotaReservation(w) {
-		name = w.Status.Admission.ClusterQueue
-	} else {
-		var ok bool
-		name, ok = h.qManager.ClusterQueueForWorkload(w)
-		if !ok {
-			return nil
-		}
-	}
-	return &reconcile.Request{
-		NamespacedName: types.NamespacedName{
-			Name: string(name),
-		},
-	}
-}
-
 // cqNamespaceHandler handles namespace update events.
 type cqNamespaceHandler struct {
 	qManager *queue.Manager
@@ -541,98 +537,28 @@ func (h *cqNamespaceHandler) Delete(context.Context, event.DeleteEvent, workqueu
 func (h *cqNamespaceHandler) Generic(context.Context, event.GenericEvent, workqueue.TypedRateLimitingInterface[reconcile.Request]) {
 }
 
-type cqResourceFlavorHandler struct {
-	cache *cache.Cache
-}
+type nonCQObjectHandler struct{}
 
-func (h *cqResourceFlavorHandler) Create(context.Context, event.CreateEvent, workqueue.TypedRateLimitingInterface[reconcile.Request]) {
-}
+var _ handler.TypedEventHandler[iter.Seq[kueue.ClusterQueueReference], reconcile.Request] = (*nonCQObjectHandler)(nil)
 
-func (h *cqResourceFlavorHandler) Update(context.Context, event.UpdateEvent, workqueue.TypedRateLimitingInterface[reconcile.Request]) {
+func (h *nonCQObjectHandler) Create(context.Context, event.TypedCreateEvent[iter.Seq[kueue.ClusterQueueReference]], workqueue.TypedRateLimitingInterface[reconcile.Request]) {
 }
-
-func (h *cqResourceFlavorHandler) Delete(context.Context, event.DeleteEvent, workqueue.TypedRateLimitingInterface[reconcile.Request]) {
+func (h *nonCQObjectHandler) Update(context.Context, event.TypedUpdateEvent[iter.Seq[kueue.ClusterQueueReference]], workqueue.TypedRateLimitingInterface[reconcile.Request]) {
 }
-
-func (h *cqResourceFlavorHandler) Generic(_ context.Context, e event.GenericEvent, q workqueue.TypedRateLimitingInterface[reconcile.Request]) {
-	rf, ok := e.Object.(*kueue.ResourceFlavor)
-	if !ok {
-		return
-	}
-
-	if cqs := h.cache.ClusterQueuesUsingFlavor(kueue.ResourceFlavorReference(rf.Name)); len(cqs) != 0 {
-		for _, cq := range cqs {
-			req := reconcile.Request{
-				NamespacedName: types.NamespacedName{
-					Name: string(cq),
-				}}
-			q.Add(req)
-		}
-	}
+func (h *nonCQObjectHandler) Delete(context.Context, event.TypedDeleteEvent[iter.Seq[kueue.ClusterQueueReference]], workqueue.TypedRateLimitingInterface[reconcile.Request]) {
 }
-
-type cqAdmissionCheckHandler struct {
-	cache *cache.Cache
+func (h *nonCQObjectHandler) Generic(_ context.Context, e event.TypedGenericEvent[iter.Seq[kueue.ClusterQueueReference]], q workqueue.TypedRateLimitingInterface[reconcile.Request]) {
+	for cq := range e.Object {
+		q.AddAfter(reconcile.Request{NamespacedName: types.NamespacedName{
+			Name: string(cq),
+		}}, constants.UpdatesBatchPeriod)
+	}
 }
 
 type cqSnapshotHandler struct {
 	queueVisibilityUpdateInterval time.Duration
 }
 
-func (h *cqAdmissionCheckHandler) Create(context.Context, event.CreateEvent, workqueue.TypedRateLimitingInterface[reconcile.Request]) {
-}
-
-func (h *cqAdmissionCheckHandler) Update(context.Context, event.UpdateEvent, workqueue.TypedRateLimitingInterface[reconcile.Request]) {
-}
-
-func (h *cqAdmissionCheckHandler) Delete(context.Context, event.DeleteEvent, workqueue.TypedRateLimitingInterface[reconcile.Request]) {
-}
-
-func (h *cqAdmissionCheckHandler) Generic(_ context.Context, e event.GenericEvent, q workqueue.TypedRateLimitingInterface[reconcile.Request]) {
-	ac, isAc := e.Object.(*kueue.AdmissionCheck)
-	if !isAc {
-		return
-	}
-
-	if cqs := h.cache.ClusterQueuesUsingAdmissionCheck(ac.Name); len(cqs) != 0 {
-		for _, cq := range cqs {
-			req := reconcile.Request{
-				NamespacedName: types.NamespacedName{
-					Name: string(cq),
-				}}
-			q.Add(req)
-		}
-	}
-}
-
-type cqTopologyHandler struct {
-	cache *cache.Cache
-}
-
-func (h *cqTopologyHandler) Create(context.Context, event.CreateEvent, workqueue.TypedRateLimitingInterface[reconcile.Request]) {
-}
-
-func (h *cqTopologyHandler) Update(context.Context, event.UpdateEvent, workqueue.TypedRateLimitingInterface[reconcile.Request]) {
-}
-
-func (h *cqTopologyHandler) Delete(context.Context, event.DeleteEvent, workqueue.TypedRateLimitingInterface[reconcile.Request]) {
-}
-
-func (h *cqTopologyHandler) Generic(_ context.Context, e event.GenericEvent, q workqueue.TypedRateLimitingInterface[reconcile.Request]) {
-	topology, isTopology := e.Object.(*kueuealpha.Topology)
-	if !isTopology {
-		return
-	}
-	cqs := h.cache.ClusterQueuesUsingTopology(kueue.TopologyReference(topology.Name))
-	for _, cq := range cqs {
-		req := reconcile.Request{
-			NamespacedName: types.NamespacedName{
-				Name: string(cq),
-			}}
-		q.Add(req)
-	}
-}
-
 func (h *cqSnapshotHandler) Create(context.Context, event.CreateEvent, workqueue.TypedRateLimitingInterface[reconcile.Request]) {
 }
 
@@ -662,22 +588,10 @@ func (h *cqSnapshotHandler) Generic(_ context.Context, e event.GenericEvent, q w
 
 // SetupWithManager sets up the controller with the Manager.
 func (r *ClusterQueueReconciler) SetupWithManager(mgr ctrl.Manager, cfg *config.Configuration) error {
-	wHandler := cqWorkloadHandler{
-		qManager: r.qManager,
-	}
 	nsHandler := cqNamespaceHandler{
 		qManager: r.qManager,
 		cache:    r.cache,
 	}
-	rfHandler := cqResourceFlavorHandler{
-		cache: r.cache,
-	}
-	acHandler := cqAdmissionCheckHandler{
-		cache: r.cache,
-	}
-	topologyHandler := cqTopologyHandler{
-		cache: r.cache,
-	}
 	snapHandler := cqSnapshotHandler{
 		queueVisibilityUpdateInterval: r.queueVisibilityUpdateInterval,
 	}
@@ -685,11 +599,8 @@ func (r *ClusterQueueReconciler) SetupWithManager(mgr ctrl.Manager, cfg *config.
 		For(&kueue.ClusterQueue{}).
 		WithOptions(controller.Options{NeedLeaderElection: ptr.To(false)}).
 		Watches(&corev1.Namespace{}, &nsHandler).
-		WatchesRawSource(source.Channel(r.wlUpdateCh, &wHandler)).
-		WatchesRawSource(source.Channel(r.rfUpdateCh, &rfHandler)).
-		WatchesRawSource(source.Channel(r.acUpdateCh, &acHandler)).
-		WatchesRawSource(source.Channel(r.topologyUpdateCh, &topologyHandler)).
 		WatchesRawSource(source.Channel(r.snapUpdateCh, &snapHandler)).
+		WatchesRawSource(source.Channel(r.nonCQObjectUpdateCh, &nonCQObjectHandler{})).
 		WithEventFilter(r).
 		Complete(WithLeadingManager(mgr, r, &kueue.ClusterQueue{}, cfg))
 }
diff --git a/pkg/controller/core/cohort_controller.go b/pkg/controller/core/cohort_controller.go
index c5aad5b83..4201303d7 100644
--- a/pkg/controller/core/cohort_controller.go
+++ b/pkg/controller/core/cohort_controller.go
@@ -25,9 +25,14 @@ import (
 	"k8s.io/klog/v2"
 	"k8s.io/utils/ptr"
 	ctrl "sigs.k8s.io/controller-runtime"
+	"sigs.k8s.io/controller-runtime/pkg/builder"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 	"sigs.k8s.io/controller-runtime/pkg/controller"
 	"sigs.k8s.io/controller-runtime/pkg/event"
+	"sigs.k8s.io/controller-runtime/pkg/handler"
+	"sigs.k8s.io/controller-runtime/pkg/predicate"
+	"sigs.k8s.io/controller-runtime/pkg/reconcile"
+	"sigs.k8s.io/controller-runtime/pkg/source"
 
 	config "sigs.k8s.io/kueue/apis/config/v1beta1"
 	kueue "sigs.k8s.io/kueue/apis/kueue/v1alpha1"
@@ -46,34 +51,34 @@ type CohortReconciler struct {
 	qManager *queue.Manager
 }
 
+var _ reconcile.Reconciler = (*CohortReconciler)(nil)
+var _ predicate.TypedPredicate[*kueue.Cohort] = (*CohortReconciler)(nil)
+
 func NewCohortReconciler(client client.Client, cache *cache.Cache, qManager *queue.Manager) CohortReconciler {
 	return CohortReconciler{client, ctrl.Log.WithName("cohort-reconciler"), cache, qManager}
 }
 
 func (r *CohortReconciler) SetupWithManager(mgr ctrl.Manager, cfg *config.Configuration) error {
-	return ctrl.NewControllerManagedBy(mgr).
-		For(&kueue.Cohort{}).
+	return builder.TypedControllerManagedBy[reconcile.Request](mgr).
+		Named("cohort_controller").
+		WatchesRawSource(source.TypedKind(
+			mgr.GetCache(),
+			&kueue.Cohort{},
+			&handler.TypedEnqueueRequestForObject[*kueue.Cohort]{},
+			r,
+		)).
 		WithOptions(controller.Options{NeedLeaderElection: ptr.To(false)}).
-		WithEventFilter(r).
 		Complete(WithLeadingManager(mgr, r, &kueue.Cohort{}, cfg))
 }
 
-func (r *CohortReconciler) Create(e event.CreateEvent) bool {
+func (r *CohortReconciler) Create(event.TypedCreateEvent[*kueue.Cohort]) bool {
 	return true
 }
 
-func (r *CohortReconciler) Update(e event.UpdateEvent) bool {
-	oldCohort, ok := e.ObjectOld.(*kueue.Cohort)
-	if !ok {
-		return false
-	}
-	newCohort, ok := e.ObjectNew.(*kueue.Cohort)
-	if !ok {
-		return false
-	}
-	log := r.log.WithValues("cohort", klog.KObj(newCohort))
-	if equality.Semantic.DeepEqual(oldCohort.Spec.ResourceGroups, newCohort.Spec.ResourceGroups) &&
-		oldCohort.Spec.Parent == newCohort.Spec.Parent {
+func (r *CohortReconciler) Update(e event.TypedUpdateEvent[*kueue.Cohort]) bool {
+	log := r.log.WithValues("cohort", klog.KObj(e.ObjectNew))
+	if equality.Semantic.DeepEqual(e.ObjectOld.Spec.ResourceGroups, e.ObjectNew.Spec.ResourceGroups) &&
+		e.ObjectOld.Spec.Parent == e.ObjectNew.Spec.Parent {
 		log.V(2).Info("Skip Cohort update event as Cohort unchanged")
 		return false
 	}
@@ -81,11 +86,11 @@ func (r *CohortReconciler) Update(e event.UpdateEvent) bool {
 	return true
 }
 
-func (r *CohortReconciler) Delete(e event.DeleteEvent) bool {
+func (r *CohortReconciler) Delete(event.TypedDeleteEvent[*kueue.Cohort]) bool {
 	return true
 }
 
-func (r *CohortReconciler) Generic(e event.GenericEvent) bool {
+func (r *CohortReconciler) Generic(event.TypedGenericEvent[*kueue.Cohort]) bool {
 	return true
 }
 
diff --git a/pkg/controller/core/localqueue_controller.go b/pkg/controller/core/localqueue_controller.go
index 2652136d6..a0ab56ad2 100644
--- a/pkg/controller/core/localqueue_controller.go
+++ b/pkg/controller/core/localqueue_controller.go
@@ -29,9 +29,12 @@ import (
 	"k8s.io/klog/v2"
 	"k8s.io/utils/ptr"
 	ctrl "sigs.k8s.io/controller-runtime"
+	"sigs.k8s.io/controller-runtime/pkg/builder"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 	"sigs.k8s.io/controller-runtime/pkg/controller"
 	"sigs.k8s.io/controller-runtime/pkg/event"
+	"sigs.k8s.io/controller-runtime/pkg/handler"
+	"sigs.k8s.io/controller-runtime/pkg/predicate"
 	"sigs.k8s.io/controller-runtime/pkg/reconcile"
 	"sigs.k8s.io/controller-runtime/pkg/source"
 
@@ -66,6 +69,9 @@ type LocalQueueReconciler struct {
 	wlUpdateCh chan event.GenericEvent
 }
 
+var _ reconcile.Reconciler = (*LocalQueueReconciler)(nil)
+var _ predicate.TypedPredicate[*kueue.LocalQueue] = (*LocalQueueReconciler)(nil)
+
 func NewLocalQueueReconciler(
 	client client.Client,
 	queues *queue.Manager,
@@ -129,74 +135,57 @@ func (r *LocalQueueReconciler) Reconcile(ctx context.Context, req ctrl.Request)
 	return ctrl.Result{}, client.IgnoreNotFound(err)
 }
 
-func (r *LocalQueueReconciler) Create(e event.CreateEvent) bool {
-	q, match := e.Object.(*kueue.LocalQueue)
-	if !match {
-		// No need to interact with the queue manager for other objects.
-		return true
-	}
-	log := r.log.WithValues("localQueue", klog.KObj(q))
+func (r *LocalQueueReconciler) Create(e event.TypedCreateEvent[*kueue.LocalQueue]) bool {
+	log := r.log.WithValues("localQueue", klog.KObj(e.Object))
 	log.V(2).Info("LocalQueue create event")
 
-	if ptr.Deref(q.Spec.StopPolicy, kueue.None) == kueue.None {
+	if ptr.Deref(e.Object.Spec.StopPolicy, kueue.None) == kueue.None {
 		ctx := logr.NewContext(context.Background(), log)
-		if err := r.queues.AddLocalQueue(ctx, q); err != nil {
+		if err := r.queues.AddLocalQueue(ctx, e.Object); err != nil {
 			log.Error(err, "Failed to add localQueue to the queueing system")
 		}
 	}
 
-	if err := r.cache.AddLocalQueue(q); err != nil {
+	if err := r.cache.AddLocalQueue(e.Object); err != nil {
 		log.Error(err, "Failed to add localQueue to the cache")
 	}
 
 	if features.Enabled(features.LocalQueueMetrics) {
-		recordLocalQueueUsageMetrics(q)
+		recordLocalQueueUsageMetrics(e.Object)
 	}
 
 	return true
 }
 
-func (r *LocalQueueReconciler) Delete(e event.DeleteEvent) bool {
-	q, match := e.Object.(*kueue.LocalQueue)
-	if !match {
-		// No need to interact with the queue manager for other objects.
-		return true
-	}
-
+func (r *LocalQueueReconciler) Delete(e event.TypedDeleteEvent[*kueue.LocalQueue]) bool {
 	if features.Enabled(features.LocalQueueMetrics) {
-		metrics.ClearLocalQueueResourceMetrics(localQueueReferenceFromLocalQueue(q))
+		metrics.ClearLocalQueueResourceMetrics(localQueueReferenceFromLocalQueue(e.Object))
 	}
 
-	r.log.V(2).Info("LocalQueue delete event", "localQueue", klog.KObj(q))
-	r.queues.DeleteLocalQueue(q)
-	r.cache.DeleteLocalQueue(q)
+	r.log.V(2).Info("LocalQueue delete event", "localQueue", klog.KObj(e.Object))
+	r.queues.DeleteLocalQueue(e.Object)
+	r.cache.DeleteLocalQueue(e.Object)
 	return true
 }
 
-func (r *LocalQueueReconciler) Update(e event.UpdateEvent) bool {
-	oldLq, oldIsLq := e.ObjectOld.(*kueue.LocalQueue)
-	newLq, newIsLq := e.ObjectNew.(*kueue.LocalQueue)
-	if !oldIsLq || !newIsLq {
-		// No need to interact with the queue manager for other objects.
-		return true
-	}
-	log := r.log.WithValues("localQueue", klog.KObj(newLq))
+func (r *LocalQueueReconciler) Update(e event.TypedUpdateEvent[*kueue.LocalQueue]) bool {
+	log := r.log.WithValues("localQueue", klog.KObj(e.ObjectNew))
 	log.V(2).Info("Queue update event")
 
 	if features.Enabled(features.LocalQueueMetrics) {
-		updateLocalQueueResourceMetrics(newLq)
+		updateLocalQueueResourceMetrics(e.ObjectNew)
 	}
 
-	oldStopPolicy := ptr.Deref(oldLq.Spec.StopPolicy, kueue.None)
-	newStopPolicy := ptr.Deref(newLq.Spec.StopPolicy, kueue.None)
+	oldStopPolicy := ptr.Deref(e.ObjectOld.Spec.StopPolicy, kueue.None)
+	newStopPolicy := ptr.Deref(e.ObjectNew.Spec.StopPolicy, kueue.None)
 
 	if newStopPolicy == oldStopPolicy {
 		if newStopPolicy == kueue.None {
-			if err := r.queues.UpdateLocalQueue(newLq); err != nil {
+			if err := r.queues.UpdateLocalQueue(e.ObjectNew); err != nil {
 				log.Error(err, "Failed to update queue in the queueing system")
 			}
 		}
-		if err := r.cache.UpdateLocalQueue(oldLq, newLq); err != nil {
+		if err := r.cache.UpdateLocalQueue(e.ObjectOld, e.ObjectNew); err != nil {
 			log.Error(err, "Failed to update localQueue in the cache")
 		}
 		return true
@@ -204,13 +193,13 @@ func (r *LocalQueueReconciler) Update(e event.UpdateEvent) bool {
 
 	if newStopPolicy == kueue.None {
 		ctx := logr.NewContext(context.Background(), log)
-		if err := r.queues.AddLocalQueue(ctx, newLq); err != nil {
+		if err := r.queues.AddLocalQueue(ctx, e.ObjectNew); err != nil {
 			log.Error(err, "Failed to add localQueue to the queueing system")
 		}
 		return true
 	}
 
-	r.queues.DeleteLocalQueue(oldLq)
+	r.queues.DeleteLocalQueue(e.ObjectOld)
 
 	return true
 }
@@ -240,8 +229,8 @@ func updateLocalQueueResourceMetrics(queue *kueue.LocalQueue) {
 	recordLocalQueueUsageMetrics(queue)
 }
 
-func (r *LocalQueueReconciler) Generic(e event.GenericEvent) bool {
-	r.log.V(3).Info("Got Workload event", "workload", klog.KObj(e.Object))
+func (r *LocalQueueReconciler) Generic(e event.TypedGenericEvent[*kueue.LocalQueue]) bool {
+	r.log.V(2).Info("LocalQueue generic event", "localQueue", klog.KObj(e.Object))
 	return true
 }
 
@@ -336,12 +325,17 @@ func (r *LocalQueueReconciler) SetupWithManager(mgr ctrl.Manager, cfg *config.Co
 	queueCQHandler := qCQHandler{
 		client: r.client,
 	}
-	return ctrl.NewControllerManagedBy(mgr).
-		For(&kueue.LocalQueue{}).
+	return builder.TypedControllerManagedBy[reconcile.Request](mgr).
+		Named("localqueue_controller").
+		WatchesRawSource(source.TypedKind(
+			mgr.GetCache(),
+			&kueue.LocalQueue{},
+			&handler.TypedEnqueueRequestForObject[*kueue.LocalQueue]{},
+			r,
+		)).
 		WithOptions(controller.Options{NeedLeaderElection: ptr.To(false)}).
 		WatchesRawSource(source.Channel(r.wlUpdateCh, &qWorkloadHandler{})).
 		Watches(&kueue.ClusterQueue{}, &queueCQHandler).
-		WithEventFilter(r).
 		Complete(WithLeadingManager(mgr, r, &kueue.LocalQueue{}, cfg))
 }
 
diff --git a/pkg/controller/core/resourceflavor_controller.go b/pkg/controller/core/resourceflavor_controller.go
index 7addc739c..9b1bd478d 100644
--- a/pkg/controller/core/resourceflavor_controller.go
+++ b/pkg/controller/core/resourceflavor_controller.go
@@ -26,10 +26,13 @@ import (
 	"k8s.io/klog/v2"
 	"k8s.io/utils/ptr"
 	ctrl "sigs.k8s.io/controller-runtime"
+	"sigs.k8s.io/controller-runtime/pkg/builder"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 	"sigs.k8s.io/controller-runtime/pkg/controller"
 	"sigs.k8s.io/controller-runtime/pkg/controller/controllerutil"
 	"sigs.k8s.io/controller-runtime/pkg/event"
+	"sigs.k8s.io/controller-runtime/pkg/handler"
+	"sigs.k8s.io/controller-runtime/pkg/predicate"
 	"sigs.k8s.io/controller-runtime/pkg/reconcile"
 	"sigs.k8s.io/controller-runtime/pkg/source"
 
@@ -53,6 +56,9 @@ type ResourceFlavorReconciler struct {
 	watchers   []ResourceFlavorUpdateWatcher
 }
 
+var _ reconcile.Reconciler = (*ResourceFlavorReconciler)(nil)
+var _ predicate.TypedPredicate[*kueue.ResourceFlavor] = (*ResourceFlavorReconciler)(nil)
+
 func NewResourceFlavorReconciler(
 	client client.Client,
 	qMgr *queue.Manager,
@@ -120,19 +126,15 @@ func (r *ResourceFlavorReconciler) notifyWatchers(oldRF, newRF *kueue.ResourceFl
 	}
 }
 
-func (r *ResourceFlavorReconciler) Create(e event.CreateEvent) bool {
-	flv, match := e.Object.(*kueue.ResourceFlavor)
-	if !match {
-		return false
-	}
-	defer r.notifyWatchers(nil, flv)
+func (r *ResourceFlavorReconciler) Create(e event.TypedCreateEvent[*kueue.ResourceFlavor]) bool {
+	defer r.notifyWatchers(nil, e.Object)
 
-	log := r.log.WithValues("resourceFlavor", klog.KObj(flv))
+	log := r.log.WithValues("resourceFlavor", klog.KObj(e.Object))
 	log.V(2).Info("ResourceFlavor create event")
 
 	// As long as one clusterQueue becomes active,
 	// we should inform clusterQueue controller to broadcast the event.
-	if cqNames := r.cache.AddOrUpdateResourceFlavor(flv.DeepCopy()); len(cqNames) > 0 {
+	if cqNames := r.cache.AddOrUpdateResourceFlavor(e.Object.DeepCopy()); len(cqNames) > 0 {
 		r.qManager.QueueInadmissibleWorkloads(context.Background(), cqNames)
 		// If at least one CQ becomes active, then those CQs should now get evaluated by the scheduler;
 		// note that the workloads in those CQs are not necessarily "inadmissible", and hence we trigger a
@@ -142,48 +144,36 @@ func (r *ResourceFlavorReconciler) Create(e event.CreateEvent) bool {
 	return true
 }
 
-func (r *ResourceFlavorReconciler) Delete(e event.DeleteEvent) bool {
-	flv, match := e.Object.(*kueue.ResourceFlavor)
-	if !match {
-		return false
-	}
-	defer r.notifyWatchers(flv, nil)
+func (r *ResourceFlavorReconciler) Delete(e event.TypedDeleteEvent[*kueue.ResourceFlavor]) bool {
+	defer r.notifyWatchers(e.Object, nil)
 
-	log := r.log.WithValues("resourceFlavor", klog.KObj(flv))
+	log := r.log.WithValues("resourceFlavor", klog.KObj(e.Object))
 	log.V(2).Info("ResourceFlavor delete event")
 
-	if cqNames := r.cache.DeleteResourceFlavor(flv); len(cqNames) > 0 {
+	if cqNames := r.cache.DeleteResourceFlavor(e.Object); len(cqNames) > 0 {
 		r.qManager.QueueInadmissibleWorkloads(context.Background(), cqNames)
 	}
 	return false
 }
 
-func (r *ResourceFlavorReconciler) Update(e event.UpdateEvent) bool {
-	oldFlv, match := e.ObjectOld.(*kueue.ResourceFlavor)
-	if !match {
-		return false
-	}
-	newFlv, match := e.ObjectNew.(*kueue.ResourceFlavor)
-	if !match {
-		return false
-	}
-	defer r.notifyWatchers(oldFlv, newFlv)
+func (r *ResourceFlavorReconciler) Update(e event.TypedUpdateEvent[*kueue.ResourceFlavor]) bool {
+	defer r.notifyWatchers(e.ObjectOld, e.ObjectNew)
 
-	log := r.log.WithValues("resourceFlavor", klog.KObj(newFlv))
+	log := r.log.WithValues("resourceFlavor", klog.KObj(e.ObjectNew))
 	log.V(2).Info("ResourceFlavor update event")
 
-	if newFlv.DeletionTimestamp != nil {
+	if e.ObjectNew.DeletionTimestamp != nil {
 		return true
 	}
 
-	if cqNames := r.cache.AddOrUpdateResourceFlavor(newFlv.DeepCopy()); len(cqNames) > 0 {
+	if cqNames := r.cache.AddOrUpdateResourceFlavor(e.ObjectNew.DeepCopy()); len(cqNames) > 0 {
 		r.qManager.QueueInadmissibleWorkloads(context.Background(), cqNames)
 	}
 	return false
 }
 
-func (r *ResourceFlavorReconciler) Generic(e event.GenericEvent) bool {
-	r.log.V(2).Info("Got generic event", "obj", klog.KObj(e.Object), "kind", e.Object.GetObjectKind().GroupVersionKind())
+func (r *ResourceFlavorReconciler) Generic(e event.TypedGenericEvent[*kueue.ResourceFlavor]) bool {
+	r.log.V(3).Info("Got ResourceFlavor generic event", "resourceFlavor", klog.KObj(e.Object))
 	return true
 }
 
@@ -253,14 +243,19 @@ func (h *cqHandler) Generic(_ context.Context, e event.GenericEvent, q workqueue
 
 // SetupWithManager sets up the controller with the Manager.
 func (r *ResourceFlavorReconciler) SetupWithManager(mgr ctrl.Manager, cfg *config.Configuration) error {
-	handler := cqHandler{
+	h := cqHandler{
 		cache: r.cache,
 	}
-	return ctrl.NewControllerManagedBy(mgr).
-		For(&kueue.ResourceFlavor{}).
+	return builder.TypedControllerManagedBy[reconcile.Request](mgr).
+		Named("resourceflavor_controller").
+		WatchesRawSource(source.TypedKind(
+			mgr.GetCache(),
+			&kueue.ResourceFlavor{},
+			&handler.TypedEnqueueRequestForObject[*kueue.ResourceFlavor]{},
+			r,
+		)).
 		WithOptions(controller.Options{NeedLeaderElection: ptr.To(false)}).
-		WatchesRawSource(source.Channel(r.cqUpdateCh, &handler)).
-		WithEventFilter(r).
+		WatchesRawSource(source.Channel(r.cqUpdateCh, &h)).
 		Complete(WithLeadingManager(mgr, r, &kueue.ResourceFlavor{}, cfg))
 }
 
diff --git a/pkg/controller/core/workload_controller.go b/pkg/controller/core/workload_controller.go
index a097dde19..6619edafa 100644
--- a/pkg/controller/core/workload_controller.go
+++ b/pkg/controller/core/workload_controller.go
@@ -38,11 +38,14 @@ import (
 	"k8s.io/utils/clock"
 	"k8s.io/utils/ptr"
 	ctrl "sigs.k8s.io/controller-runtime"
+	"sigs.k8s.io/controller-runtime/pkg/builder"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 	"sigs.k8s.io/controller-runtime/pkg/controller"
 	"sigs.k8s.io/controller-runtime/pkg/event"
 	"sigs.k8s.io/controller-runtime/pkg/handler"
+	"sigs.k8s.io/controller-runtime/pkg/predicate"
 	"sigs.k8s.io/controller-runtime/pkg/reconcile"
+	"sigs.k8s.io/controller-runtime/pkg/source"
 
 	config "sigs.k8s.io/kueue/apis/config/v1beta1"
 	kueue "sigs.k8s.io/kueue/apis/kueue/v1beta1"
@@ -109,6 +112,9 @@ type WorkloadReconciler struct {
 	clock            clock.Clock
 }
 
+var _ reconcile.Reconciler = (*WorkloadReconciler)(nil)
+var _ predicate.TypedPredicate[*kueue.Workload] = (*WorkloadReconciler)(nil)
+
 func NewWorkloadReconciler(client client.Client, queues *queue.Manager, cache *cache.Cache, recorder record.EventRecorder, opts ...Option) *WorkloadReconciler {
 	options := defaultOptions
 	for _, opt := range opts {
@@ -588,15 +594,10 @@ func (r *WorkloadReconciler) triggerDeactivationOrBackoffRequeue(ctx context.Con
 	return false, nil
 }
 
-func (r *WorkloadReconciler) Create(e event.CreateEvent) bool {
-	wl, isWorkload := e.Object.(*kueue.Workload)
-	if !isWorkload {
-		// this event will be handled by the LimitRange/RuntimeClass handle
-		return true
-	}
-	defer r.notifyWatchers(nil, wl)
-	status := workload.Status(wl)
-	log := r.log.WithValues("workload", klog.KObj(wl), "queue", wl.Spec.QueueName, "status", status)
+func (r *WorkloadReconciler) Create(e event.TypedCreateEvent[*kueue.Workload]) bool {
+	defer r.notifyWatchers(nil, e.Object)
+	status := workload.Status(e.Object)
+	log := r.log.WithValues("workload", klog.KObj(e.Object), "queue", e.Object.Spec.QueueName, "status", status)
 	log.V(2).Info("Workload create event")
 
 	if status == workload.StatusFinished {
@@ -604,10 +605,10 @@ func (r *WorkloadReconciler) Create(e event.CreateEvent) bool {
 	}
 
 	ctx := ctrl.LoggerInto(context.Background(), log)
-	wlCopy := wl.DeepCopy()
+	wlCopy := e.Object.DeepCopy()
 	workload.AdjustResources(ctx, r.client, wlCopy)
 
-	if !workload.HasQuotaReservation(wl) {
+	if !workload.HasQuotaReservation(e.Object) {
 		if err := r.queues.AddOrUpdateWorkload(wlCopy); err != nil {
 			log.V(2).Info("ignored an error for now", "error", err)
 		}
@@ -620,31 +621,26 @@ func (r *WorkloadReconciler) Create(e event.CreateEvent) bool {
 	return true
 }
 
-func (r *WorkloadReconciler) Delete(e event.DeleteEvent) bool {
-	wl, isWorkload := e.Object.(*kueue.Workload)
-	if !isWorkload {
-		// this event will be handled by the LimitRange/RuntimeClass handle
-		return true
-	}
-	defer r.notifyWatchers(wl, nil)
+func (r *WorkloadReconciler) Delete(e event.TypedDeleteEvent[*kueue.Workload]) bool {
+	defer r.notifyWatchers(e.Object, nil)
 	status := "unknown"
 	if !e.DeleteStateUnknown {
-		status = workload.Status(wl)
+		status = workload.Status(e.Object)
 	}
-	log := r.log.WithValues("workload", klog.KObj(wl), "queue", wl.Spec.QueueName, "status", status)
+	log := r.log.WithValues("workload", klog.KObj(e.Object), "queue", e.Object.Spec.QueueName, "status", status)
 	log.V(2).Info("Workload delete event")
 	ctx := ctrl.LoggerInto(context.Background(), log)
 
 	// 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.
-	if workload.HasQuotaReservation(wl) || e.DeleteStateUnknown {
+	if workload.HasQuotaReservation(e.Object) || e.DeleteStateUnknown {
 		// trigger the move of associated inadmissibleWorkloads if required.
-		r.queues.QueueAssociatedInadmissibleWorkloadsAfter(ctx, wl, func() {
+		r.queues.QueueAssociatedInadmissibleWorkloadsAfter(ctx, e.Object, func() {
 			// Delete the workload from cache while holding the queues lock
 			// to guarantee that requeued workloads are taken into account before
 			// the next scheduling cycle.
-			if err := r.cache.DeleteWorkload(wl); err != nil {
+			if err := r.cache.DeleteWorkload(e.Object); err != nil {
 				if !e.DeleteStateUnknown {
 					log.Error(err, "Failed to delete workload from cache")
 				}
@@ -654,85 +650,79 @@ func (r *WorkloadReconciler) Delete(e event.DeleteEvent) bool {
 
 	// Even if the state is unknown, the last cached state tells us whether the
 	// workload was in the queues and should be cleared from them.
-	r.queues.DeleteWorkload(wl)
+	r.queues.DeleteWorkload(e.Object)
 
 	return true
 }
 
-func (r *WorkloadReconciler) Update(e event.UpdateEvent) bool {
-	oldWl, isWorkload := e.ObjectOld.(*kueue.Workload)
-	if !isWorkload {
-		// this event will be handled by the LimitRange/RuntimeClass handle
-		return true
-	}
-	wl := e.ObjectNew.(*kueue.Workload)
-	defer r.notifyWatchers(oldWl, wl)
+func (r *WorkloadReconciler) Update(e event.TypedUpdateEvent[*kueue.Workload]) bool {
+	defer r.notifyWatchers(e.ObjectOld, e.ObjectNew)
 
-	status := workload.Status(wl)
-	log := r.log.WithValues("workload", klog.KObj(wl), "queue", wl.Spec.QueueName, "status", status)
+	status := workload.Status(e.ObjectNew)
+	log := r.log.WithValues("workload", klog.KObj(e.ObjectNew), "queue", e.ObjectNew.Spec.QueueName, "status", status)
 	ctx := ctrl.LoggerInto(context.Background(), log)
-	active := workload.IsActive(wl)
+	active := workload.IsActive(e.ObjectNew)
 
-	prevQueue := oldWl.Spec.QueueName
-	if prevQueue != wl.Spec.QueueName {
+	prevQueue := e.ObjectOld.Spec.QueueName
+	if prevQueue != e.ObjectNew.Spec.QueueName {
 		log = log.WithValues("prevQueue", prevQueue)
 	}
-	prevStatus := workload.Status(oldWl)
+	prevStatus := workload.Status(e.ObjectOld)
 	if prevStatus != status {
 		log = log.WithValues("prevStatus", prevStatus)
 	}
-	if workload.HasQuotaReservation(wl) {
-		log = log.WithValues("clusterQueue", wl.Status.Admission.ClusterQueue)
+	if workload.HasQuotaReservation(e.ObjectNew) {
+		log = log.WithValues("clusterQueue", e.ObjectNew.Status.Admission.ClusterQueue)
 	}
-	if workload.HasQuotaReservation(oldWl) && (!workload.HasQuotaReservation(wl) || wl.Status.Admission.ClusterQueue != oldWl.Status.Admission.ClusterQueue) {
-		log = log.WithValues("prevClusterQueue", oldWl.Status.Admission.ClusterQueue)
+	if workload.HasQuotaReservation(e.ObjectOld) && (!workload.HasQuotaReservation(e.ObjectNew) || e.ObjectNew.Status.Admission.ClusterQueue != e.ObjectOld.Status.Admission.ClusterQueue) {
+		log = log.WithValues("prevClusterQueue", e.ObjectOld.Status.Admission.ClusterQueue)
 	}
 	log.V(2).Info("Workload update event")
 
-	wlCopy := wl.DeepCopy()
+	wlCopy := e.ObjectNew.DeepCopy()
 	// We do not handle old workload here as it will be deleted or replaced by new one anyway.
 	workload.AdjustResources(ctrl.LoggerInto(ctx, log), r.client, wlCopy)
 
 	switch {
 	case status == workload.StatusFinished || !active:
 		if !active {
-			log.V(2).Info("Workload will not be queued because the workload is not active", "workload", klog.KObj(wl))
+			log.V(2).Info("Workload will not be queued because the workload is not active", "workload", klog.KObj(e.ObjectNew))
 		}
 		// The workload could have been in the queues if we missed an event.
-		r.queues.DeleteWorkload(wl)
+		r.queues.DeleteWorkload(e.ObjectNew)
 
 		// trigger the move of associated inadmissibleWorkloads, if there are any.
-		r.queues.QueueAssociatedInadmissibleWorkloadsAfter(ctx, wl, func() {
+		r.queues.QueueAssociatedInadmissibleWorkloadsAfter(ctx, e.ObjectNew, func() {
 			// Delete the workload from cache while holding the queues lock
 			// to guarantee that requeued workloads are taken into account before
 			// the next scheduling cycle.
-			if err := r.cache.DeleteWorkload(oldWl); err != nil && prevStatus == workload.StatusAdmitted {
+			if err := r.cache.DeleteWorkload(e.ObjectOld); err != nil && prevStatus == workload.StatusAdmitted {
 				log.Error(err, "Failed to delete workload from cache")
 			}
 		})
 
 	case prevStatus == workload.StatusPending && status == workload.StatusPending:
-		err := r.queues.UpdateWorkload(oldWl, wlCopy)
+		err := r.queues.UpdateWorkload(e.ObjectOld, wlCopy)
 		if err != nil {
 			log.V(2).Info("ignored an error for now", "error", err)
 		}
 	case prevStatus == workload.StatusPending && (status == workload.StatusQuotaReserved || status == workload.StatusAdmitted):
-		r.queues.DeleteWorkload(oldWl)
+		r.queues.DeleteWorkload(e.ObjectOld)
 		if !r.cache.AddOrUpdateWorkload(wlCopy) {
 			log.V(2).Info("ClusterQueue for workload didn't exist; ignored for now")
 		}
 	case (prevStatus == workload.StatusQuotaReserved || prevStatus == workload.StatusAdmitted) && status == workload.StatusPending:
 		var backoff time.Duration
 		if wlCopy.Status.RequeueState != nil && wlCopy.Status.RequeueState.RequeueAt != nil {
-			backoff = time.Until(wl.Status.RequeueState.RequeueAt.Time)
+			backoff = time.Until(e.ObjectNew.Status.RequeueState.RequeueAt.Time)
 		}
 		immediate := backoff <= 0
 		// trigger the move of associated inadmissibleWorkloads, if there are any.
-		r.queues.QueueAssociatedInadmissibleWorkloadsAfter(ctx, wl, func() {
+		r.queues.QueueAssociatedInadmissibleWorkloadsAfter(ctx, e.ObjectNew, func() {
 			// Delete the workload from cache while holding the queues lock
 			// to guarantee that requeued workloads are taken into account before
 			// the next scheduling cycle.
-			if err := r.cache.DeleteWorkload(wl); err != nil {
+			if err := r.cache.DeleteWorkload(e.ObjectNew); err != nil {
 				log.Error(err, "Failed to delete workload from cache")
 			}
 			// Here we don't take the lock as it is already taken by the wrapping
@@ -745,10 +735,10 @@ func (r *WorkloadReconciler) Update(e event.UpdateEvent) bool {
 		})
 
 		if !immediate {
-			log.V(3).Info("Workload to be requeued after backoff", "backoff", backoff, "requeueAt", wl.Status.RequeueState.RequeueAt.Time)
+			log.V(3).Info("Workload to be requeued after backoff", "backoff", backoff, "requeueAt", e.ObjectNew.Status.RequeueState.RequeueAt.Time)
 			time.AfterFunc(backoff, func() {
 				updatedWl := kueue.Workload{}
-				err := r.client.Get(ctx, client.ObjectKeyFromObject(wl), &updatedWl)
+				err := r.client.Get(ctx, client.ObjectKeyFromObject(e.ObjectNew), &updatedWl)
 				if err == nil && workload.Status(&updatedWl) == workload.StatusPending {
 					if err = r.queues.AddOrUpdateWorkload(wlCopy); err != nil {
 						log.V(2).Info("ignored an error for now", "error", err)
@@ -758,13 +748,13 @@ func (r *WorkloadReconciler) Update(e event.UpdateEvent) bool {
 				}
 			})
 		}
-	case prevStatus == workload.StatusAdmitted && status == workload.StatusAdmitted && !equality.Semantic.DeepEqual(oldWl.Status.ReclaimablePods, wl.Status.ReclaimablePods):
+	case prevStatus == workload.StatusAdmitted && status == workload.StatusAdmitted && !equality.Semantic.DeepEqual(e.ObjectOld.Status.ReclaimablePods, e.ObjectNew.Status.ReclaimablePods):
 		// trigger the move of associated inadmissibleWorkloads, if there are any.
-		r.queues.QueueAssociatedInadmissibleWorkloadsAfter(ctx, wl, func() {
+		r.queues.QueueAssociatedInadmissibleWorkloadsAfter(ctx, e.ObjectNew, func() {
 			// Update the workload from cache while holding the queues lock
 			// to guarantee that requeued workloads are taken into account before
 			// the next scheduling cycle.
-			if err := r.cache.UpdateWorkload(oldWl, wlCopy); err != nil {
+			if err := r.cache.UpdateWorkload(e.ObjectOld, wlCopy); err != nil {
 				log.Error(err, "Failed to delete workload from cache")
 			}
 		})
@@ -772,7 +762,7 @@ func (r *WorkloadReconciler) Update(e event.UpdateEvent) bool {
 	default:
 		// Workload update in the cache is handled here; however, some fields are immutable
 		// and are not supposed to actually change anything.
-		if err := r.cache.UpdateWorkload(oldWl, wlCopy); err != nil {
+		if err := r.cache.UpdateWorkload(e.ObjectOld, wlCopy); err != nil {
 			log.Error(err, "Updating workload in cache")
 		}
 	}
@@ -780,8 +770,8 @@ func (r *WorkloadReconciler) Update(e event.UpdateEvent) bool {
 	return true
 }
 
-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())
+func (r *WorkloadReconciler) Generic(e event.TypedGenericEvent[*kueue.Workload]) bool {
+	r.log.V(3).Info("Ignore Workload generic event", "workload", klog.KObj(e.Object))
 	return false
 }
 
@@ -795,14 +785,19 @@ func (r *WorkloadReconciler) notifyWatchers(oldWl, newWl *kueue.Workload) {
 func (r *WorkloadReconciler) SetupWithManager(mgr ctrl.Manager, cfg *config.Configuration) error {
 	ruh := &resourceUpdatesHandler{r: r}
 	wqh := &workloadQueueHandler{r: r}
-	return ctrl.NewControllerManagedBy(mgr).
-		For(&kueue.Workload{}).
+	return builder.TypedControllerManagedBy[reconcile.Request](mgr).
+		Named("workload_controller").
+		WatchesRawSource(source.TypedKind(
+			mgr.GetCache(),
+			&kueue.Workload{},
+			&handler.TypedEnqueueRequestForObject[*kueue.Workload]{},
+			r,
+		)).
 		WithOptions(controller.Options{NeedLeaderElection: ptr.To(false)}).
 		Watches(&corev1.LimitRange{}, ruh).
 		Watches(&nodev1.RuntimeClass{}, ruh).
 		Watches(&kueue.ClusterQueue{}, wqh).
 		Watches(&kueue.LocalQueue{}, wqh).
-		WithEventFilter(r).
 		Complete(WithLeadingManager(mgr, r, &kueue.Workload{}, cfg))
 }
 
diff --git a/pkg/controller/jobs/jobset/OWNERS b/pkg/controller/jobs/jobset/OWNERS
new file mode 100644
index 000000000..ef7abba9d
--- /dev/null
+++ b/pkg/controller/jobs/jobset/OWNERS
@@ -0,0 +1,5 @@
+# See the OWNERS docs at https://go.k8s.io/owners
+
+reviewers:
+- kannon92
+
diff --git a/pkg/controller/jobs/pod/pod_controller.go b/pkg/controller/jobs/pod/pod_controller.go
index 6cdc275f9..c42a200df 100644
--- a/pkg/controller/jobs/pod/pod_controller.go
+++ b/pkg/controller/jobs/pod/pod_controller.go
@@ -268,8 +268,7 @@ func (p *Pod) Run(ctx context.Context, c client.Client, podSetsInfo []podset.Pod
 		}
 
 		if err := clientutil.Patch(ctx, c, &p.pod, true, func() (bool, error) {
-			ungate(&p.pod)
-			return true, podset.Merge(&p.pod.ObjectMeta, &p.pod.Spec, podSetsInfo[0])
+			return true, prepare(&p.pod, podSetsInfo[0])
 		}); err != nil {
 			return err
 		}
@@ -289,8 +288,6 @@ func (p *Pod) Run(ctx context.Context, c client.Client, podSetsInfo []podset.Pod
 		}
 
 		if err := clientutil.Patch(ctx, c, pod, true, func() (bool, error) {
-			ungate(pod)
-
 			roleHash, err := getRoleHash(*pod)
 			if err != nil {
 				return false, err
@@ -303,7 +300,7 @@ func (p *Pod) Run(ctx context.Context, c client.Client, podSetsInfo []podset.Pod
 				return false, fmt.Errorf("%w: podSetInfo with the name '%s' is not found", podset.ErrInvalidPodsetInfo, roleHash)
 			}
 
-			err = podset.Merge(&pod.ObjectMeta, &pod.Spec, podSetsInfo[podSetIndex])
+			err = prepare(pod, podSetsInfo[podSetIndex])
 			if err != nil {
 				return false, err
 			}
@@ -1342,8 +1339,16 @@ func isGated(pod *corev1.Pod) bool {
 	return utilpod.HasGate(pod, podconstants.SchedulingGateName)
 }
 
-func ungate(pod *corev1.Pod) bool {
-	return utilpod.Ungate(pod, podconstants.SchedulingGateName)
+func prepare(pod *corev1.Pod, info podset.PodSetInfo) error {
+	if err := podset.Merge(&pod.ObjectMeta, &pod.Spec, info); err != nil {
+		return err
+	}
+	utilpod.Ungate(pod, podconstants.SchedulingGateName)
+	// Remove the TopologySchedulingGate if the Pod is scheduled without using TAS
+	if _, found := pod.Labels[kueuealpha.TASLabel]; !found {
+		utilpod.Ungate(pod, kueuealpha.TopologySchedulingGate)
+	}
+	return nil
 }
 
 func gate(pod *corev1.Pod) bool {
diff --git a/pkg/controller/jobs/pod/pod_webhook.go b/pkg/controller/jobs/pod/pod_webhook.go
index a8ccf767d..a3c0513a5 100644
--- a/pkg/controller/jobs/pod/pod_webhook.go
+++ b/pkg/controller/jobs/pod/pod_webhook.go
@@ -28,7 +28,6 @@ import (
 	"k8s.io/apimachinery/pkg/labels"
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/util/validation/field"
-	"k8s.io/utils/ptr"
 	ctrl "sigs.k8s.io/controller-runtime"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 	"sigs.k8s.io/controller-runtime/pkg/controller/controllerutil"
@@ -207,11 +206,7 @@ func (w *PodWebhook) Default(ctx context.Context, obj runtime.Object) error {
 			if val, ok := pod.pod.Annotations[kueuealpha.PodGroupPodIndexLabelAnnotation]; ok {
 				pod.pod.Labels[kueuealpha.PodGroupPodIndexLabel] = pod.pod.Labels[val]
 			}
-
-			if jobframework.PodSetTopologyRequest(&pod.pod.ObjectMeta, ptr.To(kueuealpha.PodGroupPodIndexLabel), nil, nil) != nil {
-				pod.pod.Labels[kueuealpha.TASLabel] = "true"
-				utilpod.Gate(&pod.pod, kueuealpha.TopologySchedulingGate)
-			}
+			utilpod.Gate(&pod.pod, kueuealpha.TopologySchedulingGate)
 		}
 
 		if podGroupName(pod.pod) != "" {
diff --git a/pkg/controller/tas/resource_flavor.go b/pkg/controller/tas/resource_flavor.go
index 0e653a439..9e5a5516a 100644
--- a/pkg/controller/tas/resource_flavor.go
+++ b/pkg/controller/tas/resource_flavor.go
@@ -18,7 +18,6 @@ package tas
 
 import (
 	"context"
-	"time"
 
 	corev1 "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/types"
@@ -37,14 +36,11 @@ import (
 	kueuealpha "sigs.k8s.io/kueue/apis/kueue/v1alpha1"
 	kueue "sigs.k8s.io/kueue/apis/kueue/v1beta1"
 	"sigs.k8s.io/kueue/pkg/cache"
+	"sigs.k8s.io/kueue/pkg/constants"
 	"sigs.k8s.io/kueue/pkg/controller/core"
 	"sigs.k8s.io/kueue/pkg/queue"
 )
 
-const (
-	nodeBatchPeriod = time.Second
-)
-
 type rfReconciler struct {
 	queues   *queue.Manager
 	cache    *cache.Cache
@@ -125,7 +121,7 @@ func (h *nodeHandler) queueReconcileForNode(node *corev1.Node, q workqueue.Typed
 		if nodeBelongsToFlavor(node, flavor.NodeLabels, flavor.Levels) {
 			q.AddAfter(reconcile.Request{NamespacedName: types.NamespacedName{
 				Name: string(name),
-			}}, nodeBatchPeriod)
+			}}, constants.UpdatesBatchPeriod)
 		}
 	}
 }
diff --git a/pkg/controller/tas/topology_controller.go b/pkg/controller/tas/topology_controller.go
index 0cc35b077..74032d715 100644
--- a/pkg/controller/tas/topology_controller.go
+++ b/pkg/controller/tas/topology_controller.go
@@ -37,6 +37,7 @@ import (
 	kueuealpha "sigs.k8s.io/kueue/apis/kueue/v1alpha1"
 	kueue "sigs.k8s.io/kueue/apis/kueue/v1beta1"
 	"sigs.k8s.io/kueue/pkg/cache"
+	"sigs.k8s.io/kueue/pkg/constants"
 	"sigs.k8s.io/kueue/pkg/controller/core"
 	"sigs.k8s.io/kueue/pkg/controller/tas/indexer"
 	"sigs.k8s.io/kueue/pkg/queue"
@@ -206,5 +207,5 @@ func (h *resourceFlavorHandler) Delete(_ context.Context, e event.DeleteEvent, q
 		NamespacedName: types.NamespacedName{
 			Name: string(*resourceFlavor.Spec.TopologyName),
 		},
-	}, nodeBatchPeriod)
+	}, constants.UpdatesBatchPeriod)
 }
diff --git a/pkg/controller/tas/topology_ungater.go b/pkg/controller/tas/topology_ungater.go
index 386b08ab3..e8e5d4498 100644
--- a/pkg/controller/tas/topology_ungater.go
+++ b/pkg/controller/tas/topology_ungater.go
@@ -21,7 +21,6 @@ import (
 	"errors"
 	"fmt"
 	"slices"
-	"time"
 
 	"github.com/go-logr/logr"
 	corev1 "k8s.io/api/core/v1"
@@ -40,6 +39,7 @@ import (
 	configapi "sigs.k8s.io/kueue/apis/config/v1beta1"
 	kueuealpha "sigs.k8s.io/kueue/apis/kueue/v1alpha1"
 	kueue "sigs.k8s.io/kueue/apis/kueue/v1beta1"
+	"sigs.k8s.io/kueue/pkg/constants"
 	"sigs.k8s.io/kueue/pkg/controller/core"
 	"sigs.k8s.io/kueue/pkg/controller/tas/indexer"
 	utilclient "sigs.k8s.io/kueue/pkg/util/client"
@@ -51,10 +51,6 @@ import (
 	"sigs.k8s.io/kueue/pkg/workload"
 )
 
-const (
-	ungateBatchPeriod = time.Second
-)
-
 var (
 	errPendingUngateOps = errors.New("pending ungate operations")
 )
@@ -142,7 +138,7 @@ func (h *podHandler) queueReconcileForPod(ctx context.Context, object client.Obj
 			log := ctrl.LoggerFrom(ctx).WithValues("pod", klog.KObj(pod), "workload", key.String())
 			h.expectationsStore.ObservedUID(log, key, pod.UID)
 		}
-		q.AddAfter(reconcile.Request{NamespacedName: key}, ungateBatchPeriod)
+		q.AddAfter(reconcile.Request{NamespacedName: key}, constants.UpdatesBatchPeriod)
 	}
 }
 
diff --git a/site/OWNERS b/site/OWNERS
index dfa91ceb6..5dbff6270 100644
--- a/site/OWNERS
+++ b/site/OWNERS
@@ -2,3 +2,7 @@
 
 approvers:
 - moficodes
+
+reviewers:
+- kannon92
+



Test patch:
diff --git a/pkg/controller/core/cohort_controller_test.go b/pkg/controller/core/cohort_controller_test.go
index 0a3932b6c..8212103f5 100644
--- a/pkg/controller/core/cohort_controller_test.go
+++ b/pkg/controller/core/cohort_controller_test.go
@@ -27,6 +27,7 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/event"
 	"sigs.k8s.io/controller-runtime/pkg/reconcile"
 
+	kueue "sigs.k8s.io/kueue/apis/kueue/v1alpha1"
 	"sigs.k8s.io/kueue/pkg/cache"
 	"sigs.k8s.io/kueue/pkg/queue"
 	"sigs.k8s.io/kueue/pkg/resources"
@@ -283,38 +284,28 @@ func TestCohortReconcilerFilters(t *testing.T) {
 	reconciler := NewCohortReconciler(cl, cache, qManager)
 
 	t.Run("delete returns true", func(t *testing.T) {
-		if !reconciler.Delete(event.DeleteEvent{}) {
+		if !reconciler.Delete(event.TypedDeleteEvent[*kueue.Cohort]{}) {
 			t.Fatal("expected delete to return true")
 		}
 	})
 
 	t.Run("create returns true", func(t *testing.T) {
-		if !reconciler.Create(event.CreateEvent{}) {
+		if !reconciler.Create(event.TypedCreateEvent[*kueue.Cohort]{}) {
 			t.Fatal("expected create to return true")
 		}
 	})
 
 	t.Run("generic returns true", func(t *testing.T) {
-		if !reconciler.Generic(event.GenericEvent{}) {
+		if !reconciler.Generic(event.TypedGenericEvent[*kueue.Cohort]{}) {
 			t.Fatal("expected generic to return true")
 		}
 	})
 
 	cases := map[string]struct {
-		old  client.Object
-		new  client.Object
+		old  *kueue.Cohort
+		new  *kueue.Cohort
 		want bool
 	}{
-		"old wrong type returns false": {
-			old:  utiltesting.MakeClusterQueue("cq").Obj(),
-			new:  utiltesting.MakeCohort("cohort").Obj(),
-			want: false,
-		},
-		"new wrong type returns false": {
-			old:  utiltesting.MakeCohort("cohort").Obj(),
-			new:  utiltesting.MakeClusterQueue("cq").Obj(),
-			want: false,
-		},
 		"unchanged returns false": {
 			old: utiltesting.MakeCohort("cohort").ResourceGroup(
 				utiltesting.MakeFlavorQuotas("red").Resource("cpu", "5").FlavorQuotas,
@@ -351,11 +342,11 @@ func TestCohortReconcilerFilters(t *testing.T) {
 	}
 	for name, tc := range cases {
 		t.Run(name, func(t *testing.T) {
-			event := event.UpdateEvent{
+			e := event.TypedUpdateEvent[*kueue.Cohort]{
 				ObjectOld: tc.old,
 				ObjectNew: tc.new,
 			}
-			if reconciler.Update(event) != tc.want {
+			if reconciler.Update(e) != tc.want {
 				t.Fatalf("expected %v, got %v", tc.want, !tc.want)
 			}
 		})
diff --git a/pkg/controller/jobs/pod/pod_webhook_test.go b/pkg/controller/jobs/pod/pod_webhook_test.go
index 50da59804..463062000 100644
--- a/pkg/controller/jobs/pod/pod_webhook_test.go
+++ b/pkg/controller/jobs/pod/pod_webhook_test.go
@@ -308,7 +308,6 @@ func TestDefault(t *testing.T) {
 				Queue("test-queue").
 				Annotation(kueuealpha.PodSetRequiredTopologyAnnotation, "block").
 				ManagedByKueueLabel().
-				Label(kueuealpha.TASLabel, "true").
 				KueueFinalizer().
 				KueueSchedulingGate().
 				TopologySchedulingGate().
diff --git a/pkg/util/testing/wrappers.go b/pkg/util/testing/wrappers.go
index 5cc5f68b2..f1f408708 100644
--- a/pkg/util/testing/wrappers.go
+++ b/pkg/util/testing/wrappers.go
@@ -122,6 +122,10 @@ func (w *WorkloadWrapper) Limit(r corev1.ResourceName, q string) *WorkloadWrappe
 	return w
 }
 
+func (w *WorkloadWrapper) RequestAndLimit(r corev1.ResourceName, q string) *WorkloadWrapper {
+	return w.Request(r, q).Limit(r, q)
+}
+
 func (w *WorkloadWrapper) Queue(q string) *WorkloadWrapper {
 	w.Spec.QueueName = q
 	return w
diff --git a/pkg/util/testingjobs/deployment/wrappers.go b/pkg/util/testingjobs/deployment/wrappers.go
index 16af7af32..facd3e8b2 100644
--- a/pkg/util/testingjobs/deployment/wrappers.go
+++ b/pkg/util/testingjobs/deployment/wrappers.go
@@ -107,6 +107,20 @@ func (d *DeploymentWrapper) Request(r corev1.ResourceName, v string) *Deployment
 	return d
 }
 
+// Limit adds a resource limit to the default container.
+func (d *DeploymentWrapper) Limit(r corev1.ResourceName, v string) *DeploymentWrapper {
+	if d.Spec.Template.Spec.Containers[0].Resources.Limits == nil {
+		d.Spec.Template.Spec.Containers[0].Resources.Limits = corev1.ResourceList{}
+	}
+	d.Spec.Template.Spec.Containers[0].Resources.Limits[r] = resource.MustParse(v)
+	return d
+}
+
+// RequestAndLimit adds a resource request and limit to the default container.
+func (d *DeploymentWrapper) RequestAndLimit(r corev1.ResourceName, v string) *DeploymentWrapper {
+	return d.Request(r, v).Limit(r, v)
+}
+
 // Replicas updated the replicas of the Deployment
 func (d *DeploymentWrapper) Replicas(replicas int32) *DeploymentWrapper {
 	d.Spec.Replicas = &replicas
diff --git a/pkg/util/testingjobs/job/wrappers.go b/pkg/util/testingjobs/job/wrappers.go
index c4b08d9d4..5b4ac1cb2 100644
--- a/pkg/util/testingjobs/job/wrappers.go
+++ b/pkg/util/testingjobs/job/wrappers.go
@@ -186,6 +186,11 @@ func (j *JobWrapper) Limit(r corev1.ResourceName, v string) *JobWrapper {
 	return j
 }
 
+// RequestAndLimit adds a resource request and limit to the default container.
+func (j *JobWrapper) RequestAndLimit(r corev1.ResourceName, v string) *JobWrapper {
+	return j.Request(r, v).Limit(r, v)
+}
+
 func (j *JobWrapper) Image(image string, args []string) *JobWrapper {
 	j.Spec.Template.Spec.Containers[0].Image = image
 	j.Spec.Template.Spec.Containers[0].Args = args
diff --git a/pkg/util/testingjobs/jobset/wrappers.go b/pkg/util/testingjobs/jobset/wrappers.go
index f785c71c2..02c3e8559 100644
--- a/pkg/util/testingjobs/jobset/wrappers.go
+++ b/pkg/util/testingjobs/jobset/wrappers.go
@@ -154,6 +154,11 @@ func (j *JobSetWrapper) Limit(replicatedJobName string, r corev1.ResourceName, v
 	return j
 }
 
+// RequestAndLimit adds a resource request and limit to the first container of the target replicatedJob.
+func (j *JobSetWrapper) RequestAndLimit(replicatedJobName string, r corev1.ResourceName, v string) *JobSetWrapper {
+	return j.Request(replicatedJobName, r, v).Limit(replicatedJobName, r, v)
+}
+
 // PriorityClass updates JobSet priorityclass.
 func (j *JobSetWrapper) PriorityClass(pc string) *JobSetWrapper {
 	for i := range j.Spec.ReplicatedJobs {
diff --git a/pkg/util/testingjobs/leaderworkerset/wrappers.go b/pkg/util/testingjobs/leaderworkerset/wrappers.go
index 646ea989d..45c22f14d 100644
--- a/pkg/util/testingjobs/leaderworkerset/wrappers.go
+++ b/pkg/util/testingjobs/leaderworkerset/wrappers.go
@@ -186,6 +186,11 @@ func (w *LeaderWorkerSetWrapper) Limit(r corev1.ResourceName, v string) *LeaderW
 	return w
 }
 
+// RequestAndLimit adds a resource request and limit to the default container.
+func (w *LeaderWorkerSetWrapper) RequestAndLimit(r corev1.ResourceName, v string) *LeaderWorkerSetWrapper {
+	return w.Request(r, v).Limit(r, v)
+}
+
 // LeaderTemplate sets the leader template of the LeaderWorkerSet.
 func (w *LeaderWorkerSetWrapper) LeaderTemplate(leader corev1.PodTemplateSpec) *LeaderWorkerSetWrapper {
 	w.Spec.LeaderWorkerTemplate.LeaderTemplate = &leader
diff --git a/pkg/util/testingjobs/mpijob/wrappers_mpijob.go b/pkg/util/testingjobs/mpijob/wrappers_mpijob.go
index 0ec4b6f32..afc85ab6a 100644
--- a/pkg/util/testingjobs/mpijob/wrappers_mpijob.go
+++ b/pkg/util/testingjobs/mpijob/wrappers_mpijob.go
@@ -178,6 +178,11 @@ func (j *MPIJobWrapper) Limit(replicaType kfmpi.MPIReplicaType, r corev1.Resourc
 	return j
 }
 
+// RequestAndLimit adds a resource request and limit to the default container.
+func (j *MPIJobWrapper) RequestAndLimit(replicaType kfmpi.MPIReplicaType, r corev1.ResourceName, v string) *MPIJobWrapper {
+	return j.Request(replicaType, r, v).Limit(replicaType, r, v)
+}
+
 // Parallelism updates job parallelism.
 func (j *MPIJobWrapper) Parallelism(p int32) *MPIJobWrapper {
 	j.Spec.MPIReplicaSpecs[kfmpi.MPIReplicaTypeWorker].Replicas = ptr.To(p)
diff --git a/pkg/util/testingjobs/pod/wrappers.go b/pkg/util/testingjobs/pod/wrappers.go
index 81b739aad..6f168adc7 100644
--- a/pkg/util/testingjobs/pod/wrappers.go
+++ b/pkg/util/testingjobs/pod/wrappers.go
@@ -221,6 +221,11 @@ func (p *PodWrapper) Request(r corev1.ResourceName, v string) *PodWrapper {
 	return p
 }
 
+// RequestAndLimit adds a resource request and limit to the default container.
+func (p *PodWrapper) RequestAndLimit(r corev1.ResourceName, v string) *PodWrapper {
+	return p.Request(r, v).Limit(r, v)
+}
+
 func (p *PodWrapper) ServiceAccountName(serviceAccountName string) *PodWrapper {
 	p.Spec.ServiceAccountName = serviceAccountName
 	return p
diff --git a/pkg/util/testingjobs/pytorchjob/wrappers_pytorchjob.go b/pkg/util/testingjobs/pytorchjob/wrappers_pytorchjob.go
index 443c64683..353edca10 100644
--- a/pkg/util/testingjobs/pytorchjob/wrappers_pytorchjob.go
+++ b/pkg/util/testingjobs/pytorchjob/wrappers_pytorchjob.go
@@ -179,6 +179,11 @@ func (j *PyTorchJobWrapper) Limit(replicaType kftraining.ReplicaType, r corev1.R
 	return j
 }
 
+// RequestAndLimit adds a resource request and limit to the default container.
+func (j *PyTorchJobWrapper) RequestAndLimit(replicaType kftraining.ReplicaType, r corev1.ResourceName, v string) *PyTorchJobWrapper {
+	return j.Request(replicaType, r, v).Limit(replicaType, r, v)
+}
+
 // Parallelism updates job parallelism.
 func (j *PyTorchJobWrapper) Parallelism(p int32) *PyTorchJobWrapper {
 	j.Spec.PyTorchReplicaSpecs[kftraining.PyTorchJobReplicaTypeWorker].Replicas = ptr.To(p)
diff --git a/pkg/util/testingjobs/raycluster/wrappers.go b/pkg/util/testingjobs/raycluster/wrappers.go
index b91b3a055..e47f73254 100644
--- a/pkg/util/testingjobs/raycluster/wrappers.go
+++ b/pkg/util/testingjobs/raycluster/wrappers.go
@@ -210,6 +210,21 @@ func (j *ClusterWrapper) Request(rayType rayv1.RayNodeType, r corev1.ResourceNam
 	return j
 }
 
+// Limit adds a resource limit to the default container.
+func (j *ClusterWrapper) Limit(rayType rayv1.RayNodeType, r corev1.ResourceName, v string) *ClusterWrapper {
+	if rayType == rayv1.HeadNode {
+		j.Spec.HeadGroupSpec.Template.Spec.Containers[0].Resources.Limits[r] = resource.MustParse(v)
+	} else if rayType == rayv1.WorkerNode {
+		j.Spec.WorkerGroupSpecs[0].Template.Spec.Containers[0].Resources.Limits[r] = resource.MustParse(v)
+	}
+	return j
+}
+
+// RequestAndLimit adds a resource request and limit to the default container.
+func (j *ClusterWrapper) RequestAndLimit(rayType rayv1.RayNodeType, r corev1.ResourceName, v string) *ClusterWrapper {
+	return j.Request(rayType, r, v).Limit(rayType, r, v)
+}
+
 func (j *ClusterWrapper) Image(rayType rayv1.RayNodeType, image string, args []string) *ClusterWrapper {
 	if rayType == rayv1.HeadNode {
 		j.Spec.HeadGroupSpec.Template.Spec.Containers[0].Image = image
diff --git a/pkg/util/testingjobs/rayjob/wrappers.go b/pkg/util/testingjobs/rayjob/wrappers.go
index 703001245..a0f3e0f25 100644
--- a/pkg/util/testingjobs/rayjob/wrappers.go
+++ b/pkg/util/testingjobs/rayjob/wrappers.go
@@ -227,6 +227,21 @@ func (j *JobWrapper) Request(rayType rayv1.RayNodeType, r corev1.ResourceName, v
 	return j
 }
 
+// Limit adds a resource request to the default container.
+func (j *JobWrapper) Limit(rayType rayv1.RayNodeType, r corev1.ResourceName, v string) *JobWrapper {
+	if rayType == rayv1.HeadNode {
+		j.Spec.RayClusterSpec.HeadGroupSpec.Template.Spec.Containers[0].Resources.Limits[r] = resource.MustParse(v)
+	} else if rayType == rayv1.WorkerNode {
+		j.Spec.RayClusterSpec.WorkerGroupSpecs[0].Template.Spec.Containers[0].Resources.Limits[r] = resource.MustParse(v)
+	}
+	return j
+}
+
+// RequestAndLimit adds a resource request and limit to the default container.
+func (j *JobWrapper) RequestAndLimit(rayType rayv1.RayNodeType, r corev1.ResourceName, v string) *JobWrapper {
+	return j.Request(rayType, r, v).Limit(rayType, r, v)
+}
+
 func (j *JobWrapper) Image(rayType rayv1.RayNodeType, image string, args ...string) *JobWrapper {
 	if rayType == rayv1.HeadNode {
 		j.Spec.RayClusterSpec.HeadGroupSpec.Template.Spec.Containers[0].Image = image
diff --git a/pkg/util/testingjobs/statefulset/wrappers.go b/pkg/util/testingjobs/statefulset/wrappers.go
index ee5efae70..f28c168b9 100644
--- a/pkg/util/testingjobs/statefulset/wrappers.go
+++ b/pkg/util/testingjobs/statefulset/wrappers.go
@@ -210,3 +210,8 @@ func (ss *StatefulSetWrapper) Limit(r corev1.ResourceName, v string) *StatefulSe
 	ss.Spec.Template.Spec.Containers[0].Resources.Limits[r] = resource.MustParse(v)
 	return ss
 }
+
+// RequestAndLimit adds a resource request and limit to the default container.
+func (ss *StatefulSetWrapper) RequestAndLimit(r corev1.ResourceName, v string) *StatefulSetWrapper {
+	return ss.Request(r, v).Limit(r, v)
+}
diff --git a/test/OWNERS b/test/OWNERS
index f8fdba0e9..497236848 100644
--- a/test/OWNERS
+++ b/test/OWNERS
@@ -1,4 +1,7 @@
 # See the OWNERS docs at https://go.k8s.io/owners
 
+reviewers:
+- kannon92
+
 emeritus_approvers:
 - trasc
diff --git a/test/e2e/customconfigs/skipjobswithoutqueuename_test.go b/test/e2e/customconfigs/skipjobswithoutqueuename_test.go
index 9199f9b6c..c4cc5fdad 100644
--- a/test/e2e/customconfigs/skipjobswithoutqueuename_test.go
+++ b/test/e2e/customconfigs/skipjobswithoutqueuename_test.go
@@ -131,7 +131,7 @@ var _ = ginkgo.Describe("ManageJobsWithoutQueueName", ginkgo.Ordered, func() {
 			numPods := 2
 			aw := awtesting.MakeAppWrapper("aw-child", ns.Name).
 				Component(testingjob.MakeJob("job-0", ns.Name).
-					Request(corev1.ResourceCPU, "100m").
+					RequestAndLimit(corev1.ResourceCPU, "200m").
 					Parallelism(int32(numPods)).
 					Completions(int32(numPods)).
 					Suspend(false).
@@ -194,7 +194,7 @@ var _ = ginkgo.Describe("ManageJobsWithoutQueueName", ginkgo.Ordered, func() {
 					).
 					SetTypeMeta().
 					Suspend(false).
-					Request("replicated-job-1", corev1.ResourceCPU, "100m").
+					RequestAndLimit("replicated-job-1", corev1.ResourceCPU, "200m").
 					Obj()).
 				Suspend(false).
 				Obj()
@@ -251,9 +251,7 @@ var _ = ginkgo.Describe("ManageJobsWithoutQueueName", ginkgo.Ordered, func() {
 				podLookupKey = types.NamespacedName{Name: testPod.Name, Namespace: ns.Name}
 				gomega.Eventually(func(g gomega.Gomega) {
 					g.Expect(k8sClient.Get(ctx, podLookupKey, createdPod)).Should(gomega.Succeed())
-					g.Expect(createdPod.Spec.SchedulingGates).Should(gomega.BeComparableTo([]corev1.PodSchedulingGate{
-						{Name: podcontroller.SchedulingGateName},
-					}))
+					g.Expect(createdPod.Spec.SchedulingGates).ShouldNot(gomega.BeEmpty())
 					g.Expect(createdPod.Labels).Should(gomega.HaveKeyWithValue(constants.ManagedByKueueLabelKey, constants.ManagedByKueueLabelValue))
 					g.Expect(createdPod.Finalizers).Should(gomega.ContainElement(podcontroller.PodFinalizer))
 				}, util.Timeout, util.Interval).Should(gomega.Succeed())
@@ -266,8 +264,8 @@ var _ = ginkgo.Describe("ManageJobsWithoutQueueName", ginkgo.Ordered, func() {
 			ginkgo.By("creating a pod without a queue name", func() {
 				testPod = testingpod.MakePod("test-pod", "kube-system").
 					Image(util.E2eTestAgnHostImage, util.BehaviorWaitForDeletion).
-					Request(corev1.ResourceCPU, "1").
-					Request(corev1.ResourceMemory, "2Gi").
+					RequestAndLimit(corev1.ResourceCPU, "1").
+					RequestAndLimit(corev1.ResourceMemory, "2Gi").
 					Obj()
 				gomega.Expect(k8sClient.Create(ctx, testPod)).Should(gomega.Succeed())
 			})
@@ -294,8 +292,8 @@ var _ = ginkgo.Describe("ManageJobsWithoutQueueName", ginkgo.Ordered, func() {
 			ginkgo.By("creating a deployment without a queue name", func() {
 				testDeploy = testingdeploy.MakeDeployment("test-deploy", ns.Name).
 					Image(util.E2eTestAgnHostImage, util.BehaviorWaitForDeletion).
-					Request(corev1.ResourceCPU, "1").
-					Request(corev1.ResourceMemory, "2Gi").
+					RequestAndLimit(corev1.ResourceCPU, "1").
+					RequestAndLimit(corev1.ResourceMemory, "2Gi").
 					Replicas(2).
 					Obj()
 				gomega.Expect(k8sClient.Create(ctx, testDeploy)).Should(gomega.Succeed())
@@ -308,9 +306,7 @@ var _ = ginkgo.Describe("ManageJobsWithoutQueueName", ginkgo.Ordered, func() {
 						client.MatchingLabels(testDeploy.Spec.Selector.MatchLabels))).To(gomega.Succeed())
 					g.Expect(pods.Items).Should(gomega.HaveLen(2))
 					for _, pod := range pods.Items {
-						g.Expect(pod.Spec.SchedulingGates).Should(gomega.BeComparableTo([]corev1.PodSchedulingGate{
-							{Name: podcontroller.SchedulingGateName},
-						}))
+						g.Expect(pod.Spec.SchedulingGates).ShouldNot(gomega.BeEmpty())
 						g.Expect(pod.Labels).Should(gomega.HaveKeyWithValue(constants.ManagedByKueueLabelKey, constants.ManagedByKueueLabelValue))
 						g.Expect(pod.Finalizers).Should(gomega.ContainElement(podcontroller.PodFinalizer))
 					}
@@ -323,8 +319,8 @@ var _ = ginkgo.Describe("ManageJobsWithoutQueueName", ginkgo.Ordered, func() {
 			ginkgo.By("creating a deployment without a queue name in the kube-system namespace", func() {
 				testDeploy = testingdeploy.MakeDeployment("test-deploy", "kube-system").
 					Image(util.E2eTestAgnHostImage, util.BehaviorWaitForDeletion).
-					Request(corev1.ResourceCPU, "1").
-					Request(corev1.ResourceMemory, "2Gi").
+					RequestAndLimit(corev1.ResourceCPU, "1").
+					RequestAndLimit(corev1.ResourceMemory, "2Gi").
 					Replicas(2).
 					Obj()
 				gomega.Expect(k8sClient.Create(ctx, testDeploy)).Should(gomega.Succeed())
@@ -358,8 +354,8 @@ var _ = ginkgo.Describe("ManageJobsWithoutQueueName", ginkgo.Ordered, func() {
 			ginkgo.By("creating a StatefulSet without a queue name", func() {
 				testSts = testingsts.MakeStatefulSet("test-sts", ns.Name).
 					Image(util.E2eTestAgnHostImage, util.BehaviorWaitForDeletion).
-					Request(corev1.ResourceCPU, "1").
-					Request(corev1.ResourceMemory, "2Gi").
+					RequestAndLimit(corev1.ResourceCPU, "1").
+					RequestAndLimit(corev1.ResourceMemory, "2Gi").
 					Replicas(2).
 					Obj()
 				gomega.Expect(k8sClient.Create(ctx, testSts)).Should(gomega.Succeed())
@@ -373,9 +369,7 @@ var _ = ginkgo.Describe("ManageJobsWithoutQueueName", ginkgo.Ordered, func() {
 					// If the first pod can't be scheduled, the second won't be created
 					g.Expect(pods.Items).Should(gomega.HaveLen(1))
 					for _, pod := range pods.Items {
-						g.Expect(pod.Spec.SchedulingGates).Should(gomega.BeComparableTo([]corev1.PodSchedulingGate{
-							{Name: podcontroller.SchedulingGateName},
-						}))
+						g.Expect(pod.Spec.SchedulingGates).ShouldNot(gomega.BeEmpty())
 						g.Expect(pod.Labels).Should(gomega.HaveKeyWithValue(constants.ManagedByKueueLabelKey, constants.ManagedByKueueLabelValue))
 						g.Expect(pod.Finalizers).Should(gomega.ContainElement(podcontroller.PodFinalizer))
 					}
@@ -388,8 +382,8 @@ var _ = ginkgo.Describe("ManageJobsWithoutQueueName", ginkgo.Ordered, func() {
 			ginkgo.By("creating a StatefulSet without a queue name in the kube-system namespace", func() {
 				testSts = testingsts.MakeStatefulSet("test-sts", "kube-system").
 					Image(util.E2eTestAgnHostImage, util.BehaviorWaitForDeletion).
-					Request(corev1.ResourceCPU, "1").
-					Request(corev1.ResourceMemory, "2Gi").
+					RequestAndLimit(corev1.ResourceCPU, "1").
+					RequestAndLimit(corev1.ResourceMemory, "2Gi").
 					Replicas(2).
 					Obj()
 				gomega.Expect(k8sClient.Create(ctx, testSts)).Should(gomega.Succeed())
diff --git a/test/e2e/customconfigs/suite_test.go b/test/e2e/customconfigs/suite_test.go
index 04f847098..5456f4765 100644
--- a/test/e2e/customconfigs/suite_test.go
+++ b/test/e2e/customconfigs/suite_test.go
@@ -25,7 +25,6 @@ import (
 
 	"github.com/onsi/ginkgo/v2"
 	"github.com/onsi/gomega"
-	ctrl "sigs.k8s.io/controller-runtime"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 
 	"sigs.k8s.io/kueue/apis/config/v1beta1"
@@ -50,7 +49,7 @@ func TestAPIs(t *testing.T) {
 }
 
 var _ = ginkgo.BeforeSuite(func() {
-	ctrl.SetLogger(util.NewTestingLogger(ginkgo.GinkgoWriter, -3))
+	util.SetupLogger()
 
 	k8sClient, _ = util.CreateClientUsingCluster("")
 	ctx = context.Background()
diff --git a/test/e2e/multikueue/e2e_test.go b/test/e2e/multikueue/e2e_test.go
index 4d2e2cc8d..ee2d83aea 100644
--- a/test/e2e/multikueue/e2e_test.go
+++ b/test/e2e/multikueue/e2e_test.go
@@ -209,8 +209,8 @@ var _ = ginkgo.Describe("MultiKueue", func() {
 		ginkgo.It("Should create a pod on worker if admitted", func() {
 			pod := testingpod.MakePod("pod", managerNs.Name).
 				Image(util.E2eTestAgnHostImage, util.BehaviorExitFast).
-				Request("cpu", "1").
-				Request("memory", "2G").
+				RequestAndLimit("cpu", "1").
+				RequestAndLimit("memory", "2G").
 				Queue(managerLq.Name).
 				Obj()
 			// Since it requires 2G of memory, this pod can only be admitted in worker 2.
@@ -396,8 +396,8 @@ var _ = ginkgo.Describe("MultiKueue", func() {
 			// Since it requires 2G of memory, this job can only be admitted in worker 2.
 			job := testingjob.MakeJob("job", managerNs.Name).
 				Queue(managerLq.Name).
-				Request("cpu", "1").
-				Request("memory", "2G").
+				RequestAndLimit("cpu", "1").
+				RequestAndLimit("memory", "2G").
 				// Give it the time to be observed Active in the live status update step.
 				Image(util.E2eTestAgnHostImage, util.BehaviorWaitForDeletion).
 				Obj()
@@ -492,8 +492,8 @@ var _ = ginkgo.Describe("MultiKueue", func() {
 						Args: util.BehaviorWaitForDeletion,
 					},
 				).
-				Request("replicated-job-1", "cpu", "500m").
-				Request("replicated-job-1", "memory", "200M").
+				RequestAndLimit("replicated-job-1", "cpu", "500m").
+				RequestAndLimit("replicated-job-1", "memory", "200M").
 				Obj()
 
 			ginkgo.By("Creating the jobSet", func() {
@@ -586,7 +586,7 @@ var _ = ginkgo.Describe("MultiKueue", func() {
 					Suspend(false).
 					Image(util.E2eTestAgnHostImage, util.BehaviorWaitForDeletion). // Give it the time to be observed Active in the live status update step.
 					Parallelism(2).
-					Request(corev1.ResourceCPU, "1").
+					RequestAndLimit(corev1.ResourceCPU, "1").
 					SetTypeMeta().Obj()).
 				Obj()
 
@@ -659,10 +659,10 @@ var _ = ginkgo.Describe("MultiKueue", func() {
 						RestartPolicy: "OnFailure",
 					},
 				).
-				Request(kftraining.PyTorchJobReplicaTypeMaster, corev1.ResourceCPU, "0.2").
-				Request(kftraining.PyTorchJobReplicaTypeMaster, corev1.ResourceMemory, "800M").
-				Request(kftraining.PyTorchJobReplicaTypeWorker, corev1.ResourceCPU, "0.5").
-				Request(kftraining.PyTorchJobReplicaTypeWorker, corev1.ResourceMemory, "800M").
+				RequestAndLimit(kftraining.PyTorchJobReplicaTypeMaster, corev1.ResourceCPU, "0.2").
+				RequestAndLimit(kftraining.PyTorchJobReplicaTypeMaster, corev1.ResourceMemory, "800M").
+				RequestAndLimit(kftraining.PyTorchJobReplicaTypeWorker, corev1.ResourceCPU, "0.5").
+				RequestAndLimit(kftraining.PyTorchJobReplicaTypeWorker, corev1.ResourceMemory, "800M").
 				Image(kftraining.PyTorchJobReplicaTypeMaster, util.E2eTestAgnHostImage, util.BehaviorExitFast).
 				Image(kftraining.PyTorchJobReplicaTypeWorker, util.E2eTestAgnHostImage, util.BehaviorExitFast).
 				Obj()
@@ -722,10 +722,10 @@ var _ = ginkgo.Describe("MultiKueue", func() {
 						RestartPolicy: "OnFailure",
 					},
 				).
-				Request(kfmpi.MPIReplicaTypeLauncher, corev1.ResourceCPU, "1").
-				Request(kfmpi.MPIReplicaTypeLauncher, corev1.ResourceMemory, "200M").
-				Request(kfmpi.MPIReplicaTypeWorker, corev1.ResourceCPU, "0.5").
-				Request(kfmpi.MPIReplicaTypeWorker, corev1.ResourceMemory, "100M").
+				RequestAndLimit(kfmpi.MPIReplicaTypeLauncher, corev1.ResourceCPU, "1").
+				RequestAndLimit(kfmpi.MPIReplicaTypeLauncher, corev1.ResourceMemory, "200M").
+				RequestAndLimit(kfmpi.MPIReplicaTypeWorker, corev1.ResourceCPU, "0.5").
+				RequestAndLimit(kfmpi.MPIReplicaTypeWorker, corev1.ResourceMemory, "100M").
 				Image(kfmpi.MPIReplicaTypeLauncher, util.E2eTestAgnHostImage, util.BehaviorExitFast).
 				Image(kfmpi.MPIReplicaTypeWorker, util.E2eTestAgnHostImage, util.BehaviorExitFast).
 				Obj()
@@ -774,8 +774,8 @@ var _ = ginkgo.Describe("MultiKueue", func() {
 				Suspend(true).
 				Queue(managerLq.Name).
 				WithSubmissionMode(rayv1.K8sJobMode).
-				Request(rayv1.HeadNode, corev1.ResourceCPU, "1").
-				Request(rayv1.WorkerNode, corev1.ResourceCPU, "0.5").
+				RequestAndLimit(rayv1.HeadNode, corev1.ResourceCPU, "1").
+				RequestAndLimit(rayv1.WorkerNode, corev1.ResourceCPU, "0.5").
 				Entrypoint("python -c \"import ray; ray.init(); print(ray.cluster_resources())\"").
 				Image(rayv1.HeadNode, kuberayTestImage).
 				Image(rayv1.WorkerNode, kuberayTestImage).
@@ -817,8 +817,8 @@ var _ = ginkgo.Describe("MultiKueue", func() {
 			raycluster := testingraycluster.MakeCluster("raycluster1", managerNs.Name).
 				Suspend(true).
 				Queue(managerLq.Name).
-				Request(rayv1.HeadNode, corev1.ResourceCPU, "1").
-				Request(rayv1.WorkerNode, corev1.ResourceCPU, "0.5").
+				RequestAndLimit(rayv1.HeadNode, corev1.ResourceCPU, "1").
+				RequestAndLimit(rayv1.WorkerNode, corev1.ResourceCPU, "0.5").
 				Image(rayv1.HeadNode, kuberayTestImage, []string{}).
 				Image(rayv1.WorkerNode, kuberayTestImage, []string{}).
 				Obj()
diff --git a/test/e2e/multikueue/suite_test.go b/test/e2e/multikueue/suite_test.go
index 2c560cc56..273cef599 100644
--- a/test/e2e/multikueue/suite_test.go
+++ b/test/e2e/multikueue/suite_test.go
@@ -40,7 +40,6 @@ import (
 	"k8s.io/client-go/tools/clientcmd"
 	clientcmdapi "k8s.io/client-go/tools/clientcmd/api"
 	"k8s.io/utils/ptr"
-	ctrl "sigs.k8s.io/controller-runtime"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 	jobset "sigs.k8s.io/jobset/api/jobset/v1alpha2"
 
@@ -249,7 +248,7 @@ func TestAPIs(t *testing.T) {
 }
 
 var _ = ginkgo.BeforeSuite(func() {
-	ctrl.SetLogger(util.NewTestingLogger(ginkgo.GinkgoWriter, -3))
+	util.SetupLogger()
 
 	managerClusterName = os.Getenv("MANAGER_KIND_CLUSTER_NAME")
 	gomega.Expect(managerClusterName).NotTo(gomega.BeEmpty(), "MANAGER_KIND_CLUSTER_NAME should not be empty")
diff --git a/test/e2e/singlecluster/appwrapper_test.go b/test/e2e/singlecluster/appwrapper_test.go
index 5991eaac6..b03bbfc49 100644
--- a/test/e2e/singlecluster/appwrapper_test.go
+++ b/test/e2e/singlecluster/appwrapper_test.go
@@ -84,7 +84,7 @@ var _ = ginkgo.Describe("AppWrapper", func() {
 		numPods := 2
 		aw := awtesting.MakeAppWrapper("appwrapper", ns.Name).
 			Component(utiltestingjob.MakeJob("job-0", ns.Name).
-				Request(corev1.ResourceCPU, "100m").
+				RequestAndLimit(corev1.ResourceCPU, "200m").
 				Parallelism(int32(numPods)).
 				Completions(int32(numPods)).
 				Suspend(false).
diff --git a/test/e2e/singlecluster/deployment_test.go b/test/e2e/singlecluster/deployment_test.go
index 0210894cf..c0056de7d 100644
--- a/test/e2e/singlecluster/deployment_test.go
+++ b/test/e2e/singlecluster/deployment_test.go
@@ -87,7 +87,7 @@ var _ = ginkgo.Describe("Deployment", func() {
 	ginkgo.It("should admit workloads that fits", func() {
 		deployment := deploymenttesting.MakeDeployment("deployment", ns.Name).
 			Image(util.E2eTestAgnHostImage, util.BehaviorWaitForDeletion).
-			Request(corev1.ResourceCPU, "100m").
+			RequestAndLimit(corev1.ResourceCPU, "200m").
 			Replicas(3).
 			Queue(lq.Name).
 			Obj()
@@ -136,7 +136,7 @@ var _ = ginkgo.Describe("Deployment", func() {
 	ginkgo.It("should admit workloads after change queue-name if AvailableReplicas = 0", func() {
 		deployment := deploymenttesting.MakeDeployment("deployment", ns.Name).
 			Image(util.E2eTestAgnHostImage, util.BehaviorWaitForDeletion).
-			Request(corev1.ResourceCPU, "100m").
+			RequestAndLimit(corev1.ResourceCPU, "200m").
 			Replicas(3).
 			Queue("invalid-queue-name").
 			Obj()
diff --git a/test/e2e/singlecluster/e2e_test.go b/test/e2e/singlecluster/e2e_test.go
index 9880df275..543245b23 100644
--- a/test/e2e/singlecluster/e2e_test.go
+++ b/test/e2e/singlecluster/e2e_test.go
@@ -51,8 +51,8 @@ var _ = ginkgo.Describe("Kueue", func() {
 		gomega.Expect(k8sClient.Create(ctx, ns)).To(gomega.Succeed())
 		sampleJob = testingjob.MakeJob("test-job", ns.Name).
 			Queue("main").
-			Request("cpu", "1").
-			Request("memory", "20Mi").
+			RequestAndLimit("cpu", "1").
+			RequestAndLimit("memory", "20Mi").
 			Obj()
 		jobKey = client.ObjectKeyFromObject(sampleJob)
 	})
@@ -234,7 +234,7 @@ var _ = ginkgo.Describe("Kueue", func() {
 				job := testingjob.MakeJob("high", ns.Name).
 					Queue("main").
 					PriorityClass("high").
-					Request(corev1.ResourceCPU, "1").
+					RequestAndLimit(corev1.ResourceCPU, "1").
 					NodeSelector("instance-type", "on-demand"). // target the same flavor to cause preemption
 					Obj()
 				gomega.Expect(k8sClient.Create(ctx, job)).Should(gomega.Succeed())
@@ -270,7 +270,7 @@ var _ = ginkgo.Describe("Kueue", func() {
 				job := testingjob.MakeJob("high-with-wpc", ns.Name).
 					Queue("main").
 					WorkloadPriorityClass("high-workload").
-					Request(corev1.ResourceCPU, "1").
+					RequestAndLimit(corev1.ResourceCPU, "1").
 					NodeSelector("instance-type", "on-demand"). // target the same flavor to cause preemption
 					Obj()
 				gomega.Expect(k8sClient.Create(ctx, job)).Should(gomega.Succeed())
@@ -291,7 +291,7 @@ var _ = ginkgo.Describe("Kueue", func() {
 			job := testingjob.MakeJob("job", ns.Name).
 				Queue("main").
 				Image(util.E2eTestAgnHostImage, util.BehaviorExitFast).
-				Request("cpu", "500m").
+				RequestAndLimit("cpu", "500m").
 				Parallelism(3).
 				Completions(4).
 				SetAnnotation(workloadjob.JobMinParallelismAnnotation, "1").
diff --git a/test/e2e/singlecluster/fair_sharing_test.go b/test/e2e/singlecluster/fair_sharing_test.go
index a1bca83ec..703ba43da 100644
--- a/test/e2e/singlecluster/fair_sharing_test.go
+++ b/test/e2e/singlecluster/fair_sharing_test.go
@@ -101,8 +101,8 @@ var _ = ginkgo.Describe("Fair Sharing", ginkgo.Ordered, ginkgo.ContinueOnFailure
 					Image(util.E2eTestAgnHostImage, util.BehaviorExitFast).
 					Parallelism(3).
 					Completions(3).
-					Request("cpu", "1").
-					Request("memory", "200Mi").
+					RequestAndLimit("cpu", "1").
+					RequestAndLimit("memory", "200Mi").
 					Obj()
 				gomega.Expect(k8sClient.Create(ctx, job)).To(gomega.Succeed())
 			}
diff --git a/test/e2e/singlecluster/jobset_test.go b/test/e2e/singlecluster/jobset_test.go
index 30e15a167..6597135c6 100644
--- a/test/e2e/singlecluster/jobset_test.go
+++ b/test/e2e/singlecluster/jobset_test.go
@@ -90,8 +90,8 @@ var _ = ginkgo.Describe("JobSet", func() {
 						Completions: 2,
 					},
 				).
-				Request("replicated-job-1", "cpu", "500m").
-				Request("replicated-job-1", "memory", "200M").
+				RequestAndLimit("replicated-job-1", "cpu", "500m").
+				RequestAndLimit("replicated-job-1", "memory", "200M").
 				Obj()
 
 			ginkgo.By("Creating the jobSet", func() {
@@ -172,8 +172,8 @@ var _ = ginkgo.Describe("JobSet", func() {
 						Completions: 1,
 					},
 				).
-				Request("replicated-job-1", "cpu", "500m").
-				Request("replicated-job-1", "memory", "200M").
+				RequestAndLimit("replicated-job-1", "cpu", "500m").
+				RequestAndLimit("replicated-job-1", "memory", "200M").
 				Obj()
 
 			ginkgo.By("Creating the jobSet", func() {
diff --git a/test/e2e/singlecluster/leaderworkerset_test.go b/test/e2e/singlecluster/leaderworkerset_test.go
index 4c108d496..c18e25aa5 100644
--- a/test/e2e/singlecluster/leaderworkerset_test.go
+++ b/test/e2e/singlecluster/leaderworkerset_test.go
@@ -88,7 +88,7 @@ var _ = ginkgo.Describe("LeaderWorkerSet integration", func() {
 				Image(util.E2eTestAgnHostImage, util.BehaviorWaitForDeletion).
 				Size(1).
 				Replicas(1).
-				Request(corev1.ResourceCPU, "100m").
+				RequestAndLimit(corev1.ResourceCPU, "200m").
 				Queue(lq.Name).
 				Obj()
 
@@ -146,7 +146,7 @@ var _ = ginkgo.Describe("LeaderWorkerSet integration", func() {
 				Image(util.E2eTestAgnHostImage, util.BehaviorWaitForDeletion).
 				Size(3).
 				Replicas(1).
-				Request(corev1.ResourceCPU, "100m").
+				RequestAndLimit(corev1.ResourceCPU, "200m").
 				Queue(lq.Name).
 				Obj()
 			ginkgo.By("Create a LeaderWorkerSet", func() {
@@ -200,7 +200,7 @@ var _ = ginkgo.Describe("LeaderWorkerSet integration", func() {
 				Image(util.E2eTestAgnHostImage, util.BehaviorWaitForDeletion).
 				Size(3).
 				Replicas(2).
-				Request(corev1.ResourceCPU, "100m").
+				RequestAndLimit(corev1.ResourceCPU, "200m").
 				Queue(lq.Name).
 				Obj()
 
@@ -263,7 +263,7 @@ var _ = ginkgo.Describe("LeaderWorkerSet integration", func() {
 					Image(util.E2eTestAgnHostImage, util.BehaviorWaitForDeletion).
 					Size(3).
 					Replicas(1).
-					Request(corev1.ResourceCPU, "100m").
+					RequestAndLimit(corev1.ResourceCPU, "200m").
 					Queue(lq.Name).
 					StartupPolicy(startupPolicyType).
 					Obj()
@@ -357,7 +357,7 @@ var _ = ginkgo.Describe("LeaderWorkerSet integration", func() {
 					Image(util.E2eTestAgnHostImage, util.BehaviorWaitForDeletion).
 					Size(3).
 					Replicas(2).
-					Request(corev1.ResourceCPU, "100m").
+					RequestAndLimit(corev1.ResourceCPU, "200m").
 					Queue(lq.Name).
 					StartupPolicy(startupPolicyType).
 					Obj()
@@ -454,7 +454,7 @@ var _ = ginkgo.Describe("LeaderWorkerSet integration", func() {
 					Image(util.E2eTestAgnHostImage, util.BehaviorWaitForDeletion).
 					Size(3).
 					Replicas(2).
-					Request(corev1.ResourceCPU, "100m").
+					RequestAndLimit(corev1.ResourceCPU, "200m").
 					Queue(lq.Name).
 					LeaderTemplate(corev1.PodTemplateSpec{
 						Spec: corev1.PodSpec{
@@ -537,7 +537,7 @@ var _ = ginkgo.Describe("LeaderWorkerSet integration", func() {
 				Image(util.E2eTestAgnHostImageOld, util.BehaviorWaitForDeletion).
 				Size(3).
 				Replicas(2).
-				Request(corev1.ResourceCPU, "100m").
+				RequestAndLimit(corev1.ResourceCPU, "200m").
 				Queue(lq.Name).
 				LeaderTemplate(corev1.PodTemplateSpec{
 					Spec: corev1.PodSpec{
diff --git a/test/e2e/singlecluster/metrics_test.go b/test/e2e/singlecluster/metrics_test.go
index 5770d2d6f..7bfa873b3 100644
--- a/test/e2e/singlecluster/metrics_test.go
+++ b/test/e2e/singlecluster/metrics_test.go
@@ -136,7 +136,7 @@ var _ = ginkgo.Describe("Metrics", func() {
 				PodSets(
 					*utiltesting.MakePodSet("ps1", 1).Obj(),
 				).
-				Request(corev1.ResourceCPU, "1").
+				RequestAndLimit(corev1.ResourceCPU, "1").
 				Obj()
 			gomega.Expect(k8sClient.Create(ctx, workload)).To(gomega.Succeed())
 		})
@@ -268,7 +268,7 @@ var _ = ginkgo.Describe("Metrics", func() {
 
 			createdJob = testingjob.MakeJob("admission-checked-job", ns.Name).
 				Queue(localQueue.Name).
-				Request("cpu", "1").
+				RequestAndLimit("cpu", "1").
 				Obj()
 			gomega.Expect(k8sClient.Create(ctx, createdJob)).To(gomega.Succeed())
 
@@ -412,7 +412,7 @@ var _ = ginkgo.Describe("Metrics", func() {
 
 			lowerJob1 = testingjob.MakeJob("lower-job-1", ns.Name).
 				Queue(localQueue1.Name).
-				Request("cpu", "1").
+				RequestAndLimit("cpu", "1").
 				Obj()
 			gomega.Expect(k8sClient.Create(ctx, lowerJob1)).To(gomega.Succeed())
 
@@ -431,7 +431,7 @@ var _ = ginkgo.Describe("Metrics", func() {
 
 			lowerJob2 = testingjob.MakeJob("lower-job-2", ns.Name).
 				Queue(localQueue1.Name).
-				Request("cpu", "1").
+				RequestAndLimit("cpu", "1").
 				Obj()
 			gomega.Expect(k8sClient.Create(ctx, lowerJob2)).To(gomega.Succeed())
 
@@ -451,7 +451,7 @@ var _ = ginkgo.Describe("Metrics", func() {
 			blockerJob = testingjob.MakeJob("blocker", ns.Name).
 				Queue(localQueue2.Name).
 				PriorityClass(highPriorityClass.Name).
-				Request(corev1.ResourceCPU, "3").
+				RequestAndLimit(corev1.ResourceCPU, "3").
 				Obj()
 			gomega.Expect(k8sClient.Create(ctx, blockerJob)).Should(gomega.Succeed())
 
@@ -471,14 +471,14 @@ var _ = ginkgo.Describe("Metrics", func() {
 			higherJob1 = testingjob.MakeJob("high-large-1", ns.Name).
 				Queue(localQueue1.Name).
 				PriorityClass(highPriorityClass.Name).
-				Request(corev1.ResourceCPU, "4").
+				RequestAndLimit(corev1.ResourceCPU, "4").
 				Obj()
 			gomega.Expect(k8sClient.Create(ctx, higherJob1)).Should(gomega.Succeed())
 
 			higherJob2 = testingjob.MakeJob("high-large-2", ns.Name).
 				Queue(localQueue2.Name).
 				PriorityClass(highPriorityClass.Name).
-				Request(corev1.ResourceCPU, "4").
+				RequestAndLimit(corev1.ResourceCPU, "4").
 				Obj()
 			gomega.Expect(k8sClient.Create(ctx, higherJob2)).Should(gomega.Succeed())
 		})
diff --git a/test/e2e/singlecluster/pod_test.go b/test/e2e/singlecluster/pod_test.go
index c305df033..547a93415 100644
--- a/test/e2e/singlecluster/pod_test.go
+++ b/test/e2e/singlecluster/pod_test.go
@@ -87,7 +87,7 @@ var _ = ginkgo.Describe("Pod groups", func() {
 			group := podtesting.MakePod("group", ns.Name).
 				Image(util.E2eTestAgnHostImage, util.BehaviorExitFast).
 				Queue(lq.Name).
-				Request(corev1.ResourceCPU, "1").
+				RequestAndLimit(corev1.ResourceCPU, "1").
 				MakeGroup(2)
 			gKey := client.ObjectKey{Namespace: ns.Name, Name: "group"}
 			for _, p := range group {
@@ -130,7 +130,7 @@ var _ = ginkgo.Describe("Pod groups", func() {
 			group := podtesting.MakePod("group", ns.Name).
 				Image(util.E2eTestAgnHostImage, util.BehaviorExitFast).
 				Queue(lq.Name).
-				Request(corev1.ResourceCPU, "1").
+				RequestAndLimit(corev1.ResourceCPU, "1").
 				MakeGroup(3)
 
 			ginkgo.By("Incomplete group should not start", func() {
@@ -182,7 +182,7 @@ var _ = ginkgo.Describe("Pod groups", func() {
 				Image(util.E2eTestAgnHostImage, util.BehaviorExitFast).
 				TerminationGracePeriod(1).
 				Queue(lq.Name).
-				Request(corev1.ResourceCPU, "1").
+				RequestAndLimit(corev1.ResourceCPU, "1").
 				MakeGroup(3)
 
 			// First pod runs for much longer, so that there is time to terminate it.
@@ -296,7 +296,7 @@ var _ = ginkgo.Describe("Pod groups", func() {
 			group := podtesting.MakePod("group", ns.Name).
 				Image(util.E2eTestAgnHostImage, util.BehaviorExitFast).
 				Queue(lq.Name).
-				Request(corev1.ResourceCPU, "1").
+				RequestAndLimit(corev1.ResourceCPU, "1").
 				MakeGroup(2)
 
 			// The first pod has a node selector for a missing node.
@@ -367,7 +367,7 @@ var _ = ginkgo.Describe("Pod groups", func() {
 			group := podtesting.MakePod("group", ns.Name).
 				Image(util.E2eTestAgnHostImage, util.BehaviorExitFast).
 				Queue(lq.Name).
-				Request(corev1.ResourceCPU, "3").
+				RequestAndLimit(corev1.ResourceCPU, "3").
 				MakeGroup(2)
 			gKey := client.ObjectKey{Namespace: ns.Name, Name: "group"}
 
@@ -425,7 +425,7 @@ var _ = ginkgo.Describe("Pod groups", func() {
 				Image(util.E2eTestAgnHostImage, util.BehaviorWaitForDeletionFailOnExit).
 				TerminationGracePeriod(1).
 				Queue(lq.Name).
-				Request(corev1.ResourceCPU, "2").
+				RequestAndLimit(corev1.ResourceCPU, "2").
 				MakeGroup(2)
 			defaultGroupKey := client.ObjectKey{Namespace: ns.Name, Name: "default-priority-group"}
 			defaultGroupPods := sets.New(
@@ -450,7 +450,7 @@ var _ = ginkgo.Describe("Pod groups", func() {
 				Image(util.E2eTestAgnHostImage, util.BehaviorWaitForDeletion).
 				Queue(lq.Name).
 				PriorityClass("high").
-				Request(corev1.ResourceCPU, "1").
+				RequestAndLimit(corev1.ResourceCPU, "1").
 				MakeGroup(2)
 			highGroupKey := client.ObjectKey{Namespace: ns.Name, Name: "high-priority-group"}
 
diff --git a/test/e2e/singlecluster/statefulset_test.go b/test/e2e/singlecluster/statefulset_test.go
index e0649c54f..164b7880d 100644
--- a/test/e2e/singlecluster/statefulset_test.go
+++ b/test/e2e/singlecluster/statefulset_test.go
@@ -89,7 +89,7 @@ var _ = ginkgo.Describe("StatefulSet integration", func() {
 		ginkgo.It("should admit group that fits", func() {
 			statefulSet := statefulsettesting.MakeStatefulSet("sts", ns.Name).
 				Image(util.E2eTestAgnHostImage, util.BehaviorWaitForDeletion).
-				Request(corev1.ResourceCPU, "100m").
+				RequestAndLimit(corev1.ResourceCPU, "200m").
 				Replicas(3).
 				Queue(lq.Name).
 				Obj()
@@ -108,7 +108,7 @@ var _ = ginkgo.Describe("StatefulSet integration", func() {
 			ginkgo.By("Creating potentially conflicting stateful-set", func() {
 				conflictingStatefulSet := statefulsettesting.MakeStatefulSet("sts-conflict", ns.Name).
 					Image(util.E2eTestAgnHostImage, util.BehaviorWaitForDeletion).
-					Request(corev1.ResourceCPU, "100m").
+					RequestAndLimit(corev1.ResourceCPU, "200m").
 					Replicas(1).
 					Queue(lq.Name).
 					Obj()
@@ -145,7 +145,7 @@ var _ = ginkgo.Describe("StatefulSet integration", func() {
 		ginkgo.It("should allow to update the PodTemplate in StatefulSet", func() {
 			statefulSet := statefulsettesting.MakeStatefulSet("sts", ns.Name).
 				Image(util.E2eTestAgnHostImageOld, util.BehaviorWaitForDeletion).
-				Request(corev1.ResourceCPU, "100m").
+				RequestAndLimit(corev1.ResourceCPU, "200m").
 				Replicas(3).
 				Queue(lq.Name).
 				Obj()
@@ -195,7 +195,7 @@ var _ = ginkgo.Describe("StatefulSet integration", func() {
 		ginkgo.It("should delete all pods on scale down to zero", func() {
 			statefulSet := statefulsettesting.MakeStatefulSet("sts", ns.Name).
 				Image(util.E2eTestAgnHostImage, util.BehaviorWaitForDeletion).
-				Request(corev1.ResourceCPU, "100m").
+				RequestAndLimit(corev1.ResourceCPU, "200m").
 				Replicas(3).
 				Queue(lq.Name).
 				Obj()
@@ -243,7 +243,7 @@ var _ = ginkgo.Describe("StatefulSet integration", func() {
 		ginkgo.It("should create pods after scale up from zero", func() {
 			statefulSet := statefulsettesting.MakeStatefulSet("sts", ns.Name).
 				Image(util.E2eTestAgnHostImage, util.BehaviorWaitForDeletion).
-				Request(corev1.ResourceCPU, "100m").
+				RequestAndLimit(corev1.ResourceCPU, "200m").
 				Replicas(0).
 				Queue(lq.Name).
 				Obj()
@@ -279,7 +279,7 @@ var _ = ginkgo.Describe("StatefulSet integration", func() {
 		ginkgo.It("should allow to scale up after scale down to zero", func() {
 			statefulSet := statefulsettesting.MakeStatefulSet("sts", ns.Name).
 				Image(util.E2eTestAgnHostImage, util.BehaviorWaitForDeletion).
-				Request(corev1.ResourceCPU, "100m").
+				RequestAndLimit(corev1.ResourceCPU, "200m").
 				Replicas(3).
 				Queue(lq.Name).
 				Obj()
@@ -341,7 +341,7 @@ var _ = ginkgo.Describe("StatefulSet integration", func() {
 		ginkgo.It("should allow to change queue name if ReadyReplicas=0", func() {
 			statefulSet := statefulsettesting.MakeStatefulSet("sts", ns.Name).
 				Image(util.E2eTestAgnHostImage, util.BehaviorWaitForDeletion).
-				Request(corev1.ResourceCPU, "100m").
+				RequestAndLimit(corev1.ResourceCPU, "200m").
 				Replicas(3).
 				Queue(fmt.Sprintf("%s-invalid", localQueueName)).
 				Obj()
@@ -385,7 +385,7 @@ var _ = ginkgo.Describe("StatefulSet integration", func() {
 		ginkgo.It("should delete all Pods if StatefulSet was deleted after being partially ready", func() {
 			statefulSet := statefulsettesting.MakeStatefulSet("sts", ns.Name).
 				Image(util.E2eTestAgnHostImage, util.BehaviorWaitForDeletion).
-				Request(corev1.ResourceCPU, "100m").
+				RequestAndLimit(corev1.ResourceCPU, "200m").
 				Replicas(3).
 				Queue(localQueueName).
 				Obj()
diff --git a/test/e2e/singlecluster/suite_test.go b/test/e2e/singlecluster/suite_test.go
index d44f51975..fc08c99f3 100644
--- a/test/e2e/singlecluster/suite_test.go
+++ b/test/e2e/singlecluster/suite_test.go
@@ -28,7 +28,6 @@ import (
 	"github.com/onsi/gomega"
 	"k8s.io/client-go/rest"
 	"k8s.io/utils/clock"
-	ctrl "sigs.k8s.io/controller-runtime"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 
 	visibilityv1beta1 "sigs.k8s.io/kueue/client-go/clientset/versioned/typed/visibility/v1beta1"
@@ -58,7 +57,7 @@ func TestAPIs(t *testing.T) {
 }
 
 var _ = ginkgo.BeforeSuite(func() {
-	ctrl.SetLogger(util.NewTestingLogger(ginkgo.GinkgoWriter, -3))
+	util.SetupLogger()
 
 	k8sClient, cfg = util.CreateClientUsingCluster("")
 	restClient = util.CreateRestClient(cfg)
diff --git a/test/e2e/singlecluster/tas_test.go b/test/e2e/singlecluster/tas_test.go
index cc75dc852..089acac04 100644
--- a/test/e2e/singlecluster/tas_test.go
+++ b/test/e2e/singlecluster/tas_test.go
@@ -98,8 +98,8 @@ var _ = ginkgo.Describe("TopologyAwareScheduling", func() {
 		ginkgo.It("should admit a Job via TAS", func() {
 			sampleJob := testingjob.MakeJob("test-job", ns.Name).
 				Queue(localQueue.Name).
-				Request("cpu", "700m").
-				Request("memory", "20Mi").
+				RequestAndLimit("cpu", "700m").
+				RequestAndLimit("memory", "20Mi").
 				Obj()
 			jobKey := client.ObjectKeyFromObject(sampleJob)
 			sampleJob = (&testingjob.JobWrapper{Job: *sampleJob}).
@@ -218,10 +218,10 @@ var _ = ginkgo.Describe("TopologyAwareScheduling", func() {
 						},
 					},
 				).
-				Request("rj1", "cpu", "200m").
-				Request("rj1", "memory", "20Mi").
-				Request("rj2", "cpu", "200m").
-				Request("rj2", "memory", "20Mi").
+				RequestAndLimit("rj1", "cpu", "200m").
+				RequestAndLimit("rj1", "memory", "20Mi").
+				RequestAndLimit("rj2", "cpu", "200m").
+				RequestAndLimit("rj2", "memory", "20Mi").
 				Obj()
 
 			ginkgo.By("Creating the JobSet", func() {
@@ -331,8 +331,8 @@ var _ = ginkgo.Describe("TopologyAwareScheduling", func() {
 				Queue(localQueue.Name).
 				Image(util.E2eTestAgnHostImage, util.BehaviorExitFast).
 				Annotation(kueuealpha.PodSetRequiredTopologyAnnotation, corev1.LabelHostname).
-				Request("cpu", "100m").
-				Request("memory", "100Mi").
+				RequestAndLimit("cpu", "200m").
+				RequestAndLimit("memory", "200Mi").
 				Obj()
 
 			ginkgo.By("Creating the Pod", func() {
@@ -341,7 +341,6 @@ var _ = ginkgo.Describe("TopologyAwareScheduling", func() {
 					corev1.PodSchedulingGate{Name: podconstants.SchedulingGateName},
 					corev1.PodSchedulingGate{Name: kueuealpha.TopologySchedulingGate},
 				))
-				gomega.Expect(p.Labels).To(gomega.HaveKeyWithValue(kueuealpha.TASLabel, "true"))
 			})
 
 			ginkgo.By("waiting for the Pod to be unsuspended", func() {
@@ -390,8 +389,8 @@ var _ = ginkgo.Describe("TopologyAwareScheduling", func() {
 				Queue(localQueue.Name).
 				Image(util.E2eTestAgnHostImage, util.BehaviorExitFast).
 				Annotation(kueuealpha.PodSetRequiredTopologyAnnotation, corev1.LabelHostname).
-				Request("cpu", "100m").
-				Request("memory", "100Mi").
+				RequestAndLimit("cpu", "200m").
+				RequestAndLimit("memory", "200Mi").
 				MakeGroup(2)
 
 			ginkgo.By("Creating the Pod group", func() {
@@ -401,7 +400,6 @@ var _ = ginkgo.Describe("TopologyAwareScheduling", func() {
 						corev1.PodSchedulingGate{Name: podconstants.SchedulingGateName},
 						corev1.PodSchedulingGate{Name: kueuealpha.TopologySchedulingGate},
 					))
-					gomega.Expect(p.Labels).To(gomega.HaveKeyWithValue(kueuealpha.TASLabel, "true"))
 				}
 			})
 
diff --git a/test/e2e/singlecluster/visibility_test.go b/test/e2e/singlecluster/visibility_test.go
index 9c5a7d7ed..1198ba425 100644
--- a/test/e2e/singlecluster/visibility_test.go
+++ b/test/e2e/singlecluster/visibility_test.go
@@ -114,7 +114,7 @@ var _ = ginkgo.Describe("Kueue visibility server", func() {
 				blockingJob = testingjob.MakeJob("test-job-1", nsA.Name).
 					Queue(localQueueA.Name).
 					Image(util.E2eTestAgnHostImage, util.BehaviorWaitForDeletion).
-					Request(corev1.ResourceCPU, "1").
+					RequestAndLimit(corev1.ResourceCPU, "1").
 					TerminationGracePeriod(1).
 					BackoffLimit(0).
 					PriorityClass(highPriorityClass.Name).
@@ -154,7 +154,7 @@ var _ = ginkgo.Describe("Kueue visibility server", func() {
 				sampleJob2 = testingjob.MakeJob("test-job-2", nsA.Name).
 					Queue(localQueueA.Name).
 					Image(util.E2eTestAgnHostImage, util.BehaviorExitFast).
-					Request(corev1.ResourceCPU, "1").
+					RequestAndLimit(corev1.ResourceCPU, "1").
 					PriorityClass(lowPriorityClass.Name).
 					Obj()
 				gomega.Expect(k8sClient.Create(ctx, sampleJob2)).Should(gomega.Succeed())
@@ -216,7 +216,7 @@ var _ = ginkgo.Describe("Kueue visibility server", func() {
 					job := testingjob.MakeJob(jobCase.JobName, nsA.Name).
 						Queue(jobCase.LocalQueueName).
 						Image(util.E2eTestAgnHostImage, util.BehaviorExitFast).
-						Request(corev1.ResourceCPU, "1").
+						RequestAndLimit(corev1.ResourceCPU, "1").
 						PriorityClass(jobCase.JobPrioClassName).
 						Obj()
 					gomega.Expect(k8sClient.Create(ctx, job)).Should(gomega.Succeed())
@@ -275,7 +275,7 @@ var _ = ginkgo.Describe("Kueue visibility server", func() {
 				sampleJob2 = testingjob.MakeJob("test-job-2", nsA.Name).
 					Queue(localQueueA.Name).
 					Image(util.E2eTestAgnHostImage, util.BehaviorExitFast).
-					Request(corev1.ResourceCPU, "1").
+					RequestAndLimit(corev1.ResourceCPU, "1").
 					PriorityClass(lowPriorityClass.Name).
 					Obj()
 				gomega.Expect(k8sClient.Create(ctx, sampleJob2)).Should(gomega.Succeed())
@@ -337,7 +337,7 @@ var _ = ginkgo.Describe("Kueue visibility server", func() {
 					job := testingjob.MakeJob(jobCase.JobName, nsA.Name).
 						Queue(jobCase.LocalQueueName).
 						Image(util.E2eTestAgnHostImage, util.BehaviorExitFast).
-						Request(corev1.ResourceCPU, "1").
+						RequestAndLimit(corev1.ResourceCPU, "1").
 						PriorityClass(jobCase.JobPrioClassName).
 						Obj()
 					gomega.Expect(k8sClient.Create(ctx, job)).Should(gomega.Succeed())
@@ -430,7 +430,7 @@ var _ = ginkgo.Describe("Kueue visibility server", func() {
 					job := testingjob.MakeJob(jobCase.JobName, jobCase.nsName).
 						Queue(jobCase.LocalQueueName).
 						Image(util.E2eTestAgnHostImage, util.BehaviorExitFast).
-						Request(corev1.ResourceCPU, "1").
+						RequestAndLimit(corev1.ResourceCPU, "1").
 						PriorityClass(jobCase.JobPrioClassName).
 						Obj()
 					gomega.Expect(k8sClient.Create(ctx, job)).Should(gomega.Succeed())
diff --git a/test/e2e/tas/appwrapper_test.go b/test/e2e/tas/appwrapper_test.go
index 15fe000d5..3e17648ca 100644
--- a/test/e2e/tas/appwrapper_test.go
+++ b/test/e2e/tas/appwrapper_test.go
@@ -92,12 +92,10 @@ var _ = ginkgo.Describe("TopologyAwareScheduling for AppWrapper", func() {
 				Component(utiltestingjob.MakeJob("job-0", ns.Name).
 					Parallelism(int32(numPods)).
 					Completions(int32(numPods)).
-					Request(corev1.ResourceCPU, "100m").
-					Limit(corev1.ResourceCPU, "100m").
-					Request(extraResource, "1").
-					Limit(extraResource, "1").
+					RequestAndLimit(corev1.ResourceCPU, "200m").
+					RequestAndLimit(extraResource, "1").
 					Suspend(false).
-					Image(util.E2eTestAgnHostImage, util.BehaviorWaitForDeletion).
+					Image(util.E2eTestAgnHostImage, util.BehaviorExitFast).
 					PodAnnotation(kueuealpha.PodSetPreferredTopologyAnnotation, testing.DefaultRackTopologyLevel).
 					SetTypeMeta().Obj()).
 				Queue(localQueue.Name).
@@ -138,10 +136,9 @@ var _ = ginkgo.Describe("TopologyAwareScheduling for AppWrapper", func() {
 				Completions(int32(numPods)).
 				Indexed(true).
 				Suspend(false).
-				Request(extraResource, "1").
-				Limit(extraResource, "1").
+				RequestAndLimit(extraResource, "1").
 				PodAnnotation(kueuealpha.PodSetRequiredTopologyAnnotation, testing.DefaultBlockTopologyLevel).
-				Image(util.E2eTestAgnHostImage, util.BehaviorWaitForDeletion).
+				Image(util.E2eTestAgnHostImage, util.BehaviorExitFast).
 				SetTypeMeta().
 				Obj()
 			aw := awtesting.MakeAppWrapper("aw-ranks-job", ns.Name).
diff --git a/test/e2e/tas/job_test.go b/test/e2e/tas/job_test.go
index 30cc289e3..47447f577 100644
--- a/test/e2e/tas/job_test.go
+++ b/test/e2e/tas/job_test.go
@@ -102,8 +102,7 @@ var _ = ginkgo.Describe("TopologyAwareScheduling for Job", func() {
 				Queue(localQueue.Name).
 				Parallelism(3).
 				Completions(3).
-				Request(extraResource, "1").
-				Limit(extraResource, "1").
+				RequestAndLimit(extraResource, "1").
 				Obj()
 			sampleJob = (&testingjob.JobWrapper{Job: *sampleJob}).
 				PodAnnotation(kueuealpha.PodSetRequiredTopologyAnnotation, testing.DefaultRackTopologyLevel).
@@ -126,8 +125,7 @@ var _ = ginkgo.Describe("TopologyAwareScheduling for Job", func() {
 				Queue(localQueue.Name).
 				Parallelism(3).
 				Completions(3).
-				Request(extraResource, "1").
-				Limit(extraResource, "1").
+				RequestAndLimit(extraResource, "1").
 				Obj()
 			sampleJob = (&testingjob.JobWrapper{Job: *sampleJob}).
 				PodAnnotation(kueuealpha.PodSetPreferredTopologyAnnotation, testing.DefaultRackTopologyLevel).
@@ -179,8 +177,7 @@ var _ = ginkgo.Describe("TopologyAwareScheduling for Job", func() {
 				Queue(localQueue.Name).
 				Parallelism(3).
 				Completions(3).
-				Request(extraResource, "1").
-				Limit(extraResource, "1").
+				RequestAndLimit(extraResource, "1").
 				Obj()
 			sampleJob = (&testingjob.JobWrapper{Job: *sampleJob}).
 				PodAnnotation(kueuealpha.PodSetRequiredTopologyAnnotation, testing.DefaultBlockTopologyLevel).
@@ -233,8 +230,7 @@ var _ = ginkgo.Describe("TopologyAwareScheduling for Job", func() {
 				Queue(localQueue.Name).
 				Parallelism(2).
 				Completions(3).
-				Request(extraResource, "1").
-				Limit(extraResource, "1").
+				RequestAndLimit(extraResource, "1").
 				Obj()
 			sampleJob = (&testingjob.JobWrapper{Job: *sampleJob}).
 				PodAnnotation(kueuealpha.PodSetRequiredTopologyAnnotation, testing.DefaultBlockTopologyLevel).
@@ -262,8 +258,7 @@ var _ = ginkgo.Describe("TopologyAwareScheduling for Job", func() {
 				Parallelism(int32(numPods)).
 				Completions(int32(numPods)).
 				Indexed(true).
-				Request(extraResource, "1").
-				Limit(extraResource, "1").
+				RequestAndLimit(extraResource, "1").
 				Obj()
 			sampleJob = (&testingjob.JobWrapper{Job: *sampleJob}).
 				PodAnnotation(kueuealpha.PodSetRequiredTopologyAnnotation, testing.DefaultBlockTopologyLevel).
diff --git a/test/e2e/tas/jobset_test.go b/test/e2e/tas/jobset_test.go
index 03412e759..7e8ace75e 100644
--- a/test/e2e/tas/jobset_test.go
+++ b/test/e2e/tas/jobset_test.go
@@ -99,7 +99,7 @@ var _ = ginkgo.Describe("TopologyAwareScheduling for JobSet", func() {
 					testingjobset.ReplicatedJobRequirements{
 						Name:        "replicated-job-1",
 						Image:       util.E2eTestAgnHostImage,
-						Args:        util.BehaviorWaitForDeletion,
+						Args:        util.BehaviorExitFast,
 						Replicas:    int32(replicas),
 						Parallelism: int32(parallelism),
 						Completions: int32(parallelism),
@@ -108,8 +108,7 @@ var _ = ginkgo.Describe("TopologyAwareScheduling for JobSet", func() {
 						},
 					},
 				).
-				Request("replicated-job-1", extraResource, "1").
-				Limit("replicated-job-1", extraResource, "1").
+				RequestAndLimit("replicated-job-1", extraResource, "1").
 				Obj()
 			gomega.Expect(k8sClient.Create(ctx, sampleJob)).Should(gomega.Succeed())
 
diff --git a/test/e2e/tas/mpijob_test.go b/test/e2e/tas/mpijob_test.go
index f9618fa4a..cda56937e 100644
--- a/test/e2e/tas/mpijob_test.go
+++ b/test/e2e/tas/mpijob_test.go
@@ -115,12 +115,10 @@ var _ = ginkgo.Describe("TopologyAwareScheduling for MPIJob", func() {
 						},
 					},
 				).
-				Image(kfmpi.MPIReplicaTypeLauncher, util.E2eTestAgnHostImage, util.BehaviorWaitForDeletion).
-				Image(kfmpi.MPIReplicaTypeWorker, util.E2eTestAgnHostImage, util.BehaviorWaitForDeletion).
-				Request(kfmpi.MPIReplicaTypeLauncher, corev1.ResourceCPU, "100m").
-				Limit(kfmpi.MPIReplicaTypeLauncher, corev1.ResourceCPU, "100m").
-				Request(kfmpi.MPIReplicaTypeWorker, extraResource, "1").
-				Limit(kfmpi.MPIReplicaTypeWorker, extraResource, "1").
+				Image(kfmpi.MPIReplicaTypeLauncher, util.E2eTestAgnHostImage, util.BehaviorExitFast).
+				Image(kfmpi.MPIReplicaTypeWorker, util.E2eTestAgnHostImage, util.BehaviorExitFast).
+				RequestAndLimit(kfmpi.MPIReplicaTypeLauncher, corev1.ResourceCPU, "200m").
+				RequestAndLimit(kfmpi.MPIReplicaTypeWorker, extraResource, "1").
 				Obj()
 			gomega.Expect(k8sClient.Create(ctx, mpijob)).Should(gomega.Succeed())
 
diff --git a/test/e2e/tas/pod_group_test.go b/test/e2e/tas/pod_group_test.go
index 674679ceb..753174c65 100644
--- a/test/e2e/tas/pod_group_test.go
+++ b/test/e2e/tas/pod_group_test.go
@@ -89,8 +89,9 @@ var _ = ginkgo.Describe("TopologyAwareScheduling for Pod group", func() {
 			numPods := 4
 			basePod := testingpod.MakePod("test-pod", ns.Name).
 				Queue("test-queue").
-				Request(extraResource, "1").
+				RequestAndLimit(extraResource, "1").
 				Limit(extraResource, "1").
+				Image(util.E2eTestAgnHostImage, util.BehaviorExitFast).
 				Annotation(kueuealpha.PodSetRequiredTopologyAnnotation, testing.DefaultBlockTopologyLevel)
 			podGroup := basePod.MakeIndexedGroup(numPods)
 
@@ -133,5 +134,119 @@ var _ = ginkgo.Describe("TopologyAwareScheduling for Pod group", func() {
 				gomega.Expect(wantAssignment).Should(gomega.BeComparableTo(gotAssignment))
 			})
 		})
+
+		ginkgo.It("Should schedule Pods without explicit TAS annotation", func() {
+			ginkgo.By("Creating pod group with 4 pods")
+			numPods := 4
+			basePod := testingpod.MakePod("test-pod", ns.Name).
+				Queue("test-queue").
+				Request(extraResource, "1").
+				Limit(extraResource, "1")
+			podGroup := basePod.MakeIndexedGroup(numPods)
+
+			for _, pod := range podGroup {
+				gomega.Expect(k8sClient.Create(ctx, pod)).Should(gomega.Succeed())
+			}
+
+			pods := &corev1.PodList{}
+			ginkgo.By("ensure all pods are created", func() {
+				gomega.Eventually(func(g gomega.Gomega) {
+					g.Expect(k8sClient.List(ctx, pods, client.InNamespace(ns.Name))).To(gomega.Succeed())
+					g.Expect(pods.Items).Should(gomega.HaveLen(numPods))
+				}, util.LongTimeout, util.Interval).Should(gomega.Succeed())
+			})
+
+			ginkgo.By("ensure all pods are scheduled", func() {
+				listOpts := &client.ListOptions{
+					FieldSelector: fields.OneTermNotEqualSelector("spec.nodeName", ""),
+				}
+				gomega.Eventually(func(g gomega.Gomega) {
+					g.Expect(k8sClient.List(ctx, pods, client.InNamespace(ns.Name), listOpts)).To(gomega.Succeed())
+					g.Expect(pods.Items).Should(gomega.HaveLen(numPods))
+				}, util.LongTimeout, util.Interval).Should(gomega.Succeed())
+			})
+
+			ginkgo.By("verify the assignment for the Pods was using TAS", func() {
+				gomega.Expect(k8sClient.List(ctx, pods, client.InNamespace(ns.Name),
+					client.MatchingLabels(basePod.Labels))).To(gomega.Succeed())
+				var gotAssignment []string
+				for _, pod := range pods.Items {
+					gotAssignment = append(gotAssignment, pod.Spec.NodeName)
+				}
+				wantAssignment := []string{
+					"kind-worker",
+					"kind-worker2",
+					"kind-worker3",
+					"kind-worker4",
+				}
+				gomega.Expect(wantAssignment).Should(gomega.ConsistOf(gotAssignment))
+			})
+		})
+	})
+
+	ginkgo.When("Creating a Pod group which is not using TAS", func() {
+		var (
+			flavor       *kueue.ResourceFlavor
+			localQueue   *kueue.LocalQueue
+			clusterQueue *kueue.ClusterQueue
+		)
+		ginkgo.BeforeEach(func() {
+			flavor = testing.MakeResourceFlavor("flavor").
+				NodeLabel(tasNodeGroupLabel, instanceType).Obj()
+			gomega.Expect(k8sClient.Create(ctx, flavor)).Should(gomega.Succeed())
+			clusterQueue = testing.MakeClusterQueue("cluster-queue").
+				ResourceGroup(
+					*testing.MakeFlavorQuotas("flavor").
+						Resource(extraResource, "8").
+						Obj(),
+				).
+				Obj()
+			gomega.Expect(k8sClient.Create(ctx, clusterQueue)).Should(gomega.Succeed())
+			util.ExpectClusterQueuesToBeActive(ctx, k8sClient, clusterQueue)
+
+			localQueue = testing.MakeLocalQueue("test-queue", ns.Name).ClusterQueue("cluster-queue").Obj()
+			gomega.Expect(k8sClient.Create(ctx, localQueue)).Should(gomega.Succeed())
+		})
+		ginkgo.AfterEach(func() {
+			gomega.Expect(util.DeleteAllPodsInNamespace(ctx, k8sClient, ns)).Should(gomega.Succeed())
+			// Force remove workloads to be sure that cluster queue can be removed.
+			gomega.Expect(util.DeleteWorkloadsInNamespace(ctx, k8sClient, ns)).Should(gomega.Succeed())
+			util.ExpectObjectToBeDeleted(ctx, k8sClient, localQueue, true)
+			util.ExpectObjectToBeDeleted(ctx, k8sClient, clusterQueue, true)
+			util.ExpectObjectToBeDeleted(ctx, k8sClient, flavor, true)
+			util.ExpectAllPodsInNamespaceDeleted(ctx, k8sClient, ns)
+		})
+
+		ginkgo.It("Should let the Job scheduled", func() {
+			ginkgo.By("Creating pod group with 4 pods")
+			numPods := 4
+			basePod := testingpod.MakePod("test-pod", ns.Name).
+				Queue("test-queue").
+				Request(extraResource, "1").
+				Limit(extraResource, "1")
+			podGroup := basePod.MakeIndexedGroup(numPods)
+
+			for _, pod := range podGroup {
+				gomega.Expect(k8sClient.Create(ctx, pod)).Should(gomega.Succeed())
+			}
+
+			pods := &corev1.PodList{}
+			ginkgo.By("ensure all pods are created", func() {
+				gomega.Eventually(func(g gomega.Gomega) {
+					g.Expect(k8sClient.List(ctx, pods, client.InNamespace(ns.Name))).To(gomega.Succeed())
+					g.Expect(pods.Items).Should(gomega.HaveLen(numPods))
+				}, util.LongTimeout, util.Interval).Should(gomega.Succeed())
+			})
+
+			ginkgo.By("ensure all pods are scheduled", func() {
+				listOpts := &client.ListOptions{
+					FieldSelector: fields.OneTermNotEqualSelector("spec.nodeName", ""),
+				}
+				gomega.Eventually(func(g gomega.Gomega) {
+					g.Expect(k8sClient.List(ctx, pods, client.InNamespace(ns.Name), listOpts)).To(gomega.Succeed())
+					g.Expect(pods.Items).Should(gomega.HaveLen(numPods))
+				}, util.LongTimeout, util.Interval).Should(gomega.Succeed())
+			})
+		})
 	})
 })
diff --git a/test/e2e/tas/pytorch_test.go b/test/e2e/tas/pytorch_test.go
index af86490b3..c0e0da35e 100644
--- a/test/e2e/tas/pytorch_test.go
+++ b/test/e2e/tas/pytorch_test.go
@@ -114,12 +114,10 @@ var _ = ginkgo.Describe("TopologyAwareScheduling for PyTorchJob", func() {
 						},
 					},
 				).
-				Image(kftraining.PyTorchJobReplicaTypeMaster, util.E2eTestAgnHostImage, util.BehaviorWaitForDeletion).
-				Image(kftraining.PyTorchJobReplicaTypeWorker, util.E2eTestAgnHostImage, util.BehaviorWaitForDeletion).
-				Request(kftraining.PyTorchJobReplicaTypeMaster, corev1.ResourceCPU, "100m").
-				Limit(kftraining.PyTorchJobReplicaTypeMaster, corev1.ResourceCPU, "100m").
-				Request(kftraining.PyTorchJobReplicaTypeWorker, extraResource, "1").
-				Limit(kftraining.PyTorchJobReplicaTypeWorker, extraResource, "1").
+				Image(kftraining.PyTorchJobReplicaTypeMaster, util.E2eTestAgnHostImage, util.BehaviorExitFast).
+				Image(kftraining.PyTorchJobReplicaTypeWorker, util.E2eTestAgnHostImage, util.BehaviorExitFast).
+				RequestAndLimit(kftraining.PyTorchJobReplicaTypeMaster, corev1.ResourceCPU, "200m").
+				RequestAndLimit(kftraining.PyTorchJobReplicaTypeWorker, extraResource, "1").
 				Obj()
 			gomega.Expect(k8sClient.Create(ctx, pytorchjob)).Should(gomega.Succeed())
 
diff --git a/test/e2e/tas/rayjob_test.go b/test/e2e/tas/rayjob_test.go
index 20f8aad69..e4896ff26 100644
--- a/test/e2e/tas/rayjob_test.go
+++ b/test/e2e/tas/rayjob_test.go
@@ -110,10 +110,10 @@ var _ = ginkgo.Describe("TopologyAwareScheduling for RayJob", ginkgo.Ordered, fu
 										Name: "head-container",
 										Resources: corev1.ResourceRequirements{
 											Requests: corev1.ResourceList{
-												corev1.ResourceCPU: resource.MustParse("100m"),
+												corev1.ResourceCPU: resource.MustParse("200m"),
 											},
 											Limits: corev1.ResourceList{
-												corev1.ResourceCPU: resource.MustParse("100m"),
+												corev1.ResourceCPU: resource.MustParse("200m"),
 											},
 										},
 									},
diff --git a/test/e2e/tas/statefulset_test.go b/test/e2e/tas/statefulset_test.go
index e63ecc1f0..c248e3435 100644
--- a/test/e2e/tas/statefulset_test.go
+++ b/test/e2e/tas/statefulset_test.go
@@ -80,8 +80,7 @@ var _ = ginkgo.Describe("TopologyAwareScheduling for StatefulSet", func() {
 			const replicas = 3
 			sts := statefulset.MakeStatefulSet("sts", ns.Name).
 				Image(util.E2eTestAgnHostImage, util.BehaviorWaitForDeletion).
-				Request(extraResource, "1").
-				Limit(extraResource, "1").
+				RequestAndLimit(extraResource, "1").
 				Replicas(replicas).
 				Queue(localQueue.Name).
 				PodTemplateSpecAnnotation(kueuealpha.PodSetRequiredTopologyAnnotation, testing.DefaultBlockTopologyLevel).
diff --git a/test/e2e/tas/suite_test.go b/test/e2e/tas/suite_test.go
index 5a3498a42..717b18c45 100644
--- a/test/e2e/tas/suite_test.go
+++ b/test/e2e/tas/suite_test.go
@@ -27,7 +27,6 @@ import (
 	"github.com/onsi/gomega"
 	corev1 "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/api/resource"
-	ctrl "sigs.k8s.io/controller-runtime"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 
 	clientutil "sigs.k8s.io/kueue/pkg/util/client"
@@ -51,7 +50,7 @@ func TestAPIs(t *testing.T) {
 }
 
 var _ = ginkgo.BeforeSuite(func() {
-	ctrl.SetLogger(util.NewTestingLogger(ginkgo.GinkgoWriter, -3))
+	util.SetupLogger()
 
 	k8sClient, _ = util.CreateClientUsingCluster("")
 	ctx = context.Background()
diff --git a/test/integration/framework/framework.go b/test/integration/framework/framework.go
index 2a559b511..3c7ac6c50 100644
--- a/test/integration/framework/framework.go
+++ b/test/integration/framework/framework.go
@@ -25,7 +25,6 @@ import (
 	"path/filepath"
 	"strconv"
 	"strings"
-	"sync"
 	"time"
 
 	kfmpi "github.com/kubeflow/mpi-operator/pkg/apis/kubeflow/v2beta1"
@@ -68,12 +67,8 @@ type Framework struct {
 	managerDone   <-chan struct{}
 }
 
-var setupLogger = sync.OnceFunc(func() {
-	ctrl.SetLogger(util.NewTestingLogger(ginkgo.GinkgoWriter, -3))
-})
-
 func (f *Framework) Init() *rest.Config {
-	setupLogger()
+	util.SetupLogger()
 
 	var cfg *rest.Config
 	ginkgo.By("bootstrapping test environment", func() {
diff --git a/test/integration/singlecluster/controller/jobs/pod/pod_controller_test.go b/test/integration/singlecluster/controller/jobs/pod/pod_controller_test.go
index 0b542bdab..721099f09 100644
--- a/test/integration/singlecluster/controller/jobs/pod/pod_controller_test.go
+++ b/test/integration/singlecluster/controller/jobs/pod/pod_controller_test.go
@@ -2239,7 +2239,6 @@ var _ = ginkgo.Describe("Pod controller when TopologyAwareScheduling enabled", g
 				corev1.PodSchedulingGate{Name: podconstants.SchedulingGateName},
 				corev1.PodSchedulingGate{Name: kueuealpha.TopologySchedulingGate},
 			))
-			gomega.Expect(pod.Labels).To(gomega.HaveKeyWithValue(kueuealpha.TASLabel, "true"))
 		})
 
 		wl := &kueue.Workload{}
@@ -2293,7 +2292,6 @@ var _ = ginkgo.Describe("Pod controller when TopologyAwareScheduling enabled", g
 					corev1.PodSchedulingGate{Name: podconstants.SchedulingGateName},
 					corev1.PodSchedulingGate{Name: kueuealpha.TopologySchedulingGate},
 				))
-				gomega.Expect(p.Labels).To(gomega.HaveKeyWithValue(kueuealpha.TASLabel, "true"))
 			}
 		})
 
diff --git a/test/util/e2e.go b/test/util/e2e.go
index f75063d35..5b57aa41b 100644
--- a/test/util/e2e.go
+++ b/test/util/e2e.go
@@ -26,6 +26,7 @@ import (
 	"github.com/google/go-cmp/cmp/cmpopts"
 	kfmpi "github.com/kubeflow/mpi-operator/pkg/apis/kubeflow/v2beta1"
 	kftraining "github.com/kubeflow/training-operator/pkg/apis/kubeflow.org/v1"
+	"github.com/onsi/ginkgo/v2"
 	"github.com/onsi/gomega"
 	awv1beta2 "github.com/project-codeflare/appwrapper/api/v1beta2"
 	rayv1 "github.com/ray-project/kuberay/ray-operator/apis/ray/v1"
@@ -164,6 +165,8 @@ func rolloutOperatorDeployment(ctx context.Context, k8sClient client.Client, key
 func waitForOperatorAvailability(ctx context.Context, k8sClient client.Client, key types.NamespacedName) {
 	deployment := &appsv1.Deployment{}
 	pods := &corev1.PodList{}
+	waitForAvailableStart := time.Now()
+	ginkgo.By(fmt.Sprintf("Waiting for availability of deployment: %q", key))
 	gomega.EventuallyWithOffset(2, func(g gomega.Gomega) error {
 		g.Expect(k8sClient.Get(ctx, key, deployment)).To(gomega.Succeed())
 		g.Expect(k8sClient.List(ctx, pods, client.InNamespace(key.Namespace), client.MatchingLabels(deployment.Spec.Selector.MatchLabels))).To(gomega.Succeed())
@@ -184,6 +187,7 @@ func waitForOperatorAvailability(ctx context.Context, k8sClient client.Client, k
 		))
 		return nil
 	}, StartUpTimeout, Interval).Should(gomega.Succeed())
+	ginkgo.GinkgoLogr.Info("Deployment is available in the cluster", "deployment", key, "waitingTime", time.Since(waitForAvailableStart))
 }
 
 func WaitForKueueAvailability(ctx context.Context, k8sClient client.Client) {
diff --git a/test/util/util.go b/test/util/util.go
index ae12626c0..ad1042948 100644
--- a/test/util/util.go
+++ b/test/util/util.go
@@ -25,6 +25,8 @@ import (
 	"os"
 	"path/filepath"
 	"slices"
+	"strconv"
+	"sync"
 	"time"
 
 	"github.com/go-logr/logr"
@@ -55,6 +57,7 @@ import (
 	"k8s.io/klog/v2"
 	"k8s.io/utils/clock"
 	"k8s.io/utils/ptr"
+	ctrl "sigs.k8s.io/controller-runtime"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 	"sigs.k8s.io/controller-runtime/pkg/controller/controllerutil"
 	"sigs.k8s.io/controller-runtime/pkg/log/zap"
@@ -70,6 +73,22 @@ import (
 	"sigs.k8s.io/kueue/pkg/workload"
 )
 
+const (
+	defaultLogLevel = -3
+)
+
+func logLevel() int {
+	level, err := strconv.Atoi(os.Getenv("TEST_LOG_LEVEL"))
+	if err != nil {
+		return defaultLogLevel
+	}
+	return level
+}
+
+var SetupLogger = sync.OnceFunc(func() {
+	ctrl.SetLogger(NewTestingLogger(ginkgo.GinkgoWriter, logLevel()))
+})
+
 type objAsPtr[T any] interface {
 	client.Object
 	*T