diff --git a/pkg/client/client.go b/pkg/client/client.go
index 092deb43d4..7e38142273 100644
--- a/pkg/client/client.go
+++ b/pkg/client/client.go
@@ -544,6 +544,30 @@ func (po *SubResourcePatchOptions) ApplyToSubResourcePatch(o *SubResourcePatchOp
 	}
 }
 
+// SubResourceApplyOptions are the options for a subresource
+// apply request.
+type SubResourceApplyOptions struct {
+	ApplyOptions
+	SubResourceBody runtime.ApplyConfiguration
+}
+
+// ApplyOpts applies the given options.
+func (ao *SubResourceApplyOptions) ApplyOpts(opts []SubResourceApplyOption) *SubResourceApplyOptions {
+	for _, o := range opts {
+		o.ApplyToSubResourceApply(ao)
+	}
+
+	return ao
+}
+
+// ApplyToSubResourceApply applies the configuration on the given patch options.
+func (ao *SubResourceApplyOptions) ApplyToSubResourceApply(o *SubResourceApplyOptions) {
+	ao.ApplyOptions.ApplyToApply(&o.ApplyOptions)
+	if ao.SubResourceBody != nil {
+		o.SubResourceBody = ao.SubResourceBody
+	}
+}
+
 func (sc *subResourceClient) Get(ctx context.Context, obj Object, subResource Object, opts ...SubResourceGetOption) error {
 	switch obj.(type) {
 	case runtime.Unstructured:
@@ -595,3 +619,13 @@ func (sc *subResourceClient) Patch(ctx context.Context, obj Object, patch Patch,
 		return sc.client.typedClient.PatchSubResource(ctx, obj, sc.subResource, patch, opts...)
 	}
 }
+
+func (sc *subResourceClient) Apply(ctx context.Context, obj runtime.ApplyConfiguration, opts ...SubResourceApplyOption) error {
+	switch obj := obj.(type) {
+	case *unstructuredApplyConfiguration:
+		defer sc.client.resetGroupVersionKind(obj, obj.GetObjectKind().GroupVersionKind())
+		return sc.client.unstructuredClient.ApplySubResource(ctx, obj, sc.subResource, opts...)
+	default:
+		return sc.client.typedClient.ApplySubResource(ctx, obj, sc.subResource, opts...)
+	}
+}
diff --git a/pkg/client/client_test.go b/pkg/client/client_test.go
index c775f28718..42e14771cc 100644
--- a/pkg/client/client_test.go
+++ b/pkg/client/client_test.go
@@ -43,6 +43,8 @@ import (
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/runtime/schema"
 	"k8s.io/apimachinery/pkg/types"
+	appsv1applyconfigurations "k8s.io/client-go/applyconfigurations/apps/v1"
+	autoscaling1applyconfigurations "k8s.io/client-go/applyconfigurations/autoscaling/v1"
 	corev1applyconfigurations "k8s.io/client-go/applyconfigurations/core/v1"
 	kscheme "k8s.io/client-go/kubernetes/scheme"
 	"k8s.io/client-go/rest"
@@ -1127,6 +1129,34 @@ U5wwSivyi7vmegHKmblOzNVKA5qPO8zWzqBC
 				Expect(err).NotTo(HaveOccurred())
 				Expect(*dep.Spec.Replicas).To(Equal(replicaCount))
 			})
+
+			It("should be able to apply the scale subresource", func(ctx SpecContext) {
+				cl, err := client.New(cfg, client.Options{})
+				Expect(err).NotTo(HaveOccurred())
+				Expect(cl).NotTo(BeNil())
+
+				By("Creating a deployment")
+				dep, err := clientset.AppsV1().Deployments(dep.Namespace).Create(ctx, dep, metav1.CreateOptions{})
+				Expect(err).NotTo(HaveOccurred())
+				replicaCount := *dep.Spec.Replicas + 1
+
+				By("Applying the scale subresurce")
+				deploymentAC, err := appsv1applyconfigurations.ExtractDeployment(dep, "foo")
+				Expect(err).NotTo(HaveOccurred())
+				scale := autoscaling1applyconfigurations.Scale().
+					WithSpec(autoscaling1applyconfigurations.ScaleSpec().WithReplicas(replicaCount))
+				err = cl.SubResource("scale").Apply(ctx, deploymentAC,
+					&client.SubResourceApplyOptions{SubResourceBody: scale},
+					client.FieldOwner("foo"),
+					client.ForceOwnership,
+				)
+				Expect(err).NotTo(HaveOccurred())
+
+				By("Asserting replicas got updated")
+				dep, err = clientset.AppsV1().Deployments(dep.Namespace).Get(ctx, dep.Name, metav1.GetOptions{})
+				Expect(err).NotTo(HaveOccurred())
+				Expect(*dep.Spec.Replicas).To(Equal(replicaCount))
+			})
 		})
 
 		Context("with unstructured objects", func() {
@@ -1322,8 +1352,8 @@ U5wwSivyi7vmegHKmblOzNVKA5qPO8zWzqBC
 				By("Creating a deployment")
 				dep, err := clientset.AppsV1().Deployments(dep.Namespace).Create(ctx, dep, metav1.CreateOptions{})
 				Expect(err).NotTo(HaveOccurred())
-				dep.APIVersion = "apps/v1"
-				dep.Kind = "Deployment"
+				dep.APIVersion = appsv1.SchemeGroupVersion.String()
+				dep.Kind = "Deployment" //nolint:goconst
 				depUnstructured, err := toUnstructured(dep)
 				Expect(err).NotTo(HaveOccurred())
 
@@ -1374,6 +1404,41 @@ U5wwSivyi7vmegHKmblOzNVKA5qPO8zWzqBC
 				Expect(err).NotTo(HaveOccurred())
 				Expect(*dep.Spec.Replicas).To(Equal(replicaCount))
 			})
+
+			It("should be able to apply the scale subresource", func(ctx SpecContext) {
+				cl, err := client.New(cfg, client.Options{Scheme: runtime.NewScheme()})
+				Expect(err).NotTo(HaveOccurred())
+				Expect(cl).NotTo(BeNil())
+
+				By("Creating a deployment")
+				dep, err := clientset.AppsV1().Deployments(dep.Namespace).Create(ctx, dep, metav1.CreateOptions{})
+				Expect(err).NotTo(HaveOccurred())
+				dep.APIVersion = "apps/v1"
+				dep.Kind = "Deployment"
+				depUnstructured, err := toUnstructured(dep)
+				Expect(err).NotTo(HaveOccurred())
+
+				By("Updating the scale subresurce")
+				replicaCount := *dep.Spec.Replicas + 1
+				scale := &unstructured.Unstructured{}
+				scale.SetAPIVersion("autoscaling/v1")
+				scale.SetKind("Scale")
+				Expect(unstructured.SetNestedField(scale.Object, int64(replicaCount), "spec", "replicas")).NotTo(HaveOccurred())
+				err = cl.SubResource("scale").Apply(ctx,
+					client.ApplyConfigurationFromUnstructured(depUnstructured),
+					&client.SubResourceApplyOptions{SubResourceBody: client.ApplyConfigurationFromUnstructured(scale)},
+					client.FieldOwner("foo"),
+					client.ForceOwnership,
+				)
+				Expect(err).NotTo(HaveOccurred())
+				Expect(scale.GetAPIVersion()).To(Equal("autoscaling/v1"))
+				Expect(scale.GetKind()).To(Equal("Scale"))
+
+				By("Asserting replicas got updated")
+				dep, err = clientset.AppsV1().Deployments(dep.Namespace).Get(ctx, dep.Name, metav1.GetOptions{})
+				Expect(err).NotTo(HaveOccurred())
+				Expect(*dep.Spec.Replicas).To(Equal(replicaCount))
+			})
 		})
 
 	})
