diff --git a/cmd/operator-controller/main.go b/cmd/operator-controller/main.go
index 20d55bc3c..170c0fc11 100644
--- a/cmd/operator-controller/main.go
+++ b/cmd/operator-controller/main.go
@@ -589,6 +589,14 @@ func setupBoxcutter(
 		ActionClientGetter: acg,
 		RevisionGenerator:  rg,
 	}
+	ceReconciler.ReconcileSteps = []controllers.ReconcileStepFunc{
+		controllers.HandleFinalizers(ceReconciler.Finalizers),
+		controllers.MigrateStorage(ceReconciler.StorageMigrator),
+		controllers.RetrieveRevisionStates(ceReconciler.RevisionStatesGetter),
+		controllers.RetrieveRevisionMetadata(ceReconciler.Resolver),
+		controllers.UnpackBundle(ceReconciler.ImagePuller, ceReconciler.ImageCache),
+		controllers.ApplyBundle(ceReconciler.Applier),
+	}
 
 	baseDiscoveryClient, err := discovery.NewDiscoveryClientForConfig(mgr.GetConfig())
 	if err != nil {
@@ -700,6 +708,14 @@ func setupHelm(
 		Manager:                       cm,
 	}
 	ceReconciler.RevisionStatesGetter = &controllers.HelmRevisionStatesGetter{ActionClientGetter: acg}
+	ceReconciler.ReconcileSteps = []controllers.ReconcileStepFunc{
+		controllers.HandleFinalizers(ceReconciler.Finalizers),
+		controllers.RetrieveRevisionStates(ceReconciler.RevisionStatesGetter),
+		controllers.RetrieveRevisionMetadata(ceReconciler.Resolver),
+		controllers.UnpackBundle(ceReconciler.ImagePuller, ceReconciler.ImageCache),
+		controllers.ApplyBundle(ceReconciler.Applier),
+	}
+
 	return nil
 }
 
