diff --git a/hack/lib/serverless.bash b/hack/lib/serverless.bash
index 6be1703106..272a5a0a82 100644
--- a/hack/lib/serverless.bash
+++ b/hack/lib/serverless.bash
@@ -14,29 +14,26 @@ function ensure_serverless_installed {
   # Otherwise, we cannot change log level by configmap.
   enable_debug_log
 
-  local csv
+  local channel csv
   if [[ "${INSTALL_OLDEST_COMPATIBLE}" == "true" ]]; then
+    channel="$(metadata.get "olm.channels.list[3]")"
     csv="$(metadata.get "upgrade_sequence[0].csv")"
     OLM_SOURCE=redhat-operators
   elif [[ "${INSTALL_PREVIOUS_VERSION}" == "true" ]]; then
+    channel="$(metadata.get "olm.channels.list[2]")"
     csv="$PREVIOUS_CSV"
   else
+    channel="$(metadata.get "olm.channels.list[1]")"
     csv="$CURRENT_CSV"
   fi
 
-  # Remove installplan from previous installations, leaving this would make the operator
-  # upgrade to the latest version immediately
-  if [[ "$csv" != "$CURRENT_CSV" ]]; then
-    remove_installplan "$CURRENT_CSV"
-  fi
-
-  logger.info "Installing Serverless version $csv"
+  logger.info "Installing Serverless version $channel"
 
-  deploy_serverless_operator "$csv"
+  deploy_serverless_operator "$channel"
 
   install_knative_resources "${csv#serverless-operator.v}"
 
-  logger.success "Serverless is installed: $csv"
+  logger.success "Serverless is installed: $channel"
 }
 
 function install_knative_resources {
@@ -68,26 +65,14 @@ function install_knative_resources {
   fi
 }
 
-function remove_installplan {
-  local install_plan csv
-  csv="${1:?Pass a CSV as arg[1]}"
-  logger.info "Removing installplan for $csv"
-  install_plan=$(find_install_plan "$csv")
-  if [[ -n $install_plan ]]; then
-    oc delete "$install_plan" -n "${OPERATORS_NAMESPACE}"
-  else
-    logger.debug "No install plan for $csv"
-  fi
-}
-
 function deploy_serverless_operator_latest {
-  deploy_serverless_operator "$CURRENT_CSV"
+  deploy_serverless_operator "${OLM_UPGRADE_CHANNEL}"
 }
 
 function deploy_serverless_operator {
-  local csv tmpfile
-  csv="${1:?Pass as CSV as arg[1]}"
-  logger.info "Install the Serverless Operator: ${csv}"
+  local channel tmpfile
+  channel="${1:?Pass a channel as arg[1]}"
+  logger.info "Install the Serverless Operator: ${channel}"
   tmpfile=$(mktemp /tmp/subscription.XXXXXX.yaml)
   cat > "$tmpfile" <<EOF
 apiVersion: operators.coreos.com/v1alpha1
@@ -96,54 +81,13 @@ metadata:
   name: "${OPERATOR}"
   namespace: "${OPERATORS_NAMESPACE}"
 spec:
-  channel: "${OLM_CHANNEL}"
+  channel: "${channel}"
   name: "${OPERATOR}"
   source: "${OLM_SOURCE}"
   sourceNamespace: "${OLM_NAMESPACE}"
-  installPlanApproval: Manual
-  startingCSV: "${csv}"
 EOF
   [ -n "$OPENSHIFT_CI" ] && cat "$tmpfile"
   oc apply -f "$tmpfile"
-
-  # Approve the initial installplan automatically
-  approve_csv "$csv" "$OLM_CHANNEL"
-}
-
-function approve_csv {
-  local csv_version install_plan channel
-  csv_version=${1:?Pass a CSV as arg[1]}
-  channel=${2:?Pass channel as arg[2]}
-
-  logger.info 'Ensure channel and source is set properly'
-  oc patch subscriptions.operators.coreos.com "$OPERATOR" -n "${OPERATORS_NAMESPACE}" \
-    --type 'merge' \
-    --patch '{"spec": {"channel": "'"${channel}"'", "source": "'"${OLM_SOURCE}"'"}}'
-
-  logger.info 'Wait for the installplan to be available'
-  timeout 900 "[[ -z \$(find_install_plan ${csv_version}) ]]"
-
-  install_plan=$(find_install_plan "${csv_version}")
-  oc patch "$install_plan" -n "${OPERATORS_NAMESPACE}" \
-    --type merge --patch '{"spec":{"approved":true}}'
-
-  if ! timeout 300 "[[ \$(oc get ClusterServiceVersion $csv_version -n ${OPERATORS_NAMESPACE} -o jsonpath='{.status.phase}') != Succeeded ]]" ; then
-    oc get ClusterServiceVersion "$csv_version" -n "${OPERATORS_NAMESPACE}" -o yaml || true
-    return 105
-  fi
-}
-
-function find_install_plan {
-  local csv="${1:-Pass a CSV as arg[1]}"
-  for plan in $(oc get installplan -n "${OPERATORS_NAMESPACE}" --no-headers -o name); do
-    if [[ $(oc get "$plan" -n "${OPERATORS_NAMESPACE}" -o=jsonpath='{.spec.clusterServiceVersionNames}' | grep -c "$csv") -eq 1 && \
-      $(oc get "$plan" -n "${OPERATORS_NAMESPACE}" -o=jsonpath="{.status.bundleLookups[0].catalogSourceRef.name}" | grep -c "$OLM_SOURCE") -eq 1 ]]
-    then
-      echo "$plan"
-      return 0
-    fi
-  done
-  echo ""
 }
 
 function deploy_knativeserving_cr {
diff --git a/hack/lib/vars.bash b/hack/lib/vars.bash
index baea3658a5..fde84b22cf 100644
--- a/hack/lib/vars.bash
+++ b/hack/lib/vars.bash
@@ -65,10 +65,11 @@ export UPGRADE_OCP_IMAGE="${UPGRADE_OCP_IMAGE:-}"
 export INSTALL_PREVIOUS_VERSION="${INSTALL_PREVIOUS_VERSION:-"false"}"
 export INSTALL_OLDEST_COMPATIBLE="${INSTALL_OLDEST_COMPATIBLE:-"false"}"
 
-OLM_CHANNEL="${OLM_CHANNEL:-$(metadata.get olm.channels.default)}"
-export OLM_CHANNEL
+OLM_PREVIOUS_CHANNEL="${OLM_PREVIOUS_CHANNEL:-$(metadata.get olm.channels.list[2])}"
+export OLM_PREVIOUS_CHANNEL
 # Change this when upgrades need switching to a different channel
-export OLM_UPGRADE_CHANNEL="${OLM_UPGRADE_CHANNEL:-"$OLM_CHANNEL"}"
+OLM_UPGRADE_CHANNEL="${OLM_UPGRADE_CHANNEL:-$(metadata.get olm.channels.list[1])}"
+export OLM_UPGRADE_CHANNEL
 export OLM_SOURCE="${OLM_SOURCE:-"$OPERATOR"}"
 export TEST_KNATIVE_UPGRADE="${TEST_KNATIVE_UPGRADE:-true}"
 export TEST_KNATIVE_E2E="${TEST_KNATIVE_E2E:-true}"
diff --git a/test/installplan.go b/test/installplan.go
deleted file mode 100644
index 0e912990b9..0000000000
--- a/test/installplan.go
+++ /dev/null
@@ -1,59 +0,0 @@
-package test
-
-import (
-	"context"
-	"fmt"
-	"time"
-
-	"k8s.io/apimachinery/pkg/types"
-
-	"k8s.io/apimachinery/pkg/util/wait"
-
-	operatorsv1alpha1 "github.com/operator-framework/api/pkg/operators/v1alpha1"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-)
-
-func WaitForInstallPlan(ctx *Context, namespace string, csvName, olmSource string, timeout time.Duration) (*operatorsv1alpha1.InstallPlan, error) {
-	var plan *operatorsv1alpha1.InstallPlan
-	if waitErr := wait.PollImmediate(Interval, timeout, func() (bool, error) {
-		installPlans, err := ctx.Clients.OLM.OperatorsV1alpha1().InstallPlans(namespace).List(context.Background(), metav1.ListOptions{})
-		if err != nil {
-			return false, err
-		}
-		for _, installPlan := range installPlans.Items {
-			if installsCSVFromSource(installPlan, csvName, olmSource) {
-				plan = &installPlan
-				return true, nil
-			}
-		}
-		return false, nil
-	}); waitErr != nil {
-		return plan, fmt.Errorf("installplan for CSV %s and OLM source %s not found: %w", csvName, olmSource, waitErr)
-	}
-	return plan, nil
-}
-
-func installsCSVFromSource(installPlan operatorsv1alpha1.InstallPlan, csvName, olmSource string) bool {
-	if installPlan.Status.BundleLookups == nil ||
-		len(installPlan.Status.BundleLookups) == 0 ||
-		installPlan.Status.BundleLookups[0].CatalogSourceRef == nil ||
-		installPlan.Status.BundleLookups[0].CatalogSourceRef.Name != olmSource {
-		return false
-	}
-	for _, name := range installPlan.Spec.ClusterServiceVersionNames {
-		if name == csvName {
-			return true
-		}
-	}
-	return false
-}
-
-func ApproveInstallPlan(ctx *Context, name string) error {
-	patch := []byte(`{"spec":{"approved":true}}`)
-	_, err := ctx.Clients.OLM.OperatorsV1alpha1().InstallPlans(OperatorsNamespace).
-		Patch(context.Background(), name, types.MergePatchType, patch, metav1.PatchOptions{})
-	if err != nil {
-		return err
-	}
-	return nil
-}
diff --git a/test/lib.bash b/test/lib.bash
index 4a841e7c65..ff91bb32bc 100644
--- a/test/lib.bash
+++ b/test/lib.bash
@@ -86,7 +86,7 @@ function serverless_operator_e2e_tests {
   fi
 
   go_test_e2e -tags=e2e "${RUN_FLAGS[@]}" ./test/e2e \
-    --channel "$OLM_CHANNEL" \
+    --channel "$OLM_UPGRADE_CHANNEL" \
     --kubeconfigs "${kubeconfigs_str}" \
     --imagetemplate "${IMAGE_TEMPLATE}" \
     "$@"
@@ -111,7 +111,7 @@ function serverless_operator_kafka_e2e_tests {
   fi
 
   go_test_e2e -tags=e2e "${RUN_FLAGS[@]}" ./test/e2ekafka \
-    --channel "$OLM_CHANNEL" \
+    --channel "$OLM_UPGRADE_CHANNEL" \
     --kubeconfigs "${kubeconfigs_str}" \
     --imagetemplate "${IMAGE_TEMPLATE}" \
     "$@"
@@ -419,7 +419,7 @@ EOF
     "--imagetemplate=${image_template}" \
     "--images.producer.file=${images_file}" \
     "--catalogsource=${OLM_SOURCE}" \
-    "--channel=${OLM_CHANNEL}" \
+    "--channel=${OLM_PREVIOUS_CHANNEL}" \
     "--upgradechannel=${OLM_UPGRADE_CHANNEL}" \
     "--csv=${CURRENT_CSV}" \
     "--csvprevious=${PREVIOUS_CSV}" \
@@ -460,9 +460,9 @@ EOF
     oc create namespace serving-tests
     # Make sure the cluster upgrade is run with latest version of Serverless as
     # the Serverless upgrade tests leave the product at the previous version (after downgrade).
-    approve_csv "$CURRENT_CSV" "$OLM_UPGRADE_CHANNEL"
     go_test_e2e -run=TestClusterUpgrade -timeout=220m "${common_opts[@]}" \
       --openshiftimage="${UPGRADE_OCP_IMAGE}" \
+      --upgradechannel="${OLM_UPGRADE_CHANNEL}" \
       --upgradeopenshift
   fi
 
diff --git a/test/subscription.go b/test/subscription.go
index af46bcc34e..fd1b782c7d 100644
--- a/test/subscription.go
+++ b/test/subscription.go
@@ -25,6 +25,8 @@ const (
 )
 
 func UpdateSubscriptionChannelSource(ctx *Context, name, channel, source string) (*operatorsv1alpha1.Subscription, error) {
+	ctx.T.Logf("Updating subscription %s to channel %s and source %s", name, channel, source)
+
 	patch := []byte(fmt.Sprintf(`{"spec":{"channel":"%s","source":"%s"}}`, channel, source))
 	return ctx.Clients.OLM.OperatorsV1alpha1().Subscriptions(OperatorsNamespace).
 		Patch(context.Background(), name, types.MergePatchType, patch, metav1.PatchOptions{})
@@ -55,11 +57,15 @@ func DeleteClusterServiceVersion(ctx *Context, name, namespace string) error {
 	return ctx.Clients.OLM.OperatorsV1alpha1().ClusterServiceVersions(namespace).Delete(context.Background(), name, metav1.DeleteOptions{})
 }
 
+func GetSubscription(ctx *Context, name, namespace string) (*operatorsv1alpha1.Subscription, error) {
+	return ctx.Clients.OLM.OperatorsV1alpha1().Subscriptions(namespace).Get(context.Background(), name, metav1.GetOptions{})
+}
+
 func DeleteSubscription(ctx *Context, name, namespace string) error {
 	return ctx.Clients.OLM.OperatorsV1alpha1().Subscriptions(namespace).Delete(context.Background(), name, metav1.DeleteOptions{})
 }
 
-func Subscription(subscriptionName, startingCSV string) *operatorsv1alpha1.Subscription {
+func Subscription(subscriptionName, channel string) *operatorsv1alpha1.Subscription {
 	return &operatorsv1alpha1.Subscription{
 		TypeMeta: metav1.TypeMeta{
 			Kind:       operatorsv1alpha1.SubscriptionKind,
@@ -73,15 +79,15 @@ func Subscription(subscriptionName, startingCSV string) *operatorsv1alpha1.Subsc
 			CatalogSource:          Flags.CatalogSource,
 			CatalogSourceNamespace: OLMNamespace,
 			Package:                ServerlessOperatorPackage,
-			Channel:                Flags.Channel,
-			InstallPlanApproval:    operatorsv1alpha1.ApprovalManual,
-			StartingCSV:            startingCSV,
+			Channel:                channel,
 		},
 	}
 }
 
-func CreateSubscription(ctx *Context, name, startingCSV string) (*operatorsv1alpha1.Subscription, error) {
-	subs, err := ctx.Clients.OLM.OperatorsV1alpha1().Subscriptions(OperatorsNamespace).Create(context.Background(), Subscription(name, startingCSV), metav1.CreateOptions{})
+func CreateSubscription(ctx *Context, name, channel string) (*operatorsv1alpha1.Subscription, error) {
+	ctx.T.Logf("Creating subscription %s with channel %s", name, channel)
+
+	subs, err := ctx.Clients.OLM.OperatorsV1alpha1().Subscriptions(OperatorsNamespace).Create(context.Background(), Subscription(name, channel), metav1.CreateOptions{})
 	if err != nil {
 		return nil, err
 	}
diff --git a/test/upgrade/installation/serverless.go b/test/upgrade/installation/serverless.go
index 582f03559b..97b5e61126 100644
--- a/test/upgrade/installation/serverless.go
+++ b/test/upgrade/installation/serverless.go
@@ -3,60 +3,28 @@ package installation
 import (
 	"context"
 	_ "embed"
-	"errors"
 	"fmt"
 	"os/exec"
 	"strings"
-	"time"
 
-	"github.com/openshift-knative/serverless-operator/openshift-knative-operator/pkg/common"
-	"github.com/openshift-knative/serverless-operator/test"
-	"github.com/openshift-knative/serverless-operator/test/v1alpha1"
-	"github.com/openshift-knative/serverless-operator/test/v1beta1"
 	apiextensionsv1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/util/wait"
 	"k8s.io/client-go/util/retry"
-)
 
-const (
-	DefaultInstallPlanTimeout = 15 * time.Minute
+	"github.com/openshift-knative/serverless-operator/openshift-knative-operator/pkg/common"
+	"github.com/openshift-knative/serverless-operator/test"
+	"github.com/openshift-knative/serverless-operator/test/v1alpha1"
+	"github.com/openshift-knative/serverless-operator/test/v1beta1"
 )
 
 //go:embed downgrade.sh
 var downgradeContractScript string
 
-func UpgradeServerlessTo(ctx *test.Context, csv, source string, timeout time.Duration) error {
+func UpgradeServerlessTo(ctx *test.Context, source string) error {
 	if _, err := test.UpdateSubscriptionChannelSource(ctx, test.Flags.Subscription, test.Flags.UpgradeChannel, source); err != nil {
 		return err
 	}
 
-	installPlan, err := test.WaitForInstallPlan(ctx, test.OperatorsNamespace, csv, source, timeout)
-	if err != nil {
-		if !errors.Is(err, wait.ErrWaitTimeout) {
-			return err
-		}
-		if source != test.ServerlessOperatorPackage {
-			// InstallPlan not found in the original catalog source, try the one that was just built.
-			if _, err := test.UpdateSubscriptionChannelSource(ctx,
-				test.Flags.Subscription, test.Flags.UpgradeChannel, test.ServerlessOperatorPackage); err != nil {
-				return err
-			}
-			installPlan, err = test.WaitForInstallPlan(ctx,
-				test.OperatorsNamespace, csv, test.ServerlessOperatorPackage, timeout)
-		}
-		if err != nil {
-			return err
-		}
-	}
-
-	if err := test.ApproveInstallPlan(ctx, installPlan.Name); err != nil {
-		return err
-	}
-	if _, err := test.WaitForClusterServiceVersionState(ctx, csv, test.OperatorsNamespace, test.IsCSVSucceeded); err != nil {
-		return err
-	}
-
 	servingInStateFunc := v1beta1.IsKnativeServingWithVersionReady(strings.TrimPrefix(test.Flags.ServingVersion, "v"))
 	if len(test.Flags.ServingVersion) == 0 {
 		servingInStateFunc = v1beta1.IsKnativeServingReady
@@ -99,18 +67,23 @@ func UpgradeServerlessTo(ctx *test.Context, csv, source string, timeout time.Dur
 }
 
 func UpgradeServerless(ctx *test.Context) error {
-	return UpgradeServerlessTo(ctx, test.Flags.CSV, test.Flags.CatalogSource, DefaultInstallPlanTimeout)
+	return UpgradeServerlessTo(ctx, test.Flags.CatalogSource)
 }
 
 func DowngradeServerless(ctx *test.Context) error {
 	const subscription = "serverless-operator"
 	crds := []string{"knativeservings.operator.knative.dev", "knativeeventings.operator.knative.dev"}
 
+	sub, err := test.GetSubscription(ctx, subscription, test.OperatorsNamespace)
+	if err != nil {
+		return err
+	}
+
 	if err := test.DeleteSubscription(ctx, subscription, test.OperatorsNamespace); err != nil {
 		return err
 	}
 
-	if err := test.DeleteClusterServiceVersion(ctx, test.Flags.CSV, test.OperatorsNamespace); err != nil {
+	if err := test.DeleteClusterServiceVersion(ctx, sub.Status.InstalledCSV, test.OperatorsNamespace); err != nil {
 		return err
 	}
 
@@ -158,16 +131,7 @@ func DowngradeServerless(ctx *test.Context) error {
 		return err
 	}
 
-	if _, err := test.CreateSubscription(ctx, subscription, test.Flags.CSVPrevious); err != nil {
-		return err
-	}
-
-	installPlan, err := test.WaitForInstallPlan(ctx, test.OperatorsNamespace, test.Flags.CSVPrevious, test.Flags.CatalogSource, DefaultInstallPlanTimeout)
-	if err != nil {
-		return err
-	}
-
-	if err := test.ApproveInstallPlan(ctx, installPlan.Name); err != nil {
+	if _, err := test.CreateSubscription(ctx, subscription, test.Flags.Channel); err != nil {
 		return err
 	}
 
diff --git a/test/upgrade/kitchensink/kitchensink_test.go b/test/upgrade/kitchensink/kitchensink_test.go
index 6d91719035..ca34931c3d 100644
--- a/test/upgrade/kitchensink/kitchensink_test.go
+++ b/test/upgrade/kitchensink/kitchensink_test.go
@@ -28,16 +28,17 @@ import (
 	"testing"
 	"time"
 
-	"github.com/openshift-knative/serverless-operator/test"
-	"github.com/openshift-knative/serverless-operator/test/kitchensinke2e/features"
-	"github.com/openshift-knative/serverless-operator/test/upgrade"
-	"github.com/openshift-knative/serverless-operator/test/upgrade/installation"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	_ "knative.dev/pkg/system/testing"
 	pkgupgrade "knative.dev/pkg/test/upgrade"
 	"knative.dev/reconciler-test/pkg/environment"
 	"knative.dev/reconciler-test/pkg/feature"
 
+	"github.com/openshift-knative/serverless-operator/test"
+	"github.com/openshift-knative/serverless-operator/test/kitchensinke2e/features"
+	"github.com/openshift-knative/serverless-operator/test/upgrade"
+	"github.com/openshift-knative/serverless-operator/test/upgrade/installation"
+
 	// Make sure to initialize flags from knative.dev/pkg/test before parsing them.
 	pkgTest "knative.dev/pkg/test"
 )
@@ -137,7 +138,7 @@ func TestKitchensink(t *testing.T) {
 				Installations: pkgupgrade.Installations{
 					UpgradeWith: []pkgupgrade.Operation{
 						pkgupgrade.NewOperation("UpgradeServerless", func(c pkgupgrade.Context) {
-							if err := installation.UpgradeServerlessTo(ctx, csv, "redhat-operators", 3*time.Minute); err != nil {
+							if err := installation.UpgradeServerlessTo(ctx, "redhat-operators"); err != nil {
 								c.T.Error("Serverless upgrade failed:", err)
 							}
 						}),
diff --git a/test/upgrade/upgrade_test.go b/test/upgrade/upgrade_test.go
index 9a90030ddd..8fdbdf5e1c 100644
--- a/test/upgrade/upgrade_test.go
+++ b/test/upgrade/upgrade_test.go
@@ -42,15 +42,16 @@ import (
 	pkgupgrade "knative.dev/pkg/test/upgrade"
 	servingupgrade "knative.dev/serving/test/upgrade"
 
-	"github.com/openshift-knative/serverless-operator/test"
-	kafkafeatures "github.com/openshift-knative/serverless-operator/test/extensione2erekt/features"
-	"github.com/openshift-knative/serverless-operator/test/upgrade"
-	"github.com/openshift-knative/serverless-operator/test/upgrade/installation"
 	"knative.dev/eventing-kafka-broker/test/rekt/features"
 	"knative.dev/reconciler-test/pkg/environment"
 	"knative.dev/reconciler-test/pkg/k8s"
 	"knative.dev/reconciler-test/pkg/knative"
 	"knative.dev/reconciler-test/pkg/manifest"
+
+	"github.com/openshift-knative/serverless-operator/test"
+	kafkafeatures "github.com/openshift-knative/serverless-operator/test/extensione2erekt/features"
+	"github.com/openshift-knative/serverless-operator/test/upgrade"
+	"github.com/openshift-knative/serverless-operator/test/upgrade/installation"
 )
 
 var global environment.GlobalEnvironment
@@ -104,6 +105,11 @@ func TestClusterUpgrade(t *testing.T) {
 	if !test.Flags.UpgradeOpenShift {
 		t.Skip("Cluster upgrade tests disabled unless enabled by a flag.")
 	}
+
+	if err := installation.UpgradeServerlessTo(ctx, test.Flags.UpgradeChannel); err != nil {
+		t.Fatalf("Failed to upgrade Serverless to %s: %v", test.Flags.UpgradeChannel, err)
+	}
+
 	suite := pkgupgrade.Suite{
 		Tests: pkgupgrade.Tests{
 			PreUpgrade:  preUpgradeTests(),