@@ -1440,6 +1505,29 @@ U5wwSivyi7vmegHKmblOzNVKA5qPO8zWzqBC
 				Expect(dep.GroupVersionKind()).To(Equal(depGvk))
 			})
 
+			It("should apply status", func(ctx SpecContext) {
+				cl, err := client.New(cfg, client.Options{})
+				Expect(err).NotTo(HaveOccurred())
+				Expect(cl).NotTo(BeNil())
+
+				By("initially creating a Deployment")
+				dep, err := clientset.AppsV1().Deployments(ns).Create(ctx, dep, metav1.CreateOptions{})
+				Expect(err).NotTo(HaveOccurred())
+				Expect(dep.Status.Replicas).To(BeEquivalentTo(0))
+
+				By("applying the status of Deployment")
+				deploymentAC, err := appsv1applyconfigurations.ExtractDeployment(dep, "foo")
+				Expect(err).NotTo(HaveOccurred())
+				deploymentAC.WithStatus(&appsv1applyconfigurations.DeploymentStatusApplyConfiguration{
+					Replicas: ptr.To(int32(1)),
+				})
+				Expect(cl.Status().Apply(ctx, deploymentAC, client.FieldOwner("foo"))).To(Succeed())
+
+				dep, err = clientset.AppsV1().Deployments(ns).Get(ctx, dep.Name, metav1.GetOptions{})
+				Expect(err).NotTo(HaveOccurred())
+				Expect(dep.Status.Replicas).To(BeEquivalentTo(1))
+			})
+
 			It("should not update spec of an existing object", func(ctx SpecContext) {
 				cl, err := client.New(cfg, client.Options{})
 				Expect(err).NotTo(HaveOccurred())
@@ -1592,6 +1680,34 @@ U5wwSivyi7vmegHKmblOzNVKA5qPO8zWzqBC
 				Expect(actual.Status.Replicas).To(BeEquivalentTo(1))
 			})
 