diff --git a/internal/operator-controller/controllers/boxcutter_reconcile_steps.go b/internal/operator-controller/controllers/boxcutter_reconcile_steps.go
new file mode 100644
index 000000000..69994c41f
--- /dev/null
+++ b/internal/operator-controller/controllers/boxcutter_reconcile_steps.go
@@ -0,0 +1,95 @@
+/*
+Copyright 2025.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package controllers
+
+import (
+	"cmp"
+	"context"
+	"fmt"
+	"slices"
+
+	apimeta "k8s.io/apimachinery/pkg/api/meta"
+	ctrl "sigs.k8s.io/controller-runtime"
+	"sigs.k8s.io/controller-runtime/pkg/client"
+
+	ocv1 "github.com/operator-framework/operator-controller/api/v1"
+	"github.com/operator-framework/operator-controller/internal/operator-controller/labels"
+)
+
+type BoxcutterRevisionStatesGetter struct {
+	Reader client.Reader
+}
+
+func (d *BoxcutterRevisionStatesGetter) GetRevisionStates(ctx context.Context, ext *ocv1.ClusterExtension) (*RevisionStates, error) {
+	// TODO: boxcutter applier has a nearly identical bit of code for listing and sorting revisions
+	//   only difference here is that it sorts in reverse order to start iterating with the most
+	//   recent revisions. We should consolidate to avoid code duplication.
+	existingRevisionList := &ocv1.ClusterExtensionRevisionList{}
+	if err := d.Reader.List(ctx, existingRevisionList, client.MatchingLabels{
+		ClusterExtensionRevisionOwnerLabel: ext.Name,
+	}); err != nil {
+		return nil, fmt.Errorf("listing revisions: %w", err)
+	}
+	slices.SortFunc(existingRevisionList.Items, func(a, b ocv1.ClusterExtensionRevision) int {
+		return cmp.Compare(a.Spec.Revision, b.Spec.Revision)
+	})
+
+	rs := &RevisionStates{}
+	for _, rev := range existingRevisionList.Items {
+		switch rev.Spec.LifecycleState {
+		case ocv1.ClusterExtensionRevisionLifecycleStateActive,
+			ocv1.ClusterExtensionRevisionLifecycleStatePaused:
+		default:
+			// Skip anything not active or paused, which should only be "Archived".
+			continue
+		}
+
+		// TODO: the setting of these annotations (happens in boxcutter applier when we pass in "storageLabels")
+		//   is fairly decoupled from this code where we get the annotations back out. We may want to co-locate
+		//   the set/get logic a bit better to make it more maintainable and less likely to get out of sync.
+		rm := &RevisionMetadata{
+			Package: rev.Labels[labels.PackageNameKey],
+			Image:   rev.Annotations[labels.BundleReferenceKey],
+			BundleMetadata: ocv1.BundleMetadata{
+				Name:    rev.Annotations[labels.BundleNameKey],
+				Version: rev.Annotations[labels.BundleVersionKey],
+			},
+		}
+
+		if apimeta.IsStatusConditionTrue(rev.Status.Conditions, ocv1.ClusterExtensionRevisionTypeSucceeded) {
+			rs.Installed = rm
+		} else {
+			rs.RollingOut = append(rs.RollingOut, rm)
+		}
+	}
+
+	return rs, nil
+}
+
+func MigrateStorage(m StorageMigrator) ReconcileStepFunc {
+	return func(ctx context.Context, ext *ocv1.ClusterExtension) (context.Context, *ctrl.Result, error) {
+		objLbls := map[string]string{
+			labels.OwnerKindKey: ocv1.ClusterExtensionKind,
+			labels.OwnerNameKey: ext.GetName(),
+		}
+
+		if err := m.Migrate(ctx, ext, objLbls); err != nil {
+			return ctx, nil, fmt.Errorf("migrating storage: %w", err)
+		}
+		return ctx, nil, nil
+	}
+}
diff --git a/internal/operator-controller/controllers/clusterextension_controller.go b/internal/operator-controller/controllers/clusterextension_controller.go
index 7bcedde65..532ff40b5 100644
--- a/internal/operator-controller/controllers/clusterextension_controller.go
+++ b/internal/operator-controller/controllers/clusterextension_controller.go
@@ -17,12 +17,10 @@ limitations under the License.
 package controllers
 
 import (
-	"cmp"
 	"context"
 	"errors"
 	"fmt"
 	"io/fs"
-	"slices"
 	"strings"
 
 	"github.com/go-logr/logr"
@@ -49,8 +47,6 @@ import (
 	"github.com/operator-framework/operator-registry/alpha/declcfg"
 
 	ocv1 "github.com/operator-framework/operator-controller/api/v1"
-	"github.com/operator-framework/operator-controller/internal/operator-controller/authentication"
-	"github.com/operator-framework/operator-controller/internal/operator-controller/bundleutil"
 	"github.com/operator-framework/operator-controller/internal/operator-controller/conditionsets"
 	"github.com/operator-framework/operator-controller/internal/operator-controller/labels"
 	"github.com/operator-framework/operator-controller/internal/operator-controller/resolve"
@@ -62,6 +58,39 @@ const (
 	ClusterExtensionCleanupContentManagerCacheFinalizer = "olm.operatorframework.io/cleanup-contentmanager-cache"
 )
 
+// ReconcileStepFunc represents a single step in the ClusterExtension reconciliation process.
+// It takes a context and ClusterExtension object as input and returns:
+// - A potentially modified context for the next step
+// - An optional reconciliation result that if non-nil will stop reconciliation
+// - Any error that occurred during reconciliation, which will be returned to the caller
+type ReconcileStepFunc func(context.Context, *ocv1.ClusterExtension) (context.Context, *ctrl.Result, error)
+type ReconcileSteps []ReconcileStepFunc
+
+// Reconcile executes a series of reconciliation steps in sequence for a ClusterExtension.
+// It takes a context and ClusterExtension object as input and executes each step in the ReconcileSteps slice.
+// If any step returns an error, reconciliation stops and the error is returned.
+// If any step returns a non-nil ctrl.Result, reconciliation stops and that result is returned.
+// If any step returns a nil context, reconciliation stops successfully.
+// If all steps complete successfully, returns an empty ctrl.Result and nil error.
+func (steps *ReconcileSteps) Reconcile(ctx context.Context, ext *ocv1.ClusterExtension) (ctrl.Result, error) {
+	var res *ctrl.Result
+	var err error
+	stepCtx := ctx
+	for _, step := range *steps {
+		stepCtx, res, err = step(stepCtx, ext)
+		if err != nil {
+			return ctrl.Result{}, err
+		}
+		if res != nil {
+			return *res, nil
+		}
+		if stepCtx == nil {
+			return ctrl.Result{}, nil
+		}
+	}
+	return ctrl.Result{}, nil
+}
+
 // ClusterExtensionReconciler reconciles a ClusterExtension object
 type ClusterExtensionReconciler struct {
 	client.Client
@@ -74,6 +103,7 @@ type ClusterExtensionReconciler struct {
 	Applier              Applier
 	RevisionStatesGetter RevisionStatesGetter
 	Finalizers           crfinalizer.Finalizers
+	ReconcileSteps       ReconcileSteps
 }
 
 type StorageMigrator interface {
@@ -106,7 +136,7 @@ func (r *ClusterExtensionReconciler) Reconcile(ctx context.Context, req ctrl.Req
 	defer l.Info("reconcile ending")
 
 	reconciledExt := existingExt.DeepCopy()
-	res, reconcileErr := r.reconcile(ctx, reconciledExt)
+	res, reconcileErr := r.ReconcileSteps.Reconcile(ctx, reconciledExt)
 
 	// Do checks before any Update()s, as Update() may modify the resource structure!
 	updateStatus := !equality.Semantic.DeepEqual(existingExt.Status, reconciledExt.Status)
@@ -164,168 +194,6 @@ func checkForUnexpectedClusterExtensionFieldChange(a, b ocv1.ClusterExtension) b
 	return !equality.Semantic.DeepEqual(a, b)
 }
 
-// Helper function to do the actual reconcile
-//
-// Today we always return ctrl.Result{} and an error.
-// But in the future we might update this function
-// to return different results (e.g. requeue).
-//
-/* The reconcile functions performs the following major tasks:
-1. Resolution: Run the resolution to find the bundle from the catalog which needs to be installed.
-2. Validate: Ensure that the bundle returned from the resolution for install meets our requirements.
-3. Unpack: Unpack the contents from the bundle and store in a localdir in the pod.
-4. Install: The process of installing involves:
-4.1 Converting the CSV in the bundle into a set of plain k8s objects.
-4.2 Generating a chart from k8s objects.
-4.3 Store the release on cluster.
-*/
-//nolint:unparam
-func (r *ClusterExtensionReconciler) reconcile(ctx context.Context, ext *ocv1.ClusterExtension) (ctrl.Result, error) {
-	l := log.FromContext(ctx)
-
-	l.Info("handling finalizers")
-	finalizeResult, err := r.Finalizers.Finalize(ctx, ext)
-	if err != nil {
-		setStatusProgressing(ext, err)
-		return ctrl.Result{}, err
-	}
-	if finalizeResult.Updated || finalizeResult.StatusUpdated {
-		// On create: make sure the finalizer is applied before we do anything
-		// On delete: make sure we do nothing after the finalizer is removed
-		return ctrl.Result{}, nil
-	}
-
-	if ext.GetDeletionTimestamp() != nil {
-		// If we've gotten here, that means the cluster extension is being deleted, we've handled all of
-		// _our_ finalizers (above), but the cluster extension is still present in the cluster, likely
-		// because there are _other_ finalizers that other controllers need to handle, (e.g. the orphan
-		// deletion finalizer).
-		return ctrl.Result{}, nil
-	}
-
-	objLbls := map[string]string{
-		labels.OwnerKindKey: ocv1.ClusterExtensionKind,
-		labels.OwnerNameKey: ext.GetName(),
-	}
-
-	if r.StorageMigrator != nil {
-		if err := r.StorageMigrator.Migrate(ctx, ext, objLbls); err != nil {
-			return ctrl.Result{}, fmt.Errorf("migrating storage: %w", err)
-		}
-	}
-
-	l.Info("getting installed bundle")
-	revisionStates, err := r.RevisionStatesGetter.GetRevisionStates(ctx, ext)
-	if err != nil {
-		setInstallStatus(ext, nil)
-		var saerr *authentication.ServiceAccountNotFoundError
-		if errors.As(err, &saerr) {
-			setInstalledStatusConditionUnknown(ext, saerr.Error())
-			setStatusProgressing(ext, errors.New("installation cannot proceed due to missing ServiceAccount"))
-			return ctrl.Result{}, err
-		}
-		setInstalledStatusConditionUnknown(ext, err.Error())
-		setStatusProgressing(ext, errors.New("retrying to get installed bundle"))
-		return ctrl.Result{}, err
-	}
-
-	var resolvedRevisionMetadata *RevisionMetadata
-	if len(revisionStates.RollingOut) == 0 {
-		l.Info("resolving bundle")
-		var bm *ocv1.BundleMetadata
-		if revisionStates.Installed != nil {
-			bm = &revisionStates.Installed.BundleMetadata
-		}
-		resolvedBundle, resolvedBundleVersion, resolvedDeprecation, err := r.Resolver.Resolve(ctx, ext, bm)
-		if err != nil {
-			// Note: We don't distinguish between resolution-specific errors and generic errors
-			setStatusProgressing(ext, err)
-			setInstalledStatusFromRevisionStates(ext, revisionStates)
-			ensureAllConditionsWithReason(ext, ocv1.ReasonFailed, err.Error())
-			return ctrl.Result{}, err
-		}
-
-		// set deprecation status after _successful_ resolution
-		// TODO:
-		//  1. It seems like deprecation status should reflect the currently installed bundle, not the resolved
-		//     bundle. So perhaps we should set package and channel deprecations directly after resolution, but
-		//     defer setting the bundle deprecation until we successfully install the bundle.
-		//  2. If resolution fails because it can't find a bundle, that doesn't mean we wouldn't be able to find
-		//     a deprecation for the ClusterExtension's spec.packageName. Perhaps we should check for a non-nil
-		//     resolvedDeprecation even if resolution returns an error. If present, we can still update some of
-		//     our deprecation status.
-		//       - Open question though: what if different catalogs have different opinions of what's deprecated.
-		//         If we can't resolve a bundle, how do we know which catalog to trust for deprecation information?
-		//         Perhaps if the package shows up in multiple catalogs and deprecations don't match, we can set
-		//         the deprecation status to unknown? Or perhaps we somehow combine the deprecation information from
-		//         all catalogs?
-		SetDeprecationStatus(ext, resolvedBundle.Name, resolvedDeprecation)
-		resolvedRevisionMetadata = &RevisionMetadata{
-			Package:        resolvedBundle.Package,
-			Image:          resolvedBundle.Image,
-			BundleMetadata: bundleutil.MetadataFor(resolvedBundle.Name, *resolvedBundleVersion),
-		}
-	} else {
-		resolvedRevisionMetadata = revisionStates.RollingOut[0]
-	}
-
-	l.Info("unpacking resolved bundle")
-	imageFS, _, _, err := r.ImagePuller.Pull(ctx, ext.GetName(), resolvedRevisionMetadata.Image, r.ImageCache)
-	if err != nil {
-		// Wrap the error passed to this with the resolution information until we have successfully
-		// installed since we intend for the progressing condition to replace the resolved condition
-		// and will be removing the .status.resolution field from the ClusterExtension status API
-		setStatusProgressing(ext, wrapErrorWithResolutionInfo(resolvedRevisionMetadata.BundleMetadata, err))
-		setInstalledStatusFromRevisionStates(ext, revisionStates)
-		return ctrl.Result{}, err
-	}
-
-	storeLbls := map[string]string{
-		labels.BundleNameKey:      resolvedRevisionMetadata.Name,
-		labels.PackageNameKey:     resolvedRevisionMetadata.Package,
-		labels.BundleVersionKey:   resolvedRevisionMetadata.Version,
-		labels.BundleReferenceKey: resolvedRevisionMetadata.Image,
-	}
-
-	l.Info("applying bundle contents")
-	// NOTE: We need to be cautious of eating errors here.
-	// We should always return any error that occurs during an
-	// attempt to apply content to the cluster. Only when there is
-	// a verifiable reason to eat the error (i.e it is recoverable)
-	// should an exception be made.
-	// The following kinds of errors should be returned up the stack
-	// to ensure exponential backoff can occur:
-	//   - Permission errors (it is not possible to watch changes to permissions.
-	//     The only way to eventually recover from permission errors is to keep retrying).
-	rolloutSucceeded, rolloutStatus, err := r.Applier.Apply(ctx, imageFS, ext, objLbls, storeLbls)
-
-	// Set installed status
-	if rolloutSucceeded {
-		revisionStates = &RevisionStates{Installed: resolvedRevisionMetadata}
-	} else if err == nil && revisionStates.Installed == nil && len(revisionStates.RollingOut) == 0 {
-		revisionStates = &RevisionStates{RollingOut: []*RevisionMetadata{resolvedRevisionMetadata}}
-	}
-	setInstalledStatusFromRevisionStates(ext, revisionStates)
-
-	// If there was an error applying the resolved bundle,
-	// report the error via the Progressing condition.
-	if err != nil {
-		setStatusProgressing(ext, wrapErrorWithResolutionInfo(resolvedRevisionMetadata.BundleMetadata, err))
-		return ctrl.Result{}, err
-	} else if !rolloutSucceeded {
-		apimeta.SetStatusCondition(&ext.Status.Conditions, metav1.Condition{
-			Type:               ocv1.TypeProgressing,
-			Status:             metav1.ConditionTrue,
-			Reason:             ocv1.ReasonRolloutInProgress,
-			Message:            rolloutStatus,
-			ObservedGeneration: ext.GetGeneration(),
-		})
-	} else {
-		setStatusProgressing(ext, nil)
-	}
-	return ctrl.Result{}, nil
-}
-
 // SetDeprecationStatus will set the appropriate deprecation statuses for a ClusterExtension
 // based on the provided bundle
 func SetDeprecationStatus(ext *ocv1.ClusterExtension, bundleName string, deprecation *declcfg.Deprecation) {
@@ -441,7 +309,6 @@ func (r *ClusterExtensionReconciler) SetupWithManager(mgr ctrl.Manager, opts ...
 	for _, applyOpt := range opts {
 		applyOpt(ctrlBuilder)
 	}
-
 	return ctrlBuilder.Build(r)
 }
 
@@ -520,53 +387,3 @@ func (d *HelmRevisionStatesGetter) GetRevisionStates(ctx context.Context, ext *o
 	}
 	return rs, nil
 }
