diff --git a/bootstrap/kubeadm/main.go b/bootstrap/kubeadm/main.go
index 847f9733ce23..2306dee40eb2 100644
--- a/bootstrap/kubeadm/main.go
+++ b/bootstrap/kubeadm/main.go
@@ -247,6 +247,8 @@ func main() {
 					&corev1.ConfigMap{},
 					&corev1.Secret{},
 				},
+				// Use the cache for all Unstructured get/list calls.
+				Unstructured: true,
 			},
 		},
 		WebhookServer: webhook.NewServer(
diff --git a/cmd/clusterctl/client/cluster/topology.go b/cmd/clusterctl/client/cluster/topology.go
index 08e5d5d16471..76a68e518771 100644
--- a/cmd/clusterctl/client/cluster/topology.go
+++ b/cmd/clusterctl/client/cluster/topology.go
@@ -200,9 +200,8 @@ func (t *topologyClient) Plan(ctx context.Context, in *TopologyPlanInput) (*Topo
 
 	res.ReconciledCluster = targetCluster
 	reconciler := &clustertopologycontroller.Reconciler{
-		Client:                    dryRunClient,
-		APIReader:                 dryRunClient,
-		UnstructuredCachingClient: dryRunClient,
+		Client:    dryRunClient,
+		APIReader: dryRunClient,
 	}
 	reconciler.SetupForDryRun(&noOpRecorder{})
 	request := reconcile.Request{NamespacedName: *targetCluster}
@@ -515,8 +514,7 @@ func reconcileClusterClass(ctx context.Context, apiReader client.Reader, class c
 	reconcilerClient := dryrun.NewClient(apiReader, reconciliationObjects)
 
 	clusterClassReconciler := &clusterclasscontroller.Reconciler{
-		Client:                    reconcilerClient,
-		UnstructuredCachingClient: reconcilerClient,
+		Client: reconcilerClient,
 	}
 
 	if _, err := clusterClassReconciler.Reconcile(ctx, reconcile.Request{NamespacedName: targetClusterClass}); err != nil {
diff --git a/controllers/alias.go b/controllers/alias.go
index fba47941cb7e..322d9b22a56e 100644
--- a/controllers/alias.go
+++ b/controllers/alias.go
@@ -42,9 +42,8 @@ import (
 
 // ClusterReconciler reconciles a Cluster object.
 type ClusterReconciler struct {
-	Client                    client.Client
-	UnstructuredCachingClient client.Client
-	APIReader                 client.Reader
+	Client    client.Client
+	APIReader client.Reader
 
 	// WatchFilterValue is the label value used to filter events prior to reconciliation.
 	WatchFilterValue string
@@ -52,19 +51,17 @@ type ClusterReconciler struct {
 
 func (r *ClusterReconciler) SetupWithManager(ctx context.Context, mgr ctrl.Manager, options controller.Options) error {
 	return (&clustercontroller.Reconciler{
-		Client:                    r.Client,
-		UnstructuredCachingClient: r.UnstructuredCachingClient,
-		APIReader:                 r.APIReader,
-		WatchFilterValue:          r.WatchFilterValue,
+		Client:           r.Client,
+		APIReader:        r.APIReader,
+		WatchFilterValue: r.WatchFilterValue,
 	}).SetupWithManager(ctx, mgr, options)
 }
 
 // MachineReconciler reconciles a Machine object.
 type MachineReconciler struct {
-	Client                    client.Client
-	UnstructuredCachingClient client.Client
-	APIReader                 client.Reader
-	Tracker                   *remote.ClusterCacheTracker
+	Client    client.Client
+	APIReader client.Reader
+	Tracker   *remote.ClusterCacheTracker
 
 	// WatchFilterValue is the label value used to filter events prior to reconciliation.
 	WatchFilterValue string
@@ -75,21 +72,19 @@ type MachineReconciler struct {
 
 func (r *MachineReconciler) SetupWithManager(ctx context.Context, mgr ctrl.Manager, options controller.Options) error {
 	return (&machinecontroller.Reconciler{
-		Client:                    r.Client,
-		UnstructuredCachingClient: r.UnstructuredCachingClient,
-		APIReader:                 r.APIReader,
-		Tracker:                   r.Tracker,
-		WatchFilterValue:          r.WatchFilterValue,
-		NodeDrainClientTimeout:    r.NodeDrainClientTimeout,
+		Client:                 r.Client,
+		APIReader:              r.APIReader,
+		Tracker:                r.Tracker,
+		WatchFilterValue:       r.WatchFilterValue,
+		NodeDrainClientTimeout: r.NodeDrainClientTimeout,
 	}).SetupWithManager(ctx, mgr, options)
 }
 
 // MachineSetReconciler reconciles a MachineSet object.
 type MachineSetReconciler struct {
-	Client                    client.Client
-	UnstructuredCachingClient client.Client
-	APIReader                 client.Reader
-	Tracker                   *remote.ClusterCacheTracker
+	Client    client.Client
+	APIReader client.Reader
+	Tracker   *remote.ClusterCacheTracker
 
 	// WatchFilterValue is the label value used to filter events prior to reconciliation.
 	WatchFilterValue string
@@ -101,7 +96,6 @@ type MachineSetReconciler struct {
 func (r *MachineSetReconciler) SetupWithManager(ctx context.Context, mgr ctrl.Manager, options controller.Options) error {
 	return (&machinesetcontroller.Reconciler{
 		Client:                       r.Client,
-		UnstructuredCachingClient:    r.UnstructuredCachingClient,
 		APIReader:                    r.APIReader,
 		Tracker:                      r.Tracker,
 		WatchFilterValue:             r.WatchFilterValue,
@@ -111,9 +105,8 @@ func (r *MachineSetReconciler) SetupWithManager(ctx context.Context, mgr ctrl.Ma
 
 // MachineDeploymentReconciler reconciles a MachineDeployment object.
 type MachineDeploymentReconciler struct {
-	Client                    client.Client
-	UnstructuredCachingClient client.Client
-	APIReader                 client.Reader
+	Client    client.Client
+	APIReader client.Reader
 
 	// WatchFilterValue is the label value used to filter events prior to reconciliation.
 	WatchFilterValue string
@@ -121,10 +114,9 @@ type MachineDeploymentReconciler struct {
 
 func (r *MachineDeploymentReconciler) SetupWithManager(ctx context.Context, mgr ctrl.Manager, options controller.Options) error {
 	return (&machinedeploymentcontroller.Reconciler{
-		Client:                    r.Client,
-		UnstructuredCachingClient: r.UnstructuredCachingClient,
-		APIReader:                 r.APIReader,
-		WatchFilterValue:          r.WatchFilterValue,
+		Client:           r.Client,
+		APIReader:        r.APIReader,
+		WatchFilterValue: r.WatchFilterValue,
 	}).SetupWithManager(ctx, mgr, options)
 }
 
@@ -157,20 +149,15 @@ type ClusterTopologyReconciler struct {
 
 	// WatchFilterValue is the label value used to filter events prior to reconciliation.
 	WatchFilterValue string
-
-	// UnstructuredCachingClient provides a client that forces caching of unstructured objects,
-	// thus allowing to optimize reads for templates or provider specific objects in a managed topology.
-	UnstructuredCachingClient client.Client
 }
 
 func (r *ClusterTopologyReconciler) SetupWithManager(ctx context.Context, mgr ctrl.Manager, options controller.Options) error {
 	return (&clustertopologycontroller.Reconciler{
-		Client:                    r.Client,
-		APIReader:                 r.APIReader,
-		Tracker:                   r.Tracker,
-		RuntimeClient:             r.RuntimeClient,
-		UnstructuredCachingClient: r.UnstructuredCachingClient,
-		WatchFilterValue:          r.WatchFilterValue,
+		Client:           r.Client,
+		APIReader:        r.APIReader,
+		Tracker:          r.Tracker,
+		RuntimeClient:    r.RuntimeClient,
+		WatchFilterValue: r.WatchFilterValue,
 	}).SetupWithManager(ctx, mgr, options)
 }
 
@@ -227,18 +214,13 @@ type ClusterClassReconciler struct {
 
 	// WatchFilterValue is the label value used to filter events prior to reconciliation.
 	WatchFilterValue string
-
-	// UnstructuredCachingClient provides a client that forces caching of unstructured objects,
-	// thus allowing to optimize reads for templates or provider specific objects.
-	UnstructuredCachingClient client.Client
 }
 
 func (r *ClusterClassReconciler) SetupWithManager(ctx context.Context, mgr ctrl.Manager, options controller.Options) error {
 	r.internalReconciler = &clusterclasscontroller.Reconciler{
-		Client:                    r.Client,
-		RuntimeClient:             r.RuntimeClient,
-		UnstructuredCachingClient: r.UnstructuredCachingClient,
-		WatchFilterValue:          r.WatchFilterValue,
+		Client:           r.Client,
+		RuntimeClient:    r.RuntimeClient,
+		WatchFilterValue: r.WatchFilterValue,
 	}
 	return r.internalReconciler.SetupWithManager(ctx, mgr, options)
 }
diff --git a/controlplane/kubeadm/internal/controllers/helpers_test.go b/controlplane/kubeadm/internal/controllers/helpers_test.go
index ffde4eb284f0..eb5d8ffb6539 100644
--- a/controlplane/kubeadm/internal/controllers/helpers_test.go
+++ b/controlplane/kubeadm/internal/controllers/helpers_test.go
@@ -338,7 +338,7 @@ func TestCloneConfigsAndGenerateMachine(t *testing.T) {
 			},
 		},
 	}
-	g.Expect(env.Create(ctx, genericInfrastructureMachineTemplate)).To(Succeed())
+	g.Expect(env.CreateAndWait(ctx, genericInfrastructureMachineTemplate)).To(Succeed())
 
 	kcp := &controlplanev1.KubeadmControlPlane{
 		ObjectMeta: metav1.ObjectMeta{
diff --git a/controlplane/kubeadm/internal/controllers/upgrade_test.go b/controlplane/kubeadm/internal/controllers/upgrade_test.go
index be5939f30963..998fb39ada25 100644
--- a/controlplane/kubeadm/internal/controllers/upgrade_test.go
+++ b/controlplane/kubeadm/internal/controllers/upgrade_test.go
@@ -68,7 +68,7 @@ func TestKubeadmControlPlaneReconciler_RolloutStrategy_ScaleUp(t *testing.T) {
 	timeout := 30 * time.Second
 
 	cluster, kcp, genericInfrastructureMachineTemplate := createClusterWithControlPlane(namespace.Name)
-	g.Expect(env.Create(ctx, genericInfrastructureMachineTemplate, client.FieldOwner("manager"))).To(Succeed())
+	g.Expect(env.CreateAndWait(ctx, genericInfrastructureMachineTemplate, client.FieldOwner("manager"))).To(Succeed())
 	cluster.UID = types.UID(util.RandomString(10))
 	cluster.Spec.ControlPlaneEndpoint.Host = Host
 	cluster.Spec.ControlPlaneEndpoint.Port = 6443
diff --git a/controlplane/kubeadm/main.go b/controlplane/kubeadm/main.go
index 34c84c077927..d24eadeb2ddd 100644
--- a/controlplane/kubeadm/main.go
+++ b/controlplane/kubeadm/main.go
@@ -257,7 +257,7 @@ func main() {
 					&corev1.ConfigMap{},
 					&corev1.Secret{},
 				},
-				// This config ensures that the default client caches Unstructured objects.
+				// This config ensures that the default client uses the cache for all Unstructured get/list calls.
 				// KCP is only using Unstructured to retrieve InfraMachines and InfraMachineTemplates.
 				// As the cache should be used in those cases, caching is configured globally instead of
 				// creating a separate client that caches Unstructured.
diff --git a/docs/proposals/20220221-runtime-SDK.md b/docs/proposals/20220221-runtime-SDK.md
index 096b0088b62d..b65de8049c2e 100644
--- a/docs/proposals/20220221-runtime-SDK.md
+++ b/docs/proposals/20220221-runtime-SDK.md
@@ -576,7 +576,6 @@ func setupReconcilers(ctx context.Context, mgr ctrl.Manager) {
 		Client:                    mgr.GetClient(),
 		APIReader:                 mgr.GetAPIReader(),
 		RuntimeClient:             runtimeClient,
-		UnstructuredCachingClient: unstructuredCachingClient,
 		WatchFilterValue:          watchFilterValue,
 	}).SetupWithManager(ctx, mgr, concurrency(clusterTopologyConcurrency)); err != nil {
 		setupLog.Error(err, "Unable to create controller", "controller", "ClusterTopology")
diff --git a/internal/controllers/cluster/cluster_controller.go b/internal/controllers/cluster/cluster_controller.go
index e1157a90c1da..e16004675f13 100644
--- a/internal/controllers/cluster/cluster_controller.go
+++ b/internal/controllers/cluster/cluster_controller.go
@@ -66,9 +66,8 @@ const (
 
 // Reconciler reconciles a Cluster object.
 type Reconciler struct {
-	Client                    client.Client
-	UnstructuredCachingClient client.Client
-	APIReader                 client.Reader
+	Client    client.Client
+	APIReader client.Reader
 
 	// WatchFilterValue is the label value used to filter events prior to reconciliation.
 	WatchFilterValue string
@@ -279,7 +278,7 @@ func (r *Reconciler) reconcileDelete(ctx context.Context, cluster *clusterv1.Clu
 	}
 
 	if cluster.Spec.ControlPlaneRef != nil {
-		obj, err := external.Get(ctx, r.UnstructuredCachingClient, cluster.Spec.ControlPlaneRef, cluster.Namespace)
+		obj, err := external.Get(ctx, r.Client, cluster.Spec.ControlPlaneRef, cluster.Namespace)
 		switch {
 		case apierrors.IsNotFound(errors.Cause(err)):
 			// All good - the control plane resource has been deleted
@@ -310,7 +309,7 @@ func (r *Reconciler) reconcileDelete(ctx context.Context, cluster *clusterv1.Clu
 	}
 
 	if cluster.Spec.InfrastructureRef != nil {
-		obj, err := external.Get(ctx, r.UnstructuredCachingClient, cluster.Spec.InfrastructureRef, cluster.Namespace)
+		obj, err := external.Get(ctx, r.Client, cluster.Spec.InfrastructureRef, cluster.Namespace)
 		switch {
 		case apierrors.IsNotFound(errors.Cause(err)):
 			// All good - the infra resource has been deleted
diff --git a/internal/controllers/cluster/cluster_controller_phases.go b/internal/controllers/cluster/cluster_controller_phases.go
index c70d3389d4bd..547c1dcf188a 100644
--- a/internal/controllers/cluster/cluster_controller_phases.go
+++ b/internal/controllers/cluster/cluster_controller_phases.go
@@ -83,7 +83,7 @@ func (r *Reconciler) reconcileExternal(ctx context.Context, cluster *clusterv1.C
 		return external.ReconcileOutput{}, err
 	}
 
-	obj, err := external.Get(ctx, r.UnstructuredCachingClient, ref, cluster.Namespace)
+	obj, err := external.Get(ctx, r.Client, ref, cluster.Namespace)
 	if err != nil {
 		if apierrors.IsNotFound(errors.Cause(err)) {
 			log.Info("Could not find external object for cluster, requeuing", "refGroupVersionKind", ref.GroupVersionKind(), "refName", ref.Name)
diff --git a/internal/controllers/cluster/cluster_controller_phases_test.go b/internal/controllers/cluster/cluster_controller_phases_test.go
index 998cf744d628..0df695613ecc 100644
--- a/internal/controllers/cluster/cluster_controller_phases_test.go
+++ b/internal/controllers/cluster/cluster_controller_phases_test.go
@@ -137,9 +137,8 @@ func TestClusterReconcilePhases(t *testing.T) {
 						Build()
 				}
 				r := &Reconciler{
-					Client:                    c,
-					UnstructuredCachingClient: c,
-					recorder:                  record.NewFakeRecorder(32),
+					Client:   c,
+					recorder: record.NewFakeRecorder(32),
 				}
 
 				res, err := r.reconcileInfrastructure(ctx, tt.cluster)
@@ -218,9 +217,8 @@ func TestClusterReconcilePhases(t *testing.T) {
 						Build()
 				}
 				r := &Reconciler{
-					Client:                    c,
-					UnstructuredCachingClient: c,
-					recorder:                  record.NewFakeRecorder(32),
+					Client:   c,
+					recorder: record.NewFakeRecorder(32),
 				}
 				res, err := r.reconcileKubeconfig(ctx, tt.cluster)
 				if tt.wantErr {
@@ -370,9 +368,8 @@ func TestClusterReconciler_reconcilePhase(t *testing.T) {
 				Build()
 
 			r := &Reconciler{
-				Client:                    c,
-				UnstructuredCachingClient: c,
-				recorder:                  record.NewFakeRecorder(32),
+				Client:   c,
+				recorder: record.NewFakeRecorder(32),
 			}
 			r.reconcilePhase(ctx, tt.cluster)
 			g.Expect(tt.cluster.Status.GetTypedPhase()).To(Equal(tt.wantPhase))
@@ -488,9 +485,8 @@ func TestClusterReconcilePhases_reconcileFailureDomains(t *testing.T) {
 
 			c := fake.NewClientBuilder().WithObjects(objs...).Build()
 			r := &Reconciler{
-				Client:                    c,
-				UnstructuredCachingClient: c,
-				recorder:                  record.NewFakeRecorder(32),
+				Client:   c,
+				recorder: record.NewFakeRecorder(32),
 			}
 
 			_, err := r.reconcileInfrastructure(ctx, tt.cluster)
diff --git a/internal/controllers/cluster/cluster_controller_test.go b/internal/controllers/cluster/cluster_controller_test.go
index 7e505b7d13b8..b2f7fc47377c 100644
--- a/internal/controllers/cluster/cluster_controller_test.go
+++ b/internal/controllers/cluster/cluster_controller_test.go
@@ -389,9 +389,8 @@ func TestClusterReconciler_reconcileDelete(t *testing.T) {
 			g := NewWithT(t)
 			fakeClient := fake.NewClientBuilder().WithObjects(fakeInfraCluster, tt.cluster).Build()
 			r := &Reconciler{
-				Client:                    fakeClient,
-				UnstructuredCachingClient: fakeClient,
-				APIReader:                 fakeClient,
+				Client:    fakeClient,
+				APIReader: fakeClient,
 			}
 
 			_, _ = r.reconcileDelete(ctx, tt.cluster)
@@ -527,8 +526,7 @@ func TestClusterReconcilerNodeRef(t *testing.T) {
 
 				c := fake.NewClientBuilder().WithObjects(cluster, controlPlaneWithNoderef, controlPlaneWithoutNoderef, nonControlPlaneWithNoderef, nonControlPlaneWithoutNoderef).Build()
 				r := &Reconciler{
-					Client:                    c,
-					UnstructuredCachingClient: c,
+					Client: c,
 				}
 				requests := r.controlPlaneMachineToCluster(ctx, tt.o)
 				g.Expect(requests).To(BeComparableTo(tt.want))
diff --git a/internal/controllers/cluster/suite_test.go b/internal/controllers/cluster/suite_test.go
index fa85378ed486..ef2985a14ca6 100644
--- a/internal/controllers/cluster/suite_test.go
+++ b/internal/controllers/cluster/suite_test.go
@@ -28,7 +28,6 @@ import (
 	"k8s.io/apimachinery/pkg/runtime"
 	clientgoscheme "k8s.io/client-go/kubernetes/scheme"
 	ctrl "sigs.k8s.io/controller-runtime"
-	"sigs.k8s.io/controller-runtime/pkg/client"
 	"sigs.k8s.io/controller-runtime/pkg/controller"
 
 	clusterv1 "sigs.k8s.io/cluster-api/api/v1beta1"
@@ -81,29 +80,16 @@ func TestMain(m *testing.M) {
 			panic(fmt.Sprintf("Failed to start ClusterCacheReconciler: %v", err))
 		}
 
-		unstructuredCachingClient, err := client.New(mgr.GetConfig(), client.Options{
-			HTTPClient: mgr.GetHTTPClient(),
-			Cache: &client.CacheOptions{
-				Reader:       mgr.GetCache(),
-				Unstructured: true,
-			},
-		})
-		if err != nil {
-			panic(fmt.Sprintf("unable to create unstructuredCachineClient: %v", err))
-		}
-
 		if err := (&Reconciler{
-			Client:                    mgr.GetClient(),
-			UnstructuredCachingClient: unstructuredCachingClient,
-			APIReader:                 mgr.GetClient(),
+			Client:    mgr.GetClient(),
+			APIReader: mgr.GetClient(),
 		}).SetupWithManager(ctx, mgr, controller.Options{MaxConcurrentReconciles: 1}); err != nil {
 			panic(fmt.Sprintf("Failed to start ClusterReconciler: %v", err))
 		}
 		if err := (&machinecontroller.Reconciler{
-			Client:                    mgr.GetClient(),
-			UnstructuredCachingClient: unstructuredCachingClient,
-			APIReader:                 mgr.GetAPIReader(),
-			Tracker:                   tracker,
+			Client:    mgr.GetClient(),
+			APIReader: mgr.GetAPIReader(),
+			Tracker:   tracker,
 		}).SetupWithManager(ctx, mgr, controller.Options{MaxConcurrentReconciles: 1}); err != nil {
 			panic(fmt.Sprintf("Failed to start MachineReconciler: %v", err))
 		}
diff --git a/internal/controllers/clusterclass/clusterclass_controller.go b/internal/controllers/clusterclass/clusterclass_controller.go
index 9e5d3821cf59..d0be641f0963 100644
--- a/internal/controllers/clusterclass/clusterclass_controller.go
+++ b/internal/controllers/clusterclass/clusterclass_controller.go
@@ -65,10 +65,6 @@ type Reconciler struct {
 
 	// RuntimeClient is a client for calling runtime extensions.
 	RuntimeClient runtimeclient.Client
-
-	// UnstructuredCachingClient provides a client that forces caching of unstructured objects,
-	// thus allowing to optimize reads for templates or provider specific objects.
-	UnstructuredCachingClient client.Client
 }
 
 func (r *Reconciler) SetupWithManager(ctx context.Context, mgr ctrl.Manager, options controller.Options) error {
@@ -358,7 +354,7 @@ func refString(ref *corev1.ObjectReference) string {
 func (r *Reconciler) reconcileExternal(ctx context.Context, clusterClass *clusterv1.ClusterClass, ref *corev1.ObjectReference) error {
 	log := ctrl.LoggerFrom(ctx)
 
-	obj, err := external.Get(ctx, r.UnstructuredCachingClient, ref, clusterClass.Namespace)
+	obj, err := external.Get(ctx, r.Client, ref, clusterClass.Namespace)
 	if err != nil {
 		if apierrors.IsNotFound(errors.Cause(err)) {
 			return errors.Wrapf(err, "Could not find external object for the ClusterClass. refGroupVersionKind: %s, refName: %s", ref.GroupVersionKind(), ref.Name)
diff --git a/internal/controllers/clusterclass/suite_test.go b/internal/controllers/clusterclass/suite_test.go
index 1880b4304726..3a9e4b37af41 100644
--- a/internal/controllers/clusterclass/suite_test.go
+++ b/internal/controllers/clusterclass/suite_test.go
@@ -62,18 +62,8 @@ func TestMain(m *testing.M) {
 		}
 	}
 	setupReconcilers := func(ctx context.Context, mgr ctrl.Manager) {
-		unstructuredCachingClient, err := client.New(mgr.GetConfig(), client.Options{
-			Cache: &client.CacheOptions{
-				Reader:       mgr.GetCache(),
-				Unstructured: true,
-			},
-		})
-		if err != nil {
-			panic(fmt.Sprintf("unable to create unstructuredCachineClient: %v", err))
-		}
 		if err := (&Reconciler{
-			Client:                    mgr.GetClient(),
-			UnstructuredCachingClient: unstructuredCachingClient,
+			Client: mgr.GetClient(),
 		}).SetupWithManager(ctx, mgr, controller.Options{MaxConcurrentReconciles: 5}); err != nil {
 			panic(fmt.Sprintf("unable to create clusterclass reconciler: %v", err))
 		}
diff --git a/internal/controllers/machine/machine_controller.go b/internal/controllers/machine/machine_controller.go
index f519f33db114..54ca39a7bef7 100644
--- a/internal/controllers/machine/machine_controller.go
+++ b/internal/controllers/machine/machine_controller.go
@@ -73,10 +73,9 @@ var (
 
 // Reconciler reconciles a Machine object.
 type Reconciler struct {
-	Client                    client.Client
-	UnstructuredCachingClient client.Client
-	APIReader                 client.Reader
-	Tracker                   *remote.ClusterCacheTracker
+	Client    client.Client
+	APIReader client.Reader
+	Tracker   *remote.ClusterCacheTracker
 
 	// WatchFilterValue is the label value used to filter events prior to reconciliation.
 	WatchFilterValue string
@@ -786,7 +785,7 @@ func (r *Reconciler) reconcileDeleteExternal(ctx context.Context, cluster *clust
 	}
 
 	// get the external object
-	obj, err := external.Get(ctx, r.UnstructuredCachingClient, ref, m.Namespace)
+	obj, err := external.Get(ctx, r.Client, ref, m.Namespace)
 	if err != nil && !apierrors.IsNotFound(errors.Cause(err)) {
 		return nil, errors.Wrapf(err, "failed to get %s %q for Machine %q in namespace %q",
 			ref.GroupVersionKind(), ref.Name, m.Name, m.Namespace)
diff --git a/internal/controllers/machine/machine_controller_noderef_test.go b/internal/controllers/machine/machine_controller_noderef_test.go
index 48ebcabf3b02..52dfc42331f4 100644
--- a/internal/controllers/machine/machine_controller_noderef_test.go
+++ b/internal/controllers/machine/machine_controller_noderef_test.go
@@ -132,9 +132,8 @@ func TestGetNode(t *testing.T) {
 	g.Expect(err).ToNot(HaveOccurred())
 
 	r := &Reconciler{
-		Tracker:                   tracker,
-		Client:                    env,
-		UnstructuredCachingClient: env,
+		Tracker: tracker,
+		Client:  env,
 	}
 
 	w, err := ctrl.NewControllerManagedBy(env.Manager).For(&corev1.Node{}).Build(r)
@@ -902,8 +901,7 @@ func TestPatchNode(t *testing.T) {
 	}
 
 	r := Reconciler{
-		Client:                    env,
-		UnstructuredCachingClient: env,
+		Client: env,
 	}
 	for _, tc := range testCases {
 		t.Run(tc.name, func(t *testing.T) {
diff --git a/internal/controllers/machine/machine_controller_phases.go b/internal/controllers/machine/machine_controller_phases.go
index 1bd41f4d821b..e922accef42a 100644
--- a/internal/controllers/machine/machine_controller_phases.go
+++ b/internal/controllers/machine/machine_controller_phases.go
@@ -125,7 +125,7 @@ func (r *Reconciler) reconcileExternal(ctx context.Context, cluster *clusterv1.C
 func (r *Reconciler) ensureExternalOwnershipAndWatch(ctx context.Context, cluster *clusterv1.Cluster, m *clusterv1.Machine, ref *corev1.ObjectReference) (external.ReconcileOutput, error) {
 	log := ctrl.LoggerFrom(ctx)
 
-	obj, err := external.Get(ctx, r.UnstructuredCachingClient, ref, m.Namespace)
+	obj, err := external.Get(ctx, r.Client, ref, m.Namespace)
 	if err != nil {
 		if apierrors.IsNotFound(errors.Cause(err)) {
 			log.Info("could not find external ref, requeuing", ref.Kind, klog.KRef(ref.Namespace, ref.Name))
diff --git a/internal/controllers/machine/machine_controller_phases_test.go b/internal/controllers/machine/machine_controller_phases_test.go
index 7334716d0f7c..2aac3e6e9b67 100644
--- a/internal/controllers/machine/machine_controller_phases_test.go
+++ b/internal/controllers/machine/machine_controller_phases_test.go
@@ -907,8 +907,7 @@ func TestReconcileBootstrap(t *testing.T) {
 					bootstrapConfig,
 				).Build()
 			r := &Reconciler{
-				Client:                    c,
-				UnstructuredCachingClient: c,
+				Client: c,
 			}
 
 			s := &scope{cluster: defaultCluster, machine: tc.machine}
@@ -1120,8 +1119,7 @@ func TestReconcileInfrastructure(t *testing.T) {
 					infraConfig,
 				).Build()
 			r := &Reconciler{
-				Client:                    c,
-				UnstructuredCachingClient: c,
+				Client: c,
 			}
 			s := &scope{cluster: defaultCluster, machine: tc.machine}
 			result, err := r.reconcileInfrastructure(ctx, s)
diff --git a/internal/controllers/machine/machine_controller_test.go b/internal/controllers/machine/machine_controller_test.go
index b547f6afa87e..28654378a86a 100644
--- a/internal/controllers/machine/machine_controller_test.go
+++ b/internal/controllers/machine/machine_controller_test.go
@@ -577,8 +577,7 @@ func TestMachineFinalizer(t *testing.T) {
 				machineWithFinalizer,
 			).Build()
 			mr := &Reconciler{
-				Client:                    c,
-				UnstructuredCachingClient: c,
+				Client: c,
 			}
 
 			_, _ = mr.Reconcile(ctx, tc.request)
@@ -740,9 +739,8 @@ func TestMachineOwnerReference(t *testing.T) {
 				machineValidControlled,
 			).WithStatusSubresource(&clusterv1.Machine{}).Build()
 			mr := &Reconciler{
-				Client:                    c,
-				UnstructuredCachingClient: c,
-				APIReader:                 c,
+				Client:    c,
+				APIReader: c,
 			}
 
 			key := client.ObjectKey{Namespace: tc.m.Namespace, Name: tc.m.Name}
@@ -913,10 +911,9 @@ func TestReconcileRequest(t *testing.T) {
 			).WithStatusSubresource(&clusterv1.Machine{}).WithIndex(&corev1.Node{}, index.NodeProviderIDField, index.NodeByProviderID).Build()
 
 			r := &Reconciler{
-				Client:                    clientFake,
-				UnstructuredCachingClient: clientFake,
-				Tracker:                   remote.NewTestClusterCacheTracker(logr.New(log.NullLogSink{}), clientFake, clientFake, scheme.Scheme, client.ObjectKey{Name: testCluster.Name, Namespace: testCluster.Namespace}),
-				ssaCache:                  ssa.NewCache(),
+				Client:   clientFake,
+				Tracker:  remote.NewTestClusterCacheTracker(logr.New(log.NullLogSink{}), clientFake, clientFake, scheme.Scheme, client.ObjectKey{Name: testCluster.Name, Namespace: testCluster.Namespace}),
+				ssaCache: ssa.NewCache(),
 			}
 
 			result, err := r.Reconcile(ctx, reconcile.Request{NamespacedName: util.ObjectKey(&tc.machine)})
@@ -1193,11 +1190,10 @@ func TestMachineConditions(t *testing.T) {
 				Build()
 
 			r := &Reconciler{
-				Client:                    clientFake,
-				UnstructuredCachingClient: clientFake,
-				recorder:                  record.NewFakeRecorder(10),
-				Tracker:                   remote.NewTestClusterCacheTracker(logr.New(log.NullLogSink{}), clientFake, clientFake, scheme.Scheme, client.ObjectKey{Name: testCluster.Name, Namespace: testCluster.Namespace}),
-				ssaCache:                  ssa.NewCache(),
+				Client:   clientFake,
+				recorder: record.NewFakeRecorder(10),
+				Tracker:  remote.NewTestClusterCacheTracker(logr.New(log.NullLogSink{}), clientFake, clientFake, scheme.Scheme, client.ObjectKey{Name: testCluster.Name, Namespace: testCluster.Namespace}),
+				ssaCache: ssa.NewCache(),
 			}
 
 			_, err := r.Reconcile(ctx, reconcile.Request{NamespacedName: util.ObjectKey(&machine)})
@@ -1290,8 +1286,7 @@ func TestReconcileDeleteExternal(t *testing.T) {
 
 			c := fake.NewClientBuilder().WithObjects(objs...).Build()
 			r := &Reconciler{
-				Client:                    c,
-				UnstructuredCachingClient: c,
+				Client: c,
 			}
 
 			obj, err := r.reconcileDeleteExternal(ctx, testCluster, machine, machine.Spec.Bootstrap.ConfigRef)
@@ -1334,8 +1329,7 @@ func TestRemoveMachineFinalizerAfterDeleteReconcile(t *testing.T) {
 	key := client.ObjectKey{Namespace: m.Namespace, Name: m.Name}
 	c := fake.NewClientBuilder().WithObjects(testCluster, m).WithStatusSubresource(&clusterv1.Machine{}).Build()
 	mr := &Reconciler{
-		Client:                    c,
-		UnstructuredCachingClient: c,
+		Client: c,
 	}
 	_, err := mr.Reconcile(ctx, reconcile.Request{NamespacedName: key})
 	g.Expect(err).ToNot(HaveOccurred())
@@ -1462,8 +1456,7 @@ func TestIsNodeDrainedAllowed(t *testing.T) {
 
 			c := fake.NewClientBuilder().WithObjects(objs...).Build()
 			r := &Reconciler{
-				Client:                    c,
-				UnstructuredCachingClient: c,
+				Client: c,
 			}
 
 			got := r.isNodeDrainAllowed(tt.machine)
@@ -1589,8 +1582,7 @@ func TestIsNodeVolumeDetachingAllowed(t *testing.T) {
 
 			c := fake.NewClientBuilder().WithObjects(objs...).Build()
 			r := &Reconciler{
-				Client:                    c,
-				UnstructuredCachingClient: c,
+				Client: c,
 			}
 
 			got := r.isNodeVolumeDetachingAllowed(tt.machine)
@@ -1951,8 +1943,7 @@ func TestIsDeleteNodeAllowed(t *testing.T) {
 				empBeingDeleted,
 			).Build()
 			mr := &Reconciler{
-				Client:                    c,
-				UnstructuredCachingClient: c,
+				Client: c,
 			}
 
 			err := mr.isDeleteNodeAllowed(ctx, tc.cluster, tc.machine)
@@ -2217,8 +2208,7 @@ func TestNodeToMachine(t *testing.T) {
 	}
 
 	r := &Reconciler{
-		Client:                    env,
-		UnstructuredCachingClient: env,
+		Client: env,
 	}
 	for _, node := range fakeNodes {
 		request := r.nodeToMachine(ctx, node)
@@ -2396,11 +2386,10 @@ func TestNodeDeletion(t *testing.T) {
 			tracker := remote.NewTestClusterCacheTracker(ctrl.Log, fakeClient, fakeClient, fakeScheme, client.ObjectKeyFromObject(&testCluster))
 
 			r := &Reconciler{
-				Client:                    fakeClient,
-				UnstructuredCachingClient: fakeClient,
-				Tracker:                   tracker,
-				recorder:                  record.NewFakeRecorder(10),
-				nodeDeletionRetryTimeout:  10 * time.Millisecond,
+				Client:                   fakeClient,
+				Tracker:                  tracker,
+				recorder:                 record.NewFakeRecorder(10),
+				nodeDeletionRetryTimeout: 10 * time.Millisecond,
 			}
 
 			cluster := testCluster.DeepCopy()
diff --git a/internal/controllers/machine/suite_test.go b/internal/controllers/machine/suite_test.go
index 0881d273c323..eb0ad7a983e1 100644
--- a/internal/controllers/machine/suite_test.go
+++ b/internal/controllers/machine/suite_test.go
@@ -33,7 +33,6 @@ import (
 	"k8s.io/apimachinery/pkg/runtime/schema"
 	clientgoscheme "k8s.io/client-go/kubernetes/scheme"
 	ctrl "sigs.k8s.io/controller-runtime"
-	"sigs.k8s.io/controller-runtime/pkg/client"
 	"sigs.k8s.io/controller-runtime/pkg/controller"
 
 	clusterv1 "sigs.k8s.io/cluster-api/api/v1beta1"
@@ -86,22 +85,10 @@ func TestMain(m *testing.M) {
 			panic(fmt.Sprintf("Failed to start ClusterCacheReconciler: %v", err))
 		}
 
-		unstructuredCachingClient, err := client.New(mgr.GetConfig(), client.Options{
-			HTTPClient: mgr.GetHTTPClient(),
-			Cache: &client.CacheOptions{
-				Reader:       mgr.GetCache(),
-				Unstructured: true,
-			},
-		})
-		if err != nil {
-			panic(fmt.Sprintf("unable to create unstructuredCachineClient: %v", err))
-		}
-
 		if err := (&Reconciler{
-			Client:                    mgr.GetClient(),
-			UnstructuredCachingClient: unstructuredCachingClient,
-			APIReader:                 mgr.GetAPIReader(),
-			Tracker:                   tracker,
+			Client:    mgr.GetClient(),
+			APIReader: mgr.GetAPIReader(),
+			Tracker:   tracker,
 		}).SetupWithManager(ctx, mgr, controller.Options{MaxConcurrentReconciles: 1}); err != nil {
 			panic(fmt.Sprintf("Failed to start MachineReconciler: %v", err))
 		}
diff --git a/internal/controllers/machinedeployment/machinedeployment_controller.go b/internal/controllers/machinedeployment/machinedeployment_controller.go
index b22eed51912e..6cf903e2e93e 100644
--- a/internal/controllers/machinedeployment/machinedeployment_controller.go
+++ b/internal/controllers/machinedeployment/machinedeployment_controller.go
@@ -62,9 +62,8 @@ const machineDeploymentManagerName = "capi-machinedeployment"
 
 // Reconciler reconciles a MachineDeployment object.
 type Reconciler struct {
-	Client                    client.Client
-	UnstructuredCachingClient client.Client
-	APIReader                 client.Reader
+	Client    client.Client
+	APIReader client.Reader
 
 	// WatchFilterValue is the label value used to filter events prior to reconciliation.
 	WatchFilterValue string
@@ -212,12 +211,12 @@ func (r *Reconciler) reconcile(ctx context.Context, cluster *clusterv1.Cluster,
 	}))
 
 	// Make sure to reconcile the external infrastructure reference.
-	if err := reconcileExternalTemplateReference(ctx, r.UnstructuredCachingClient, cluster, &md.Spec.Template.Spec.InfrastructureRef); err != nil {
+	if err := reconcileExternalTemplateReference(ctx, r.Client, cluster, &md.Spec.Template.Spec.InfrastructureRef); err != nil {
 		return err
 	}
 	// Make sure to reconcile the external bootstrap reference, if any.
 	if md.Spec.Template.Spec.Bootstrap.ConfigRef != nil {
-		if err := reconcileExternalTemplateReference(ctx, r.UnstructuredCachingClient, cluster, md.Spec.Template.Spec.Bootstrap.ConfigRef); err != nil {
+		if err := reconcileExternalTemplateReference(ctx, r.Client, cluster, md.Spec.Template.Spec.Bootstrap.ConfigRef); err != nil {
 			return err
 		}
 	}
diff --git a/internal/controllers/machinedeployment/suite_test.go b/internal/controllers/machinedeployment/suite_test.go
index 0c3058652ca2..104df1bb50b0 100644
--- a/internal/controllers/machinedeployment/suite_test.go
+++ b/internal/controllers/machinedeployment/suite_test.go
@@ -88,37 +88,23 @@ func TestMain(m *testing.M) {
 			panic(fmt.Sprintf("Failed to start ClusterCacheReconciler: %v", err))
 		}
 
-		unstructuredCachingClient, err := client.New(mgr.GetConfig(), client.Options{
-			HTTPClient: mgr.GetHTTPClient(),
-			Cache: &client.CacheOptions{
-				Reader:       mgr.GetCache(),
-				Unstructured: true,
-			},
-		})
-		if err != nil {
-			panic(fmt.Sprintf("unable to create unstructuredCachineClient: %v", err))
-		}
-
 		if err := (&machinecontroller.Reconciler{
-			Client:                    mgr.GetClient(),
-			UnstructuredCachingClient: unstructuredCachingClient,
-			APIReader:                 mgr.GetAPIReader(),
-			Tracker:                   tracker,
+			Client:    mgr.GetClient(),
+			APIReader: mgr.GetAPIReader(),
+			Tracker:   tracker,
 		}).SetupWithManager(ctx, mgr, controller.Options{MaxConcurrentReconciles: 1}); err != nil {
 			panic(fmt.Sprintf("Failed to start MachineReconciler: %v", err))
 		}
 		if err := (&machinesetcontroller.Reconciler{
-			Client:                    mgr.GetClient(),
-			UnstructuredCachingClient: unstructuredCachingClient,
-			APIReader:                 mgr.GetAPIReader(),
-			Tracker:                   tracker,
+			Client:    mgr.GetClient(),
+			APIReader: mgr.GetAPIReader(),
+			Tracker:   tracker,
 		}).SetupWithManager(ctx, mgr, controller.Options{MaxConcurrentReconciles: 1}); err != nil {
 			panic(fmt.Sprintf("Failed to start MachineSetReconciler: %v", err))
 		}
 		if err := (&Reconciler{
-			Client:                    mgr.GetClient(),
-			UnstructuredCachingClient: unstructuredCachingClient,
-			APIReader:                 mgr.GetAPIReader(),
+			Client:    mgr.GetClient(),
+			APIReader: mgr.GetAPIReader(),
 		}).SetupWithManager(ctx, mgr, controller.Options{MaxConcurrentReconciles: 1}); err != nil {
 			panic(fmt.Sprintf("Failed to start MachineDeploymentReconciler: %v", err))
 		}
diff --git a/internal/controllers/machinehealthcheck/suite_test.go b/internal/controllers/machinehealthcheck/suite_test.go
index 009612377918..fdd86997d03a 100644
--- a/internal/controllers/machinehealthcheck/suite_test.go
+++ b/internal/controllers/machinehealthcheck/suite_test.go
@@ -28,7 +28,6 @@ import (
 	"k8s.io/apimachinery/pkg/runtime"
 	clientgoscheme "k8s.io/client-go/kubernetes/scheme"
 	ctrl "sigs.k8s.io/controller-runtime"
-	"sigs.k8s.io/controller-runtime/pkg/client"
 	"sigs.k8s.io/controller-runtime/pkg/controller"
 
 	clusterv1 "sigs.k8s.io/cluster-api/api/v1beta1"
@@ -84,21 +83,9 @@ func TestMain(m *testing.M) {
 			panic(fmt.Sprintf("Failed to start ClusterCacheReconciler: %v", err))
 		}
 
-		unstructuredCachingClient, err := client.New(mgr.GetConfig(), client.Options{
-			HTTPClient: mgr.GetHTTPClient(),
-			Cache: &client.CacheOptions{
-				Reader:       mgr.GetCache(),
-				Unstructured: true,
-			},
-		})
-		if err != nil {
-			panic(fmt.Sprintf("unable to create unstructuredCachineClient: %v", err))
-		}
-
 		if err := (&clustercontroller.Reconciler{
-			Client:                    mgr.GetClient(),
-			UnstructuredCachingClient: unstructuredCachingClient,
-			APIReader:                 mgr.GetClient(),
+			Client:    mgr.GetClient(),
+			APIReader: mgr.GetClient(),
 		}).SetupWithManager(ctx, mgr, controller.Options{MaxConcurrentReconciles: 1}); err != nil {
 			panic(fmt.Sprintf("Failed to start ClusterReconciler: %v", err))
 		}
@@ -109,18 +96,16 @@ func TestMain(m *testing.M) {
 			panic(fmt.Sprintf("Failed to start Reconciler : %v", err))
 		}
 		if err := (&machinecontroller.Reconciler{
-			Client:                    mgr.GetClient(),
-			UnstructuredCachingClient: unstructuredCachingClient,
-			APIReader:                 mgr.GetAPIReader(),
-			Tracker:                   tracker,
+			Client:    mgr.GetClient(),
+			APIReader: mgr.GetAPIReader(),
+			Tracker:   tracker,
 		}).SetupWithManager(ctx, mgr, controller.Options{MaxConcurrentReconciles: 1}); err != nil {
 			panic(fmt.Sprintf("Failed to start MachineReconciler: %v", err))
 		}
 		if err := (&machinesetcontroller.Reconciler{
-			Client:                    mgr.GetClient(),
-			UnstructuredCachingClient: unstructuredCachingClient,
-			APIReader:                 mgr.GetAPIReader(),
-			Tracker:                   tracker,
+			Client:    mgr.GetClient(),
+			APIReader: mgr.GetAPIReader(),
+			Tracker:   tracker,
 		}).SetupWithManager(ctx, mgr, controller.Options{MaxConcurrentReconciles: 1}); err != nil {
 			panic(fmt.Sprintf("Failed to start MMachineSetReconciler: %v", err))
 		}
diff --git a/internal/controllers/machineset/machineset_controller.go b/internal/controllers/machineset/machineset_controller.go
index 95fc483dd3d4..220d8ae1ffd8 100644
--- a/internal/controllers/machineset/machineset_controller.go
+++ b/internal/controllers/machineset/machineset_controller.go
@@ -78,10 +78,9 @@ const machineSetManagerName = "capi-machineset"
 
 // Reconciler reconciles a MachineSet object.
 type Reconciler struct {
-	Client                    client.Client
-	UnstructuredCachingClient client.Client
-	APIReader                 client.Reader
-	Tracker                   *remote.ClusterCacheTracker
+	Client    client.Client
+	APIReader client.Reader
+	Tracker   *remote.ClusterCacheTracker
 
 	// WatchFilterValue is the label value used to filter events prior to reconciliation.
 	WatchFilterValue string
@@ -237,12 +236,12 @@ func (r *Reconciler) reconcile(ctx context.Context, cluster *clusterv1.Cluster,
 	}
 
 	// Make sure to reconcile the external infrastructure reference.
-	if err := reconcileExternalTemplateReference(ctx, r.UnstructuredCachingClient, cluster, &machineSet.Spec.Template.Spec.InfrastructureRef); err != nil {
+	if err := reconcileExternalTemplateReference(ctx, r.Client, cluster, &machineSet.Spec.Template.Spec.InfrastructureRef); err != nil {
 		return ctrl.Result{}, err
 	}
 	// Make sure to reconcile the external bootstrap reference, if any.
 	if machineSet.Spec.Template.Spec.Bootstrap.ConfigRef != nil {
-		if err := reconcileExternalTemplateReference(ctx, r.UnstructuredCachingClient, cluster, machineSet.Spec.Template.Spec.Bootstrap.ConfigRef); err != nil {
+		if err := reconcileExternalTemplateReference(ctx, r.Client, cluster, machineSet.Spec.Template.Spec.Bootstrap.ConfigRef); err != nil {
 			return ctrl.Result{}, err
 		}
 	}
@@ -386,7 +385,7 @@ func (r *Reconciler) syncMachines(ctx context.Context, machineSet *clusterv1.Mac
 		}
 		machines[i] = updatedMachine
 
-		infraMachine, err := external.Get(ctx, r.UnstructuredCachingClient, &updatedMachine.Spec.InfrastructureRef, updatedMachine.Namespace)
+		infraMachine, err := external.Get(ctx, r.Client, &updatedMachine.Spec.InfrastructureRef, updatedMachine.Namespace)
 		if err != nil {
 			return errors.Wrapf(err, "failed to get InfrastructureMachine %s",
 				klog.KRef(updatedMachine.Spec.InfrastructureRef.Namespace, updatedMachine.Spec.InfrastructureRef.Name))
@@ -408,7 +407,7 @@ func (r *Reconciler) syncMachines(ctx context.Context, machineSet *clusterv1.Mac
 		}
 
 		if updatedMachine.Spec.Bootstrap.ConfigRef != nil {
-			bootstrapConfig, err := external.Get(ctx, r.UnstructuredCachingClient, updatedMachine.Spec.Bootstrap.ConfigRef, updatedMachine.Namespace)
+			bootstrapConfig, err := external.Get(ctx, r.Client, updatedMachine.Spec.Bootstrap.ConfigRef, updatedMachine.Namespace)
 			if err != nil {
 				return errors.Wrapf(err, "failed to get BootstrapConfig %s",
 					klog.KRef(updatedMachine.Spec.Bootstrap.ConfigRef.Namespace, updatedMachine.Spec.Bootstrap.ConfigRef.Name))
@@ -475,7 +474,7 @@ func (r *Reconciler) syncReplicas(ctx context.Context, cluster *clusterv1.Cluste
 			// Create the BootstrapConfig if necessary.
 			if ms.Spec.Template.Spec.Bootstrap.ConfigRef != nil {
 				bootstrapRef, err = external.CreateFromTemplate(ctx, &external.CreateFromTemplateInput{
-					Client:      r.UnstructuredCachingClient,
+					Client:      r.Client,
 					TemplateRef: ms.Spec.Template.Spec.Bootstrap.ConfigRef,
 					Namespace:   machine.Namespace,
 					Name:        machine.Name,
@@ -505,7 +504,7 @@ func (r *Reconciler) syncReplicas(ctx context.Context, cluster *clusterv1.Cluste
 			}
 			// Create the InfraMachine.
 			infraRef, err = external.CreateFromTemplate(ctx, &external.CreateFromTemplateInput{
-				Client:      r.UnstructuredCachingClient,
+				Client:      r.Client,
 				TemplateRef: &ms.Spec.Template.Spec.InfrastructureRef,
 				Namespace:   machine.Namespace,
 				Name:        infraMachineName,
diff --git a/internal/controllers/machineset/machineset_controller_test.go b/internal/controllers/machineset/machineset_controller_test.go
index ff323b18d52c..edc8591d0e16 100644
--- a/internal/controllers/machineset/machineset_controller_test.go
+++ b/internal/controllers/machineset/machineset_controller_test.go
@@ -471,9 +471,8 @@ func TestMachineSetOwnerReference(t *testing.T) {
 				ms3,
 			).WithStatusSubresource(&clusterv1.MachineSet{}).Build()
 			msr := &Reconciler{
-				Client:                    c,
-				UnstructuredCachingClient: c,
-				recorder:                  record.NewFakeRecorder(32),
+				Client:   c,
+				recorder: record.NewFakeRecorder(32),
 			}
 
 			_, err := msr.Reconcile(ctx, tc.request)
@@ -521,9 +520,8 @@ func TestMachineSetReconcile(t *testing.T) {
 
 		c := fake.NewClientBuilder().WithObjects(testCluster, ms).WithStatusSubresource(&clusterv1.MachineSet{}).Build()
 		msr := &Reconciler{
-			Client:                    c,
-			UnstructuredCachingClient: c,
-			recorder:                  record.NewFakeRecorder(32),
+			Client:   c,
+			recorder: record.NewFakeRecorder(32),
 		}
 		result, err := msr.Reconcile(ctx, request)
 		g.Expect(err).ToNot(HaveOccurred())
@@ -545,9 +543,8 @@ func TestMachineSetReconcile(t *testing.T) {
 		rec := record.NewFakeRecorder(32)
 		c := fake.NewClientBuilder().WithObjects(testCluster, ms).WithStatusSubresource(&clusterv1.MachineSet{}).Build()
 		msr := &Reconciler{
-			Client:                    c,
-			UnstructuredCachingClient: c,
-			recorder:                  rec,
+			Client:   c,
+			recorder: rec,
 		}
 		_, _ = msr.Reconcile(ctx, request)
 		g.Eventually(rec.Events).Should(Receive())
@@ -568,9 +565,8 @@ func TestMachineSetReconcile(t *testing.T) {
 		rec := record.NewFakeRecorder(32)
 		c := fake.NewClientBuilder().WithObjects(testCluster, ms).WithStatusSubresource(&clusterv1.MachineSet{}).Build()
 		msr := &Reconciler{
-			Client:                    c,
-			UnstructuredCachingClient: c,
-			recorder:                  rec,
+			Client:   c,
+			recorder: rec,
 		}
 		_, err := msr.Reconcile(ctx, request)
 		g.Expect(err).ToNot(HaveOccurred())
@@ -656,8 +652,7 @@ func TestMachineSetToMachines(t *testing.T) {
 
 	c := fake.NewClientBuilder().WithObjects(append(machineSetList, &m, &m2, &m3)...).Build()
 	r := &Reconciler{
-		Client:                    c,
-		UnstructuredCachingClient: c,
+		Client: c,
 	}
 
 	for _, tc := range testsCases {
@@ -802,8 +797,7 @@ func TestAdoptOrphan(t *testing.T) {
 
 	c := fake.NewClientBuilder().WithObjects(&m).Build()
 	r := &Reconciler{
-		Client:                    c,
-		UnstructuredCachingClient: c,
+		Client: c,
 	}
 	for i := range testCases {
 		tc := testCases[i]
@@ -899,9 +893,8 @@ func TestMachineSetReconcile_MachinesCreatedConditionFalseOnBadInfraRef(t *testi
 	fakeClient := fake.NewClientBuilder().WithObjects(cluster, ms, builder.GenericInfrastructureMachineTemplateCRD.DeepCopy()).WithStatusSubresource(&clusterv1.MachineSet{}).Build()
 
 	msr := &Reconciler{
-		Client:                    fakeClient,
-		UnstructuredCachingClient: fakeClient,
-		recorder:                  record.NewFakeRecorder(32),
+		Client:   fakeClient,
+		recorder: record.NewFakeRecorder(32),
 	}
 	_, err := msr.Reconcile(ctx, request)
 	g.Expect(err).To(HaveOccurred())
@@ -958,9 +951,8 @@ func TestMachineSetReconciler_updateStatusResizedCondition(t *testing.T) {
 
 			c := fake.NewClientBuilder().WithObjects().Build()
 			msr := &Reconciler{
-				Client:                    c,
-				UnstructuredCachingClient: c,
-				recorder:                  record.NewFakeRecorder(32),
+				Client:   c,
+				recorder: record.NewFakeRecorder(32),
 			}
 			err := msr.updateStatus(ctx, cluster, tc.machineSet, tc.machines)
 			g.Expect(err).ToNot(HaveOccurred())
@@ -1196,9 +1188,8 @@ func TestMachineSetReconciler_syncMachines(t *testing.T) {
 	// Run syncMachines to clean up managed fields and have proper field ownership
 	// for Machines, InfrastructureMachines and BootstrapConfigs.
 	reconciler := &Reconciler{
-		Client:                    env,
-		UnstructuredCachingClient: env,
-		ssaCache:                  ssa.NewCache(),
+		Client:   env,
+		ssaCache: ssa.NewCache(),
 	}
 	g.Expect(reconciler.syncMachines(ctx, ms, machines)).To(Succeed())
 
@@ -1397,8 +1388,7 @@ func TestMachineSetReconciler_reconcileUnhealthyMachines(t *testing.T) {
 
 		fakeClient := fake.NewClientBuilder().WithObjects(controlPlaneStable, unhealthyMachine, healthyMachine).Build()
 		r := &Reconciler{
-			Client:                    fakeClient,
-			UnstructuredCachingClient: fakeClient,
+			Client: fakeClient,
 		}
 		_, err := r.reconcileUnhealthyMachines(ctx, cluster, machineSet, machines)
 		g.Expect(err).ToNot(HaveOccurred())
@@ -1458,8 +1448,7 @@ func TestMachineSetReconciler_reconcileUnhealthyMachines(t *testing.T) {
 		machines := []*clusterv1.Machine{unhealthyMachine, healthyMachine}
 		fakeClient := fake.NewClientBuilder().WithObjects(controlPlaneUpgrading, unhealthyMachine, healthyMachine).WithStatusSubresource(&clusterv1.Machine{}).Build()
 		r := &Reconciler{
-			Client:                    fakeClient,
-			UnstructuredCachingClient: fakeClient,
+			Client: fakeClient,
 		}
 		_, err := r.reconcileUnhealthyMachines(ctx, cluster, machineSet, machines)
 		g.Expect(err).ToNot(HaveOccurred())
@@ -1518,8 +1507,7 @@ func TestMachineSetReconciler_syncReplicas(t *testing.T) {
 
 		fakeClient := fake.NewClientBuilder().WithObjects(controlPlaneUpgrading, machineSet).WithStatusSubresource(&clusterv1.MachineSet{}).Build()
 		r := &Reconciler{
-			Client:                    fakeClient,
-			UnstructuredCachingClient: fakeClient,
+			Client: fakeClient,
 		}
 		result, err := r.syncReplicas(ctx, cluster, machineSet, nil)
 		g.Expect(err).ToNot(HaveOccurred())
diff --git a/internal/controllers/machineset/machineset_preflight.go b/internal/controllers/machineset/machineset_preflight.go
index 34c92fd6d4a5..ae959329e2f8 100644
--- a/internal/controllers/machineset/machineset_preflight.go
+++ b/internal/controllers/machineset/machineset_preflight.go
@@ -66,7 +66,7 @@ func (r *Reconciler) runPreflightChecks(ctx context.Context, cluster *clusterv1.
 	}
 
 	// Get the control plane object.
-	controlPlane, err := external.Get(ctx, r.UnstructuredCachingClient, cluster.Spec.ControlPlaneRef, cluster.Namespace)
+	controlPlane, err := external.Get(ctx, r.Client, cluster.Spec.ControlPlaneRef, cluster.Namespace)
 	if err != nil {
 		return ctrl.Result{}, "", errors.Wrapf(err, "failed to perform %q: failed to perform preflight checks: failed to get ControlPlane %s", action, klog.KRef(cluster.Spec.ControlPlaneRef.Namespace, cluster.Spec.ControlPlaneRef.Name))
 	}
diff --git a/internal/controllers/machineset/machineset_preflight_test.go b/internal/controllers/machineset/machineset_preflight_test.go
index ba598d0a171e..262c840ed3c5 100644
--- a/internal/controllers/machineset/machineset_preflight_test.go
+++ b/internal/controllers/machineset/machineset_preflight_test.go
@@ -556,8 +556,7 @@ func TestMachineSetReconciler_runPreflightChecks(t *testing.T) {
 				}
 				fakeClient := fake.NewClientBuilder().WithObjects(objs...).Build()
 				r := &Reconciler{
-					Client:                    fakeClient,
-					UnstructuredCachingClient: fakeClient,
+					Client: fakeClient,
 				}
 				result, _, err := r.runPreflightChecks(ctx, tt.cluster, tt.machineSet, "")
 				if tt.wantErr {
diff --git a/internal/controllers/machineset/suite_test.go b/internal/controllers/machineset/suite_test.go
index f45ed3ad6013..49cf1a7ce6c8 100644
--- a/internal/controllers/machineset/suite_test.go
+++ b/internal/controllers/machineset/suite_test.go
@@ -87,30 +87,17 @@ func TestMain(m *testing.M) {
 			panic(fmt.Sprintf("Failed to start ClusterCacheReconciler: %v", err))
 		}
 
-		unstructuredCachingClient, err := client.New(mgr.GetConfig(), client.Options{
-			HTTPClient: mgr.GetHTTPClient(),
-			Cache: &client.CacheOptions{
-				Reader:       mgr.GetCache(),
-				Unstructured: true,
-			},
-		})
-		if err != nil {
-			panic(fmt.Sprintf("unable to create unstructuredCachineClient: %v", err))
-		}
-
 		if err := (&Reconciler{
-			Client:                    mgr.GetClient(),
-			UnstructuredCachingClient: unstructuredCachingClient,
-			APIReader:                 mgr.GetAPIReader(),
-			Tracker:                   tracker,
+			Client:    mgr.GetClient(),
+			APIReader: mgr.GetAPIReader(),
+			Tracker:   tracker,
 		}).SetupWithManager(ctx, mgr, controller.Options{MaxConcurrentReconciles: 1}); err != nil {
 			panic(fmt.Sprintf("Failed to start MMachineSetReconciler: %v", err))
 		}
 		if err := (&machinecontroller.Reconciler{
-			Client:                    mgr.GetClient(),
-			UnstructuredCachingClient: unstructuredCachingClient,
-			APIReader:                 mgr.GetAPIReader(),
-			Tracker:                   tracker,
+			Client:    mgr.GetClient(),
+			APIReader: mgr.GetAPIReader(),
+			Tracker:   tracker,
 		}).SetupWithManager(ctx, mgr, controller.Options{MaxConcurrentReconciles: 1}); err != nil {
 			panic(fmt.Sprintf("Failed to start MachineReconciler: %v", err))
 		}
diff --git a/internal/controllers/topology/cluster/blueprint_test.go b/internal/controllers/topology/cluster/blueprint_test.go
index 0e05f3767fd4..14f1ccd027a0 100644
--- a/internal/controllers/topology/cluster/blueprint_test.go
+++ b/internal/controllers/topology/cluster/blueprint_test.go
@@ -392,9 +392,8 @@ func TestGetBlueprint(t *testing.T) {
 
 			// Calls getBlueprint.
 			r := &Reconciler{
-				Client:                    fakeClient,
-				patchHelperFactory:        dryRunPatchHelperFactory(fakeClient),
-				UnstructuredCachingClient: fakeClient,
+				Client:             fakeClient,
+				patchHelperFactory: dryRunPatchHelperFactory(fakeClient),
 			}
 			got, err := r.getBlueprint(ctx, scope.New(cluster).Current.Cluster, tt.clusterClass)
 
diff --git a/internal/controllers/topology/cluster/cluster_controller.go b/internal/controllers/topology/cluster/cluster_controller.go
index 696c16a95c29..025c4565e623 100644
--- a/internal/controllers/topology/cluster/cluster_controller.go
+++ b/internal/controllers/topology/cluster/cluster_controller.go
@@ -77,10 +77,6 @@ type Reconciler struct {
 	// WatchFilterValue is the label value used to filter events prior to reconciliation.
 	WatchFilterValue string
 
-	// UnstructuredCachingClient provides a client that forces caching of unstructured objects,
-	// thus allowing to optimize reads for templates or provider specific objects in a managed topology.
-	UnstructuredCachingClient client.Client
-
 	externalTracker external.ObjectTracker
 	recorder        record.EventRecorder
 
diff --git a/internal/controllers/topology/cluster/current_state_test.go b/internal/controllers/topology/cluster/current_state_test.go
index e8a29e17c018..d2fefcece368 100644
--- a/internal/controllers/topology/cluster/current_state_test.go
+++ b/internal/controllers/topology/cluster/current_state_test.go
@@ -1077,10 +1077,9 @@ func TestGetCurrentState(t *testing.T) {
 
 			// Calls getCurrentState.
 			r := &Reconciler{
-				Client:                    fakeClient,
-				APIReader:                 fakeClient,
-				UnstructuredCachingClient: fakeClient,
-				patchHelperFactory:        dryRunPatchHelperFactory(fakeClient),
+				Client:             fakeClient,
+				APIReader:          fakeClient,
+				patchHelperFactory: dryRunPatchHelperFactory(fakeClient),
 			}
 			got, err := r.getCurrentState(ctx, s)
 
diff --git a/internal/controllers/topology/cluster/suite_test.go b/internal/controllers/topology/cluster/suite_test.go
index 211c24e81c46..080980413274 100644
--- a/internal/controllers/topology/cluster/suite_test.go
+++ b/internal/controllers/topology/cluster/suite_test.go
@@ -65,15 +65,6 @@ func TestMain(m *testing.M) {
 		}
 	}
 	setupReconcilers := func(ctx context.Context, mgr ctrl.Manager) {
-		unstructuredCachingClient, err := client.New(mgr.GetConfig(), client.Options{
-			Cache: &client.CacheOptions{
-				Reader:       mgr.GetCache(),
-				Unstructured: true,
-			},
-		})
-		if err != nil {
-			panic(fmt.Sprintf("unable to create unstructuredCachineClient: %v", err))
-		}
 		// Set up a ClusterCacheTracker and ClusterCacheReconciler to provide to controllers
 		// requiring a connection to a remote cluster
 		secretCachingClient, err := client.New(mgr.GetConfig(), client.Options{
@@ -102,16 +93,14 @@ func TestMain(m *testing.M) {
 			panic(fmt.Sprintf("Failed to start ClusterCacheReconciler: %v", err))
 		}
 		if err := (&Reconciler{
-			Client:                    mgr.GetClient(),
-			APIReader:                 mgr.GetAPIReader(),
-			UnstructuredCachingClient: unstructuredCachingClient,
-			Tracker:                   tracker,
+			Client:    mgr.GetClient(),
+			APIReader: mgr.GetAPIReader(),
+			Tracker:   tracker,
 		}).SetupWithManager(ctx, mgr, controller.Options{MaxConcurrentReconciles: 1}); err != nil {
 			panic(fmt.Sprintf("unable to create topology cluster reconciler: %v", err))
 		}
 		if err := (&clusterclass.Reconciler{
-			Client:                    mgr.GetClient(),
-			UnstructuredCachingClient: unstructuredCachingClient,
+			Client: mgr.GetClient(),
 		}).SetupWithManager(ctx, mgr, controller.Options{MaxConcurrentReconciles: 5}); err != nil {
 			panic(fmt.Sprintf("unable to create clusterclass reconciler: %v", err))
 		}
diff --git a/internal/controllers/topology/cluster/util.go b/internal/controllers/topology/cluster/util.go
index ada48570c919..81a6963ae29b 100644
--- a/internal/controllers/topology/cluster/util.go
+++ b/internal/controllers/topology/cluster/util.go
@@ -32,7 +32,7 @@ func (r *Reconciler) getReference(ctx context.Context, ref *corev1.ObjectReferen
 		return nil, errors.New("reference is not set")
 	}
 
-	obj, err := external.Get(ctx, r.UnstructuredCachingClient, ref, ref.Namespace)
+	obj, err := external.Get(ctx, r.Client, ref, ref.Namespace)
 	if err != nil {
 		return nil, errors.Wrapf(err, "failed to retrieve %s %q in namespace %q", ref.Kind, ref.Name, ref.Namespace)
 	}
diff --git a/internal/controllers/topology/cluster/util_test.go b/internal/controllers/topology/cluster/util_test.go
index 373d00274b57..70e92e437f37 100644
--- a/internal/controllers/topology/cluster/util_test.go
+++ b/internal/controllers/topology/cluster/util_test.go
@@ -98,9 +98,8 @@ func TestGetReference(t *testing.T) {
 				Build()
 
 			r := &Reconciler{
-				Client:                    fakeClient,
-				UnstructuredCachingClient: fakeClient,
-				patchHelperFactory:        dryRunPatchHelperFactory(fakeClient),
+				Client:             fakeClient,
+				patchHelperFactory: dryRunPatchHelperFactory(fakeClient),
 			}
 			got, err := r.getReference(ctx, tt.ref)
 			if tt.wantErr {
diff --git a/internal/test/envtest/environment.go b/internal/test/envtest/environment.go
index f6ff4af4bce4..6e33d91f76ff 100644
--- a/internal/test/envtest/environment.go
+++ b/internal/test/envtest/environment.go
@@ -260,6 +260,8 @@ func newEnvironment(uncachedObjs ...client.Object) *Environment {
 		Client: client.Options{
 			Cache: &client.CacheOptions{
 				DisableFor: uncachedObjs,
+				// Use the cache for all Unstructured get/list calls.
+				Unstructured: true,
 			},
 		},
 		WebhookServer: webhook.NewServer(
diff --git a/internal/webhooks/test/suite_test.go b/internal/webhooks/test/suite_test.go
index 4bb04e2f54dc..e592897427a3 100644
--- a/internal/webhooks/test/suite_test.go
+++ b/internal/webhooks/test/suite_test.go
@@ -24,7 +24,6 @@ import (
 
 	"k8s.io/component-base/featuregate"
 	ctrl "sigs.k8s.io/controller-runtime"
-	"sigs.k8s.io/controller-runtime/pkg/client"
 	"sigs.k8s.io/controller-runtime/pkg/controller"
 
 	"sigs.k8s.io/cluster-api/api/v1beta1/index"
@@ -48,18 +47,8 @@ func TestMain(m *testing.M) {
 		}
 	}
 	setupReconcilers := func(ctx context.Context, mgr ctrl.Manager) {
-		unstructuredCachingClient, err := client.New(mgr.GetConfig(), client.Options{
-			Cache: &client.CacheOptions{
-				Reader:       mgr.GetCache(),
-				Unstructured: true,
-			},
-		})
-		if err != nil {
-			panic(fmt.Sprintf("unable to create unstructuredCachineClient: %v", err))
-		}
 		if err := (&clusterclass.Reconciler{
-			Client:                    mgr.GetClient(),
-			UnstructuredCachingClient: unstructuredCachingClient,
+			Client: mgr.GetClient(),
 		}).SetupWithManager(ctx, mgr, controller.Options{MaxConcurrentReconciles: 5}); err != nil {
 			panic(fmt.Sprintf("unable to create clusterclass reconciler: %v", err))
 		}
diff --git a/main.go b/main.go
index fcd767d5f495..affbcba5bf57 100644
--- a/main.go
+++ b/main.go
@@ -334,6 +334,8 @@ func main() {
 					&corev1.ConfigMap{},
 					&corev1.Secret{},
 				},
+				// Use the cache for all Unstructured get/list calls.
+				Unstructured: true,
 			},
 		},
 		WebhookServer: webhook.NewServer(
@@ -434,36 +436,22 @@ func setupReconcilers(ctx context.Context, mgr ctrl.Manager) webhooks.ClusterCac
 		})
 	}
 
-	unstructuredCachingClient, err := client.New(mgr.GetConfig(), client.Options{
-		HTTPClient: mgr.GetHTTPClient(),
-		Cache: &client.CacheOptions{
-			Reader:       mgr.GetCache(),
-			Unstructured: true,
-		},
-	})
-	if err != nil {
-		setupLog.Error(err, "unable to create unstructured caching client")
-		os.Exit(1)
-	}
-
 	if feature.Gates.Enabled(feature.ClusterTopology) {
 		if err := (&controllers.ClusterClassReconciler{
-			Client:                    mgr.GetClient(),
-			RuntimeClient:             runtimeClient,
-			UnstructuredCachingClient: unstructuredCachingClient,
-			WatchFilterValue:          watchFilterValue,
+			Client:           mgr.GetClient(),
+			RuntimeClient:    runtimeClient,
+			WatchFilterValue: watchFilterValue,
 		}).SetupWithManager(ctx, mgr, concurrency(clusterClassConcurrency)); err != nil {
 			setupLog.Error(err, "unable to create controller", "controller", "ClusterClass")
 			os.Exit(1)
 		}
 
 		if err := (&controllers.ClusterTopologyReconciler{
-			Client:                    mgr.GetClient(),
-			APIReader:                 mgr.GetAPIReader(),
-			RuntimeClient:             runtimeClient,
-			Tracker:                   tracker,
-			UnstructuredCachingClient: unstructuredCachingClient,
-			WatchFilterValue:          watchFilterValue,
+			Client:           mgr.GetClient(),
+			APIReader:        mgr.GetAPIReader(),
+			RuntimeClient:    runtimeClient,
+			Tracker:          tracker,
+			WatchFilterValue: watchFilterValue,
 		}).SetupWithManager(ctx, mgr, concurrency(clusterTopologyConcurrency)); err != nil {
 			setupLog.Error(err, "unable to create controller", "controller", "ClusterTopology")
 			os.Exit(1)
@@ -501,28 +489,25 @@ func setupReconcilers(ctx context.Context, mgr ctrl.Manager) webhooks.ClusterCac
 	}
 
 	if err := (&controllers.ClusterReconciler{
-		Client:                    mgr.GetClient(),
-		UnstructuredCachingClient: unstructuredCachingClient,
-		APIReader:                 mgr.GetAPIReader(),
-		WatchFilterValue:          watchFilterValue,
+		Client:           mgr.GetClient(),
+		APIReader:        mgr.GetAPIReader(),
+		WatchFilterValue: watchFilterValue,
 	}).SetupWithManager(ctx, mgr, concurrency(clusterConcurrency)); err != nil {
 		setupLog.Error(err, "unable to create controller", "controller", "Cluster")
 		os.Exit(1)
 	}
 	if err := (&controllers.MachineReconciler{
-		Client:                    mgr.GetClient(),
-		UnstructuredCachingClient: unstructuredCachingClient,
-		APIReader:                 mgr.GetAPIReader(),
-		Tracker:                   tracker,
-		WatchFilterValue:          watchFilterValue,
-		NodeDrainClientTimeout:    nodeDrainClientTimeout,
+		Client:                 mgr.GetClient(),
+		APIReader:              mgr.GetAPIReader(),
+		Tracker:                tracker,
+		WatchFilterValue:       watchFilterValue,
+		NodeDrainClientTimeout: nodeDrainClientTimeout,
 	}).SetupWithManager(ctx, mgr, concurrency(machineConcurrency)); err != nil {
 		setupLog.Error(err, "unable to create controller", "controller", "Machine")
 		os.Exit(1)
 	}
 	if err := (&controllers.MachineSetReconciler{
 		Client:                       mgr.GetClient(),
-		UnstructuredCachingClient:    unstructuredCachingClient,
 		APIReader:                    mgr.GetAPIReader(),
 		Tracker:                      tracker,
 		WatchFilterValue:             watchFilterValue,
@@ -532,10 +517,9 @@ func setupReconcilers(ctx context.Context, mgr ctrl.Manager) webhooks.ClusterCac
 		os.Exit(1)
 	}
 	if err := (&controllers.MachineDeploymentReconciler{
-		Client:                    mgr.GetClient(),
-		UnstructuredCachingClient: unstructuredCachingClient,
-		APIReader:                 mgr.GetAPIReader(),
-		WatchFilterValue:          watchFilterValue,
+		Client:           mgr.GetClient(),
+		APIReader:        mgr.GetAPIReader(),
+		WatchFilterValue: watchFilterValue,
 	}).SetupWithManager(ctx, mgr, concurrency(machineDeploymentConcurrency)); err != nil {
 		setupLog.Error(err, "unable to create controller", "controller", "MachineDeployment")
 		os.Exit(1)
diff --git a/test/extension/handlers/topologymutation/handler_integration_test.go b/test/extension/handlers/topologymutation/handler_integration_test.go
index 4a1391d8430d..cd5326a5edc9 100644
--- a/test/extension/handlers/topologymutation/handler_integration_test.go
+++ b/test/extension/handlers/topologymutation/handler_integration_test.go
@@ -91,9 +91,8 @@ func TestHandler(t *testing.T) {
 	fakeClient, mgr, err := createClusterClassFakeClientAndManager(s.Blueprint)
 	g.Expect(err).ToNot(HaveOccurred())
 	clusterClassReconciler := controllers.ClusterClassReconciler{
-		Client:                    fakeClient,
-		UnstructuredCachingClient: fakeClient,
-		RuntimeClient:             runtimeClient,
+		Client:        fakeClient,
+		RuntimeClient: runtimeClient,
 	}
 	err = clusterClassReconciler.SetupWithManager(ctx, mgr, controller.Options{})
 	g.Expect(err).ToNot(HaveOccurred())
diff --git a/test/extension/main.go b/test/extension/main.go
index 2a6742bba8d2..17ee5f2d6e28 100644
--- a/test/extension/main.go
+++ b/test/extension/main.go
@@ -243,6 +243,8 @@ func main() {
 					&corev1.ConfigMap{},
 					&corev1.Secret{},
 				},
+				// Use the cache for all Unstructured get/list calls.
+				Unstructured: true,
 			},
 		},
 		WebhookServer: runtimeExtensionWebhookServer,
diff --git a/test/infrastructure/docker/main.go b/test/infrastructure/docker/main.go
index 64f679b27ec4..c7f385997164 100644
--- a/test/infrastructure/docker/main.go
+++ b/test/infrastructure/docker/main.go
@@ -253,6 +253,8 @@ func main() {
 					&corev1.ConfigMap{},
 					&corev1.Secret{},
 				},
+				// Use the cache for all Unstructured get/list calls.
+				Unstructured: true,
 			},
 		},
 		WebhookServer: webhook.NewServer(
diff --git a/test/infrastructure/inmemory/main.go b/test/infrastructure/inmemory/main.go
index 99ac7b337934..9edfa4b07979 100644
--- a/test/infrastructure/inmemory/main.go
+++ b/test/infrastructure/inmemory/main.go
@@ -232,6 +232,8 @@ func main() {
 					&corev1.ConfigMap{},
 					&corev1.Secret{},
 				},
+				// Use the cache for all Unstructured get/list calls.
+				Unstructured: true,
 			},
 		},
 		WebhookServer: webhook.NewServer(