+			It("should apply status and preserve type information", func(ctx SpecContext) {
+				cl, err := client.New(cfg, client.Options{})
+				Expect(err).NotTo(HaveOccurred())
+				Expect(cl).NotTo(BeNil())
+
+				By("initially creating a Deployment")
+				dep, err := clientset.AppsV1().Deployments(ns).Create(ctx, dep, metav1.CreateOptions{})
+				Expect(err).NotTo(HaveOccurred())
+				Expect(dep.Status.Replicas).To(BeEquivalentTo(0))
+
+				By("applying the status of Deployment")
+				dep.Status.Replicas = 1
+				dep.ManagedFields = nil // Must be unset in SSA requests
+				u := &unstructured.Unstructured{}
+				Expect(scheme.Convert(dep, u, nil)).To(Succeed())
+				err = cl.Status().Apply(ctx, client.ApplyConfigurationFromUnstructured(u), client.FieldOwner("foo"))
+				Expect(err).NotTo(HaveOccurred())
+
+				By("validating updated Deployment has type information")
+				Expect(u.GroupVersionKind()).To(Equal(depGvk))
+
+				By("validating patched Deployment has new status")
+				actual, err := clientset.AppsV1().Deployments(ns).Get(ctx, dep.Name, metav1.GetOptions{})
+				Expect(err).NotTo(HaveOccurred())
+				Expect(actual).NotTo(BeNil())
+				Expect(actual.Status.Replicas).To(BeEquivalentTo(1))
+			})
+
 			It("should not update spec of an existing object", func(ctx SpecContext) {
 				cl, err := client.New(cfg, client.Options{})
 				Expect(err).NotTo(HaveOccurred())
diff --git a/pkg/client/dryrun.go b/pkg/client/dryrun.go
index a185860d33..fb7012200f 100644
--- a/pkg/client/dryrun.go
+++ b/pkg/client/dryrun.go
@@ -132,3 +132,7 @@ func (sw *dryRunSubResourceClient) Update(ctx context.Context, obj Object, opts
 func (sw *dryRunSubResourceClient) Patch(ctx context.Context, obj Object, patch Patch, opts ...SubResourcePatchOption) error {
 	return sw.client.Patch(ctx, obj, patch, append(opts, DryRunAll)...)
 }
+
+func (sw *dryRunSubResourceClient) Apply(ctx context.Context, obj runtime.ApplyConfiguration, opts ...SubResourceApplyOption) error {
+	return sw.client.Apply(ctx, obj, append(opts, DryRunAll)...)
+}
diff --git a/pkg/client/dryrun_test.go b/pkg/client/dryrun_test.go
index 912a4a10dc..35a9b63869 100644
--- a/pkg/client/dryrun_test.go
+++ b/pkg/client/dryrun_test.go
@@ -27,6 +27,7 @@ import (
 	apierrors "k8s.io/apimachinery/pkg/api/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/types"
+	appsv1applyconfigurations "k8s.io/client-go/applyconfigurations/apps/v1"
 	"k8s.io/utils/ptr"
 
 	"sigs.k8s.io/controller-runtime/pkg/client"
@@ -260,4 +261,36 @@ var _ = Describe("DryRunClient", func() {
 		Expect(actual).NotTo(BeNil())
 		Expect(actual).To(BeEquivalentTo(dep))
 	})
+
+	It("should not change objects via status apply", func(ctx SpecContext) {
+		deploymentAC, err := appsv1applyconfigurations.ExtractDeployment(dep, "test-owner")
+		Expect(err).NotTo(HaveOccurred())
+		deploymentAC.WithStatus(&appsv1applyconfigurations.DeploymentStatusApplyConfiguration{
+			Replicas: ptr.To(int32(99)),
+		})
+
+		Expect(getClient().Status().Apply(ctx, deploymentAC, client.FieldOwner("test-owner"))).NotTo(HaveOccurred())
+
+		actual, err := clientset.AppsV1().Deployments(ns).Get(ctx, dep.Name, metav1.GetOptions{})
+		Expect(err).NotTo(HaveOccurred())
+		Expect(actual).NotTo(BeNil())
+		Expect(actual).To(BeEquivalentTo(dep))
+	})
+
+	It("should not change objects via status apply with opts", func(ctx SpecContext) {
+		deploymentAC, err := appsv1applyconfigurations.ExtractDeployment(dep, "test-owner")
+		Expect(err).NotTo(HaveOccurred())
+		deploymentAC.WithStatus(&appsv1applyconfigurations.DeploymentStatusApplyConfiguration{
+			Replicas: ptr.To(int32(99)),
+		})
+
+		opts := &client.SubResourceApplyOptions{ApplyOptions: client.ApplyOptions{DryRun: []string{"Bye", "Pippa"}}}
+
+		Expect(getClient().Status().Apply(ctx, deploymentAC, client.FieldOwner("test-owner"), opts)).NotTo(HaveOccurred())
+
+		actual, err := clientset.AppsV1().Deployments(ns).Get(ctx, dep.Name, metav1.GetOptions{})
+		Expect(err).NotTo(HaveOccurred())
+		Expect(actual).NotTo(BeNil())
+		Expect(actual).To(BeEquivalentTo(dep))
+	})
 })
diff --git a/pkg/client/fake/client.go b/pkg/client/fake/client.go
index 41cf233deb..c97d1ee741 100644
--- a/pkg/client/fake/client.go
+++ b/pkg/client/fake/client.go
@@ -1335,6 +1335,38 @@ func (sw *fakeSubResourceClient) statusPatch(body client.Object, patch client.Pa
 	return sw.client.patch(body, patch, &patchOptions.PatchOptions)
 }
 
+func (sw *fakeSubResourceClient) Apply(ctx context.Context, obj runtime.ApplyConfiguration, opts ...client.SubResourceApplyOption) error {
+	if sw.subResource != "status" {
+		return errors.New("fakeSubResourceClient currently only supports Apply for status subresource")
+	}
+
+	applyOpts := &client.SubResourceApplyOptions{}
+	applyOpts.ApplyOpts(opts)
+
+	data, err := json.Marshal(obj)
+	if err != nil {
+		return fmt.Errorf("failed to marshal apply configuration: %w", err)
+	}
+
+	u := &unstructured.Unstructured{}
+	if err := json.Unmarshal(data, u); err != nil {
+		return fmt.Errorf("failed to unmarshal apply configuration: %w", err)
+	}
+
+	patchOpts := &client.SubResourcePatchOptions{}
+	patchOpts.Raw = applyOpts.AsPatchOptions()
+
+	if applyOpts.SubResourceBody != nil {
+		subResourceBody := &unstructured.Unstructured{}
+		if err := json.Unmarshal(data, subResourceBody); err != nil {
+			return fmt.Errorf("failed to unmarshal subresource body: %w", err)
+		}
+		patchOpts.SubResourceBody = subResourceBody
+	}
+
+	return sw.Patch(ctx, u, &fakeApplyPatch{}, patchOpts)
+}
+
 func allowsUnconditionalUpdate(gvk schema.GroupVersionKind) bool {
 	switch gvk.Group {
 	case "apps":
diff --git a/pkg/client/fake/client_test.go b/pkg/client/fake/client_test.go
index 23f52b9fb8..36722b4ddc 100644
--- a/pkg/client/fake/client_test.go
+++ b/pkg/client/fake/client_test.go
@@ -1809,6 +1809,31 @@ var _ = Describe("Fake client", func() {
 		Expect(pod.Status).To(BeComparableTo(corev1.PodStatus{}))
 	})
 
+	It("should only change status on status apply", func(ctx SpecContext) {
+		initial := &corev1.Node{
+			ObjectMeta: metav1.ObjectMeta{
+				Name: "node",
+			},
+			Spec: corev1.NodeSpec{
+				PodCIDR: "old-cidr",
+			},
+		}
+		cl := NewClientBuilder().WithStatusSubresource(&corev1.Node{}).WithObjects(initial).Build()
+
+		ac := corev1applyconfigurations.Node(initial.Name).
+			WithSpec(corev1applyconfigurations.NodeSpec().WithPodCIDR(initial.Spec.PodCIDR + "-updated")).
+			WithStatus(corev1applyconfigurations.NodeStatus().WithPhase(corev1.NodeRunning))
+
+		Expect(cl.Status().Apply(ctx, ac, client.FieldOwner("test-owner"))).To(Succeed())
+
+		actual := &corev1.Node{ObjectMeta: metav1.ObjectMeta{Name: initial.Name}}
+		Expect(cl.Get(ctx, client.ObjectKeyFromObject(actual), actual)).To(Succeed())
+
+		initial.ResourceVersion = actual.ResourceVersion
+		initial.Status = actual.Status
+		Expect(initial).To(BeComparableTo(actual))
+	})
+
 	It("should Unmarshal the schemaless object with int64 to preserve ints", func(ctx SpecContext) {
 		schemeBuilder := &scheme.Builder{GroupVersion: schema.GroupVersion{Group: "test", Version: "v1"}}
 		schemeBuilder.Register(&WithSchemalessSpec{})
@@ -2694,7 +2719,7 @@ var _ = Describe("Fake client", func() {
 		obj.SetName("foo")
 		Expect(unstructured.SetNestedField(obj.Object, map[string]any{"some": "data"}, "data")).To(Succeed())
 
-		Expect(cl.Patch(ctx, obj, client.Apply, client.FieldOwner("foo"))).To(Succeed())
+		Expect(cl.Patch(ctx, obj, client.Apply, client.FieldOwner("foo"))).To(Succeed()) //nolint:staticcheck // will be removed once client.Apply is removed
 
 		cm := &corev1.ConfigMap{ObjectMeta: metav1.ObjectMeta{Name: "foo"}}
 
@@ -2702,7 +2727,7 @@ var _ = Describe("Fake client", func() {
 		Expect(cm.Data).To(Equal(map[string]string{"some": "data"}))
 
 		Expect(unstructured.SetNestedField(obj.Object, map[string]any{"other": "data"}, "data")).To(Succeed())
-		Expect(cl.Patch(ctx, obj, client.Apply, client.FieldOwner("foo"))).To(Succeed())
+		Expect(cl.Patch(ctx, obj, client.Apply, client.FieldOwner("foo"))).To(Succeed()) //nolint:staticcheck // will be removed once client.Apply is removed
 
 		Expect(cl.Get(ctx, client.ObjectKeyFromObject(cm), cm)).To(Succeed())
 		Expect(cm.Data).To(Equal(map[string]string{"other": "data"}))
@@ -2718,13 +2743,13 @@ var _ = Describe("Fake client", func() {
 
 		Expect(unstructured.SetNestedField(obj.Object, map[string]any{"some": "data"}, "spec")).To(Succeed())
 
-		Expect(cl.Patch(ctx, obj, client.Apply, client.FieldOwner("foo"))).To(Succeed())
+		Expect(cl.Patch(ctx, obj, client.Apply, client.FieldOwner("foo"))).To(Succeed()) //nolint:staticcheck // will be removed once client.Apply is removed
 
 		Expect(cl.Get(ctx, client.ObjectKeyFromObject(result), result)).To(Succeed())
 		Expect(result.Object["spec"]).To(Equal(map[string]any{"some": "data"}))
 
 		Expect(unstructured.SetNestedField(obj.Object, map[string]any{"other": "data"}, "spec")).To(Succeed())
-		Expect(cl.Patch(ctx, obj, client.Apply, client.FieldOwner("foo"))).To(Succeed())
+		Expect(cl.Patch(ctx, obj, client.Apply, client.FieldOwner("foo"))).To(Succeed()) //nolint:staticcheck // will be removed once client.Apply is removed
 
 		Expect(cl.Get(ctx, client.ObjectKeyFromObject(result), result)).To(Succeed())
 		Expect(result.Object["spec"]).To(Equal(map[string]any{"other": "data"}))
@@ -2738,9 +2763,9 @@ var _ = Describe("Fake client", func() {
 		obj.SetName("foo")
 		Expect(unstructured.SetNestedField(obj.Object, map[string]any{"some": "data"}, "data")).To(Succeed())
 
-		Expect(cl.Patch(ctx, obj, client.Apply, client.FieldOwner("foo"))).To(Succeed())
+		Expect(cl.Patch(ctx, obj, client.Apply, client.FieldOwner("foo"))).To(Succeed()) //nolint:staticcheck // will be removed once client.Apply is removed
 
-		err := cl.Patch(ctx, obj, client.Apply, client.FieldOwner("foo"))
+		err := cl.Patch(ctx, obj, client.Apply, client.FieldOwner("foo")) //nolint:staticcheck // will be removed once client.Apply is removed
 		Expect(err).To(HaveOccurred())
 		Expect(err.Error()).To(ContainSubstring("metadata.managedFields must be nil"))
 	})
@@ -2756,7 +2781,7 @@ var _ = Describe("Fake client", func() {
 
 		Expect(unstructured.SetNestedField(obj.Object, map[string]any{"some": "data"}, "data")).To(Succeed())
 
-		Expect(cl.Patch(ctx, obj, client.Apply, client.FieldOwner("foo"))).To(Succeed())
+		Expect(cl.Patch(ctx, obj, client.Apply, client.FieldOwner("foo"))).To(Succeed()) //nolint:staticcheck // will be removed once client.Apply is removed
 
 		cm := &corev1.ConfigMap{ObjectMeta: metav1.ObjectMeta{Name: "foo"}}
 
@@ -2764,7 +2789,7 @@ var _ = Describe("Fake client", func() {
 		Expect(cm.Data).To(Equal(map[string]string{"some": "data"}))
 
 		Expect(unstructured.SetNestedField(obj.Object, map[string]any{"other": "data"}, "data")).To(Succeed())
-		Expect(cl.Patch(ctx, obj, client.Apply, client.FieldOwner("foo"))).To(Succeed())
+		Expect(cl.Patch(ctx, obj, client.Apply, client.FieldOwner("foo"))).To(Succeed()) //nolint:staticcheck // will be removed once client.Apply is removed
 
 		Expect(cl.Get(ctx, client.ObjectKeyFromObject(cm), cm)).To(Succeed())
 		Expect(cm.Data).To(Equal(map[string]string{"other": "data"}))
@@ -2810,7 +2835,7 @@ var _ = Describe("Fake client", func() {
 				"ssa": "value",
 			},
 		}}
-		Expect(cl.Patch(ctx, u, client.Apply, client.FieldOwner("foo"))).NotTo(HaveOccurred())
+		Expect(cl.Patch(ctx, u, client.Apply, client.FieldOwner("foo"))).NotTo(HaveOccurred()) //nolint:staticcheck // will be removed once client.Apply is removed
 		_, exists, err := unstructured.NestedFieldNoCopy(u.Object, "metadata", "managedFields")
 		Expect(err).NotTo(HaveOccurred())
 		Expect(exists).To(BeTrue())
diff --git a/pkg/client/fake/versioned_tracker.go b/pkg/client/fake/versioned_tracker.go
index c1caa1ca02..bc1eaeb951 100644
--- a/pkg/client/fake/versioned_tracker.go
+++ b/pkg/client/fake/versioned_tracker.go
@@ -307,7 +307,9 @@ func (t versionedTracker) Apply(gvr schema.GroupVersionResource, applyConfigurat
 	if err != nil {
 		return err
 	}
-	applyConfiguration, needsCreate, err := t.updateObject(gvr, gvk, applyConfiguration, ns, false, false, true, patchOptions.DryRun)
+	isStatus := bytes.Contains(debug.Stack(), []byte("sigs.k8s.io/controller-runtime/pkg/client/fake.(*fakeSubResourceClient).statusPatch"))
+
+	applyConfiguration, needsCreate, err := t.updateObject(gvr, gvk, applyConfiguration, ns, isStatus, false, true, patchOptions.DryRun)
 	if err != nil {
 		return err
 	}
@@ -334,6 +336,11 @@ func (t versionedTracker) Apply(gvr schema.GroupVersionResource, applyConfigurat
 		return nil
 	}
 
+	if isStatus {
+		// We restore everything but status from the tracker where we don't put GVK
+		// into the object but it must be set for the ManagedFieldsObjectTracker
+		applyConfiguration.GetObjectKind().SetGroupVersionKind(gvk)
+	}
 	return t.upstream.Apply(gvr, applyConfiguration, ns, opts...)
 }
 
diff --git a/pkg/client/fieldowner.go b/pkg/client/fieldowner.go
index 93274f9500..5d9437ba91 100644
--- a/pkg/client/fieldowner.go
+++ b/pkg/client/fieldowner.go
@@ -108,3 +108,7 @@ func (f *subresourceClientWithFieldOwner) Update(ctx context.Context, obj Object
 func (f *subresourceClientWithFieldOwner) Patch(ctx context.Context, obj Object, patch Patch, opts ...SubResourcePatchOption) error {
 	return f.subresourceWriter.Patch(ctx, obj, patch, append([]SubResourcePatchOption{FieldOwner(f.owner)}, opts...)...)
 }
+
+func (f *subresourceClientWithFieldOwner) Apply(ctx context.Context, obj runtime.ApplyConfiguration, opts ...SubResourceApplyOption) error {
+	return f.subresourceWriter.Apply(ctx, obj, append([]SubResourceApplyOption{FieldOwner(f.owner)}, opts...)...)
+}
diff --git a/pkg/client/fieldowner_test.go b/pkg/client/fieldowner_test.go
index 95cb4e0f91..069abbc115 100644
--- a/pkg/client/fieldowner_test.go
+++ b/pkg/client/fieldowner_test.go
@@ -21,6 +21,8 @@ import (
 	"testing"
 
 	corev1 "k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/runtime"
+	corev1applyconfigurations "k8s.io/client-go/applyconfigurations/core/v1"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 	"sigs.k8s.io/controller-runtime/pkg/client/fake"
 	"sigs.k8s.io/controller-runtime/pkg/client/interceptor"
@@ -33,18 +35,22 @@ func TestWithFieldOwner(t *testing.T) {
 
 	ctx := t.Context()
 	dummyObj := &corev1.Namespace{}
+	dummyObjectAC := corev1applyconfigurations.Namespace(dummyObj.Name)
 
 	_ = wrappedClient.Create(ctx, dummyObj)
 	_ = wrappedClient.Update(ctx, dummyObj)
 	_ = wrappedClient.Patch(ctx, dummyObj, nil)
+	_ = wrappedClient.Apply(ctx, dummyObjectAC)
 	_ = wrappedClient.Status().Create(ctx, dummyObj, dummyObj)
 	_ = wrappedClient.Status().Update(ctx, dummyObj)
 	_ = wrappedClient.Status().Patch(ctx, dummyObj, nil)
+	_ = wrappedClient.Status().Apply(ctx, dummyObjectAC)
 	_ = wrappedClient.SubResource("some-subresource").Create(ctx, dummyObj, dummyObj)
 	_ = wrappedClient.SubResource("some-subresource").Update(ctx, dummyObj)
 	_ = wrappedClient.SubResource("some-subresource").Patch(ctx, dummyObj, nil)
+	_ = wrappedClient.SubResource("some-subresource").Apply(ctx, dummyObjectAC)
 
-	if expectedCalls := 9; calls != expectedCalls {
+	if expectedCalls := 12; calls != expectedCalls {
 		t.Fatalf("wrong number of calls to assertions: expected=%d; got=%d", expectedCalls, calls)
 	}
 }
@@ -57,18 +63,22 @@ func TestWithFieldOwnerOverridden(t *testing.T) {
 
 	ctx := t.Context()
 	dummyObj := &corev1.Namespace{}
+	dummyObjectAC := corev1applyconfigurations.Namespace(dummyObj.Name)
 
 	_ = wrappedClient.Create(ctx, dummyObj, client.FieldOwner("new-field-manager"))
 	_ = wrappedClient.Update(ctx, dummyObj, client.FieldOwner("new-field-manager"))
 	_ = wrappedClient.Patch(ctx, dummyObj, nil, client.FieldOwner("new-field-manager"))
+	_ = wrappedClient.Apply(ctx, dummyObjectAC, client.FieldOwner("new-field-manager"))
 	_ = wrappedClient.Status().Create(ctx, dummyObj, dummyObj, client.FieldOwner("new-field-manager"))
 	_ = wrappedClient.Status().Update(ctx, dummyObj, client.FieldOwner("new-field-manager"))
 	_ = wrappedClient.Status().Patch(ctx, dummyObj, nil, client.FieldOwner("new-field-manager"))
+	_ = wrappedClient.Status().Apply(ctx, dummyObjectAC, client.FieldOwner("new-field-manager"))
 	_ = wrappedClient.SubResource("some-subresource").Create(ctx, dummyObj, dummyObj, client.FieldOwner("new-field-manager"))
 	_ = wrappedClient.SubResource("some-subresource").Update(ctx, dummyObj, client.FieldOwner("new-field-manager"))
 	_ = wrappedClient.SubResource("some-subresource").Patch(ctx, dummyObj, nil, client.FieldOwner("new-field-manager"))
+	_ = wrappedClient.SubResource("some-subresource").Apply(ctx, dummyObjectAC, client.FieldOwner("new-field-manager"))
 
-	if expectedCalls := 9; calls != expectedCalls {
+	if expectedCalls := 12; calls != expectedCalls {
 		t.Fatalf("wrong number of calls to assertions: expected=%d; got=%d", expectedCalls, calls)
 	}
 }
@@ -144,5 +154,27 @@ func testClient(t *testing.T, expectedFieldManager string, callback func()) clie
 			}
 			return nil
 		},
+		Apply: func(ctx context.Context, c client.WithWatch, obj runtime.ApplyConfiguration, opts ...client.ApplyOption) error {
+			callback()
+			out := &client.ApplyOptions{}
+			for _, f := range opts {
+				f.ApplyToApply(out)
+			}
+			if got := out.FieldManager; expectedFieldManager != got {
+				t.Fatalf("wrong field manager: expected=%q; got=%q", expectedFieldManager, got)
+			}
+			return nil
+		},
+		SubResourceApply: func(ctx context.Context, c client.Client, subResourceName string, obj runtime.ApplyConfiguration, opts ...client.SubResourceApplyOption) error {
+			callback()
+			out := &client.SubResourceApplyOptions{}
+			for _, f := range opts {
+				f.ApplyToSubResourceApply(out)
+			}
+			if got := out.FieldManager; expectedFieldManager != got {
+				t.Fatalf("wrong field manager: expected=%q; got=%q", expectedFieldManager, got)
+			}
+			return nil
+		},
 	}).Build()
 }
diff --git a/pkg/client/fieldvalidation.go b/pkg/client/fieldvalidation.go
index ce8d0576c7..b0f660854e 100644
--- a/pkg/client/fieldvalidation.go
+++ b/pkg/client/fieldvalidation.go
@@ -27,6 +27,9 @@ import (
 // WithFieldValidation wraps a Client and configures field validation, by
 // default, for all write requests from this client. Users can override field
 // validation for individual write requests.
+//
+// This wrapper has no effect on apply requests, as they do not support a
+// custom fieldValidation setting, it is always strict.
 func WithFieldValidation(c Client, validation FieldValidation) Client {
 	return &clientWithFieldValidation{
 		validation: validation,
@@ -108,3 +111,7 @@ func (c *subresourceClientWithFieldValidation) Update(ctx context.Context, obj O
 func (c *subresourceClientWithFieldValidation) Patch(ctx context.Context, obj Object, patch Patch, opts ...SubResourcePatchOption) error {
 	return c.subresourceWriter.Patch(ctx, obj, patch, append([]SubResourcePatchOption{c.validation}, opts...)...)
 }
+
+func (c *subresourceClientWithFieldValidation) Apply(ctx context.Context, obj runtime.ApplyConfiguration, opts ...SubResourceApplyOption) error {
+	return c.subresourceWriter.Apply(ctx, obj, opts...)
+}
diff --git a/pkg/client/fieldvalidation_test.go b/pkg/client/fieldvalidation_test.go
index d32ee5717d..013224a06b 100644
--- a/pkg/client/fieldvalidation_test.go
+++ b/pkg/client/fieldvalidation_test.go
@@ -92,6 +92,15 @@ var _ = Describe("ClientWithFieldValidation", func() {
 		err = wrappedClient.SubResource("status").Patch(ctx, invalidStatusNode, patch)
 		Expect(err).To(HaveOccurred())
 		Expect(err.Error()).To(ContainSubstring("strict decoding error: unknown field \"status.invalidStatusField\""))
+
+		invalidApplyConfig := client.ApplyConfigurationFromUnstructured(invalidStatusNode)
+		err = wrappedClient.Status().Apply(ctx, invalidApplyConfig, client.FieldOwner("test-owner"))
+		Expect(err).To(HaveOccurred())
+		Expect(err.Error()).To(ContainSubstring("field not declared in schema"))
+
+		err = wrappedClient.SubResource("status").Apply(ctx, invalidApplyConfig, client.FieldOwner("test-owner"))
+		Expect(err).To(HaveOccurred())
+		Expect(err.Error()).To(ContainSubstring("field not declared in schema"))
 	})
 })
 
@@ -113,8 +122,9 @@ func TestWithStrictFieldValidation(t *testing.T) {
 	_ = wrappedClient.SubResource("some-subresource").Create(ctx, dummyObj, dummyObj)
 	_ = wrappedClient.SubResource("some-subresource").Update(ctx, dummyObj)
 	_ = wrappedClient.SubResource("some-subresource").Patch(ctx, dummyObj, nil)
+	_ = wrappedClient.SubResource("some-subresource").Apply(ctx, corev1applyconfigurations.Namespace(""), nil)
 
-	if expectedCalls := 10; calls != expectedCalls {
+	if expectedCalls := 11; calls != expectedCalls {
 		t.Fatalf("wrong number of calls to assertions: expected=%d; got=%d", expectedCalls, calls)
 	}
 }
@@ -278,5 +288,9 @@ func testFieldValidationClient(t *testing.T, expectedFieldValidation string, cal
 			}
 			return nil
 		},
+		SubResourceApply: func(ctx context.Context, c client.Client, subResourceName string, obj runtime.ApplyConfiguration, opts ...client.SubResourceApplyOption) error {
+			callback()
+			return nil
+		},
 	}).Build()
 }
diff --git a/pkg/client/interceptor/intercept.go b/pkg/client/interceptor/intercept.go
index 7ff73bd8da..b98af1a693 100644
--- a/pkg/client/interceptor/intercept.go
+++ b/pkg/client/interceptor/intercept.go
@@ -26,6 +26,7 @@ type Funcs struct {
 	SubResourceCreate func(ctx context.Context, client client.Client, subResourceName string, obj client.Object, subResource client.Object, opts ...client.SubResourceCreateOption) error
 	SubResourceUpdate func(ctx context.Context, client client.Client, subResourceName string, obj client.Object, opts ...client.SubResourceUpdateOption) error
 	SubResourcePatch  func(ctx context.Context, client client.Client, subResourceName string, obj client.Object, patch client.Patch, opts ...client.SubResourcePatchOption) error
+	SubResourceApply  func(ctx context.Context, client client.Client, subResourceName string, obj runtime.ApplyConfiguration, opts ...client.SubResourceApplyOption) error
 }
 
 // NewClient returns a new interceptor client that calls the functions in funcs instead of the underlying client's methods, if they are not nil.
@@ -173,3 +174,10 @@ func (s subResourceInterceptor) Patch(ctx context.Context, obj client.Object, pa
 	}
 	return s.client.SubResource(s.subResourceName).Patch(ctx, obj, patch, opts...)
 }
+
+func (s subResourceInterceptor) Apply(ctx context.Context, obj runtime.ApplyConfiguration, opts ...client.SubResourceApplyOption) error {
+	if s.funcs.SubResourceApply != nil {
+		return s.funcs.SubResourceApply(ctx, s.client, s.subResourceName, obj, opts...)
+	}
+	return s.client.SubResource(s.subResourceName).Apply(ctx, obj, opts...)
+}
diff --git a/pkg/client/interceptor/intercept_test.go b/pkg/client/interceptor/intercept_test.go
index 26ea5b057e..fb58dfeac1 100644
--- a/pkg/client/interceptor/intercept_test.go
+++ b/pkg/client/interceptor/intercept_test.go
@@ -351,6 +351,31 @@ var _ = Describe("NewSubResourceClient", func() {
 		_ = client2.SubResource("foo").Create(ctx, nil, nil)
 		Expect(called).To(BeTrue())
 	})
+	It("should call the provided Apply function", func(ctx SpecContext) {
+		var called bool
+		client := NewClient(c, Funcs{
+			SubResourceApply: func(_ context.Context, client client.Client, subResourceName string, obj runtime.ApplyConfiguration, opts ...client.SubResourceApplyOption) error {
+				called = true
+				Expect(subResourceName).To(BeEquivalentTo("foo"))
+				return nil
+			},
+		})
+		_ = client.SubResource("foo").Apply(ctx, nil)
+		Expect(called).To(BeTrue())
+	})
+	It("should call the underlying client if the provided Apply function is nil", func(ctx SpecContext) {
+		var called bool
+		client1 := NewClient(c, Funcs{
+			SubResourceApply: func(_ context.Context, client client.Client, subResourceName string, obj runtime.ApplyConfiguration, opts ...client.SubResourceApplyOption) error {
+				called = true
+				Expect(subResourceName).To(BeEquivalentTo("foo"))
+				return nil
+			},
+		})
+		client2 := NewClient(client1, Funcs{})
+		_ = client2.SubResource("foo").Apply(ctx, nil)
+		Expect(called).To(BeTrue())
+	})
 })
 
 type dummyClient struct{}
diff --git a/pkg/client/interfaces.go b/pkg/client/interfaces.go
index 61559ecbe1..1af1f3a368 100644
--- a/pkg/client/interfaces.go
+++ b/pkg/client/interfaces.go
@@ -155,6 +155,9 @@ type SubResourceWriter interface {
 	// pointer so that obj can be updated with the content returned by the
 	// Server.
 	Patch(ctx context.Context, obj Object, patch Patch, opts ...SubResourcePatchOption) error
+
+	// Apply applies the given apply configurations subresource.
+	Apply(ctx context.Context, obj runtime.ApplyConfiguration, opts ...SubResourceApplyOption) error
 }
 
 // SubResourceClient knows how to perform CRU operations on Kubernetes objects.
diff --git a/pkg/client/namespaced_client.go b/pkg/client/namespaced_client.go
index cacba4a9c6..445e91b98b 100644
--- a/pkg/client/namespaced_client.go
+++ b/pkg/client/namespaced_client.go
@@ -150,7 +150,7 @@ func (n *namespacedClient) Patch(ctx context.Context, obj Object, patch Patch, o
 	return n.client.Patch(ctx, obj, patch, opts...)
 }
 
-func (n *namespacedClient) Apply(ctx context.Context, obj runtime.ApplyConfiguration, opts ...ApplyOption) error {
+func (n *namespacedClient) setNamespaceForApplyConfigIfNamespaceScoped(obj runtime.ApplyConfiguration) error {
 	var gvk schema.GroupVersionKind
 	switch o := obj.(type) {
 	case applyConfiguration:
@@ -193,6 +193,14 @@ func (n *namespacedClient) Apply(ctx context.Context, obj runtime.ApplyConfigura
 		}
 	}
 
+	return nil
+}
+
+func (n *namespacedClient) Apply(ctx context.Context, obj runtime.ApplyConfiguration, opts ...ApplyOption) error {
+	if err := n.setNamespaceForApplyConfigIfNamespaceScoped(obj); err != nil {
+		return err
+	}
+
 	return n.client.Apply(ctx, obj, opts...)
 }
 
@@ -226,7 +234,10 @@ func (n *namespacedClient) Status() SubResourceWriter {
 
 // SubResource implements client.SubResourceClient.
 func (n *namespacedClient) SubResource(subResource string) SubResourceClient {
-	return &namespacedClientSubResourceClient{client: n.client.SubResource(subResource), namespace: n.namespace, namespacedclient: n}
+	return &namespacedClientSubResourceClient{
+		client:           n.client.SubResource(subResource),
+		namespacedclient: n,
+	}
 }
 
 // ensure namespacedClientSubResourceClient implements client.SubResourceClient.
@@ -234,8 +245,7 @@ var _ SubResourceClient = &namespacedClientSubResourceClient{}
 
 type namespacedClientSubResourceClient struct {
 	client           SubResourceClient
-	namespace        string
-	namespacedclient Client
+	namespacedclient *namespacedClient
 }
 
 func (nsw *namespacedClientSubResourceClient) Get(ctx context.Context, obj, subResource Object, opts ...SubResourceGetOption) error {
@@ -245,12 +255,12 @@ func (nsw *namespacedClientSubResourceClient) Get(ctx context.Context, obj, subR
 	}
 
 	objectNamespace := obj.GetNamespace()
-	if objectNamespace != nsw.namespace && objectNamespace != "" {
-		return fmt.Errorf("namespace %s of the object %s does not match the namespace %s on the client", objectNamespace, obj.GetName(), nsw.namespace)
+	if objectNamespace != nsw.namespacedclient.namespace && objectNamespace != "" {
+		return fmt.Errorf("namespace %s of the object %s does not match the namespace %s on the client", objectNamespace, obj.GetName(), nsw.namespacedclient.namespace)
 	}
 
 	if isNamespaceScoped && objectNamespace == "" {
-		obj.SetNamespace(nsw.namespace)
+		obj.SetNamespace(nsw.namespacedclient.namespace)
 	}
 
 	return nsw.client.Get(ctx, obj, subResource, opts...)
@@ -263,12 +273,12 @@ func (nsw *namespacedClientSubResourceClient) Create(ctx context.Context, obj, s
 	}
 
 	objectNamespace := obj.GetNamespace()
-	if objectNamespace != nsw.namespace && objectNamespace != "" {
-		return fmt.Errorf("namespace %s of the object %s does not match the namespace %s on the client", objectNamespace, obj.GetName(), nsw.namespace)
+	if objectNamespace != nsw.namespacedclient.namespace && objectNamespace != "" {
+		return fmt.Errorf("namespace %s of the object %s does not match the namespace %s on the client", objectNamespace, obj.GetName(), nsw.namespacedclient.namespace)
 	}
 
 	if isNamespaceScoped && objectNamespace == "" {
-		obj.SetNamespace(nsw.namespace)
+		obj.SetNamespace(nsw.namespacedclient.namespace)
 	}
 
 	return nsw.client.Create(ctx, obj, subResource, opts...)
@@ -282,12 +292,12 @@ func (nsw *namespacedClientSubResourceClient) Update(ctx context.Context, obj Ob
 	}
 
 	objectNamespace := obj.GetNamespace()
-	if objectNamespace != nsw.namespace && objectNamespace != "" {
-		return fmt.Errorf("namespace %s of the object %s does not match the namespace %s on the client", objectNamespace, obj.GetName(), nsw.namespace)
+	if objectNamespace != nsw.namespacedclient.namespace && objectNamespace != "" {
+		return fmt.Errorf("namespace %s of the object %s does not match the namespace %s on the client", objectNamespace, obj.GetName(), nsw.namespacedclient.namespace)
 	}
 
 	if isNamespaceScoped && objectNamespace == "" {
-		obj.SetNamespace(nsw.namespace)
+		obj.SetNamespace(nsw.namespacedclient.namespace)
 	}
 	return nsw.client.Update(ctx, obj, opts...)
 }
@@ -300,12 +310,19 @@ func (nsw *namespacedClientSubResourceClient) Patch(ctx context.Context, obj Obj
 	}
 
 	objectNamespace := obj.GetNamespace()
-	if objectNamespace != nsw.namespace && objectNamespace != "" {
-		return fmt.Errorf("namespace %s of the object %s does not match the namespace %s on the client", objectNamespace, obj.GetName(), nsw.namespace)
+	if objectNamespace != nsw.namespacedclient.namespace && objectNamespace != "" {
+		return fmt.Errorf("namespace %s of the object %s does not match the namespace %s on the client", objectNamespace, obj.GetName(), nsw.namespacedclient.namespace)
 	}
 
 	if isNamespaceScoped && objectNamespace == "" {
-		obj.SetNamespace(nsw.namespace)
+		obj.SetNamespace(nsw.namespacedclient.namespace)
 	}
 	return nsw.client.Patch(ctx, obj, patch, opts...)
 }
+
+func (nsw *namespacedClientSubResourceClient) Apply(ctx context.Context, obj runtime.ApplyConfiguration, opts ...SubResourceApplyOption) error {
+	if err := nsw.namespacedclient.setNamespaceForApplyConfigIfNamespaceScoped(obj); err != nil {
+		return err
+	}
+	return nsw.client.Apply(ctx, obj, opts...)
+}
diff --git a/pkg/client/namespaced_client_test.go b/pkg/client/namespaced_client_test.go
index cf28289e72..deae881d4a 100644
--- a/pkg/client/namespaced_client_test.go
+++ b/pkg/client/namespaced_client_test.go
@@ -37,6 +37,7 @@ import (
 	corev1applyconfigurations "k8s.io/client-go/applyconfigurations/core/v1"
 	metav1applyconfigurations "k8s.io/client-go/applyconfigurations/meta/v1"
 	rbacv1applyconfigurations "k8s.io/client-go/applyconfigurations/rbac/v1"
+	"k8s.io/utils/ptr"
 
 	"sigs.k8s.io/controller-runtime/pkg/client"
 )
@@ -613,6 +614,48 @@ var _ = Describe("NamespacedClient", func() {
 
 			Expect(getClient().SubResource("status").Patch(ctx, changedDep, client.MergeFrom(dep))).To(HaveOccurred())
 		})
+
+		It("should change objects via status apply", func(ctx SpecContext) {
+			deploymentAC, err := appsv1applyconfigurations.ExtractDeployment(dep, "test-owner")
+			Expect(err).NotTo(HaveOccurred())
+			deploymentAC.WithStatus(&appsv1applyconfigurations.DeploymentStatusApplyConfiguration{
+				Replicas: ptr.To(int32(99)),
+			})
+
+			Expect(getClient().SubResource("status").Apply(ctx, deploymentAC, client.FieldOwner("test-owner"))).To(Succeed())
+
+			actual, err := clientset.AppsV1().Deployments(ns).Get(ctx, dep.Name, metav1.GetOptions{})
+			Expect(err).NotTo(HaveOccurred())
+			Expect(actual).NotTo(BeNil())
+			Expect(actual.GetNamespace()).To(BeEquivalentTo(ns))
+			Expect(actual.Status.Replicas).To(BeEquivalentTo(99))
+		})
+
+		It("should set namespace on ApplyConfiguration when applying via SubResource", func(ctx SpecContext) {
+			deploymentAC := appsv1applyconfigurations.Deployment(dep.Name, "")
+			deploymentAC.WithStatus(&appsv1applyconfigurations.DeploymentStatusApplyConfiguration{
+				Replicas: ptr.To(int32(50)),
+			})
+
+			Expect(getClient().SubResource("status").Apply(ctx, deploymentAC, client.FieldOwner("test-owner"))).To(Succeed())
+
+			actual, err := clientset.AppsV1().Deployments(ns).Get(ctx, dep.Name, metav1.GetOptions{})
+			Expect(err).NotTo(HaveOccurred())
+			Expect(actual).NotTo(BeNil())
+			Expect(actual.GetNamespace()).To(BeEquivalentTo(ns))
+			Expect(actual.Status.Replicas).To(BeEquivalentTo(50))
+		})
+
+		It("should fail when applying via SubResource with conflicting namespace", func(ctx SpecContext) {
+			deploymentAC := appsv1applyconfigurations.Deployment(dep.Name, "different-namespace")
+			deploymentAC.WithStatus(&appsv1applyconfigurations.DeploymentStatusApplyConfiguration{
+				Replicas: ptr.To(int32(25)),
+			})
+
+			err := getClient().SubResource("status").Apply(ctx, deploymentAC, client.FieldOwner("test-owner"))
+			Expect(err).To(HaveOccurred())
+			Expect(err.Error()).To(ContainSubstring("namespace"))
+		})
 	})
 
 	Describe("Test on invalid objects", func() {
diff --git a/pkg/client/options.go b/pkg/client/options.go
index 33c460738c..a6b921171a 100644
--- a/pkg/client/options.go
+++ b/pkg/client/options.go
@@ -97,6 +97,12 @@ type SubResourcePatchOption interface {
 	ApplyToSubResourcePatch(*SubResourcePatchOptions)
 }
 
+// SubResourceApplyOption configures a subresource apply request.
+type SubResourceApplyOption interface {
+	// ApplyToSubResourceApply applies the configuration on the given patch options.
+	ApplyToSubResourceApply(*SubResourceApplyOptions)
+}
+
 // }}}
 
 // {{{ Multi-Type Options
@@ -148,6 +154,10 @@ func (dryRunAll) ApplyToSubResourcePatch(opts *SubResourcePatchOptions) {
 	opts.DryRun = []string{metav1.DryRunAll}
 }
 
+func (dryRunAll) ApplyToSubResourceApply(opts *SubResourceApplyOptions) {
+	opts.DryRun = []string{metav1.DryRunAll}
+}
+
 // FieldOwner set the field manager name for the given server-side apply patch.
 type FieldOwner string
 
@@ -186,6 +196,11 @@ func (f FieldOwner) ApplyToSubResourceUpdate(opts *SubResourceUpdateOptions) {
 	opts.FieldManager = string(f)
 }
 
+// ApplyToSubResourceApply applies this configuration to the given apply options.
+func (f FieldOwner) ApplyToSubResourceApply(opts *SubResourceApplyOptions) {
+	opts.FieldManager = string(f)
+}
+
 // FieldValidation configures field validation for the given requests.
 type FieldValidation string
 
@@ -949,6 +964,10 @@ func (forceOwnership) ApplyToApply(opts *ApplyOptions) {
 	opts.Force = ptr.To(true)
 }
 
+func (forceOwnership) ApplyToSubResourceApply(opts *SubResourceApplyOptions) {
+	opts.Force = ptr.To(true)
+}
+
 // }}}
 
 // {{{ DeleteAllOf Options
diff --git a/pkg/client/options_test.go b/pkg/client/options_test.go
index 0aa6a74007..082586bca3 100644
--- a/pkg/client/options_test.go
+++ b/pkg/client/options_test.go
@@ -374,6 +374,12 @@ var _ = Describe("DryRunAll", func() {
 		t.ApplyToSubResourceUpdate(o)
 		Expect(o.DryRun).To(Equal([]string{metav1.DryRunAll}))
 	})
+	It("Should apply to SubResourceApplyOptions", func() {
+		o := &client.SubResourceApplyOptions{ApplyOptions: client.ApplyOptions{DryRun: []string{"server"}}}
+		t := client.DryRunAll
+		t.ApplyToSubResourceApply(o)
+		Expect(o.DryRun).To(Equal([]string{metav1.DryRunAll}))
+	})
 })
 
 var _ = Describe("FieldOwner", func() {
@@ -419,6 +425,12 @@ var _ = Describe("FieldOwner", func() {
 		t.ApplyToSubResourceUpdate(o)
 		Expect(o.FieldManager).To(Equal("foo"))
 	})
+	It("Should apply to SubResourceApplyOptions", func() {
+		o := &client.SubResourceApplyOptions{ApplyOptions: client.ApplyOptions{FieldManager: "bar"}}
+		t := client.FieldOwner("foo")
+		t.ApplyToSubResourceApply(o)
+		Expect(o.FieldManager).To(Equal("foo"))
+	})
 })
 
 var _ = Describe("ForceOwnership", func() {
@@ -440,6 +452,12 @@ var _ = Describe("ForceOwnership", func() {
 		t.ApplyToApply(o)
 		Expect(*o.Force).To(BeTrue())
 	})
+	It("Should apply to SubResourceApplyOptions", func() {
+		o := &client.SubResourceApplyOptions{}
+		t := client.ForceOwnership
+		t.ApplyToSubResourceApply(o)
+		Expect(*o.Force).To(BeTrue())
+	})
 })
 
 var _ = Describe("HasLabels", func() {
diff --git a/pkg/client/patch.go b/pkg/client/patch.go
index b99d7663bd..9bd0953fdc 100644
--- a/pkg/client/patch.go
+++ b/pkg/client/patch.go
@@ -28,10 +28,7 @@ import (
 var (
 	// Apply uses server-side apply to patch the given object.
 	//
-	// This should now only be used to patch sub resources, e.g. with client.Client.Status().Patch().
-	// Use client.Client.Apply() instead of client.Client.Patch(..., client.Apply, ...)
-	// This will be deprecated once the Apply method has been added for sub resources.
-	// See the following issue for more details: https://github.com/kubernetes-sigs/controller-runtime/issues/3183
+	// Deprecated: Use client.Client.Apply() and client.Client.SubResource("subrsource").Apply() instead.
 	Apply Patch = applyPatch{}
 
 	// Merge uses the raw object as a merge patch, without modifications.
diff --git a/pkg/client/typed_client.go b/pkg/client/typed_client.go
index 3bd762a638..66ae2e4a5c 100644
--- a/pkg/client/typed_client.go
+++ b/pkg/client/typed_client.go
@@ -304,3 +304,36 @@ func (c *typedClient) PatchSubResource(ctx context.Context, obj Object, subResou
 		Do(ctx).
 		Into(body)
 }
+
+func (c *typedClient) ApplySubResource(ctx context.Context, obj runtime.ApplyConfiguration, subResource string, opts ...SubResourceApplyOption) error {
+	o, err := c.resources.getObjMeta(obj)
+	if err != nil {
+		return err
+	}
+
+	applyOpts := &SubResourceApplyOptions{}
+	applyOpts.ApplyOpts(opts)
+
+	body := obj
+	if applyOpts.SubResourceBody != nil {
+		body = applyOpts.SubResourceBody
+	}
+
+	req, err := apply.NewRequest(o, body)
+	if err != nil {
+		return fmt.Errorf("failed to create apply request: %w", err)
+	}
+
+	return req.
+		NamespaceIfScoped(o.namespace, o.isNamespaced()).
+		Resource(o.resource()).
+		Name(o.name).
+		SubResource(subResource).
+		VersionedParams(applyOpts.AsPatchOptions(), c.paramCodec).
+		Do(ctx).
+		// This is hacky, it is required because `Into` takes a `runtime.Object` and
+		// that is not implemented by the ApplyConfigurations. The generated clients
+		// don't have this problem because they deserialize into the api type, not the
+		// apply configuration: https://github.com/kubernetes/kubernetes/blob/22f5e01a37c0bc6a5f494dec14dd4e3688ee1d55/staging/src/k8s.io/client-go/gentype/type.go#L296-L317
+		Into(runtimeObjectFromApplyConfiguration(obj))
+}
diff --git a/pkg/client/unstructured_client.go b/pkg/client/unstructured_client.go
index e636c3beef..d2ea6d7a32 100644
--- a/pkg/client/unstructured_client.go
+++ b/pkg/client/unstructured_client.go
@@ -386,3 +386,35 @@ func (uc *unstructuredClient) PatchSubResource(ctx context.Context, obj Object,
 	u.GetObjectKind().SetGroupVersionKind(gvk)
 	return result
 }
+
+func (uc *unstructuredClient) ApplySubResource(ctx context.Context, obj runtime.ApplyConfiguration, subResource string, opts ...SubResourceApplyOption) error {
+	unstructuredApplyConfig, ok := obj.(*unstructuredApplyConfiguration)
+	if !ok {
+		return fmt.Errorf("bug: unstructured client got an applyconfiguration that was not %T but %T", &unstructuredApplyConfiguration{}, obj)
+	}
+	o, err := uc.resources.getObjMeta(unstructuredApplyConfig.Unstructured)
+	if err != nil {
+		return err
+	}
+
+	applyOpts := &SubResourceApplyOptions{}
+	applyOpts.ApplyOpts(opts)
+
+	body := obj
+	if applyOpts.SubResourceBody != nil {
+		body = applyOpts.SubResourceBody
+	}
+	req, err := apply.NewRequest(o, body)
+	if err != nil {
+		return fmt.Errorf("failed to create apply request: %w", err)
+	}
+
+	return req.
+		NamespaceIfScoped(o.namespace, o.isNamespaced()).
+		Resource(o.resource()).
+		Name(o.name).
+		SubResource(subResource).
+		VersionedParams(applyOpts.AsPatchOptions(), uc.paramCodec).
+		Do(ctx).
+		Into(unstructuredApplyConfig.Unstructured)
+}