-
-type BoxcutterRevisionStatesGetter struct {
-	Reader client.Reader
-}
-
-func (d *BoxcutterRevisionStatesGetter) GetRevisionStates(ctx context.Context, ext *ocv1.ClusterExtension) (*RevisionStates, error) {
-	// TODO: boxcutter applier has a nearly identical bit of code for listing and sorting revisions
-	//   only difference here is that it sorts in reverse order to start iterating with the most
-	//   recent revisions. We should consolidate to avoid code duplication.
-	existingRevisionList := &ocv1.ClusterExtensionRevisionList{}
-	if err := d.Reader.List(ctx, existingRevisionList, client.MatchingLabels{
-		ClusterExtensionRevisionOwnerLabel: ext.Name,
-	}); err != nil {
-		return nil, fmt.Errorf("listing revisions: %w", err)
-	}
-	slices.SortFunc(existingRevisionList.Items, func(a, b ocv1.ClusterExtensionRevision) int {
-		return cmp.Compare(a.Spec.Revision, b.Spec.Revision)
-	})
-
-	rs := &RevisionStates{}
-	for _, rev := range existingRevisionList.Items {
-		switch rev.Spec.LifecycleState {
-		case ocv1.ClusterExtensionRevisionLifecycleStateActive,
-			ocv1.ClusterExtensionRevisionLifecycleStatePaused:
-		default:
-			// Skip anything not active or paused, which should only be "Archived".
-			continue
-		}
-
-		// TODO: the setting of these annotations (happens in boxcutter applier when we pass in "storageLabels")
-		//   is fairly decoupled from this code where we get the annotations back out. We may want to co-locate
-		//   the set/get logic a bit better to make it more maintainable and less likely to get out of sync.
-		rm := &RevisionMetadata{
-			Package: rev.Labels[labels.PackageNameKey],
-			Image:   rev.Annotations[labels.BundleReferenceKey],
-			BundleMetadata: ocv1.BundleMetadata{
-				Name:    rev.Annotations[labels.BundleNameKey],
-				Version: rev.Annotations[labels.BundleVersionKey],
-			},
-		}
-
-		if apimeta.IsStatusConditionTrue(rev.Status.Conditions, ocv1.ClusterExtensionRevisionTypeSucceeded) {
-			rs.Installed = rm
-		} else {
-			rs.RollingOut = append(rs.RollingOut, rm)
-		}
-	}
-
-	return rs, nil
-}
diff --git a/internal/operator-controller/controllers/clusterextension_controller_test.go b/internal/operator-controller/controllers/clusterextension_controller_test.go
index 437f62dce..95920e542 100644
--- a/internal/operator-controller/controllers/clusterextension_controller_test.go
+++ b/internal/operator-controller/controllers/clusterextension_controller_test.go
@@ -49,15 +49,17 @@ func TestClusterExtensionDoesNotExist(t *testing.T) {
 }
 
 func TestClusterExtensionShortCircuitsReconcileDuringDeletion(t *testing.T) {
-	cl, reconciler := newClientAndReconciler(t)
-
 	installedBundleGetterCalledErr := errors.New("revision states getter called")
+
+	cl, reconciler := newClientAndReconciler(t, func(reconciler *controllers.ClusterExtensionReconciler) {
+		reconciler.RevisionStatesGetter = &MockRevisionStatesGetter{
+			Err: installedBundleGetterCalledErr,
+		}
+	})
+
 	checkInstalledBundleGetterCalled := func(t require.TestingT, err error, args ...interface{}) {
 		require.Equal(t, installedBundleGetterCalledErr, err)
 	}
-	reconciler.RevisionStatesGetter = &MockRevisionStatesGetter{
-		Err: installedBundleGetterCalledErr,
-	}
 
 	type testCase struct {
 		name         string
@@ -123,10 +125,12 @@ func TestClusterExtensionShortCircuitsReconcileDuringDeletion(t *testing.T) {
 
 func TestClusterExtensionResolutionFails(t *testing.T) {
 	pkgName := fmt.Sprintf("non-existent-%s", rand.String(6))
-	cl, reconciler := newClientAndReconciler(t)
-	reconciler.Resolver = resolve.Func(func(_ context.Context, _ *ocv1.ClusterExtension, _ *ocv1.BundleMetadata) (*declcfg.Bundle, *bsemver.Version, *declcfg.Deprecation, error) {
-		return nil, nil, nil, fmt.Errorf("no package %q found", pkgName)
+	cl, reconciler := newClientAndReconciler(t, func(reconciler *controllers.ClusterExtensionReconciler) {
+		reconciler.Resolver = resolve.Func(func(_ context.Context, _ *ocv1.ClusterExtension, _ *ocv1.BundleMetadata) (*declcfg.Bundle, *bsemver.Version, *declcfg.Deprecation, error) {
+			return nil, nil, nil, fmt.Errorf("no package %q found", pkgName)
+		})
 	})
+
 	ctx := context.Background()
 	extKey := types.NamespacedName{Name: fmt.Sprintf("cluster-extension-test-%s", rand.String(8))}
 
@@ -190,11 +194,6 @@ func TestClusterExtensionResolutionSuccessfulUnpackFails(t *testing.T) {
 		},
 	} {
 		t.Run(tc.name, func(t *testing.T) {
-			cl, reconciler := newClientAndReconciler(t)
-			reconciler.ImagePuller = &imageutil.MockPuller{
-				Error: tc.pullErr,
-			}
-
 			ctx := context.Background()
 			extKey := types.NamespacedName{Name: fmt.Sprintf("cluster-extension-test-%s", rand.String(8))}
 
@@ -223,19 +222,30 @@ func TestClusterExtensionResolutionSuccessfulUnpackFails(t *testing.T) {
 					},
 				},
 			}
+			cl, reconciler := newClientAndReconciler(t,
+				func(reconciler *controllers.ClusterExtensionReconciler) {
+					reconciler.ImagePuller = &imageutil.MockPuller{
+						Error: tc.pullErr,
+					}
+				},
+				func(reconciler *controllers.ClusterExtensionReconciler) {
+					reconciler.Resolver = resolve.Func(func(_ context.Context, _ *ocv1.ClusterExtension, _ *ocv1.BundleMetadata) (*declcfg.Bundle, *bsemver.Version, *declcfg.Deprecation, error) {
+						v := bsemver.MustParse("1.0.0")
+						return &declcfg.Bundle{
+							Name:    "prometheus.v1.0.0",
+							Package: "prometheus",
+							Image:   "quay.io/operatorhubio/prometheus@fake1.0.0",
+						}, &v, nil, nil
+					})
+				},
+			)
+
 			err := cl.Create(ctx, clusterExtension)
 			require.NoError(t, err)
 
 			t.Log("It sets resolution success status")
 			t.Log("By running reconcile")
-			reconciler.Resolver = resolve.Func(func(_ context.Context, _ *ocv1.ClusterExtension, _ *ocv1.BundleMetadata) (*declcfg.Bundle, *bsemver.Version, *declcfg.Deprecation, error) {
-				v := bsemver.MustParse("1.0.0")
-				return &declcfg.Bundle{
-					Name:    "prometheus.v1.0.0",
-					Package: "prometheus",
-					Image:   "quay.io/operatorhubio/prometheus@fake1.0.0",
-				}, &v, nil, nil
-			})
+
 			res, err := reconciler.Reconcile(ctx, ctrl.Request{NamespacedName: extKey})
 			require.Equal(t, ctrl.Result{}, res)
 			require.Error(t, err)
@@ -270,10 +280,23 @@ func TestClusterExtensionResolutionSuccessfulUnpackFails(t *testing.T) {
 }
 
 func TestClusterExtensionResolutionAndUnpackSuccessfulApplierFails(t *testing.T) {
-	cl, reconciler := newClientAndReconciler(t)
-	reconciler.ImagePuller = &imageutil.MockPuller{
-		ImageFS: fstest.MapFS{},
-	}
+	cl, reconciler := newClientAndReconciler(t,
+		func(reconciler *controllers.ClusterExtensionReconciler) {
+			reconciler.ImagePuller = &imageutil.MockPuller{
+				ImageFS: fstest.MapFS{},
+			}
+			reconciler.Resolver = resolve.Func(func(_ context.Context, _ *ocv1.ClusterExtension, _ *ocv1.BundleMetadata) (*declcfg.Bundle, *bsemver.Version, *declcfg.Deprecation, error) {
+				v := bsemver.MustParse("1.0.0")
+				return &declcfg.Bundle{
+					Name:    "prometheus.v1.0.0",
+					Package: "prometheus",
+					Image:   "quay.io/operatorhubio/prometheus@fake1.0.0",
+				}, &v, nil, nil
+			})
+			reconciler.Applier = &MockApplier{
+				err: errors.New("apply failure"),
+			}
+		})
 
 	ctx := context.Background()
 	extKey := types.NamespacedName{Name: fmt.Sprintf("cluster-extension-test-%s", rand.String(8))}
@@ -308,17 +331,7 @@ func TestClusterExtensionResolutionAndUnpackSuccessfulApplierFails(t *testing.T)
 
 	t.Log("It sets resolution success status")
 	t.Log("By running reconcile")
-	reconciler.Resolver = resolve.Func(func(_ context.Context, _ *ocv1.ClusterExtension, _ *ocv1.BundleMetadata) (*declcfg.Bundle, *bsemver.Version, *declcfg.Deprecation, error) {
-		v := bsemver.MustParse("1.0.0")
-		return &declcfg.Bundle{
-			Name:    "prometheus.v1.0.0",
-			Package: "prometheus",
-			Image:   "quay.io/operatorhubio/prometheus@fake1.0.0",
-		}, &v, nil, nil
-	})
-	reconciler.Applier = &MockApplier{
-		err: errors.New("apply failure"),
-	}
+
 	res, err := reconciler.Reconcile(ctx, ctrl.Request{NamespacedName: extKey})
 	require.Equal(t, ctrl.Result{}, res)
 	require.Error(t, err)
@@ -347,12 +360,13 @@ func TestClusterExtensionResolutionAndUnpackSuccessfulApplierFails(t *testing.T)
 }
 
 func TestClusterExtensionServiceAccountNotFound(t *testing.T) {
-	cl, reconciler := newClientAndReconciler(t)
-	reconciler.RevisionStatesGetter = &MockRevisionStatesGetter{
-		Err: &authentication.ServiceAccountNotFoundError{
-			ServiceAccountName:      "missing-sa",
-			ServiceAccountNamespace: "default",
-		}}
+	cl, reconciler := newClientAndReconciler(t, func(reconciler *controllers.ClusterExtensionReconciler) {
+		reconciler.RevisionStatesGetter = &MockRevisionStatesGetter{
+			Err: &authentication.ServiceAccountNotFoundError{
+				ServiceAccountName:      "missing-sa",
+				ServiceAccountNamespace: "default",
+			}}
+	})
 
 	ctx := context.Background()
 	extKey := types.NamespacedName{Name: fmt.Sprintf("cluster-extension-test-%s", rand.String(8))}
@@ -401,10 +415,32 @@ func TestClusterExtensionServiceAccountNotFound(t *testing.T) {
 }
 
 func TestClusterExtensionApplierFailsWithBundleInstalled(t *testing.T) {
-	cl, reconciler := newClientAndReconciler(t)
-	reconciler.ImagePuller = &imageutil.MockPuller{
-		ImageFS: fstest.MapFS{},
+	mockApplier := &MockApplier{
+		installCompleted: true,
 	}
+	cl, reconciler := newClientAndReconciler(t, func(reconciler *controllers.ClusterExtensionReconciler) {
+		reconciler.ImagePuller = &imageutil.MockPuller{
+			ImageFS: fstest.MapFS{},
+		}
+		reconciler.Resolver = resolve.Func(func(_ context.Context, _ *ocv1.ClusterExtension, _ *ocv1.BundleMetadata) (*declcfg.Bundle, *bsemver.Version, *declcfg.Deprecation, error) {
+			v := bsemver.MustParse("1.0.0")
+			return &declcfg.Bundle{
+				Name:    "prometheus.v1.0.0",
+				Package: "prometheus",
+				Image:   "quay.io/operatorhubio/prometheus@fake1.0.0",
+			}, &v, nil, nil
+		})
+
+		reconciler.RevisionStatesGetter = &MockRevisionStatesGetter{
+			RevisionStates: &controllers.RevisionStates{
+				Installed: &controllers.RevisionMetadata{
+					BundleMetadata: ocv1.BundleMetadata{Name: "prometheus.v1.0.0", Version: "1.0.0"},
+					Image:          "quay.io/operatorhubio/prometheus@fake1.0.0",
+				},
+			},
+		}
+		reconciler.Applier = mockApplier
+	})
 
 	ctx := context.Background()
 	extKey := types.NamespacedName{Name: fmt.Sprintf("cluster-extension-test-%s", rand.String(8))}
@@ -439,34 +475,13 @@ func TestClusterExtensionApplierFailsWithBundleInstalled(t *testing.T) {
 
 	t.Log("It sets resolution success status")
 	t.Log("By running reconcile")
-	reconciler.Resolver = resolve.Func(func(_ context.Context, _ *ocv1.ClusterExtension, _ *ocv1.BundleMetadata) (*declcfg.Bundle, *bsemver.Version, *declcfg.Deprecation, error) {
-		v := bsemver.MustParse("1.0.0")
-		return &declcfg.Bundle{
-			Name:    "prometheus.v1.0.0",
-			Package: "prometheus",
-			Image:   "quay.io/operatorhubio/prometheus@fake1.0.0",
-		}, &v, nil, nil
-	})
-
-	reconciler.RevisionStatesGetter = &MockRevisionStatesGetter{
-		RevisionStates: &controllers.RevisionStates{
-			Installed: &controllers.RevisionMetadata{
-				BundleMetadata: ocv1.BundleMetadata{Name: "prometheus.v1.0.0", Version: "1.0.0"},
-				Image:          "quay.io/operatorhubio/prometheus@fake1.0.0",
-			},
-		},
-	}
-	reconciler.Applier = &MockApplier{
-		installCompleted: true,
-	}
 
 	res, err := reconciler.Reconcile(ctx, ctrl.Request{NamespacedName: extKey})
 	require.Equal(t, ctrl.Result{}, res)
 	require.NoError(t, err)
 
-	reconciler.Applier = &MockApplier{
-		err: errors.New("apply failure"),
-	}
+	mockApplier.installCompleted = false
+	mockApplier.err = errors.New("apply failure")
 
 	res, err = reconciler.Reconcile(ctx, ctrl.Request{NamespacedName: extKey})
 	require.Equal(t, ctrl.Result{}, res)
@@ -496,10 +511,23 @@ func TestClusterExtensionApplierFailsWithBundleInstalled(t *testing.T) {
 }
 
 func TestClusterExtensionManagerFailed(t *testing.T) {
-	cl, reconciler := newClientAndReconciler(t)
-	reconciler.ImagePuller = &imageutil.MockPuller{
-		ImageFS: fstest.MapFS{},
-	}
+	cl, reconciler := newClientAndReconciler(t, func(reconciler *controllers.ClusterExtensionReconciler) {
+		reconciler.ImagePuller = &imageutil.MockPuller{
+			ImageFS: fstest.MapFS{},
+		}
+		reconciler.Resolver = resolve.Func(func(_ context.Context, _ *ocv1.ClusterExtension, _ *ocv1.BundleMetadata) (*declcfg.Bundle, *bsemver.Version, *declcfg.Deprecation, error) {
+			v := bsemver.MustParse("1.0.0")
+			return &declcfg.Bundle{
+				Name:    "prometheus.v1.0.0",
+				Package: "prometheus",
+				Image:   "quay.io/operatorhubio/prometheus@fake1.0.0",
+			}, &v, nil, nil
+		})
+		reconciler.Applier = &MockApplier{
+			installCompleted: true,
+			err:              errors.New("manager fail"),
+		}
+	})
 
 	ctx := context.Background()
 	extKey := types.NamespacedName{Name: fmt.Sprintf("cluster-extension-test-%s", rand.String(8))}
@@ -534,18 +562,6 @@ func TestClusterExtensionManagerFailed(t *testing.T) {
 
 	t.Log("It sets resolution success status")
 	t.Log("By running reconcile")
-	reconciler.Resolver = resolve.Func(func(_ context.Context, _ *ocv1.ClusterExtension, _ *ocv1.BundleMetadata) (*declcfg.Bundle, *bsemver.Version, *declcfg.Deprecation, error) {
-		v := bsemver.MustParse("1.0.0")
-		return &declcfg.Bundle{
-			Name:    "prometheus.v1.0.0",
-			Package: "prometheus",
-			Image:   "quay.io/operatorhubio/prometheus@fake1.0.0",
-		}, &v, nil, nil
-	})
-	reconciler.Applier = &MockApplier{
-		installCompleted: true,
-		err:              errors.New("manager fail"),
-	}
 	res, err := reconciler.Reconcile(ctx, ctrl.Request{NamespacedName: extKey})
 	require.Equal(t, ctrl.Result{}, res)
 	require.Error(t, err)
@@ -572,10 +588,23 @@ func TestClusterExtensionManagerFailed(t *testing.T) {
 }
 
 func TestClusterExtensionManagedContentCacheWatchFail(t *testing.T) {
-	cl, reconciler := newClientAndReconciler(t)
-	reconciler.ImagePuller = &imageutil.MockPuller{
-		ImageFS: fstest.MapFS{},
-	}
+	cl, reconciler := newClientAndReconciler(t, func(reconciler *controllers.ClusterExtensionReconciler) {
+		reconciler.ImagePuller = &imageutil.MockPuller{
+			ImageFS: fstest.MapFS{},
+		}
+		reconciler.Resolver = resolve.Func(func(_ context.Context, _ *ocv1.ClusterExtension, _ *ocv1.BundleMetadata) (*declcfg.Bundle, *bsemver.Version, *declcfg.Deprecation, error) {
+			v := bsemver.MustParse("1.0.0")
+			return &declcfg.Bundle{
+				Name:    "prometheus.v1.0.0",
+				Package: "prometheus",
+				Image:   "quay.io/operatorhubio/prometheus@fake1.0.0",
+			}, &v, nil, nil
+		})
+		reconciler.Applier = &MockApplier{
+			installCompleted: true,
+			err:              errors.New("watch error"),
+		}
+	})
 
 	ctx := context.Background()
 	extKey := types.NamespacedName{Name: fmt.Sprintf("cluster-extension-test-%s", rand.String(8))}
@@ -611,18 +640,7 @@ func TestClusterExtensionManagedContentCacheWatchFail(t *testing.T) {
 
 	t.Log("It sets resolution success status")
 	t.Log("By running reconcile")
-	reconciler.Resolver = resolve.Func(func(_ context.Context, _ *ocv1.ClusterExtension, _ *ocv1.BundleMetadata) (*declcfg.Bundle, *bsemver.Version, *declcfg.Deprecation, error) {
-		v := bsemver.MustParse("1.0.0")
-		return &declcfg.Bundle{
-			Name:    "prometheus.v1.0.0",
-			Package: "prometheus",
-			Image:   "quay.io/operatorhubio/prometheus@fake1.0.0",
-		}, &v, nil, nil
-	})
-	reconciler.Applier = &MockApplier{
-		installCompleted: true,
-		err:              errors.New("watch error"),
-	}
+
 	res, err := reconciler.Reconcile(ctx, ctrl.Request{NamespacedName: extKey})
 	require.Equal(t, ctrl.Result{}, res)
 	require.Error(t, err)
@@ -649,10 +667,22 @@ func TestClusterExtensionManagedContentCacheWatchFail(t *testing.T) {
 }
 
 func TestClusterExtensionInstallationSucceeds(t *testing.T) {
-	cl, reconciler := newClientAndReconciler(t)
-	reconciler.ImagePuller = &imageutil.MockPuller{
-		ImageFS: fstest.MapFS{},
-	}
+	cl, reconciler := newClientAndReconciler(t, func(reconciler *controllers.ClusterExtensionReconciler) {
+		reconciler.ImagePuller = &imageutil.MockPuller{
+			ImageFS: fstest.MapFS{},
+		}
+		reconciler.Resolver = resolve.Func(func(_ context.Context, _ *ocv1.ClusterExtension, _ *ocv1.BundleMetadata) (*declcfg.Bundle, *bsemver.Version, *declcfg.Deprecation, error) {
+			v := bsemver.MustParse("1.0.0")
+			return &declcfg.Bundle{
+				Name:    "prometheus.v1.0.0",
+				Package: "prometheus",
+				Image:   "quay.io/operatorhubio/prometheus@fake1.0.0",
+			}, &v, nil, nil
+		})
+		reconciler.Applier = &MockApplier{
+			installCompleted: true,
+		}
+	})
 
 	ctx := context.Background()
 	extKey := types.NamespacedName{Name: fmt.Sprintf("cluster-extension-test-%s", rand.String(8))}
@@ -687,17 +717,6 @@ func TestClusterExtensionInstallationSucceeds(t *testing.T) {
 
 	t.Log("It sets resolution success status")
 	t.Log("By running reconcile")
-	reconciler.Resolver = resolve.Func(func(_ context.Context, _ *ocv1.ClusterExtension, _ *ocv1.BundleMetadata) (*declcfg.Bundle, *bsemver.Version, *declcfg.Deprecation, error) {
-		v := bsemver.MustParse("1.0.0")
-		return &declcfg.Bundle{
-			Name:    "prometheus.v1.0.0",
-			Package: "prometheus",
-			Image:   "quay.io/operatorhubio/prometheus@fake1.0.0",
-		}, &v, nil, nil
-	})
-	reconciler.Applier = &MockApplier{
-		installCompleted: true,
-	}
 	res, err := reconciler.Reconcile(ctx, ctrl.Request{NamespacedName: extKey})
 	require.Equal(t, ctrl.Result{}, res)
 	require.NoError(t, err)
@@ -724,10 +743,32 @@ func TestClusterExtensionInstallationSucceeds(t *testing.T) {
 }
 
 func TestClusterExtensionDeleteFinalizerFails(t *testing.T) {
-	cl, reconciler := newClientAndReconciler(t)
-	reconciler.ImagePuller = &imageutil.MockPuller{
-		ImageFS: fstest.MapFS{},
-	}
+	fakeFinalizer := "fake.testfinalizer.io"
+	finalizersMessage := "still have finalizers"
+	cl, reconciler := newClientAndReconciler(t, func(reconciler *controllers.ClusterExtensionReconciler) {
+		reconciler.ImagePuller = &imageutil.MockPuller{
+			ImageFS: fstest.MapFS{},
+		}
+		reconciler.Resolver = resolve.Func(func(_ context.Context, _ *ocv1.ClusterExtension, _ *ocv1.BundleMetadata) (*declcfg.Bundle, *bsemver.Version, *declcfg.Deprecation, error) {
+			v := bsemver.MustParse("1.0.0")
+			return &declcfg.Bundle{
+				Name:    "prometheus.v1.0.0",
+				Package: "prometheus",
+				Image:   "quay.io/operatorhubio/prometheus@fake1.0.0",
+			}, &v, nil, nil
+		})
+		reconciler.Applier = &MockApplier{
+			installCompleted: true,
+		}
+		reconciler.RevisionStatesGetter = &MockRevisionStatesGetter{
+			RevisionStates: &controllers.RevisionStates{
+				Installed: &controllers.RevisionMetadata{
+					BundleMetadata: ocv1.BundleMetadata{Name: "prometheus.v1.0.0", Version: "1.0.0"},
+					Image:          "quay.io/operatorhubio/prometheus@fake1.0.0",
+				},
+			},
+		}
+	})
 
 	ctx := context.Background()
 	extKey := types.NamespacedName{Name: fmt.Sprintf("cluster-extension-test-%s", rand.String(8))}
@@ -761,27 +802,6 @@ func TestClusterExtensionDeleteFinalizerFails(t *testing.T) {
 	require.NoError(t, err)
 	t.Log("It sets resolution success status")
 	t.Log("By running reconcile")
-	reconciler.Resolver = resolve.Func(func(_ context.Context, _ *ocv1.ClusterExtension, _ *ocv1.BundleMetadata) (*declcfg.Bundle, *bsemver.Version, *declcfg.Deprecation, error) {
-		v := bsemver.MustParse("1.0.0")
-		return &declcfg.Bundle{
-			Name:    "prometheus.v1.0.0",
-			Package: "prometheus",
-			Image:   "quay.io/operatorhubio/prometheus@fake1.0.0",
-		}, &v, nil, nil
-	})
-	fakeFinalizer := "fake.testfinalizer.io"
-	finalizersMessage := "still have finalizers"
-	reconciler.Applier = &MockApplier{
-		installCompleted: true,
-	}
-	reconciler.RevisionStatesGetter = &MockRevisionStatesGetter{
-		RevisionStates: &controllers.RevisionStates{
-			Installed: &controllers.RevisionMetadata{
-				BundleMetadata: ocv1.BundleMetadata{Name: "prometheus.v1.0.0", Version: "1.0.0"},
-				Image:          "quay.io/operatorhubio/prometheus@fake1.0.0",
-			},
-		},
-	}
 	err = reconciler.Finalizers.Register(fakeFinalizer, finalizers.FinalizerFunc(func(ctx context.Context, obj client.Object) (crfinalizer.Result, error) {
 		return crfinalizer.Result{}, errors.New(finalizersMessage)
 	}))
diff --git a/internal/operator-controller/controllers/clusterextension_reconcile_steps.go b/internal/operator-controller/controllers/clusterextension_reconcile_steps.go
new file mode 100644
index 000000000..b8cfd0c8a
--- /dev/null
+++ b/internal/operator-controller/controllers/clusterextension_reconcile_steps.go
@@ -0,0 +1,211 @@
+/*
+Copyright 2025.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package controllers
+
+import (
+	"context"
+	"errors"
+	"io/fs"
+
+	apimeta "k8s.io/apimachinery/pkg/api/meta"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	ctrl "sigs.k8s.io/controller-runtime"
+	"sigs.k8s.io/controller-runtime/pkg/finalizer"
+	"sigs.k8s.io/controller-runtime/pkg/log"
+
+	ocv1 "github.com/operator-framework/operator-controller/api/v1"
+	"github.com/operator-framework/operator-controller/internal/operator-controller/authentication"
+	"github.com/operator-framework/operator-controller/internal/operator-controller/bundleutil"
+	"github.com/operator-framework/operator-controller/internal/operator-controller/labels"
+	"github.com/operator-framework/operator-controller/internal/operator-controller/resolve"
+	imageutil "github.com/operator-framework/operator-controller/internal/shared/util/image"
+)
+
+type revisionStatesKey struct{}
+type resolvedRevisionMetadataKey struct{}
+type imageFSKey struct{}
+
+func HandleFinalizers(f finalizer.Finalizer) ReconcileStepFunc {
+	return func(ctx context.Context, ext *ocv1.ClusterExtension) (context.Context, *ctrl.Result, error) {
+		l := log.FromContext(ctx)
+
+		l.Info("handling finalizers")
+		finalizeResult, err := f.Finalize(ctx, ext)
+		if err != nil {
+			setStatusProgressing(ext, err)
+			return ctx, nil, err
+		}
+		if finalizeResult.Updated || finalizeResult.StatusUpdated {
+			// On create: make sure the finalizer is applied before we do anything
+			// On delete: make sure we do nothing after the finalizer is removed
+			return ctx, &ctrl.Result{}, nil
+		}
+
+		if ext.GetDeletionTimestamp() != nil {
+			// If we've gotten here, that means the cluster extension is being deleted, we've handled all of
+			// _our_ finalizers (above), but the cluster extension is still present in the cluster, likely
+			// because there are _other_ finalizers that other controllers need to handle, (e.g. the orphan
+			// deletion finalizer).
+			return nil, nil, nil
+		}
+		return ctx, nil, nil
+	}
+}
+
+func RetrieveRevisionStates(r RevisionStatesGetter) ReconcileStepFunc {
+	return func(ctx context.Context, ext *ocv1.ClusterExtension) (context.Context, *ctrl.Result, error) {
+		l := log.FromContext(ctx)
+		l.Info("getting installed bundle")
+		revisionStates, err := r.GetRevisionStates(ctx, ext)
+		if err != nil {
+			setInstallStatus(ext, nil)
+			var saerr *authentication.ServiceAccountNotFoundError
+			if errors.As(err, &saerr) {
+				setInstalledStatusConditionUnknown(ext, saerr.Error())
+				setStatusProgressing(ext, errors.New("installation cannot proceed due to missing ServiceAccount"))
+				return ctx, nil, err
+			}
+			setInstalledStatusConditionUnknown(ext, err.Error())
+			setStatusProgressing(ext, errors.New("retrying to get installed bundle"))
+			return ctx, nil, err
+		}
+		return context.WithValue(ctx, revisionStatesKey{}, revisionStates), nil, nil
+	}
+}
+
+func RetrieveRevisionMetadata(r resolve.Resolver) ReconcileStepFunc {
+	return func(ctx context.Context, ext *ocv1.ClusterExtension) (context.Context, *ctrl.Result, error) {
+		l := log.FromContext(ctx)
+		revisionStates := ctx.Value(revisionStatesKey{}).(*RevisionStates)
+		var resolvedRevisionMetadata *RevisionMetadata
+		if len(revisionStates.RollingOut) == 0 {
+			l.Info("resolving bundle")
+			var bm *ocv1.BundleMetadata
+			if revisionStates.Installed != nil {
+				bm = &revisionStates.Installed.BundleMetadata
+			}
+			resolvedBundle, resolvedBundleVersion, resolvedDeprecation, err := r.Resolve(ctx, ext, bm)
+			if err != nil {
+				// Note: We don't distinguish between resolution-specific errors and generic errors
+				setStatusProgressing(ext, err)
+				setInstalledStatusFromRevisionStates(ext, revisionStates)
+				ensureAllConditionsWithReason(ext, ocv1.ReasonFailed, err.Error())
+				return ctx, nil, err
+			}
+
+			// set deprecation status after _successful_ resolution
+			// TODO:
+			//  1. It seems like deprecation status should reflect the currently installed bundle, not the resolved
+			//     bundle. So perhaps we should set package and channel deprecations directly after resolution, but
+			//     defer setting the bundle deprecation until we successfully install the bundle.
+			//  2. If resolution fails because it can't find a bundle, that doesn't mean we wouldn't be able to find
+			//     a deprecation for the ClusterExtension's spec.packageName. Perhaps we should check for a non-nil
+			//     resolvedDeprecation even if resolution returns an error. If present, we can still update some of
+			//     our deprecation status.
+			//       - Open question though: what if different catalogs have different opinions of what's deprecated.
+			//         If we can't resolve a bundle, how do we know which catalog to trust for deprecation information?
+			//         Perhaps if the package shows up in multiple catalogs and deprecations don't match, we can set
+			//         the deprecation status to unknown? Or perhaps we somehow combine the deprecation information from
+			//         all catalogs?
+			SetDeprecationStatus(ext, resolvedBundle.Name, resolvedDeprecation)
+			resolvedRevisionMetadata = &RevisionMetadata{
+				Package:        resolvedBundle.Package,
+				Image:          resolvedBundle.Image,
+				BundleMetadata: bundleutil.MetadataFor(resolvedBundle.Name, *resolvedBundleVersion),
+			}
+		} else {
+			resolvedRevisionMetadata = revisionStates.RollingOut[0]
+		}
+		return context.WithValue(ctx, resolvedRevisionMetadataKey{}, resolvedRevisionMetadata), nil, nil
+	}
+}
+
+func UnpackBundle(i imageutil.Puller, cache imageutil.Cache) ReconcileStepFunc {
+	return func(ctx context.Context, ext *ocv1.ClusterExtension) (context.Context, *ctrl.Result, error) {
+		l := log.FromContext(ctx)
+		l.Info("unpacking resolved bundle")
+		resolvedRevisionMetadata := ctx.Value(resolvedRevisionMetadataKey{}).(*RevisionMetadata)
+		imageFS, _, _, err := i.Pull(ctx, ext.GetName(), resolvedRevisionMetadata.Image, cache)
+		if err != nil {
+			revisionStates := ctx.Value(revisionStatesKey{}).(*RevisionStates)
+			// Wrap the error passed to this with the resolution information until we have successfully
+			// installed since we intend for the progressing condition to replace the resolved condition
+			// and will be removing the .status.resolution field from the ClusterExtension status API
+			setStatusProgressing(ext, wrapErrorWithResolutionInfo(resolvedRevisionMetadata.BundleMetadata, err))
+			setInstalledStatusFromRevisionStates(ext, revisionStates)
+			return ctx, nil, err
+		}
+		return context.WithValue(ctx, imageFSKey{}, imageFS), nil, nil
+	}
+}
+
+func ApplyBundle(a Applier) ReconcileStepFunc {
+	return func(ctx context.Context, ext *ocv1.ClusterExtension) (context.Context, *ctrl.Result, error) {
+		l := log.FromContext(ctx)
+		resolvedRevisionMetadata := ctx.Value(resolvedRevisionMetadataKey{}).(*RevisionMetadata)
+		imageFS := ctx.Value(imageFSKey{}).(fs.FS)
+		revisionStates := ctx.Value(revisionStatesKey{}).(*RevisionStates)
+		storeLbls := map[string]string{
+			labels.BundleNameKey:      resolvedRevisionMetadata.Name,
+			labels.PackageNameKey:     resolvedRevisionMetadata.Package,
+			labels.BundleVersionKey:   resolvedRevisionMetadata.Version,
+			labels.BundleReferenceKey: resolvedRevisionMetadata.Image,
+		}
+		objLbls := map[string]string{
+			labels.OwnerKindKey: ocv1.ClusterExtensionKind,
+			labels.OwnerNameKey: ext.GetName(),
+		}
+
+		l.Info("applying bundle contents")
+		// NOTE: We need to be cautious of eating errors here.
+		// We should always return any error that occurs during an
+		// attempt to apply content to the cluster. Only when there is
+		// a verifiable reason to eat the error (i.e it is recoverable)
+		// should an exception be made.
+		// The following kinds of errors should be returned up the stack
+		// to ensure exponential backoff can occur:
+		//   - Permission errors (it is not possible to watch changes to permissions.
+		//     The only way to eventually recover from permission errors is to keep retrying).
+		rolloutSucceeded, rolloutStatus, err := a.Apply(ctx, imageFS, ext, objLbls, storeLbls)
+
+		// Set installed status
+		if rolloutSucceeded {
+			revisionStates = &RevisionStates{Installed: resolvedRevisionMetadata}
+		} else if err == nil && revisionStates.Installed == nil && len(revisionStates.RollingOut) == 0 {
+			revisionStates = &RevisionStates{RollingOut: []*RevisionMetadata{resolvedRevisionMetadata}}
+		}
+		setInstalledStatusFromRevisionStates(ext, revisionStates)
+
+		// If there was an error applying the resolved bundle,
+		// report the error via the Progressing condition.
+		if err != nil {
+			setStatusProgressing(ext, wrapErrorWithResolutionInfo(resolvedRevisionMetadata.BundleMetadata, err))
+			return ctx, nil, err
+		} else if !rolloutSucceeded {
+			apimeta.SetStatusCondition(&ext.Status.Conditions, metav1.Condition{
+				Type:               ocv1.TypeProgressing,
+				Status:             metav1.ConditionTrue,
+				Reason:             ocv1.ReasonRolloutInProgress,
+				Message:            rolloutStatus,
+				ObservedGeneration: ext.GetGeneration(),
+			})
+		} else {
+			setStatusProgressing(ext, nil)
+		}
+		return ctx, nil, nil
+	}
+}
diff --git a/internal/operator-controller/controllers/suite_test.go b/internal/operator-controller/controllers/suite_test.go
index 02d538237..280002ef7 100644
--- a/internal/operator-controller/controllers/suite_test.go
+++ b/internal/operator-controller/controllers/suite_test.go
@@ -76,7 +76,9 @@ func (m *MockApplier) Apply(_ context.Context, _ fs.FS, _ *ocv1.ClusterExtension
 	return m.installCompleted, m.installStatus, m.err
 }
 
-func newClientAndReconciler(t *testing.T) (client.Client, *controllers.ClusterExtensionReconciler) {
+type reconcilerOption func(*controllers.ClusterExtensionReconciler)
+
+func newClientAndReconciler(t *testing.T, opts ...reconcilerOption) (client.Client, *controllers.ClusterExtensionReconciler) {
 	cl := newClient(t)
 
 	reconciler := &controllers.ClusterExtensionReconciler{
@@ -86,6 +88,20 @@ func newClientAndReconciler(t *testing.T) (client.Client, *controllers.ClusterEx
 		},
 		Finalizers: crfinalizer.NewFinalizers(),
 	}
+	for _, opt := range opts {
+		opt(reconciler)
+	}
+	reconciler.ReconcileSteps = []controllers.ReconcileStepFunc{controllers.HandleFinalizers(reconciler.Finalizers), controllers.RetrieveRevisionStates(reconciler.RevisionStatesGetter)}
+	if r := reconciler.Resolver; r != nil {
+		reconciler.ReconcileSteps = append(reconciler.ReconcileSteps, controllers.RetrieveRevisionMetadata(r))
+	}
+	if i := reconciler.ImagePuller; i != nil {
+		reconciler.ReconcileSteps = append(reconciler.ReconcileSteps, controllers.UnpackBundle(i, reconciler.ImageCache))
+	}
+	if a := reconciler.Applier; a != nil {
+		reconciler.ReconcileSteps = append(reconciler.ReconcileSteps, controllers.ApplyBundle(a))
+	}
+
 	return cl, reconciler
 }