Repository: kedacore/keda

Issue:
Add support for an annotation to pause scale down on Scale Objects
### Proposal

We would like to add support for an annotation to ScaleObjects that tells KEDA to pause Scale Down both in the HPA and in its internal Scale loop. 

Today, to disable scale down, one has to change the ScaledObject's HPA behavior to do so and that has the effect of only disabling scale down with the HPA Algorithm; scale to zero when KEDA determines a scaler is in-active is still allowed.

This annotation will not only tell the ScaledObject reconciler to set the Scale Down Select policy on HPAs to Disabled, it will also prevent the RequestScale method from scaling down a scale target when the annotation is set.

### Use-Case

We want to be able to pause scale down while still allowing scale up as an operational feature.

### Is this a feature you are interested in implementing yourself?

Yes

### Anything else?

_No response_

Discussion:
@SpiritZhou: I'm not sure this property is necessary, since preventing scaling down can also be handled by a modifier. Maybe pausing scaling for a certain period would be more practical?  WDYT @kedacore/keda-core-contributors @aliaqel-stripe: The [docs](https://keda.sh/docs/2.17/concepts/scaling-deployments/#scaling-modifiers) aren't clear how a modifier would pause scale-down. Further, the situations in which we would use this annotation would be ones where we don't know how long we need to pause scale down, for example, metrics provider outages. This annotation gives users a quick way of pausing scale down without modifying Scaled Object configuration (well, aside from the annotation)@zroubalik: In general this could work, we just need to make sure to have consistency between this annotation and a setting in the HPA behavior section (one would tell us to stop scale down the other would say the opposite). Let's think about the best UX here.@aliaqel-stripe: Yea, I can make it clear in the documentation that this annotation is for operational purposes only and overrides whatever is in the behavior portion (as it also pauses scale down by the scale loop)

Solution patch:
diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS
index 71cabf0d0..6053a89d5 100644
--- a/.github/CODEOWNERS
+++ b/.github/CODEOWNERS
@@ -1,3 +1,3 @@
 # These owners will be the default owners for everything in
 # the repo. Unless a later match takes precedence
-*       @kedacore/keda-core-contributors
+*       @kedacore/keda-core-maintainers
diff --git a/.github/cherry-pick-bot.yml b/.github/cherry-pick-bot.yml
deleted file mode 100644
index 1f62315d7..000000000
--- a/.github/cherry-pick-bot.yml
+++ /dev/null
@@ -1,2 +0,0 @@
-enabled: true
-preservePullRequestTitle: true
diff --git a/.github/reviewers.yml b/.github/reviewers.yml
new file mode 100644
index 000000000..0e06eb76c
--- /dev/null
+++ b/.github/reviewers.yml
@@ -0,0 +1,8 @@
+# https://github.com/marketplace/actions/auto-assign-reviewer-by-files
+"**/*":
+  - team: keda-core-contributors
+  - team: keda-core-maintainers
+
+# Any datadog file in pkg or tests folder
+"+(pkg|tests)/**/datadog*.go":
+  - arapulido
diff --git a/.github/workflows/pr-notify.yml b/.github/workflows/pr-notify.yml
new file mode 100644
index 000000000..cb773260f
--- /dev/null
+++ b/.github/workflows/pr-notify.yml
@@ -0,0 +1,12 @@
+name: Auto Assign
+on:
+  - pull_request_target
+
+jobs:
+  assign_reviewer:
+    runs-on: ARM64
+    steps:
+      - uses: shufo/auto-assign-reviewer-by-files@0a7fae44d02e841755d0caaac2ef05ad12a3bbc9 # v1.2.1
+        with:
+          config: ".github/reviewers.yml"
+          token: ${{ secrets.GH_AUTOMATION_PAT }}
diff --git a/CHANGELOG.md b/CHANGELOG.md
index f3a3f203e..8d184b6fa 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -64,6 +64,7 @@ To learn more about active deprecations, we recommend checking [GitHub Discussio
 ### New
 
 - **General**: Add error and event for mismatching input property ([#6721](https://github.com/kedacore/keda/issues/6721))
+- **General**: Add support for pause scale in annotation ([#6902](https://github.com/kedacore/keda/issues/6902))
 - **General**: Enable support on s390x for KEDA ([#6543](https://github.com/kedacore/keda/issues/6543))
 - **General**: Introduce new Solace Direct Messaging scaler ([#6545](https://github.com/kedacore/keda/issues/6545))
 - **General**: Introduce new Sumo Logic Scaler ([#6734](https://github.com/kedacore/keda/issues/6734))
@@ -75,14 +76,18 @@ To learn more about active deprecations, we recommend checking [GitHub Discussio
 ### Improvements
 
 - **General**: Allow excluding labels from being propagated from ScaledObject and ScaledJob to generated HPA and Job objects ([#6849](https://github.com/kedacore/keda/issues/6849))
+- **General**: chore: only add webhook DNS names when webhook patching is enabled ([#7002](https://github.com/kedacore/keda/issues/7002))
 - **General**: Improve Events emitted from ScaledObject controller ([#6802](https://github.com/kedacore/keda/issues/6802))
-- **Datadog Scaler**: Fix bug with datadogNamespace config ([#6828](https://github.com/kedacore/keda/pull/6828))
+- **Datadog Scaler**: Add a specific timeout configuration parameter for the Datadog trigger ([#6999](https://github.com/kedacore/keda/pull/6999))
+- **Datadog Scaler**: Improve Datadog scaler error messages ([#6999](https://github.com/kedacore/keda/pull/6999))
 - **Metrics API**: Support multiple auth methods simultaneously in Metrics API scaler ([#6642](https://github.com/kedacore/keda/issues/6642))
 - **Temporal Scaler**: Support custom tlsServerName ([#6820](https://github.com/kedacore/keda/pull/6820))
 
 ### Fixes
 
 - **General**: Add missing omitempty json tags in the AuthPodIdentity struct ([#6779](https://github.com/kedacore/keda/issues/6779))
+- **General**: Correct pending pod condition logic for ScaledJobs ([#6727](https://github.com/kedacore/keda/issues/6727))
+- **General**: Fix parse timeout config as milliseconds instead of seconds ([#6997](https://github.com/kedacore/keda/pull/6997))
 - **General**: Fix prefixes on envFrom elements in a deployment spec aren't being interpreted and Environment variables are not prefixed with the prefix ([#6728](https://github.com/kedacore/keda/issues/6728))
 - **General**: Remove klogr dependency and replace with zap ([#5732](https://github.com/kedacore/keda/issues/5732))
 - **General**: Sets hpaName in Status when ScaledObject adopts/finds an existing HPA ([#6336](https://github.com/kedacore/keda/issues/6336))
diff --git a/apis/eventing/v1alpha1/zz_generated.deepcopy.go b/apis/eventing/v1alpha1/zz_generated.deepcopy.go
index 114764d49..e40d3451c 100644
--- a/apis/eventing/v1alpha1/zz_generated.deepcopy.go
+++ b/apis/eventing/v1alpha1/zz_generated.deepcopy.go
@@ -82,6 +82,21 @@ func (in *CloudEventSource) DeepCopyObject() runtime.Object {
 	return nil
 }
 
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *CloudEventSourceCustomValidator) DeepCopyInto(out *CloudEventSourceCustomValidator) {
+	*out = *in
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new CloudEventSourceCustomValidator.
+func (in *CloudEventSourceCustomValidator) DeepCopy() *CloudEventSourceCustomValidator {
+	if in == nil {
+		return nil
+	}
+	out := new(CloudEventSourceCustomValidator)
+	in.DeepCopyInto(out)
+	return out
+}
+
 // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
 func (in *CloudEventSourceList) DeepCopyInto(out *CloudEventSourceList) {
 	*out = *in
@@ -183,6 +198,21 @@ func (in *ClusterCloudEventSource) DeepCopyObject() runtime.Object {
 	return nil
 }
 
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *ClusterCloudEventSourceCustomValidator) DeepCopyInto(out *ClusterCloudEventSourceCustomValidator) {
+	*out = *in
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterCloudEventSourceCustomValidator.
+func (in *ClusterCloudEventSourceCustomValidator) DeepCopy() *ClusterCloudEventSourceCustomValidator {
+	if in == nil {
+		return nil
+	}
+	out := new(ClusterCloudEventSourceCustomValidator)
+	in.DeepCopyInto(out)
+	return out
+}
+
 // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
 func (in *ClusterCloudEventSourceList) DeepCopyInto(out *ClusterCloudEventSourceList) {
 	*out = *in
diff --git a/apis/keda/v1alpha1/scaledobject_types.go b/apis/keda/v1alpha1/scaledobject_types.go
index a23d6e5e2..60ef01f72 100644
--- a/apis/keda/v1alpha1/scaledobject_types.go
+++ b/apis/keda/v1alpha1/scaledobject_types.go
@@ -57,6 +57,7 @@ const ScaledObjectExcludedLabelsAnnotation = "scaledobject.keda.sh/hpa-excluded-
 const ValidationsHpaOwnershipAnnotation = "validations.keda.sh/hpa-ownership"
 const PausedReplicasAnnotation = "autoscaling.keda.sh/paused-replicas"
 const PausedAnnotation = "autoscaling.keda.sh/paused"
+const PausedScaleInAnnotation = "autoscaling.keda.sh/paused-scale-in"
 const FallbackBehaviorStatic = "static"
 const FallbackBehaviorCurrentReplicas = "currentReplicas"
 const FallbackBehaviorCurrentReplicasIfHigher = "currentReplicasIfHigher"
@@ -230,16 +231,25 @@ func (so *ScaledObject) NeedToBePausedByAnnotation() bool {
 		return so.Status.PausedReplicaCount != nil
 	}
 
-	pausedAnnotationValue, pausedAnnotationFound := so.GetAnnotations()[PausedAnnotation]
-	if !pausedAnnotationFound {
+	return getBoolAnnotation(so, PausedAnnotation)
+}
+
+// NeedToPauseScaleIn checks whether Scale In actions for a ScaledObject need to be blocked based on the PausedScaleIn annotation
+func (so *ScaledObject) NeedToPauseScaleIn() bool {
+	return getBoolAnnotation(so, PausedScaleInAnnotation)
+}
+
+func getBoolAnnotation(so *ScaledObject, annotation string) bool {
+	value, found := so.GetAnnotations()[annotation]
+	if !found {
 		return false
 	}
-	shouldPause, err := strconv.ParseBool(pausedAnnotationValue)
+	boolVal, err := strconv.ParseBool(value)
 	if err != nil {
-		// if annotation value is not a boolean, we assume user wants to pause the ScaledObject
+		// if annotation value is not a boolean, we assume true
 		return true
 	}
-	return shouldPause
+	return boolVal
 }
 
 // IsUsingModifiers determines whether scalingModifiers are defined or not
diff --git a/apis/keda/v1alpha1/zz_generated.deepcopy.go b/apis/keda/v1alpha1/zz_generated.deepcopy.go
index 5248166f0..866c18b5a 100755
--- a/apis/keda/v1alpha1/zz_generated.deepcopy.go
+++ b/apis/keda/v1alpha1/zz_generated.deepcopy.go
@@ -396,6 +396,21 @@ func (in *ClusterTriggerAuthentication) DeepCopyObject() runtime.Object {
 	return nil
 }
 
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *ClusterTriggerAuthenticationCustomValidator) DeepCopyInto(out *ClusterTriggerAuthenticationCustomValidator) {
+	*out = *in
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterTriggerAuthenticationCustomValidator.
+func (in *ClusterTriggerAuthenticationCustomValidator) DeepCopy() *ClusterTriggerAuthenticationCustomValidator {
+	if in == nil {
+		return nil
+	}
+	out := new(ClusterTriggerAuthenticationCustomValidator)
+	in.DeepCopyInto(out)
+	return out
+}
+
 // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
 func (in *ClusterTriggerAuthenticationList) DeepCopyInto(out *ClusterTriggerAuthenticationList) {
 	*out = *in
@@ -733,6 +748,21 @@ func (in *ScaledJob) DeepCopyObject() runtime.Object {
 	return nil
 }
 
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *ScaledJobCustomValidator) DeepCopyInto(out *ScaledJobCustomValidator) {
+	*out = *in
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ScaledJobCustomValidator.
+func (in *ScaledJobCustomValidator) DeepCopy() *ScaledJobCustomValidator {
+	if in == nil {
+		return nil
+	}
+	out := new(ScaledJobCustomValidator)
+	in.DeepCopyInto(out)
+	return out
+}
+
 // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
 func (in *ScaledJobList) DeepCopyInto(out *ScaledJobList) {
 	*out = *in
@@ -1142,6 +1172,21 @@ func (in *TriggerAuthentication) DeepCopyObject() runtime.Object {
 	return nil
 }
 
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *TriggerAuthenticationCustomValidator) DeepCopyInto(out *TriggerAuthenticationCustomValidator) {
+	*out = *in
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new TriggerAuthenticationCustomValidator.
+func (in *TriggerAuthenticationCustomValidator) DeepCopy() *TriggerAuthenticationCustomValidator {
+	if in == nil {
+		return nil
+	}
+	out := new(TriggerAuthenticationCustomValidator)
+	in.DeepCopyInto(out)
+	return out
+}
+
 // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
 func (in *TriggerAuthenticationList) DeepCopyInto(out *TriggerAuthenticationList) {
 	*out = *in
diff --git a/config/metrics-server/deployment.yaml b/config/metrics-server/deployment.yaml
index 161ce6ac5..af67dd12f 100644
--- a/config/metrics-server/deployment.yaml
+++ b/config/metrics-server/deployment.yaml
@@ -54,8 +54,9 @@ spec:
                   fieldPath: metadata.namespace
             - name: KEDA_HTTP_DEFAULT_TIMEOUT
               value: ""
+          command:
+            - /keda-adapter
           args:
-          - /usr/local/bin/keda-adapter
           - --secure-port=6443
           - --zap-log-level=error
           - --client-ca-file=/certs/ca.crt
diff --git a/controllers/keda/hpa.go b/controllers/keda/hpa.go
index 31cbad6a2..c519074d7 100644
--- a/controllers/keda/hpa.go
+++ b/controllers/keda/hpa.go
@@ -84,6 +84,28 @@ func (r *ScaledObjectReconciler) newHPAForScaledObject(ctx context.Context, logg
 		behavior = nil
 	}
 
+	if scaledObject.NeedToPauseScaleIn() {
+		// If the paused-scale-in annotation is set, set the HPA ScaleDown Select policy to Disabled
+		// to prevent the HPA from scaling down the scale target
+		if behavior == nil {
+			behavior = &autoscalingv2.HorizontalPodAutoscalerBehavior{}
+		}
+		if behavior.ScaleDown == nil {
+			behavior.ScaleDown = &autoscalingv2.HPAScalingRules{}
+		}
+
+		disabledPolicy := autoscalingv2.DisabledPolicySelect
+		behavior.ScaleDown.SelectPolicy = &disabledPolicy
+
+		logger.Info(
+			"Scale in paused by annotation, setting HPA Scale Down Select Behavior to Disabled",
+			"HPA.Namespace",
+			scaledObject.Namespace,
+			"HPA.Name",
+			getHPAName(scaledObject),
+		)
+	}
+
 	// label can have max 63 chars
 	labelName := getHPAName(scaledObject)
 	if len(labelName) > 63 {
diff --git a/controllers/keda/scaledobject_controller.go b/controllers/keda/scaledobject_controller.go
index b6b6d4486..ae908245f 100755
--- a/controllers/keda/scaledobject_controller.go
+++ b/controllers/keda/scaledobject_controller.go
@@ -131,6 +131,7 @@ func (r *ScaledObjectReconciler) SetupWithManager(mgr ctrl.Manager, options cont
 			predicate.Or(
 				kedacontrollerutil.PausedPredicate{},
 				kedacontrollerutil.PausedReplicasPredicate{},
+				kedacontrollerutil.PausedScaleInPredicate{},
 				kedacontrollerutil.ScaleObjectReadyConditionPredicate{},
 				predicate.GenerationChangedPredicate{},
 			),
@@ -226,10 +227,16 @@ func (r *ScaledObjectReconciler) Reconcile(ctx context.Context, req ctrl.Request
 
 // reconcileScaledObject implements reconciler logic for ScaledObject
 func (r *ScaledObjectReconciler) reconcileScaledObject(ctx context.Context, logger logr.Logger, scaledObject *kedav1alpha1.ScaledObject, conditions *kedav1alpha1.Conditions) (string, error) {
-	// Check the presence of "autoscaling.keda.sh/paused" annotation on the scaledObject (since the presence of this annotation will pause
-	// autoscaling no matter what number of replicas is provided), and if so, stop the scale loop and delete the HPA on the scaled object.
+	// Check the presence of  the following annotations on the scaledObject:
+	// - "autoscaling.keda.sh/paused"
+	// - "autoscaling.keda.sh/paused-replicas"
+	// and if so, stop the scale loop and delete the HPA on the scaledObject.
+	// Additionally, if the following annotations are present:
+	// - "autoscaling.keda.sh/paused-scale-in"
+	// we also set the status to paused but we allow the scale loop to continue and do not delete the HPA because these are unidirectional pauses.
 	needsToPause := scaledObject.NeedToBePausedByAnnotation()
-	if needsToPause {
+	switch {
+	case needsToPause:
 		scaledToPausedCount := true
 		if conditions.GetPausedCondition().Status == metav1.ConditionTrue {
 			// If scaledobject is in paused condition but replica count is not equal to paused replica count, the following scaling logic needs to be trigger again.
@@ -251,7 +258,9 @@ func (r *ScaledObjectReconciler) reconcileScaledObject(ctx context.Context, logg
 			conditions.SetPausedCondition(metav1.ConditionTrue, kedav1alpha1.ScaledObjectConditionPausedReason, msg)
 			return msg, nil
 		}
-	} else if conditions.GetPausedCondition().Status == metav1.ConditionTrue {
+	case scaledObject.NeedToPauseScaleIn():
+		conditions.SetPausedCondition(metav1.ConditionTrue, kedav1alpha1.ScaledObjectConditionPausedReason, kedav1alpha1.ScaledObjectConditionPausedMessage)
+	case conditions.GetPausedCondition().Status == metav1.ConditionTrue:
 		conditions.SetPausedCondition(metav1.ConditionFalse, "ScaledObjectUnpaused", "pause annotation removed for ScaledObject")
 	}
 
diff --git a/controllers/keda/util/predicate.go b/controllers/keda/util/predicate.go
index 1ecc114d3..e04a464d6 100644
--- a/controllers/keda/util/predicate.go
+++ b/controllers/keda/util/predicate.go
@@ -14,25 +14,7 @@ type PausedReplicasPredicate struct {
 }
 
 func (PausedReplicasPredicate) Update(e event.UpdateEvent) bool {
-	if e.ObjectOld == nil || e.ObjectNew == nil {
-		return false
-	}
-
-	newAnnotations := e.ObjectNew.GetAnnotations()
-	oldAnnotations := e.ObjectOld.GetAnnotations()
-
-	newPausedValue := ""
-	oldPausedValue := ""
-
-	if newAnnotations != nil {
-		newPausedValue = newAnnotations[kedav1alpha1.PausedReplicasAnnotation]
-	}
-
-	if oldAnnotations != nil {
-		oldPausedValue = oldAnnotations[kedav1alpha1.PausedReplicasAnnotation]
-	}
-
-	return newPausedValue != oldPausedValue
+	return checkAnnotation(e, kedav1alpha1.PausedReplicasAnnotation)
 }
 
 type ScaleObjectReadyConditionPredicate struct {
@@ -71,6 +53,18 @@ type PausedPredicate struct {
 }
 
 func (PausedPredicate) Update(e event.UpdateEvent) bool {
+	return checkAnnotation(e, kedav1alpha1.PausedAnnotation)
+}
+
+type PausedScaleInPredicate struct {
+	predicate.Funcs
+}
+
+func (PausedScaleInPredicate) Update(e event.UpdateEvent) bool {
+	return checkAnnotation(e, kedav1alpha1.PausedScaleInAnnotation)
+}
+
+func checkAnnotation(e event.UpdateEvent, annotation string) bool {
 	if e.ObjectOld == nil || e.ObjectNew == nil {
 		return false
 	}
@@ -78,18 +72,18 @@ func (PausedPredicate) Update(e event.UpdateEvent) bool {
 	newAnnotations := e.ObjectNew.GetAnnotations()
 	oldAnnotations := e.ObjectOld.GetAnnotations()
 
-	newPausedValue := ""
-	oldPausedValue := ""
+	newValue := ""
+	oldValue := ""
 
 	if newAnnotations != nil {
-		newPausedValue = newAnnotations[kedav1alpha1.PausedAnnotation]
+		newValue = newAnnotations[annotation]
 	}
 
 	if oldAnnotations != nil {
-		oldPausedValue = oldAnnotations[kedav1alpha1.PausedAnnotation]
+		oldValue = oldAnnotations[annotation]
 	}
 
-	return newPausedValue != oldPausedValue
+	return newValue != oldValue
 }
 
 type HPASpecChangedPredicate struct {
diff --git a/pkg/certificates/certificate_manager.go b/pkg/certificates/certificate_manager.go
index 5f8f9630f..9e9e7adb3 100644
--- a/pkg/certificates/certificate_manager.go
+++ b/pkg/certificates/certificate_manager.go
@@ -79,8 +79,10 @@ func (cm CertManager) AddCertificateRotation(ctx context.Context, mgr manager.Ma
 	}
 	var extraDNSNames []string
 	extraDNSNames = append(extraDNSNames, getDNSNames(cm.OperatorService, cm.K8sClusterDomain)...)
-	extraDNSNames = append(extraDNSNames, getDNSNames(cm.WebhookService, cm.K8sClusterDomain)...)
 	extraDNSNames = append(extraDNSNames, getDNSNames(cm.MetricsServerService, cm.K8sClusterDomain)...)
+	if cm.EnableWebhookPatching {
+		extraDNSNames = append(extraDNSNames, getDNSNames(cm.WebhookService, cm.K8sClusterDomain)...)
+	}
 
 	cm.Logger.V(1).Info("setting up cert rotation")
 	err = rotator.AddRotator(mgr, &rotator.CertRotator{
diff --git a/pkg/scalers/datadog_scaler.go b/pkg/scalers/datadog_scaler.go
index d04098a67..09aff651c 100644
--- a/pkg/scalers/datadog_scaler.go
+++ b/pkg/scalers/datadog_scaler.go
@@ -2,8 +2,10 @@ package scalers
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"io"
+	"net"
 	"net/http"
 	"regexp"
 	"slices"
@@ -21,6 +23,7 @@ import (
 	"github.com/kedacore/keda/v2/pkg/scalers/authentication"
 	"github.com/kedacore/keda/v2/pkg/scalers/scalersconfig"
 	kedautil "github.com/kedacore/keda/v2/pkg/util"
+	"github.com/kedacore/keda/v2/version"
 )
 
 type datadogScaler struct {
@@ -68,7 +71,8 @@ type datadogMetadata struct {
 	HpaMetricName string  `keda:"name=hpaMetricName,          order=triggerMetadata, optional"`
 	FillValue     float64 `keda:"name=metricUnavailableValue, order=triggerMetadata, default=0"`
 	UseFiller     bool
-	TargetValue   float64 `keda:"name=targetValue;queryValue, order=triggerMetadata, default=-1"`
+	TargetValue   float64       `keda:"name=targetValue;queryValue, order=triggerMetadata, default=-1"`
+	Timeout       time.Duration `keda:"name=timeout,             	order=triggerMetadata, optional"`
 	vType         v2.MetricTargetType
 }
 
@@ -81,7 +85,7 @@ func init() {
 }
 
 // NewDatadogScaler creates a new Datadog scaler
-func NewDatadogScaler(ctx context.Context, config *scalersconfig.ScalerConfig) (Scaler, error) {
+func NewDatadogScaler(config *scalersconfig.ScalerConfig) (Scaler, error) {
 	metricType, err := GetMetricTargetType(config)
 	if err != nil {
 		return nil, fmt.Errorf("error getting scaler metric type: %w", err)
@@ -105,16 +109,13 @@ func NewDatadogScaler(ctx context.Context, config *scalersconfig.ScalerConfig) (
 		if err != nil {
 			return nil, fmt.Errorf("error parsing Datadog metadata: %w", err)
 		}
-		httpClient = kedautil.CreateHTTPClient(config.GlobalHTTPTimeout, meta.UnsafeSsl)
+		httpClient = kedautil.CreateHTTPClient(meta.Timeout, meta.UnsafeSsl)
 	} else {
 		meta, err = parseDatadogAPIMetadata(config, logger)
 		if err != nil {
 			return nil, fmt.Errorf("error parsing Datadog metadata: %w", err)
 		}
-		apiClient, err = newDatadogAPIConnection(ctx, meta, config)
-		if err != nil {
-			return nil, fmt.Errorf("error establishing Datadog connection: %w", err)
-		}
+		apiClient = newDatadogAPIClient(meta)
 	}
 
 	return &datadogScaler{
@@ -169,6 +170,11 @@ func parseDatadogAPIMetadata(config *scalersconfig.ScalerConfig, logger logr.Log
 			return nil, fmt.Errorf("no targetValue or queryValue given")
 		}
 	}
+
+	if meta.Timeout == 0 {
+		meta.Timeout = config.GlobalHTTPTimeout
+	}
+
 	if val, ok := config.TriggerMetadata["type"]; ok {
 		logger.V(0).Info("trigger.metadata.type is deprecated in favor of trigger.metricType")
 		if config.MetricType != "" {
@@ -229,6 +235,11 @@ func parseDatadogClusterAgentMetadata(config *scalersconfig.ScalerConfig, logger
 			return nil, fmt.Errorf("no targetValue or queryValue given")
 		}
 	}
+
+	if meta.Timeout == 0 {
+		meta.Timeout = config.GlobalHTTPTimeout
+	}
+
 	if val, ok := config.TriggerMetadata["type"]; ok {
 		logger.V(0).Info("trigger.metadata.type is deprecated in favor of trigger.metricType")
 		if config.MetricType != "" {
@@ -257,37 +268,13 @@ func parseDatadogClusterAgentMetadata(config *scalersconfig.ScalerConfig, logger
 	return meta, nil
 }
 
-// newDatadogAPIConnection tests a connection to the Datadog API
-func newDatadogAPIConnection(ctx context.Context, meta *datadogMetadata, config *scalersconfig.ScalerConfig) (*datadog.APIClient, error) {
-	ctx = context.WithValue(
-		ctx,
-		datadog.ContextAPIKeys,
-		map[string]datadog.APIKey{
-			"apiKeyAuth": {
-				Key: meta.APIKey,
-			},
-			"appKeyAuth": {
-				Key: meta.AppKey,
-			},
-		},
-	)
-
-	ctx = context.WithValue(ctx,
-		datadog.ContextServerVariables,
-		map[string]string{
-			"site": meta.DatadogSite,
-		})
-
+func newDatadogAPIClient(s *datadogMetadata) *datadog.APIClient {
 	configuration := datadog.NewConfiguration()
-	configuration.HTTPClient = kedautil.CreateHTTPClient(config.GlobalHTTPTimeout, false)
+	configuration.UserAgent = fmt.Sprintf("%s - KEDA/%s", configuration.UserAgent, version.Version)
+	configuration.HTTPClient = kedautil.CreateHTTPClient(s.Timeout, false)
 	apiClient := datadog.NewAPIClient(configuration)
 
-	_, _, err := apiClient.AuthenticationApi.Validate(ctx) //nolint:bodyclose
-	if err != nil {
-		return nil, fmt.Errorf("error connecting to Datadog API endpoint: %w", err)
-	}
-
-	return apiClient, nil
+	return apiClient
 }
 
 // No need to close connections
@@ -321,9 +308,17 @@ func (s *datadogScaler) getQueryResult(ctx context.Context) (float64, error) {
 
 	timeWindowTo := time.Now().Unix() - int64(s.metadata.TimeWindowOffset)
 	timeWindowFrom := timeWindowTo - int64(s.metadata.Age)
+
+	httpClientTimeout := s.apiClient.GetConfig().HTTPClient.Timeout
+	startTime := time.Now()
 	resp, r, err := s.apiClient.MetricsApi.QueryMetrics(ctx, timeWindowFrom, timeWindowTo, s.metadata.Query) //nolint:bodyclose
+	elapsed := time.Since(startTime)
 
 	if r != nil {
+		if r.StatusCode == 403 {
+			return -1, fmt.Errorf("unauthorized to connect to Datadog. Check that your Datadog API and App keys are correct and that your App key has the correct permissions: %w", err)
+		}
+
 		if r.StatusCode == 429 {
 			rateLimit := r.Header.Get("X-Ratelimit-Limit")
 			rateLimitReset := r.Header.Get("X-Ratelimit-Reset")
@@ -341,6 +336,22 @@ func (s *datadogScaler) getQueryResult(ctx context.Context) (float64, error) {
 	}
 
 	if err != nil {
+		// Check for general network timeouts
+		if nerr, ok := err.(net.Error); ok && nerr.Timeout() {
+			if httpClientTimeout > 0 {
+				return -1, fmt.Errorf("KEDA reached a network timeout while retrieving Datadog metrics (HTTP client timeout: %s, request took: %s: %w)", httpClientTimeout, elapsed, err)
+			}
+			return -1, fmt.Errorf("KEDA reached a network timeout while retrieving Datadog metrics (request took: %s: %w)", elapsed, err)
+		}
+
+		if errors.Is(err, context.DeadlineExceeded) {
+			if deadline, ok := ctx.Deadline(); ok {
+				now := time.Now()
+				exceeded := now.Sub(deadline)
+				return -1, fmt.Errorf("KEDA reached a context deadline while retrieving Datadog metrics (deadline was: %v, exceeded by: %v: %w)", deadline.Format(time.RFC3339), exceeded, err)
+			}
+			return -1, fmt.Errorf("KEDA reached a context deadline while retrieving Datadog metrics: %w", err)
+		}
 		return -1, fmt.Errorf("error when retrieving Datadog metrics: %w", err)
 	}
 
diff --git a/pkg/scalers/openstack_metrics_scaler.go b/pkg/scalers/openstack_metrics_scaler.go
index b17ddaae0..c1e6e9e17 100644
--- a/pkg/scalers/openstack_metrics_scaler.go
+++ b/pkg/scalers/openstack_metrics_scaler.go
@@ -28,14 +28,15 @@ const (
 /* expected structure declarations */
 
 type openstackMetricMetadata struct {
-	metricsURL          string
-	metricID            string
-	aggregationMethod   string
-	granularity         int
-	threshold           float64
-	activationThreshold float64
-	timeout             int
-	triggerIndex        int
+	MetricsURL          string  `keda:"name=metricsURL,          order=triggerMetadata"`
+	MetricID            string  `keda:"name=metricID,            order=triggerMetadata"`
+	AggregationMethod   string  `keda:"name=aggregationMethod,   order=triggerMetadata"`
+	Granularity         int     `keda:"name=granularity,         order=triggerMetadata"`
+	Threshold           float64 `keda:"name=threshold,           order=triggerMetadata, optional"`
+	ActivationThreshold float64 `keda:"name=activationThreshold, order=triggerMetadata, optional"`
+	Timeout             int     `keda:"name=timeout,             order=triggerMetadata, default=30"`
+
+	triggerIndex int
 }
 
 type openstackMetricAuthenticationMetadata struct {
@@ -59,7 +60,7 @@ type measureResult struct {
 
 /*  end of declarations */
 
-// NewOpenstackMetricScaler creates new openstack metrics scaler instance
+// NewOpenstackMetricScaler creates a new openstack metrics scaler instance
 func NewOpenstackMetricScaler(ctx context.Context, config *scalersconfig.ScalerConfig) (Scaler, error) {
 	var keystoneAuth *openstack.KeystoneAuthRequest
 	var metricsClient openstack.Client
@@ -71,7 +72,7 @@ func NewOpenstackMetricScaler(ctx context.Context, config *scalersconfig.ScalerC
 
 	logger := InitializeLogger(config, "openstack_metric_scaler")
 
-	openstackMetricMetadata, err := parseOpenstackMetricMetadata(config, logger)
+	openstackMetricMetadata, err := parseOpenstackMetricMetadata(config)
 
 	if err != nil {
 		return nil, fmt.Errorf("error parsing openstack Metric metadata: %w", err)
@@ -83,17 +84,15 @@ func NewOpenstackMetricScaler(ctx context.Context, config *scalersconfig.ScalerC
 		return nil, fmt.Errorf("error parsing openstack metric authentication metadata: %w", err)
 	}
 
-	// User choose the "application_credentials" authentication method
 	if authMetadata.appCredentialSecretID != "" {
-		keystoneAuth, err = openstack.NewAppCredentialsAuth(authMetadata.authURL, authMetadata.appCredentialSecretID, authMetadata.appCredentialSecret, openstackMetricMetadata.timeout)
+		keystoneAuth, err = openstack.NewAppCredentialsAuth(authMetadata.authURL, authMetadata.appCredentialSecretID, authMetadata.appCredentialSecret, openstackMetricMetadata.Timeout)
 
 		if err != nil {
 			return nil, fmt.Errorf("error getting openstack credentials for application credentials method: %w", err)
 		}
 	} else {
-		// User choose the "password" authentication method
 		if authMetadata.userID != "" {
-			keystoneAuth, err = openstack.NewPasswordAuth(authMetadata.authURL, authMetadata.userID, authMetadata.password, "", openstackMetricMetadata.timeout)
+			keystoneAuth, err = openstack.NewPasswordAuth(authMetadata.authURL, authMetadata.userID, authMetadata.password, "", openstackMetricMetadata.Timeout)
 
 			if err != nil {
 				return nil, fmt.Errorf("error getting openstack credentials for password method: %w", err)
@@ -117,75 +116,13 @@ func NewOpenstackMetricScaler(ctx context.Context, config *scalersconfig.ScalerC
 	}, nil
 }
 
-func parseOpenstackMetricMetadata(config *scalersconfig.ScalerConfig, logger logr.Logger) (*openstackMetricMetadata, error) {
-	meta := openstackMetricMetadata{}
-	triggerMetadata := config.TriggerMetadata
-
-	if val, ok := triggerMetadata["metricsURL"]; ok && val != "" {
-		meta.metricsURL = val
-	} else {
-		logger.Error(fmt.Errorf("no metrics url could be read"), "Error reading metricsURL")
-		return nil, fmt.Errorf("no metrics url was declared")
-	}
-
-	if val, ok := triggerMetadata["metricID"]; ok && val != "" {
-		meta.metricID = val
-	} else {
-		logger.Error(fmt.Errorf("no metric id could be read"), "Error reading metricID")
-		return nil, fmt.Errorf("no metric id was declared")
-	}
-
-	if val, ok := triggerMetadata["aggregationMethod"]; ok && val != "" {
-		meta.aggregationMethod = val
-	} else {
-		logger.Error(fmt.Errorf("no aggregation method could be read"), "Error reading aggregation method")
-		return nil, fmt.Errorf("no aggregation method could be read")
+func parseOpenstackMetricMetadata(config *scalersconfig.ScalerConfig) (*openstackMetricMetadata, error) {
+	meta := &openstackMetricMetadata{triggerIndex: config.TriggerIndex}
+	if err := config.TypedConfig(meta); err != nil {
+		return nil, fmt.Errorf("error parsing openstack metric metadata: %w", err)
 	}
 
-	if val, ok := triggerMetadata["granularity"]; ok && val != "" {
-		granularity, err := strconv.Atoi(val)
-		if err != nil {
-			logger.Error(err, "Error converting granularity information %s", err.Error)
-			return nil, err
-		}
-		meta.granularity = granularity
-	} else {
-		return nil, fmt.Errorf("no granularity found")
-	}
-
-	if val, ok := triggerMetadata["threshold"]; ok && val != "" {
-		// converts the string to float64 but its value is convertible to float32 without changing
-		_threshold, err := strconv.ParseFloat(val, 32)
-		if err != nil {
-			logger.Error(err, "error parsing openstack metric metadata", "threshold", "threshold")
-			return nil, fmt.Errorf("error parsing openstack metric metadata : %w", err)
-		}
-
-		meta.threshold = _threshold
-	}
-
-	if val, ok := triggerMetadata["activationThreshold"]; ok && val != "" {
-		// converts the string to float64 but its value is convertible to float32 without changing
-		activationThreshold, err := strconv.ParseFloat(val, 32)
-		if err != nil {
-			logger.Error(err, "error parsing openstack metric metadata", "activationThreshold", "activationThreshold")
-			return nil, fmt.Errorf("error parsing openstack metric metadata : %w", err)
-		}
-
-		meta.activationThreshold = activationThreshold
-	}
-
-	if val, ok := triggerMetadata["timeout"]; ok && val != "" {
-		httpClientTimeout, err := strconv.Atoi(val)
-		if err != nil {
-			return nil, fmt.Errorf("httpClientTimeout parsing error: %w", err)
-		}
-		meta.timeout = httpClientTimeout
-	} else {
-		meta.timeout = metricDefaultHTTPClientTimeout
-	}
-	meta.triggerIndex = config.TriggerIndex
-	return &meta, nil
+	return meta, nil
 }
 
 func parseOpenstackMetricAuthenticationMetadata(config *scalersconfig.ScalerConfig) (openstackMetricAuthenticationMetadata, error) {
@@ -216,13 +153,13 @@ func parseOpenstackMetricAuthenticationMetadata(config *scalersconfig.ScalerConf
 }
 
 func (s *openstackMetricScaler) GetMetricSpecForScaling(context.Context) []v2.MetricSpec {
-	metricName := kedautil.NormalizeString(fmt.Sprintf("openstack-metric-%s", s.metadata.metricID))
+	metricName := kedautil.NormalizeString(fmt.Sprintf("openstack-metric-%s", s.metadata.MetricID))
 
 	externalMetric := &v2.ExternalMetricSource{
 		Metric: v2.MetricIdentifier{
 			Name: GenerateMetricNameWithIndex(s.metadata.triggerIndex, metricName),
 		},
-		Target: GetMetricTargetMili(s.metricType, s.metadata.threshold),
+		Target: GetMetricTargetMili(s.metricType, s.metadata.Threshold),
 	}
 
 	metricSpec := v2.MetricSpec{
@@ -243,7 +180,7 @@ func (s *openstackMetricScaler) GetMetricsAndActivity(ctx context.Context, metri
 
 	metric := GenerateMetricInMili(metricName, val)
 
-	return []external_metrics.ExternalMetricValue{metric}, val > s.metadata.activationThreshold, nil
+	return []external_metrics.ExternalMetricValue{metric}, val > s.metadata.ActivationThreshold, nil
 }
 
 func (s *openstackMetricScaler) Close(context.Context) error {
@@ -253,7 +190,7 @@ func (s *openstackMetricScaler) Close(context.Context) error {
 
 // Gets measurement from API as float64, converts it to int and return the value.
 func (s *openstackMetricScaler) readOpenstackMetrics(ctx context.Context) (float64, error) {
-	var metricURL = s.metadata.metricsURL
+	var metricURL = s.metadata.MetricsURL
 
 	isValid, validationError := s.metricClient.IsTokenValid(ctx)
 
@@ -279,21 +216,21 @@ func (s *openstackMetricScaler) readOpenstackMetrics(ctx context.Context) (float
 		return defaultValueWhenError, fmt.Errorf("metric url is invalid: %w", err)
 	}
 
-	openstackMetricsURL.Path = path.Join(openstackMetricsURL.Path, s.metadata.metricID+"/measures")
+	openstackMetricsURL.Path = path.Join(openstackMetricsURL.Path, s.metadata.MetricID+"/measures")
 	queryParameter := openstackMetricsURL.Query()
 	granularity := 0 // We start with granularity with value 2 cause gnocchi APIm which is used by openstack, consider a time window, and we want to get the last value
 
-	if s.metadata.granularity <= 0 {
+	if s.metadata.Granularity <= 0 {
 		s.logger.Error(fmt.Errorf("granularity value is less than 1"), "Minimum acceptable value expected for granularity is 1.")
 		return defaultValueWhenError, fmt.Errorf("granularity value is less than 1")
 	}
 
-	if (s.metadata.granularity / 60) > 0 {
-		granularity = (s.metadata.granularity / 60) - 1
+	if (s.metadata.Granularity / 60) > 0 {
+		granularity = (s.metadata.Granularity / 60) - 1
 	}
 
-	queryParameter.Set("granularity", strconv.Itoa(s.metadata.granularity))
-	queryParameter.Set("aggregation", s.metadata.aggregationMethod)
+	queryParameter.Set("granularity", strconv.Itoa(s.metadata.Granularity))
+	queryParameter.Set("aggregation", s.metadata.AggregationMethod)
 
 	var currTimeWithWindow string
 
@@ -316,7 +253,7 @@ func (s *openstackMetricScaler) readOpenstackMetrics(ctx context.Context) (float
 	resp, requestError := s.metricClient.HTTPClient.Do(openstackMetricRequest)
 
 	if requestError != nil {
-		s.logger.Error(requestError, "Unable to request Metrics from URL: %s.", s.metadata.metricsURL)
+		s.logger.Error(requestError, "Unable to request Metrics from URL: %s.", s.metadata.MetricsURL)
 		return defaultValueWhenError, requestError
 	}
 
@@ -325,7 +262,7 @@ func (s *openstackMetricScaler) readOpenstackMetrics(ctx context.Context) (float
 		bodyError, readError := io.ReadAll(resp.Body)
 
 		if readError != nil {
-			s.logger.Error(readError, "Request failed with code: %s for URL: %s", resp.StatusCode, s.metadata.metricsURL)
+			s.logger.Error(readError, "Request failed with code: %s for URL: %s", resp.StatusCode, s.metadata.MetricsURL)
 			return defaultValueWhenError, readError
 		}
 
diff --git a/pkg/scalers/prometheus_scaler.go b/pkg/scalers/prometheus_scaler.go
index b6e81c2d8..54a53540d 100644
--- a/pkg/scalers/prometheus_scaler.go
+++ b/pkg/scalers/prometheus_scaler.go
@@ -82,7 +82,7 @@ func NewPrometheusScaler(config *scalersconfig.ScalerConfig) (Scaler, error) {
 	// handle HTTP client timeout
 	httpClientTimeout := config.GlobalHTTPTimeout
 	if meta.Timeout > 0 {
-		httpClientTimeout = meta.Timeout * time.Millisecond
+		httpClientTimeout = meta.Timeout
 	}
 
 	httpClient := kedautil.CreateHTTPClient(httpClientTimeout, meta.UnsafeSSL)
diff --git a/pkg/scalers/rabbitmq_scaler.go b/pkg/scalers/rabbitmq_scaler.go
index 164d6104b..b9a5f5c75 100644
--- a/pkg/scalers/rabbitmq_scaler.go
+++ b/pkg/scalers/rabbitmq_scaler.go
@@ -259,7 +259,7 @@ func NewRabbitMQScaler(config *scalersconfig.ScalerConfig) (Scaler, error) {
 
 	timeout := config.GlobalHTTPTimeout
 	if s.metadata.Timeout != 0 {
-		timeout = s.metadata.Timeout * time.Millisecond
+		timeout = s.metadata.Timeout
 	}
 
 	s.httpClient = kedautil.CreateHTTPClient(timeout, meta.UnsafeSsl)
diff --git a/pkg/scalers/scalersconfig/typed_config.go b/pkg/scalers/scalersconfig/typed_config.go
index 80a4cbfa5..e38a717d9 100644
--- a/pkg/scalers/scalersconfig/typed_config.go
+++ b/pkg/scalers/scalersconfig/typed_config.go
@@ -418,15 +418,15 @@ func setConfigValueHelper(params Params, valFromConfig string, field reflect.Val
 			field.Set(reflect.ValueOf(duration))
 			return nil
 		}
-		// If that fails, interpret as number of seconds
-		seconds, err := strconv.ParseInt(valFromConfig, 10, 64)
+		// If that fails, interpret as number of milliseconds
+		milliseconds, err := strconv.ParseInt(valFromConfig, 10, 64)
 		if err != nil {
-			return fmt.Errorf("unable to parse duration value %q: must be either a duration string (e.g. '30s', '5m') or a number of seconds", valFromConfig)
+			return fmt.Errorf("unable to parse duration value %q: must be either a duration string (e.g. '30s', '5m') or a number of milliseconds", valFromConfig)
 		}
-		if seconds < 0 {
-			return fmt.Errorf("duration cannot be negative: %d seconds", seconds)
+		if milliseconds < 0 {
+			return fmt.Errorf("duration cannot be negative: %d milliseconds", milliseconds)
 		}
-		field.Set(reflect.ValueOf(time.Duration(seconds) * time.Second))
+		field.Set(reflect.ValueOf(time.Duration(milliseconds) * time.Millisecond))
 		return nil
 	}
 	if field.Type() == reflect.TypeOf(url.Values{}) {
diff --git a/pkg/scaling/executor/scale_jobs.go b/pkg/scaling/executor/scale_jobs.go
index 42d520c42..2223aa260 100644
--- a/pkg/scaling/executor/scale_jobs.go
+++ b/pkg/scaling/executor/scale_jobs.go
@@ -281,19 +281,29 @@ func (e *scaleExecutor) areAllPendingPodConditionsFulfilled(ctx context.Context,
 		return false
 	}
 
-	var fulfilledConditionsCount int
+	// Convert pendingPodConditions to a map for faster lookup
+	requiredConditions := make(map[string]struct{})
+	for _, condition := range pendingPodConditions {
+		requiredConditions[condition] = struct{}{}
+	}
 
+	// Check if any pod has all required conditions fulfilled
 	for _, pod := range pods.Items {
-		for _, pendingConditionType := range pendingPodConditions {
-			for _, podCondition := range pod.Status.Conditions {
-				if string(podCondition.Type) == pendingConditionType && podCondition.Status == corev1.ConditionTrue {
-					fulfilledConditionsCount++
-				}
+		fulfilledConditions := make(map[string]struct{})
+
+		for _, podCondition := range pod.Status.Conditions {
+			if _, isRequired := requiredConditions[string(podCondition.Type)]; isRequired && podCondition.Status == corev1.ConditionTrue {
+				fulfilledConditions[string(podCondition.Type)] = struct{}{}
 			}
 		}
+
+		// If this pod has all required conditions fulfilled, the job is no longer pending
+		if len(fulfilledConditions) == len(pendingPodConditions) {
+			return true
+		}
 	}
 
-	return len(pendingPodConditions) == fulfilledConditionsCount
+	return false
 }
 
 func (e *scaleExecutor) getPendingJobCount(ctx context.Context, scaledJob *kedav1alpha1.ScaledJob) int64 {
diff --git a/pkg/scaling/executor/scale_scaledobjects.go b/pkg/scaling/executor/scale_scaledobjects.go
index 46b85ca9a..726bb607f 100644
--- a/pkg/scaling/executor/scale_scaledobjects.go
+++ b/pkg/scaling/executor/scale_scaledobjects.go
@@ -206,8 +206,14 @@ func (e *scaleExecutor) RequestScale(ctx context.Context, scaledObject *kedav1al
 }
 
 // An object will be scaled down to 0 only if it's passed its cooldown period
-// or if LastActiveTime is nil
+// or if LastActiveTime is nil and scale in is not paused
 func (e *scaleExecutor) scaleToZeroOrIdle(ctx context.Context, logger logr.Logger, scaledObject *kedav1alpha1.ScaledObject, scale *autoscalingv1.Scale) {
+	if scaledObject.NeedToPauseScaleIn() {
+		// The Pause Scale Down annotation is set so we should not scale down this target
+		logger.Info("Pause Scale Down annotation set on ScaledObject, no scaling down on inactive trigger")
+		return
+	}
+
 	var initialCooldownPeriod, cooldownPeriod time.Duration
 
 	if scaledObject.Spec.InitialCooldownPeriod != nil {
diff --git a/pkg/scaling/scalers_builder.go b/pkg/scaling/scalers_builder.go
index db4eeaf0a..05c03086e 100644
--- a/pkg/scaling/scalers_builder.go
+++ b/pkg/scaling/scalers_builder.go
@@ -166,7 +166,7 @@ func buildScaler(ctx context.Context, client client.Client, triggerType string,
 	case "cron":
 		return scalers.NewCronScaler(config)
 	case "datadog":
-		return scalers.NewDatadogScaler(ctx, config)
+		return scalers.NewDatadogScaler(config)
 	case "dynatrace":
 		return scalers.NewDynatraceScaler(config)
 	case "elasticsearch":



Test patch:
diff --git a/controllers/keda/scaledobject_controller_test.go b/controllers/keda/scaledobject_controller_test.go
index 18eb1ad81..3fe12d8bf 100644
--- a/controllers/keda/scaledobject_controller_test.go
+++ b/controllers/keda/scaledobject_controller_test.go
@@ -582,6 +582,233 @@ var _ = Describe("ScaledObjectController", func() {
 			Ω(hpa.Annotations).To(Equal(so.Annotations))
 		})
 
+		It("deploys ScaledObject and creates HPA with scale down select policy disabled when pause scale-in annotation set", func() {
+			deploymentName := "disable-scale-in"
+			soName := "so-" + deploymentName
+
+			// Create the scaling target.
+			err := k8sClient.Create(context.Background(), generateDeployment(deploymentName))
+			Expect(err).ToNot(HaveOccurred())
+
+			// Create the ScaledObject
+			so := &kedav1alpha1.ScaledObject{
+				ObjectMeta: metav1.ObjectMeta{
+					Name:      soName,
+					Namespace: "default",
+					Annotations: map[string]string{
+						kedav1alpha1.PausedScaleInAnnotation: "true",
+					}},
+				Spec: kedav1alpha1.ScaledObjectSpec{
+					ScaleTargetRef: &kedav1alpha1.ScaleTarget{
+						Name: deploymentName,
+					},
+					Triggers: []kedav1alpha1.ScaleTriggers{
+						{
+							Type: "cron",
+							Metadata: map[string]string{
+								"timezone":        "UTC",
+								"start":           "0 * * * *",
+								"end":             "1 * * * *",
+								"desiredReplicas": "1",
+							},
+						},
+					},
+				},
+			}
+			err = k8sClient.Create(context.Background(), so)
+			Ω(err).ToNot(HaveOccurred())
+
+			Eventually(func() metav1.ConditionStatus {
+				err = k8sClient.Get(context.Background(), types.NamespacedName{Name: soName, Namespace: "default"}, so)
+				Ω(err).ToNot(HaveOccurred())
+				return so.Status.Conditions.GetPausedCondition().Status
+			}, 5*time.Second).Should(Equal(metav1.ConditionTrue))
+
+			// Get and confirm the HPA
+			hpa := &autoscalingv2.HorizontalPodAutoscaler{}
+			Eventually(func() error {
+				return k8sClient.Get(context.Background(), types.NamespacedName{Name: "keda-hpa-" + soName, Namespace: "default"}, hpa)
+			}).ShouldNot(HaveOccurred())
+
+			Ω(*hpa.Spec.Behavior.ScaleDown.SelectPolicy).To(Equal(autoscalingv2.DisabledPolicySelect))
+		})
+
+		It("sets scale down select policy to disable when annotation added to existing object", func() {
+			deploymentName := "disable-scale-in-old-so"
+			soName := "so-" + deploymentName
+
+			// Create the scaling target.
+			err := k8sClient.Create(context.Background(), generateDeployment(deploymentName))
+			Expect(err).ToNot(HaveOccurred())
+
+			minReplicaCount := int32(1)
+			maxReplicaCount := int32(10)
+
+			// Create the ScaledObject with 1 trigger.
+			so := &kedav1alpha1.ScaledObject{
+				ObjectMeta: metav1.ObjectMeta{
+					Name:        soName,
+					Namespace:   "default",
+					Annotations: make(map[string]string),
+				},
+				Spec: kedav1alpha1.ScaledObjectSpec{
+					ScaleTargetRef: &kedav1alpha1.ScaleTarget{
+						Name: deploymentName,
+					},
+					Triggers: []kedav1alpha1.ScaleTriggers{
+						{
+							Type: "cron",
+							Metadata: map[string]string{
+								"timezone":        "UTC",
+								"start":           "0 * * * *",
+								"end":             "1 * * * *",
+								"desiredReplicas": "2",
+							},
+						},
+					},
+					MinReplicaCount: &minReplicaCount,
+					MaxReplicaCount: &maxReplicaCount,
+				},
+			}
+			err = k8sClient.Create(context.Background(), so)
+			Expect(err).ToNot(HaveOccurred())
+
+			testLogger.Info("Created scaled object")
+
+			// Get and confirm the HPA.
+			hpa := &autoscalingv2.HorizontalPodAutoscaler{}
+			Eventually(func() error {
+				return k8sClient.Get(context.Background(), types.NamespacedName{Name: "keda-hpa-" + soName, Namespace: "default"}, hpa)
+			}).ShouldNot(HaveOccurred())
+			Expect(hpa.Spec.Behavior).To(Equal((*autoscalingv2.HorizontalPodAutoscalerBehavior)(nil)))
+
+			Eventually(func() metav1.ConditionStatus {
+				err = k8sClient.Get(context.Background(), types.NamespacedName{Name: soName, Namespace: "default"}, so)
+				Ω(err).ToNot(HaveOccurred())
+				return so.Status.Conditions.GetPausedCondition().Status
+			}, 2*time.Minute).WithPolling(5 * time.Second).Should(Or(Equal(metav1.ConditionFalse), Equal(metav1.ConditionUnknown)))
+
+			// Set the annotation
+			Eventually(func() error {
+				err = k8sClient.Get(context.Background(), types.NamespacedName{Name: soName, Namespace: "default"}, so)
+				Expect(err).ToNot(HaveOccurred())
+
+				if so.Annotations == nil {
+					so.Annotations = make(map[string]string)
+				}
+				so.Annotations[kedav1alpha1.PausedScaleInAnnotation] = "true"
+
+				return k8sClient.Update(context.Background(), so)
+			}).ShouldNot(HaveOccurred())
+
+			Eventually(func() metav1.ConditionStatus {
+				err = k8sClient.Get(context.Background(), types.NamespacedName{Name: soName, Namespace: "default"}, so)
+				Ω(err).ToNot(HaveOccurred())
+				return so.Status.Conditions.GetPausedCondition().Status
+			}, 2*time.Minute).WithPolling(5 * time.Second).Should(Equal(metav1.ConditionTrue))
+
+			Eventually(func() autoscalingv2.ScalingPolicySelect {
+				err := k8sClient.Get(context.Background(), types.NamespacedName{Name: "keda-hpa-" + soName, Namespace: "default"}, hpa)
+				Expect(err).ToNot(HaveOccurred())
+				if hpa.Spec.Behavior != nil && hpa.Spec.Behavior.ScaleDown != nil && hpa.Spec.Behavior.ScaleDown.SelectPolicy != nil {
+					return *hpa.Spec.Behavior.ScaleDown.SelectPolicy
+				} else {
+					return ""
+				}
+			}).WithTimeout(1 * time.Minute).WithPolling(10 * time.Second).Should(Equal(autoscalingv2.DisabledPolicySelect))
+		})
+
+		It("sets scale down select policy to original policy when annotation removed", func() {
+			deploymentName := "remove-scale-in-disabled-annotation"
+			soName := "so-" + deploymentName
+
+			// Create the scaling target.
+			err := k8sClient.Create(context.Background(), generateDeployment(deploymentName))
+			Expect(err).ToNot(HaveOccurred())
+
+			// Create the ScaledObject with 1 trigger.
+			minPolicy := autoscalingv2.MinChangePolicySelect
+			minReplicaCount := int32(1)
+			maxReplicaCount := int32(10)
+			so := &kedav1alpha1.ScaledObject{
+				ObjectMeta: metav1.ObjectMeta{
+					Name:      soName,
+					Namespace: "default",
+					Annotations: map[string]string{
+						kedav1alpha1.PausedScaleInAnnotation: "true",
+					},
+				},
+
+				Spec: kedav1alpha1.ScaledObjectSpec{
+					ScaleTargetRef: &kedav1alpha1.ScaleTarget{
+						Name: deploymentName,
+					},
+					MinReplicaCount: &minReplicaCount,
+					MaxReplicaCount: &maxReplicaCount,
+					Triggers: []kedav1alpha1.ScaleTriggers{
+						{
+							Type: "cron",
+							Metadata: map[string]string{
+								"timezone":        "UTC",
+								"start":           "0 * * * *",
+								"end":             "1 * * * *",
+								"desiredReplicas": "2",
+							},
+						},
+					},
+					Advanced: &kedav1alpha1.AdvancedConfig{
+						HorizontalPodAutoscalerConfig: &kedav1alpha1.HorizontalPodAutoscalerConfig{
+							Behavior: &autoscalingv2.HorizontalPodAutoscalerBehavior{
+								ScaleDown: &autoscalingv2.HPAScalingRules{
+									SelectPolicy: &minPolicy,
+								},
+							},
+						},
+					},
+				},
+			}
+			err = k8sClient.Create(context.Background(), so)
+			Expect(err).ToNot(HaveOccurred())
+			testLogger.Info("Created scaled object")
+
+			// Get and confirm the HPA.
+			hpa := &autoscalingv2.HorizontalPodAutoscaler{}
+			Eventually(func() error {
+				return k8sClient.Get(context.Background(), types.NamespacedName{Name: "keda-hpa-" + soName, Namespace: "default"}, hpa)
+			}).ShouldNot(HaveOccurred())
+			Expect(*hpa.Spec.Behavior.ScaleDown.SelectPolicy).To(Equal(autoscalingv2.DisabledPolicySelect))
+
+			Eventually(func() metav1.ConditionStatus {
+				err = k8sClient.Get(context.Background(), types.NamespacedName{Name: soName, Namespace: "default"}, so)
+				Ω(err).ToNot(HaveOccurred())
+				return so.Status.Conditions.GetPausedCondition().Status
+			}, 2*time.Minute).WithPolling(5 * time.Second).Should(Equal(metav1.ConditionTrue))
+
+			// Remove the annotation.
+			Eventually(func() error {
+				err = k8sClient.Get(context.Background(), types.NamespacedName{Name: soName, Namespace: "default"}, so)
+				Expect(err).ToNot(HaveOccurred())
+				delete(so.ObjectMeta.Annotations, kedav1alpha1.PausedScaleInAnnotation)
+				return k8sClient.Update(context.Background(), so)
+			}).ShouldNot(HaveOccurred())
+
+			Eventually(func() metav1.ConditionStatus {
+				err = k8sClient.Get(context.Background(), types.NamespacedName{Name: soName, Namespace: "default"}, so)
+				Ω(err).ToNot(HaveOccurred())
+				return so.Status.Conditions.GetPausedCondition().Status
+			}, 2*time.Minute).WithPolling(5 * time.Second).Should(Or(Equal(metav1.ConditionFalse), Equal(metav1.ConditionUnknown)))
+
+			Eventually(func() autoscalingv2.ScalingPolicySelect {
+				err := k8sClient.Get(context.Background(), types.NamespacedName{Name: "keda-hpa-" + soName, Namespace: "default"}, hpa)
+				Expect(err).ToNot(HaveOccurred())
+				if hpa.Spec.Behavior != nil && hpa.Spec.Behavior.ScaleDown != nil && hpa.Spec.Behavior.ScaleDown.SelectPolicy != nil {
+					return *hpa.Spec.Behavior.ScaleDown.SelectPolicy
+				} else {
+					return ""
+				}
+			}).WithTimeout(1 * time.Minute).WithPolling(10 * time.Second).Should(Equal(autoscalingv2.MinChangePolicySelect))
+		})
+
 		It("doesn't allow MinReplicaCount > MaxReplicaCount", func() {
 			deploymentName := "minmax"
 			soName := "so-" + deploymentName
diff --git a/pkg/scalers/datadog_scaler_test.go b/pkg/scalers/datadog_scaler_test.go
index a3e16903d..9adf81ad7 100644
--- a/pkg/scalers/datadog_scaler_test.go
+++ b/pkg/scalers/datadog_scaler_test.go
@@ -126,6 +126,17 @@ var testDatadogClusterAgentMetadata = []datadogAuthMetadataTestData{
 	{"", map[string]string{"useClusterAgentProxy": "true", "datadogMetricName": "test-metric", "datadogMetricNamespace": "application-metrics", "targetValue": "10"}, map[string]string{"token": "test-token", "datadogNamespace": "datadog-system", "datadogMetricsService": "datadog-cluster-agent-metrics-api", "datadogMetricsServicePort": "8443", "authMode": "bearer"}, false},
 	// Test case with custom service name and port to verify URL building
 	{"", map[string]string{"useClusterAgentProxy": "true", "datadogMetricName": "custom-metric", "datadogMetricNamespace": "prod-metrics", "targetValue": "5"}, map[string]string{"token": "test-token", "datadogNamespace": "monitoring", "datadogMetricsService": "custom-datadog-service", "datadogMetricsServicePort": "9443", "authMode": "bearer"}, false},
+	// valid timeout values for cluster agent
+	{"", map[string]string{"useClusterAgentProxy": "true", "datadogMetricName": "nginx-hits", "datadogMetricNamespace": "default", "targetValue": "2", "timeout": "30s"}, map[string]string{"token": "token", "datadogNamespace": "datadog", "datadogMetricsService": "datadog-cluster-agent-metrics-api", "authMode": "bearer"}, false},
+	{"", map[string]string{"useClusterAgentProxy": "true", "datadogMetricName": "nginx-hits", "datadogMetricNamespace": "default", "targetValue": "2", "timeout": "1m"}, map[string]string{"token": "token", "datadogNamespace": "datadog", "datadogMetricsService": "datadog-cluster-agent-metrics-api", "authMode": "bearer"}, false},
+	{"", map[string]string{"useClusterAgentProxy": "true", "datadogMetricName": "nginx-hits", "datadogMetricNamespace": "default", "targetValue": "2", "timeout": "2m30s"}, map[string]string{"token": "token", "datadogNamespace": "datadog", "datadogMetricsService": "datadog-cluster-agent-metrics-api", "authMode": "bearer"}, false},
+	{"", map[string]string{"useClusterAgentProxy": "true", "datadogMetricName": "nginx-hits", "datadogMetricNamespace": "default", "targetValue": "2", "timeout": "500ms"}, map[string]string{"token": "token", "datadogNamespace": "datadog", "datadogMetricsService": "datadog-cluster-agent-metrics-api", "authMode": "bearer"}, false},
+	{"", map[string]string{"useClusterAgentProxy": "true", "datadogMetricName": "nginx-hits", "datadogMetricNamespace": "default", "targetValue": "2", "timeout": "0s"}, map[string]string{"token": "token", "datadogNamespace": "datadog", "datadogMetricsService": "datadog-cluster-agent-metrics-api", "authMode": "bearer"}, false},
+	{"", map[string]string{"useClusterAgentProxy": "true", "datadogMetricName": "nginx-hits", "datadogMetricNamespace": "default", "targetValue": "2", "timeout": "30"}, map[string]string{"token": "token", "datadogNamespace": "datadog", "datadogMetricsService": "datadog-cluster-agent-metrics-api", "authMode": "bearer"}, false},
+	{"", map[string]string{"useClusterAgentProxy": "true", "datadogMetricName": "nginx-hits", "datadogMetricNamespace": "default", "targetValue": "2", "timeout": ""}, map[string]string{"token": "token", "datadogNamespace": "datadog", "datadogMetricsService": "datadog-cluster-agent-metrics-api", "authMode": "bearer"}, false},
+	// invalid timeout values for cluster agent
+	{"", map[string]string{"useClusterAgentProxy": "true", "datadogMetricName": "nginx-hits", "datadogMetricNamespace": "default", "targetValue": "2", "timeout": "invalid"}, map[string]string{"token": "token", "datadogNamespace": "datadog", "datadogMetricsService": "datadog-cluster-agent-metrics-api", "authMode": "bearer"}, true},
+	{"", map[string]string{"useClusterAgentProxy": "true", "datadogMetricName": "nginx-hits", "datadogMetricNamespace": "default", "targetValue": "2", "timeout": "-10s"}, map[string]string{"token": "token", "datadogNamespace": "datadog", "datadogMetricsService": "datadog-cluster-agent-metrics-api", "authMode": "bearer"}, true},
 }
 
 var testDatadogAPIMetadata = []datadogAuthMetadataTestData{
@@ -133,6 +144,17 @@ var testDatadogAPIMetadata = []datadogAuthMetadataTestData{
 
 	// all properly formed
 	{"", map[string]string{"query": "sum:trace.redis.command.hits{env:none,service:redis}.as_count()", "queryValue": "7", "metricUnavailableValue": "1.5", "type": "average", "age": "60", "timeWindowOffset": "30", "lastAvailablePointOffset": "1"}, map[string]string{"apiKey": "apiKey", "appKey": "appKey", "datadogSite": "datadogSite"}, false},
+	// valid timeout values
+	{"", map[string]string{"query": "sum:trace.redis.command.hits{env:none,service:redis}.as_count()", "queryValue": "7", "timeout": "30s"}, map[string]string{"apiKey": "apiKey", "appKey": "appKey", "datadogSite": "datadogSite"}, false},
+	{"", map[string]string{"query": "sum:trace.redis.command.hits{env:none,service:redis}.as_count()", "queryValue": "7", "timeout": "1m"}, map[string]string{"apiKey": "apiKey", "appKey": "appKey", "datadogSite": "datadogSite"}, false},
+	{"", map[string]string{"query": "sum:trace.redis.command.hits{env:none,service:redis}.as_count()", "queryValue": "7", "timeout": "2m30s"}, map[string]string{"apiKey": "apiKey", "appKey": "appKey", "datadogSite": "datadogSite"}, false},
+	{"", map[string]string{"query": "sum:trace.redis.command.hits{env:none,service:redis}.as_count()", "queryValue": "7", "timeout": "500ms"}, map[string]string{"apiKey": "apiKey", "appKey": "appKey", "datadogSite": "datadogSite"}, false},
+	{"", map[string]string{"query": "sum:trace.redis.command.hits{env:none,service:redis}.as_count()", "queryValue": "7", "timeout": "0s"}, map[string]string{"apiKey": "apiKey", "appKey": "appKey", "datadogSite": "datadogSite"}, false},
+	{"", map[string]string{"query": "sum:trace.redis.command.hits{env:none,service:redis}.as_count()", "queryValue": "7", "timeout": "30"}, map[string]string{"apiKey": "apiKey", "appKey": "appKey", "datadogSite": "datadogSite"}, false},
+	{"", map[string]string{"query": "sum:trace.redis.command.hits{env:none,service:redis}.as_count()", "queryValue": "7", "timeout": ""}, map[string]string{"apiKey": "apiKey", "appKey": "appKey", "datadogSite": "datadogSite"}, false},
+	// invalid timeout values
+	{"", map[string]string{"query": "sum:trace.redis.command.hits{env:none,service:redis}.as_count()", "queryValue": "7", "timeout": "invalid"}, map[string]string{"apiKey": "apiKey", "appKey": "appKey", "datadogSite": "datadogSite"}, true},
+	{"", map[string]string{"query": "sum:trace.redis.command.hits{env:none,service:redis}.as_count()", "queryValue": "7", "timeout": "-5s"}, map[string]string{"apiKey": "apiKey", "appKey": "appKey", "datadogSite": "datadogSite"}, true},
 	// Multi-query all properly formed
 	{"", map[string]string{"query": "sum:trace.redis.command.hits{env:none,service:redis}.as_count(),sum:trace.redis.command.hits{env:none,service:redis}.as_count()/2", "queryValue": "7", "queryAggregator": "average", "metricUnavailableValue": "1.5", "type": "average", "age": "60"}, map[string]string{"apiKey": "apiKey", "appKey": "appKey", "datadogSite": "datadogSite"}, false},
 	// default age
diff --git a/pkg/scalers/openstack_metrics_scaler_test.go b/pkg/scalers/openstack_metrics_scaler_test.go
index 90a941c66..2bd625e98 100644
--- a/pkg/scalers/openstack_metrics_scaler_test.go
+++ b/pkg/scalers/openstack_metrics_scaler_test.go
@@ -107,7 +107,7 @@ func TestOpenstackMetricsGetMetricsForSpecScaling(t *testing.T) {
 	}
 
 	for _, testData := range testCases {
-		meta, err := parseOpenstackMetricMetadata(&scalersconfig.ScalerConfig{ResolvedEnv: testData.resolvedEnv, TriggerMetadata: testData.metadataTestData.metadata, AuthParams: testData.authMetadataTestData.authMetadata, TriggerIndex: testData.triggerIndex}, logr.Discard())
+		meta, err := parseOpenstackMetricMetadata(&scalersconfig.ScalerConfig{ResolvedEnv: testData.resolvedEnv, TriggerMetadata: testData.metadataTestData.metadata, AuthParams: testData.authMetadataTestData.authMetadata, TriggerIndex: testData.triggerIndex})
 
 		if err != nil {
 			t.Fatal("Could not parse metadata from openstack metrics scaler")
@@ -144,7 +144,7 @@ func TestOpenstackMetricsGetMetricsForSpecScalingInvalidMetaData(t *testing.T) {
 
 	for _, testData := range testCases {
 		t.Run(testData.name, func(pt *testing.T) {
-			_, err := parseOpenstackMetricMetadata(&scalersconfig.ScalerConfig{ResolvedEnv: testData.resolvedEnv, TriggerMetadata: testData.metadataTestData.metadata, AuthParams: testData.authMetadataTestData.authMetadata, TriggerIndex: testData.triggerIndex}, logr.Discard())
+			_, err := parseOpenstackMetricMetadata(&scalersconfig.ScalerConfig{ResolvedEnv: testData.resolvedEnv, TriggerMetadata: testData.metadataTestData.metadata, AuthParams: testData.authMetadataTestData.authMetadata, TriggerIndex: testData.triggerIndex})
 			assert.NotNil(t, err)
 		})
 	}
diff --git a/pkg/scalers/scalersconfig/typed_config_test.go b/pkg/scalers/scalersconfig/typed_config_test.go
index 0f7e19a97..785513579 100644
--- a/pkg/scalers/scalersconfig/typed_config_test.go
+++ b/pkg/scalers/scalersconfig/typed_config_test.go
@@ -19,6 +19,7 @@ package scalersconfig
 import (
 	"net/url"
 	"testing"
+	"time"
 
 	. "github.com/onsi/gomega"
 	"k8s.io/apimachinery/pkg/runtime"
@@ -610,6 +611,33 @@ func TestMultiName(t *testing.T) {
 	Expect(ts.Property).To(Equal("bbb"))
 }
 
+// TestDurationParsing tests the time.Duration parsing for both string and numeric values
+func TestDurationParsing(t *testing.T) {
+	RegisterTestingT(t)
+
+	sc := &ScalerConfig{
+		TriggerMetadata: map[string]string{
+			"timeoutNumeric":  "1000", // milliseconds as number
+			"timeoutDuration": "30s",  // duration string
+			"timeoutZero":     "0",    // edge case
+		},
+	}
+
+	type testStruct struct {
+		TimeoutNumeric  time.Duration `keda:"name=timeoutNumeric,  order=triggerMetadata"`
+		TimeoutDuration time.Duration `keda:"name=timeoutDuration, order=triggerMetadata"`
+		TimeoutZero     time.Duration `keda:"name=timeoutZero,     order=triggerMetadata"`
+	}
+
+	ts := testStruct{}
+	err := sc.TypedConfig(&ts)
+	Expect(err).To(BeNil())
+
+	Expect(ts.TimeoutNumeric).To(Equal(1000 * time.Millisecond))
+	Expect(ts.TimeoutDuration).To(Equal(30 * time.Second))
+	Expect(ts.TimeoutZero).To(Equal(0 * time.Millisecond))
+}
+
 // TestUnexpectedOptional tests the unexpected optional input
 func TestUnexpectedOptional(t *testing.T) {
 	RegisterTestingT(t)
diff --git a/pkg/scaling/executor/scale_jobs_test.go b/pkg/scaling/executor/scale_jobs_test.go
index 9652abdc6..ea8aa5ff8 100644
--- a/pkg/scaling/executor/scale_jobs_test.go
+++ b/pkg/scaling/executor/scale_jobs_test.go
@@ -302,20 +302,112 @@ func TestGetPendingJobCount(t *testing.T) {
 		{PendingPodConditions: pendingPodConditions, PodStatus: v1.PodStatus{Conditions: []v1.PodCondition{readyCondition}}, PendingJobCount: 1},
 		{PendingPodConditions: pendingPodConditions, PodStatus: v1.PodStatus{Conditions: []v1.PodCondition{podScheduledCondition}}, PendingJobCount: 1},
 		{PendingPodConditions: pendingPodConditions, PodStatus: v1.PodStatus{Conditions: []v1.PodCondition{readyCondition, podScheduledCondition}}, PendingJobCount: 0},
+
+		// Test case: Job with 2 pods, both have all conditions - should NOT be pending
+		{
+			PendingPodConditions: pendingPodConditions,
+			PodStatuses: []v1.PodStatus{
+				{Conditions: []v1.PodCondition{readyCondition, podScheduledCondition}},
+				{Conditions: []v1.PodCondition{readyCondition, podScheduledCondition}},
+			},
+			PendingJobCount: 0,
+		},
+
+		// Test case: Job with 2 pods, 1 has all conditions, 1 doesn't - should NOT be pending
+		{
+			PendingPodConditions: pendingPodConditions,
+			PodStatuses: []v1.PodStatus{
+				{Conditions: []v1.PodCondition{readyCondition, podScheduledCondition}},
+				{Conditions: []v1.PodCondition{readyCondition}}, // missing PodScheduled
+			},
+			PendingJobCount: 0,
+		},
+
+		// Test case: Job with 2 pods, neither has all conditions - should be pending
+		{
+			PendingPodConditions: pendingPodConditions,
+			PodStatuses: []v1.PodStatus{
+				{Conditions: []v1.PodCondition{readyCondition}},        // missing PodScheduled
+				{Conditions: []v1.PodCondition{podScheduledCondition}}, // missing Ready
+			},
+			PendingJobCount: 1,
+		},
+
+		// Test case: Job with 3 pods, 1 has all conditions - should NOT be pending
+		{
+			PendingPodConditions: pendingPodConditions,
+			PodStatuses: []v1.PodStatus{
+				{Conditions: []v1.PodCondition{}},                                      // no conditions
+				{Conditions: []v1.PodCondition{readyCondition}},                        // partial conditions
+				{Conditions: []v1.PodCondition{readyCondition, podScheduledCondition}}, // all conditions
+			},
+			PendingJobCount: 0,
+		},
+
+		// Test case: Job with 3 pods, none have all conditions - should be pending
+		{
+			PendingPodConditions: pendingPodConditions,
+			PodStatuses: []v1.PodStatus{
+				{Conditions: []v1.PodCondition{}},                      // no conditions
+				{Conditions: []v1.PodCondition{readyCondition}},        // partial conditions
+				{Conditions: []v1.PodCondition{podScheduledCondition}}, // partial conditions
+			},
+			PendingJobCount: 1,
+		},
+		// Edge case: Empty conditions list
+		{
+			PendingPodConditions: []string{},
+			PodStatuses: []v1.PodStatus{
+				{Phase: v1.PodRunning, Conditions: []v1.PodCondition{readyCondition}},
+			},
+			PendingJobCount: 0, // No conditions to check, pod is running, so not pending
+		},
 	}
 
-	for _, testData := range testPendingJobTestData {
+	for i, testData := range testPendingJobTestData {
 		ctx := context.Background()
-		client := getMockClientForTestingPendingPods(t, ctrl, testData.PodStatus)
-		scaleExecutor := getMockScaleExecutor(client)
 
+		// Support both single pod and multiple pods test cases
+		var client *mock_client.MockClient
+		if len(testData.PodStatuses) > 0 {
+			client = getMockClientForTestingPendingPodsMultiple(t, ctrl, testData.PodStatuses)
+		} else {
+			client = getMockClientForTestingPendingPods(t, ctrl, testData.PodStatus)
+		}
+
+		scaleExecutor := getMockScaleExecutor(client)
 		scaledJob := getMockScaledJobWithPendingPodConditions(testData.PendingPodConditions)
 		result := scaleExecutor.getPendingJobCount(ctx, scaledJob)
 
-		assert.Equal(t, testData.PendingJobCount, result)
+		assert.Equal(t, testData.PendingJobCount, result, "Test case %d failed", i)
 	}
 }
 
+// Test to check issue #6727
+func TestAreAllPendingPodConditionsFulfilledBugScenario(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	pendingPodConditions := []string{"Ready", "PodScheduled"}
+	readyCondition := getPodCondition(v1.PodReady)
+	podScheduledCondition := getPodCondition(v1.PodScheduled)
+
+	podStatuses := []v1.PodStatus{
+		{Conditions: []v1.PodCondition{readyCondition, podScheduledCondition}},
+		{Conditions: []v1.PodCondition{readyCondition, podScheduledCondition}},
+	}
+
+	ctx := context.Background()
+	client := getMockClientForTestingPendingPodsMultiple(t, ctrl, podStatuses)
+	scaleExecutor := getMockScaleExecutor(client)
+	scaledJob := getMockScaledJobWithPendingPodConditions(pendingPodConditions)
+
+	result := scaleExecutor.getPendingJobCount(ctx, scaledJob)
+
+	// Should be 0, because both pods have all required conditions
+	assert.Equal(t, int64(0), result, "Job with pods having all conditions should not be pending")
+}
+
 func TestCreateJobs(t *testing.T) {
 	ctx := context.Background()
 	logger := logf.Log.WithName("CreateJobsTest")
@@ -382,7 +474,8 @@ type mockJobParameter struct {
 
 type pendingJobTestData struct {
 	PendingPodConditions []string
-	PodStatus            v1.PodStatus
+	PodStatus            v1.PodStatus   // For single pod tests
+	PodStatuses          []v1.PodStatus // For multiple pods tests
 	PendingJobCount      int64
 }
 
@@ -552,6 +645,45 @@ func getMockClientForTestingPendingPods(t *testing.T, ctrl *gomock.Controller, p
 	return client
 }
 
+// getMockClientForTestingPendingPodsMultiple returns mock client function for testing pending pod conditions with multiple pods in a job
+func getMockClientForTestingPendingPodsMultiple(t *testing.T, ctrl *gomock.Controller, podStatuses []v1.PodStatus) *mock_client.MockClient {
+	client := mock_client.NewMockClient(ctrl)
+	gomock.InOrder(
+		// listing jobs
+		client.EXPECT().
+			List(gomock.Any(), gomock.Any(), gomock.Any()).Do(func(_ context.Context, list runtime.Object, _ ...runtimeclient.ListOption) {
+			j, ok := list.(*batchv1.JobList)
+
+			if !ok {
+				t.Error("Cast failed on batchv1.JobList at mocking client.List()")
+			}
+
+			if ok {
+				j.Items = append(j.Items, batchv1.Job{})
+			}
+		}).
+			Return(nil),
+		// listing pods - multiple pods this time
+		client.EXPECT().
+			List(gomock.Any(), gomock.Any(), gomock.Any()).Do(func(_ context.Context, list runtime.Object, _ ...runtimeclient.ListOption) {
+			p, ok := list.(*v1.PodList)
+
+			if !ok {
+				t.Error("Cast failed on v1.PodList at mocking client.List()")
+			}
+
+			if ok {
+				for _, podStatus := range podStatuses {
+					p.Items = append(p.Items, v1.Pod{Status: podStatus})
+				}
+			}
+		}).
+			Return(nil),
+	)
+
+	return client
+}
+
 func getJob(t *testing.T, name string, completionTime string, jobConditionType batchv1.JobConditionType) *batchv1.Job {
 	parsedCompletionTime, err := time.Parse(time.RFC3339, completionTime)
 	completionTimeT := metav1.NewTime(parsedCompletionTime)
diff --git a/pkg/scaling/executor/scale_scaledobjects_test.go b/pkg/scaling/executor/scale_scaledobjects_test.go
index de0d9ea58..fc5a50acf 100644
--- a/pkg/scaling/executor/scale_scaledobjects_test.go
+++ b/pkg/scaling/executor/scale_scaledobjects_test.go
@@ -460,3 +460,135 @@ func TestEventWitTriggerInfo(t *testing.T) {
 	eventstring := <-recorder.Events
 	assert.Equal(t, "Normal KEDAScaleTargetActivated Scaled  namespace/name from 2 to 5, triggered by testTrigger", eventstring)
 }
+
+func TestNoScaleToMinReplicasWhenNotActiveAndPauseScaleInAnnotationSet(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	client := mock_client.NewMockClient(ctrl)
+	recorder := record.NewFakeRecorder(1)
+	mockScaleClient := mock_scale.NewMockScalesGetter(ctrl)
+	mockScaleInterface := mock_scale.NewMockScaleInterface(ctrl)
+	statusWriter := mock_client.NewMockStatusWriter(ctrl)
+
+	scaleExecutor := NewScaleExecutor(client, mockScaleClient, nil, recorder)
+
+	minReplicas := int32(0)
+
+	scaledObject := v1alpha1.ScaledObject{
+		ObjectMeta: v1.ObjectMeta{
+			Name:      "name",
+			Namespace: "namespace",
+			Annotations: map[string]string{
+				v1alpha1.PausedScaleInAnnotation: "true",
+			},
+		},
+		Spec: v1alpha1.ScaledObjectSpec{
+			ScaleTargetRef: &v1alpha1.ScaleTarget{
+				Name: "name",
+			},
+			MinReplicaCount: &minReplicas,
+		},
+		Status: v1alpha1.ScaledObjectStatus{
+			ScaleTargetGVKR: &v1alpha1.GroupVersionKindResource{
+				Group: "apps",
+				Kind:  "Deployment",
+			},
+		},
+	}
+
+	scaledObject.Status.Conditions = *v1alpha1.GetInitializedConditions()
+
+	numberOfReplicas := int32(10)
+
+	client.EXPECT().Get(gomock.Any(), gomock.Any(), gomock.Any()).SetArg(2, appsv1.Deployment{
+		Spec: appsv1.DeploymentSpec{
+			Replicas: &numberOfReplicas,
+		},
+	})
+
+	scale := &autoscalingv1.Scale{
+		Spec: autoscalingv1.ScaleSpec{
+			Replicas: numberOfReplicas,
+		},
+	}
+
+	// Expect no calls to Scale
+	mockScaleClient.EXPECT().Scales(gomock.Any()).Return(mockScaleInterface).Times(0)
+	mockScaleInterface.EXPECT().Get(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Times(0)
+	mockScaleInterface.EXPECT().Update(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Times(0)
+
+	client.EXPECT().Status().Return(statusWriter).Times(2)
+	statusWriter.EXPECT().Patch(gomock.Any(), gomock.Any(), gomock.Any()).Times(2)
+
+	scaleExecutor.RequestScale(context.TODO(), &scaledObject, false, false, &ScaleExecutorOptions{})
+
+	assert.Equal(t, numberOfReplicas, scale.Spec.Replicas)
+	condition := scaledObject.Status.Conditions.GetActiveCondition()
+	assert.Equal(t, true, condition.IsFalse())
+}
+
+func TestNoScaleToIdleReplicasWhenNotActiveAndPauseScaleInAnnotationSet(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	client := mock_client.NewMockClient(ctrl)
+	recorder := record.NewFakeRecorder(1)
+	mockScaleClient := mock_scale.NewMockScalesGetter(ctrl)
+	mockScaleInterface := mock_scale.NewMockScaleInterface(ctrl)
+	statusWriter := mock_client.NewMockStatusWriter(ctrl)
+
+	scaleExecutor := NewScaleExecutor(client, mockScaleClient, nil, recorder)
+
+	idleReplicas := int32(0)
+	minReplicas := int32(5)
+
+	scaledObject := v1alpha1.ScaledObject{
+		ObjectMeta: v1.ObjectMeta{
+			Name:      "name",
+			Namespace: "namespace",
+			Annotations: map[string]string{
+				v1alpha1.PausedScaleInAnnotation: "true",
+			},
+		},
+		Spec: v1alpha1.ScaledObjectSpec{
+			ScaleTargetRef: &v1alpha1.ScaleTarget{
+				Name: "name",
+			},
+			IdleReplicaCount: &idleReplicas,
+			MinReplicaCount:  &minReplicas,
+		},
+		Status: v1alpha1.ScaledObjectStatus{
+			ScaleTargetGVKR: &v1alpha1.GroupVersionKindResource{
+				Group: "apps",
+				Kind:  "Deployment",
+			},
+		},
+	}
+
+	scaledObject.Status.Conditions = *v1alpha1.GetInitializedConditions()
+
+	numberOfReplicas := int32(10)
+
+	client.EXPECT().Get(gomock.Any(), gomock.Any(), gomock.Any()).SetArg(2, appsv1.Deployment{
+		Spec: appsv1.DeploymentSpec{
+			Replicas: &numberOfReplicas,
+		},
+	})
+
+	scale := &autoscalingv1.Scale{
+		Spec: autoscalingv1.ScaleSpec{
+			Replicas: numberOfReplicas,
+		},
+	}
+
+	// Expect no calls to Scale
+	mockScaleClient.EXPECT().Scales(gomock.Any()).Return(mockScaleInterface).Times(0)
+	mockScaleInterface.EXPECT().Get(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Times(0)
+	mockScaleInterface.EXPECT().Update(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Times(0)
+
+	client.EXPECT().Status().Return(statusWriter).Times(2)
+	statusWriter.EXPECT().Patch(gomock.Any(), gomock.Any(), gomock.Any()).Times(2)
+
+	scaleExecutor.RequestScale(context.TODO(), &scaledObject, false, false, &ScaleExecutorOptions{})
+
+	assert.Equal(t, numberOfReplicas, scale.Spec.Replicas)
+	condition := scaledObject.Status.Conditions.GetActiveCondition()
+	assert.Equal(t, true, condition.IsFalse())
+}
diff --git a/tests/README.md b/tests/README.md
index 7b198a7eb..6fd0af236 100644
--- a/tests/README.md
+++ b/tests/README.md
@@ -192,6 +192,7 @@ func testScaleOut(t *testing.T, kc *kubernetes.Clientset) {
     ...
     ...
     // Sleep / poll for replica count using helper method.
+    // Duration should be iterations * intervalSeconds
     require.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, testNamespace, 10, 60, 1),
 		"replica count should be 10 after 1 minute")
 }
diff --git a/tests/internals/fallback/fallback_test.go b/tests/internals/fallback/fallback_test.go
index 09bf1aa58..3ef334b42 100644
--- a/tests/internals/fallback/fallback_test.go
+++ b/tests/internals/fallback/fallback_test.go
@@ -420,7 +420,7 @@ func TestFallback(t *testing.T) {
 	CreateKubernetesResources(t, kc, namespace, data, templates)
 
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, namespace, minReplicas, 180, 3),
-		"replica count should be %d after 3 minutes", minReplicas)
+		"replica count should be %d after 9 minutes", minReplicas)
 
 	testScaleOut(t, kc, data)
 	testFallback(t, kc, data)
@@ -446,7 +446,7 @@ func TestFallbackWithScaledObjectWithoutMetricType(t *testing.T) {
 	CreateKubernetesResources(t, kc, namespace, data, templates)
 
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, namespace, minReplicas, 180, 3),
-		"replica count should be %d after 3 minutes", minReplicas)
+		"replica count should be %d after 9 minutes", minReplicas)
 
 	// Scale out to 4 replicas (20 / 5 = 4)
 	data.MetricValue = 20
@@ -485,7 +485,7 @@ func TestFallbackWithCurrentReplicasIfHigher(t *testing.T) {
 	CreateKubernetesResources(t, kc, namespace, data, templates)
 
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, namespace, minReplicas, 180, 3),
-		"replica count should be %d after 3 minutes", minReplicas)
+		"replica count should be %d after 9 minutes", minReplicas)
 
 	// Scale out to 4 replicas (20 / 5 = 4)
 	data.MetricValue = 20
@@ -524,7 +524,7 @@ func TestFallbackWithCurrentReplicasIfLower(t *testing.T) {
 	CreateKubernetesResources(t, kc, namespace, data, templates)
 
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, namespace, minReplicas, 180, 3),
-		"replica count should be %d after 3 minutes", minReplicas)
+		"replica count should be %d after 9 minutes", minReplicas)
 
 	// Scale out to 4 replicas (20 / 5 = 4)
 	data.MetricValue = 20
@@ -563,7 +563,7 @@ func TestFallbackWithCurrentReplicas(t *testing.T) {
 	CreateKubernetesResources(t, kc, namespace, data, templates)
 
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, namespace, minReplicas, 180, 3),
-		"replica count should be %d after 3 minutes", minReplicas)
+		"replica count should be %d after 9 minutes", minReplicas)
 
 	// Scale out to 4 replicas (20 / 5 = 4)
 	data.MetricValue = 20
@@ -602,7 +602,7 @@ func TestFallbackWithStatic(t *testing.T) {
 	CreateKubernetesResources(t, kc, namespace, data, templates)
 
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, namespace, minReplicas, 180, 3),
-		"replica count should be %d after 3 minutes", minReplicas)
+		"replica count should be %d after 9 minutes", minReplicas)
 
 	// Scale out to 4 replicas (20 / 5 = 4)
 	data.MetricValue = 20
diff --git a/tests/internals/global_custom_ca/global_custom_ca_test.go b/tests/internals/global_custom_ca/global_custom_ca_test.go
index d7c2ab9ef..3f4b4853b 100644
--- a/tests/internals/global_custom_ca/global_custom_ca_test.go
+++ b/tests/internals/global_custom_ca/global_custom_ca_test.go
@@ -227,7 +227,7 @@ func TestCustomCa(t *testing.T) {
 	CreateKubernetesResources(t, kc, testNamespace, data, templates)
 
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, testNamespace, minReplicaCount, 180, 3),
-		"replica count should be %d after 3 minutes", minReplicaCount)
+		"replica count should be %d after 9 minutes", minReplicaCount)
 
 	// test scaling
 	testScaleOut(t, kc, data)
diff --git a/tests/internals/pause_scale_in/pause_scale_in_test.go b/tests/internals/pause_scale_in/pause_scale_in_test.go
new file mode 100644
index 000000000..d94878e6f
--- /dev/null
+++ b/tests/internals/pause_scale_in/pause_scale_in_test.go
@@ -0,0 +1,131 @@
+//go:build e2e
+// +build e2e
+
+package pause_scale_in_test
+
+import (
+	"fmt"
+	"testing"
+
+	. "github.com/kedacore/keda/v2/tests/helper"
+)
+
+// Load environment variables from .env file
+
+const (
+	testName = "pause-scalein-test"
+)
+
+var (
+	testNamespace           = fmt.Sprintf("%s-ns", testName)
+	deploymentName          = fmt.Sprintf("%s-deployment", testName)
+	monitoredDeploymentName = fmt.Sprintf("%s-monitored", testName)
+	scaledObjectName        = fmt.Sprintf("%s-so", testName)
+)
+
+type templateData struct {
+	TestNamespace           string
+	DeploymentName          string
+	ScaledObjectName        string
+	MonitoredDeploymentName string
+}
+
+const (
+	monitoredDeploymentTemplate = `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: {{.MonitoredDeploymentName}}
+  namespace: {{.TestNamespace}}
+  labels:
+    app: {{.MonitoredDeploymentName}}
+spec:
+  replicas: 0
+  selector:
+    matchLabels:
+      app: {{.MonitoredDeploymentName}}
+  template:
+    metadata:
+      labels:
+        app: {{.MonitoredDeploymentName}}
+    spec:
+      containers:
+        - name: {{.MonitoredDeploymentName}}
+          image: ghcr.io/nginx/nginx-unprivileged:1.26
+`
+
+	deploymentTemplate = `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: {{.DeploymentName}}
+  namespace: {{.TestNamespace}}
+  labels:
+    app: {{.DeploymentName}}
+spec:
+  replicas: 2
+  selector:
+    matchLabels:
+      app: {{.DeploymentName}}
+  template:
+    metadata:
+      labels:
+        app: {{.DeploymentName}}
+    spec:
+      containers:
+        - name: {{.DeploymentName}}
+          image: ghcr.io/nginx/nginx-unprivileged:1.26
+`
+
+	scaledObjectTemplate = `
+apiVersion: keda.sh/v1alpha1
+kind: ScaledObject
+metadata:
+  name: {{.ScaledObjectName}}
+  namespace: {{.TestNamespace}}
+  annotations:
+    autoscaling.keda.sh/paused-scale-in: "true"
+spec:
+  scaleTargetRef:
+    name: {{.DeploymentName}}
+  pollingInterval: 5
+  minReplicaCount: 0
+  maxReplicaCount: 3
+  cooldownPeriod:  0
+  triggers:
+    - type: kubernetes-workload
+      metadata:
+        podSelector: 'app={{.MonitoredDeploymentName}}'
+        value: '1'
+`
+)
+
+func TestScaler(t *testing.T) {
+	// setup
+	t.Log("--- setting up ---")
+
+	// Create kubernetes resources
+	kc := GetKubernetesClient(t)
+	data, templates := getTemplateData()
+
+	CreateKubernetesResources(t, kc, testNamespace, data, templates)
+
+	// assert that the deployment did not scale down after one minute
+	AssertReplicaCountNotChangeDuringTimePeriod(t, kc, deploymentName, testNamespace, 2, 60)
+
+	// cleanup
+	DeleteKubernetesResources(t, testNamespace, data, templates)
+}
+
+func getTemplateData() (templateData, []Template) {
+	return templateData{
+			TestNamespace:           testNamespace,
+			DeploymentName:          deploymentName,
+			ScaledObjectName:        scaledObjectName,
+			MonitoredDeploymentName: monitoredDeploymentName,
+		}, []Template{
+			{Name: "deploymentTemplate", Config: deploymentTemplate},
+			{Name: "monitoredDeploymentTemplate", Config: monitoredDeploymentTemplate},
+			{Name: "scaledObjectAnnotatedTemplate", Config: scaledObjectTemplate},
+		}
+}
diff --git a/tests/internals/polling_cooldown_so/polling_cooldown_so_test.go b/tests/internals/polling_cooldown_so/polling_cooldown_so_test.go
index 29766f1f3..626fdebb6 100644
--- a/tests/internals/polling_cooldown_so/polling_cooldown_so_test.go
+++ b/tests/internals/polling_cooldown_so/polling_cooldown_so_test.go
@@ -269,7 +269,7 @@ func testPollingIntervalDown(t *testing.T, kc *kubernetes.Clientset, data templa
 	AssertReplicaCountNotChangeDuringTimePeriod(t, kc, deploymentName, namespace, maxReplicas, 60)
 
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, namespace, minReplicas, 12, 10),
-		"replica count should be %d after 1 minutes", maxReplicas)
+		"replica count should be %d after 2 minutes", maxReplicas)
 
 	KubectlDeleteWithTemplate(t, data, "scaledObjectTemplate", scaledObjectTemplate)
 }
diff --git a/tests/internals/replica_update_so/replica_update_so_test.go b/tests/internals/replica_update_so/replica_update_so_test.go
index e77d68e18..796d7d3b3 100644
--- a/tests/internals/replica_update_so/replica_update_so_test.go
+++ b/tests/internals/replica_update_so/replica_update_so_test.go
@@ -220,14 +220,14 @@ func scaleMaxReplicasUp(t *testing.T, kc *kubernetes.Clientset, data templateDat
 	KubectlApplyWithTemplate(t, data, "scaledObjectTriggerTemplate", scaledObjectTriggerTemplate)
 
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, namespace, maxReplicas, 180, 3),
-		"replica count should be %d after 3 minutes", maxReplicas)
+		"replica count should be %d after 9 minutes", maxReplicas)
 
 	updatedMaxReplicas := maxReplicas + 10
 	data.MaxReplicas = strconv.Itoa(updatedMaxReplicas)
 	KubectlApplyWithTemplate(t, data, "scaledObjectTriggerTemplate", scaledObjectTriggerTemplate)
 
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, namespace, updatedMaxReplicas, 180, 3),
-		"replica count should be %d after 3 minutes", updatedMaxReplicas)
+		"replica count should be %d after 9 minutes", updatedMaxReplicas)
 }
 
 // expect replicas to decrease because maxReplicas was updated
@@ -241,13 +241,13 @@ func scaleMaxReplicasDown(t *testing.T, kc *kubernetes.Clientset, data templateD
 	KubectlApplyWithTemplate(t, data, "scaledObjectTriggerTemplate", scaledObjectTriggerTemplate)
 
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, namespace, updatedMaxReplicas, 180, 3),
-		"replica count should be %d after 3 minutes", updatedMaxReplicas)
+		"replica count should be %d after 9 minutes", updatedMaxReplicas)
 
 	data.MaxReplicas = strconv.Itoa(maxReplicas)
 	KubectlApplyWithTemplate(t, data, "scaledObjectTriggerTemplate", scaledObjectTriggerTemplate)
 
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, namespace, maxReplicas, 180, 3),
-		"replica count should be %d after 3 minutes", maxReplicas)
+		"replica count should be %d after 9 minutes", maxReplicas)
 }
 
 // starts with minReplicas 0 -> update to higher, expect to scale up
@@ -259,14 +259,14 @@ func scaleMinReplicasUpFromZero(t *testing.T, kc *kubernetes.Clientset, data tem
 	KubectlApplyWithTemplate(t, data, "scaledObjectTriggerTemplate", scaledObjectTriggerTemplate)
 
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, namespace, minReplicas, 180, 3),
-		"replica count should be %d after 3 minutes", minReplicas)
+		"replica count should be %d after 9 minutes", minReplicas)
 
 	updatedMinReplicas := minReplicas + 5
 	data.MinReplicas = strconv.Itoa(updatedMinReplicas)
 	KubectlApplyWithTemplate(t, data, "scaledObjectTriggerTemplate", scaledObjectTriggerTemplate)
 
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, namespace, updatedMinReplicas, 180, 3),
-		"replica count should be %d after 3 minutes", updatedMinReplicas)
+		"replica count should be %d after 9 minutes", updatedMinReplicas)
 }
 
 // starts with 5 replicas as minReplicas -> update to 0, expect to scale down
@@ -281,7 +281,7 @@ func scaleMinReplicasDownToZero(t *testing.T, kc *kubernetes.Clientset, data tem
 	KubectlApplyWithTemplate(t, data, "scaledObjectTriggerTemplate", scaledObjectTriggerTemplate)
 
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, namespace, updatedMinReplicas, 180, 3),
-		"replica count should be %d after 3 minutes", updatedMinReplicas)
+		"replica count should be %d after 9 minutes", updatedMinReplicas)
 
 	// change minReplicas to default (0)
 	data.MinReplicas = strconv.Itoa(minReplicas)
@@ -289,7 +289,7 @@ func scaleMinReplicasDownToZero(t *testing.T, kc *kubernetes.Clientset, data tem
 
 	// check it scales down to 0
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, namespace, minReplicas, 180, 3),
-		"replica count should be %d after 3 minutes", minReplicas)
+		"replica count should be %d after 9 minutes", minReplicas)
 }
 
 // help function to load template data
diff --git a/tests/internals/scaling_modifiers/scaling_modifiers_test.go b/tests/internals/scaling_modifiers/scaling_modifiers_test.go
index 860046b19..27f211c01 100644
--- a/tests/internals/scaling_modifiers/scaling_modifiers_test.go
+++ b/tests/internals/scaling_modifiers/scaling_modifiers_test.go
@@ -282,7 +282,7 @@ func TestScalingModifiers(t *testing.T) {
 
 	// we ensure that the metrics api server is up and ready
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, metricsServerDeploymentName, namespace, 1, 60, 2),
-		"replica count should be 1 after 1 minute")
+		"replica count should be 1 after 2 minutes")
 
 	testFormula(t, kc, data)
 
@@ -307,7 +307,7 @@ func testFormula(t *testing.T, kc *kubernetes.Clientset, data templateData) {
 	assert.NoErrorf(t, err, "cannot scale workload deployment - %s", err)
 
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, "depl-workload-base", namespace, 2, 12, 10),
-		"replica count should be %d after 1 minute", 2)
+		"replica count should be %d after 2 minutes", 2)
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, namespace, 3, 12, 10),
 		"replica count should be %d after 2 minutes", 3)
 
@@ -326,7 +326,7 @@ func testFormula(t *testing.T, kc *kubernetes.Clientset, data templateData) {
 
 	// we ensure that the metrics api server is up and ready
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, metricsServerDeploymentName, namespace, 1, 60, 2),
-		"replica count should be 1 after 1 minute")
+		"replica count should be 1 after 2 minutes")
 
 	data.MetricValue = 2
 	KubectlReplaceWithTemplate(t, data, "updateMetricsTemplate", updateMetricsTemplate)
diff --git a/tests/internals/trigger_update_so/trigger_update_so_test.go b/tests/internals/trigger_update_so/trigger_update_so_test.go
index 0e400f4b2..598fb804b 100644
--- a/tests/internals/trigger_update_so/trigger_update_so_test.go
+++ b/tests/internals/trigger_update_so/trigger_update_so_test.go
@@ -301,7 +301,7 @@ func TestScaledObjectGeneral(t *testing.T) {
 	CreateKubernetesResources(t, kc, namespace, data, templates)
 
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, namespace, minReplicas, 180, 3),
-		"replica count should be %d after 3 minutes", minReplicas)
+		"replica count should be %d after 9 minutes", minReplicas)
 
 	testTargetValue(t, kc, data)          // one trigger target changes
 	testTwoTriggers(t, kc, data)          // add trigger during active scaling
@@ -320,21 +320,21 @@ func testTargetValue(t *testing.T, kc *kubernetes.Clientset, data templateData)
 	KubectlReplaceWithTemplate(t, data, "updateMetricTemplate", updateMetricTemplate)
 
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, namespace, 1, 180, 3),
-		"replica count should be %d after 3 minutes", 1)
+		"replica count should be %d after 9 minutes", 1)
 
 	t.Log("--- test target value 10 ---")
 	data.MetricValue = 10
 	KubectlReplaceWithTemplate(t, data, "updateMetricTemplate", updateMetricTemplate)
 
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, namespace, maxReplicas, 180, 3),
-		"replica count should be %d after 3 minutes", maxReplicas)
+		"replica count should be %d after 9 minutes", maxReplicas)
 
 	t.Log("--- test target value 0 ---")
 	data.MetricValue = 0
 	KubectlReplaceWithTemplate(t, data, "updateMetricTemplate", updateMetricTemplate)
 
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, namespace, minReplicas, 180, 3),
-		"replica count should be %d after 3 minutes", minReplicas)
+		"replica count should be %d after 9 minutes", minReplicas)
 }
 
 // test adding second trigger during scaling
@@ -346,14 +346,14 @@ func testTwoTriggers(t *testing.T, kc *kubernetes.Clientset, data templateData)
 	KubectlReplaceWithTemplate(t, data, "updateMetricTemplate", updateMetricTemplate)
 
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, namespace, 1, 180, 3),
-		"replica count should be %d after 3 minutes", 1)
+		"replica count should be %d after 9 minutes", 1)
 
 	KubectlApplyWithTemplate(t, data, "scaledObjectTwoTriggerTemplate", scaledObjectTwoTriggerTemplate)
 	// scale to max with k8s wl = second trigger
 	KubernetesScaleDeployment(t, kc, workloadDeploymentName, int64(maxReplicas), namespace)
 
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, namespace, maxReplicas, 180, 3),
-		"replica count should be %d after 3 minutes", maxReplicas)
+		"replica count should be %d after 9 minutes", maxReplicas)
 }
 
 // scales to max with kubernetes worload(second trigger), removes it and
@@ -367,13 +367,13 @@ func testRemoveTrigger(t *testing.T, kc *kubernetes.Clientset, data templateData
 	KubernetesScaleDeployment(t, kc, workloadDeploymentName, int64(maxReplicas), namespace)
 
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, namespace, maxReplicas, 180, 3),
-		"replica count should be %d after 3 minutes", maxReplicas)
+		"replica count should be %d after 9 minutes", maxReplicas)
 
 	// update SO -> remove k8s wl == second trigger
 	KubectlApplyWithTemplate(t, data, "scaledObjectTriggerTemplate", scaledObjectTriggerTemplate)
 
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, namespace, midReplicas, 180, 3),
-		"replica count should be %d after 3 minutes", midReplicas)
+		"replica count should be %d after 9 minutes", midReplicas)
 }
 
 // test 3 triggers scaling works including one cpu metric
@@ -387,7 +387,7 @@ func testThreeTriggersWithCPU(t *testing.T, kc *kubernetes.Clientset, data templ
 	data.MetricValue = 10
 	KubectlReplaceWithTemplate(t, data, "updateMetricTemplate", updateMetricTemplate)
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, namespace, maxReplicas, 180, 3),
-		"replica count should be %d after 3 minutes", maxReplicas)
+		"replica count should be %d after 9 minutes", maxReplicas)
 }
 
 // help function to load template data
diff --git a/tests/internals/update_ta/update_ta_test.go b/tests/internals/update_ta/update_ta_test.go
index 1a5ef57dc..0eeb5a98d 100644
--- a/tests/internals/update_ta/update_ta_test.go
+++ b/tests/internals/update_ta/update_ta_test.go
@@ -275,7 +275,7 @@ func TestTriggerAuthenticationGeneral(t *testing.T) {
 	CreateKubernetesResources(t, kc, namespace, data, templates)
 
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, namespace, minReplicas, 180, 3),
-		"replica count should be %d after 3 minutes", minReplicas)
+		"replica count should be %d after 9 minutes", minReplicas)
 
 	testTriggerAuthenticationStatusValue(t, data, triggerAuthKind)
 
@@ -287,7 +287,7 @@ func TestTriggerAuthenticationGeneral(t *testing.T) {
 	CreateKubernetesResources(t, kc, namespace, data, templates)
 
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, namespace, minReplicas, 180, 3),
-		"replica count should be %d after 3 minutes", minReplicas)
+		"replica count should be %d after 9 minutes", minReplicas)
 
 	testTriggerAuthenticationStatusValue(t, data, clusterTriggerAuthKind)
 	DeleteKubernetesResources(t, namespace, data, templates)
diff --git a/tests/scalers/aws/aws_managed_prometheus/aws_managed_prometheus_test.go b/tests/scalers/aws/aws_managed_prometheus/aws_managed_prometheus_test.go
index 38448fefb..6df8b3c8f 100644
--- a/tests/scalers/aws/aws_managed_prometheus/aws_managed_prometheus_test.go
+++ b/tests/scalers/aws/aws_managed_prometheus/aws_managed_prometheus_test.go
@@ -150,7 +150,7 @@ func TestScaler(t *testing.T) {
 	t.Log("--- assert ---")
 	expectedReplicaCountNumber := 2 // as mentioned above, as the AMP returns 100 and the threshold set to 50, the expected replica count is 100 / 50 = 2
 	assert.Truef(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, testNamespace, 0, 60, 1),
-		"replica count should be %d after a minute", expectedReplicaCountNumber)
+		"replica count should be %d after 1 minute", expectedReplicaCountNumber)
 
 	t.Log("--- cleaning up ---")
 	deleteWSInput := amp.DeleteWorkspaceInput{
diff --git a/tests/scalers/aws/aws_managed_prometheus_pod_identity/aws_managed_prometheus_pod_identity_test.go b/tests/scalers/aws/aws_managed_prometheus_pod_identity/aws_managed_prometheus_pod_identity_test.go
index 5a9d152bb..77da1e6cf 100644
--- a/tests/scalers/aws/aws_managed_prometheus_pod_identity/aws_managed_prometheus_pod_identity_test.go
+++ b/tests/scalers/aws/aws_managed_prometheus_pod_identity/aws_managed_prometheus_pod_identity_test.go
@@ -135,7 +135,7 @@ func TestScaler(t *testing.T) {
 	t.Log("--- assert ---")
 	expectedReplicaCountNumber := 2 // as mentioned above, as the AMP returns 100 and the threshold set to 50, the expected replica count is 100 / 50 = 2
 	assert.Truef(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, testNamespace, 0, 60, 1),
-		"replica count should be %d after a minute", expectedReplicaCountNumber)
+		"replica count should be %d after 1 minute", expectedReplicaCountNumber)
 
 	t.Log("--- cleaning up ---")
 	deleteWSInput := amp.DeleteWorkspaceInput{
diff --git a/tests/scalers/beanstalkd/beanstalkd_test.go b/tests/scalers/beanstalkd/beanstalkd_test.go
index 214226084..6329c5f2b 100644
--- a/tests/scalers/beanstalkd/beanstalkd_test.go
+++ b/tests/scalers/beanstalkd/beanstalkd_test.go
@@ -183,7 +183,7 @@ func TestBeanstalkdScaler(t *testing.T) {
 	CreateKubernetesResources(t, kc, testNamespace, data, templates)
 
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, beanstalkdDeploymentName, testNamespace, 1, 60, 1),
-		"replica count should be 0 after a minute")
+		"replica count should be 0 after 1 minute")
 
 	// test activation
 	testActivation(t, kc, data)
@@ -245,7 +245,7 @@ func testScaleOut(t *testing.T, kc *kubernetes.Clientset, data templateData) {
 	addBeanstalkdJobs(t, kc, &data)
 
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, testNamespace, 3, 60, 1),
-		"replica count should be 3 after a minute")
+		"replica count should be 3 after 1 minute")
 }
 
 func testScaleIn(t *testing.T, kc *kubernetes.Clientset, data templateData) {
@@ -263,5 +263,5 @@ func testScaleIn(t *testing.T, kc *kubernetes.Clientset, data templateData) {
 	removeBeanstalkdJobs(t, kc, &data)
 
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, testNamespace, 0, 60, 1),
-		"replica count should be 0 after a minute")
+		"replica count should be 0 after 1 minute")
 }
diff --git a/tests/scalers/cron/cron_test.go b/tests/scalers/cron/cron_test.go
index a0ff8c64d..c5f85e797 100644
--- a/tests/scalers/cron/cron_test.go
+++ b/tests/scalers/cron/cron_test.go
@@ -100,7 +100,7 @@ func TestScaler(t *testing.T) {
 	CreateKubernetesResources(t, kc, testNamespace, data, templates)
 
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, testNamespace, 1, 60, 2),
-		"replica count should be 1 after 1 minute")
+		"replica count should be 1 after 2 minute")
 
 	// test scaling
 	testScaleOut(t, kc)
@@ -126,11 +126,11 @@ func getTemplateData() (templateData, []Template) {
 func testScaleOut(t *testing.T, kc *kubernetes.Clientset) {
 	t.Log("--- testing scale out ---")
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, testNamespace, 4, 60, 2),
-		"replica count should be 4 after 1 minute")
+		"replica count should be 4 after 2 minutes")
 }
 
 func testScaleIn(t *testing.T, kc *kubernetes.Clientset) {
 	t.Log("--- testing scale in ---")
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, testNamespace, 1, 60, 2),
-		"replica count should be 1 after 1 minute")
+		"replica count should be 1 after 2 minutes")
 }
diff --git a/tests/scalers/datadog/datadog_api/datadog_api_test.go b/tests/scalers/datadog/datadog_api/datadog_api_test.go
index 7027a1966..9a743023d 100644
--- a/tests/scalers/datadog/datadog_api/datadog_api_test.go
+++ b/tests/scalers/datadog/datadog_api/datadog_api_test.go
@@ -272,7 +272,7 @@ func TestDatadogScalerAPI(t *testing.T) {
 	KubectlApplyWithTemplate(t, data, "scaledObjectTemplate", scaledObjectTemplate)
 
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, testNamespace, minReplicaCount, 180, 3),
-		"replica count should be %d after 3 minutes", minReplicaCount)
+		"replica count should be %d after 9 minutes", minReplicaCount)
 
 	// test scaling
 	testActivation(t, kc, data)
diff --git a/tests/scalers/dynatrace/dynatrace_test.go b/tests/scalers/dynatrace/dynatrace_test.go
index 7d20231a9..08edd01c2 100644
--- a/tests/scalers/dynatrace/dynatrace_test.go
+++ b/tests/scalers/dynatrace/dynatrace_test.go
@@ -146,7 +146,7 @@ func TestDynatraceScaler(t *testing.T) {
 	CreateKubernetesResources(t, kc, testNamespace, data, templates)
 
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, testNamespace, minReplicaCount, 60, 1),
-		"replica count should be %s after a minute", minReplicaCount)
+		"replica count should be %s after 1 minute", minReplicaCount)
 
 	// test scaling
 	testActivation(t, kc)
@@ -167,7 +167,7 @@ func testScaleOut(t *testing.T, kc *kubernetes.Clientset) {
 	stopCh := make(chan struct{})
 	go setMetricValue(t, 10, stopCh)
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, testNamespace, maxReplicaCount, 60, 3),
-		"replica count should be %d after 2 minutes", maxReplicaCount)
+		"replica count should be %d after 3 minutes", maxReplicaCount)
 	close(stopCh)
 }
 
@@ -177,7 +177,7 @@ func testScaleIn(t *testing.T, kc *kubernetes.Clientset) {
 	stopCh := make(chan struct{})
 	go setMetricValue(t, 0, stopCh)
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, testNamespace, minReplicaCount, 60, 3),
-		"replica count should be %d after 2 minutes", minReplicaCount)
+		"replica count should be %d after 3 minutes", minReplicaCount)
 	close(stopCh)
 }
 
diff --git a/tests/scalers/gcp/gcp_cloud_tasks/gcp_cloud_tasks_test.go b/tests/scalers/gcp/gcp_cloud_tasks/gcp_cloud_tasks_test.go
index 61cc92e5e..bb811921e 100644
--- a/tests/scalers/gcp/gcp_cloud_tasks/gcp_cloud_tasks_test.go
+++ b/tests/scalers/gcp/gcp_cloud_tasks/gcp_cloud_tasks_test.go
@@ -176,7 +176,7 @@ func TestScaler(t *testing.T) {
 	CreateKubernetesResources(t, kc, testNamespace, data, templates)
 
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, testNamespace, 0, 60, 1),
-		"replica count should be 0 after a minute")
+		"replica count should be 0 after 1 minute")
 
 	sdkReady := WaitForDeploymentReplicaReadyCount(t, kc, "gcp-sdk", testNamespace, 1, 60, 1)
 	assert.True(t, sdkReady, "gcp-sdk deployment should be ready after a minute")
@@ -273,7 +273,7 @@ func testScaleOut(t *testing.T, kc *kubernetes.Clientset) {
 
 	t.Log("--- waiting for replicas to scale out ---")
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, testNamespace, maxReplicaCount, 30, 10),
-		fmt.Sprintf("replica count should be %d after five minutes", maxReplicaCount))
+		fmt.Sprintf("replica count should be %d after 5 minutes", maxReplicaCount))
 }
 
 func testScaleIn(t *testing.T, kc *kubernetes.Clientset) {
@@ -284,5 +284,5 @@ func testScaleIn(t *testing.T, kc *kubernetes.Clientset) {
 
 	t.Log("--- waiting for replicas to scale in to zero ---")
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, testNamespace, 0, 30, 10),
-		"replica count should be 0 after five minute")
+		"replica count should be 0 after 5 minute")
 }
diff --git a/tests/scalers/gcp/gcp_cloud_tasks_workload_identity/gcp_cloud_tasks_workload_identity_test.go b/tests/scalers/gcp/gcp_cloud_tasks_workload_identity/gcp_cloud_tasks_workload_identity_test.go
index 1de52b506..220750363 100644
--- a/tests/scalers/gcp/gcp_cloud_tasks_workload_identity/gcp_cloud_tasks_workload_identity_test.go
+++ b/tests/scalers/gcp/gcp_cloud_tasks_workload_identity/gcp_cloud_tasks_workload_identity_test.go
@@ -186,10 +186,10 @@ func TestScaler(t *testing.T) {
 	CreateKubernetesResources(t, kc, testNamespace, data, templates)
 
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, testNamespace, 0, 60, 1),
-		"replica count should be 0 after a minute")
+		"replica count should be 0 after 1 minute")
 
 	sdkReady := WaitForDeploymentReplicaReadyCount(t, kc, "gcp-sdk", testNamespace, 1, 60, 1)
-	assert.True(t, sdkReady, "gcp-sdk deployment should be ready after a minute")
+	assert.True(t, sdkReady, "gcp-sdk deployment should be ready after 1 minute")
 
 	if sdkReady {
 		if createGcpCloudTasks(t) == nil {
@@ -284,7 +284,7 @@ func testScaleOut(t *testing.T, kc *kubernetes.Clientset) {
 
 	t.Log("--- waiting for replicas to scale out ---")
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, testNamespace, maxReplicaCount, 30, 10),
-		fmt.Sprintf("replica count should be %d after five minutes", maxReplicaCount))
+		fmt.Sprintf("replica count should be %d after 5 minutes", maxReplicaCount))
 }
 
 func testScaleIn(t *testing.T, kc *kubernetes.Clientset) {
@@ -295,5 +295,5 @@ func testScaleIn(t *testing.T, kc *kubernetes.Clientset) {
 
 	t.Log("--- waiting for replicas to scale in to zero ---")
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, testNamespace, 0, 30, 10),
-		"replica count should be 0 after five minute")
+		"replica count should be 0 after 5 minutes")
 }
diff --git a/tests/scalers/gcp/gcp_prometheus_workload_identity/gcp_prometheus_workload_identity_test.go b/tests/scalers/gcp/gcp_prometheus_workload_identity/gcp_prometheus_workload_identity_test.go
index ddf068bf3..b09906109 100644
--- a/tests/scalers/gcp/gcp_prometheus_workload_identity/gcp_prometheus_workload_identity_test.go
+++ b/tests/scalers/gcp/gcp_prometheus_workload_identity/gcp_prometheus_workload_identity_test.go
@@ -122,7 +122,7 @@ func TestScaler(t *testing.T) {
 	t.Log("--- assert ---")
 	expectedReplicaCountNumber := 2 // as mentioned above, as the GMP returns 100 and the threshold set to 50, the expected replica count is 100 / 50 = 2
 	assert.Truef(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, testNamespace, expectedReplicaCountNumber, 60, 1),
-		"replica count should be %d after a minute", expectedReplicaCountNumber)
+		"replica count should be %d after 1 minute", expectedReplicaCountNumber)
 
 	t.Log("--- cleaning up ---")
 	DeleteKubernetesResources(t, testNamespace, data, templates)
diff --git a/tests/scalers/gcp/gcp_pubsub/gcp_pubsub_test.go b/tests/scalers/gcp/gcp_pubsub/gcp_pubsub_test.go
index bfb943453..e88330c04 100644
--- a/tests/scalers/gcp/gcp_pubsub/gcp_pubsub_test.go
+++ b/tests/scalers/gcp/gcp_pubsub/gcp_pubsub_test.go
@@ -178,7 +178,7 @@ func TestScaler(t *testing.T) {
 	CreateKubernetesResources(t, kc, testNamespace, data, templates)
 
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, testNamespace, 0, 60, 1),
-		"replica count should be 0 after a minute")
+		"replica count should be 0 after 1 minute")
 
 	sdkReady := WaitForDeploymentReplicaReadyCount(t, kc, "gcp-sdk", testNamespace, 1, 60, 1)
 	assert.True(t, sdkReady, "gcp-sdk deployment should be ready after a minute")
@@ -282,7 +282,7 @@ func testScaleOut(t *testing.T, kc *kubernetes.Clientset) {
 
 	t.Log("--- waiting for replicas to scale out ---")
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, testNamespace, maxReplicaCount, 30, 10),
-		fmt.Sprintf("replica count should be %d after five minutes", maxReplicaCount))
+		fmt.Sprintf("replica count should be %d after 5 minutes", maxReplicaCount))
 }
 
 func testScaleIn(t *testing.T, kc *kubernetes.Clientset) {
@@ -293,5 +293,5 @@ func testScaleIn(t *testing.T, kc *kubernetes.Clientset) {
 
 	t.Log("--- waiting for replicas to scale in to zero ---")
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, testNamespace, 0, 30, 10),
-		"replica count should be 0 after five minute")
+		"replica count should be 0 after 5 minutes")
 }
diff --git a/tests/scalers/kubernetes_workload/kubernetes_workload_test.go b/tests/scalers/kubernetes_workload/kubernetes_workload_test.go
index b72769762..2a76b3501 100644
--- a/tests/scalers/kubernetes_workload/kubernetes_workload_test.go
+++ b/tests/scalers/kubernetes_workload/kubernetes_workload_test.go
@@ -131,24 +131,24 @@ func testScaleOut(t *testing.T, kc *kubernetes.Clientset) {
 	// scale monitored deployment to 5 replicas
 	KubernetesScaleDeployment(t, kc, monitoredDeploymentName, 5, testNamespace)
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, sutDeploymentName, testNamespace, 5, 60, 2),
-		"replica count should be 5 after 1 minute")
+		"replica count should be 5 after 2 minutes")
 
 	// scale monitored deployment to 10 replicas
 	KubernetesScaleDeployment(t, kc, monitoredDeploymentName, 10, testNamespace)
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, sutDeploymentName, testNamespace, 10, 60, 2),
-		"replica count should be 10 after 1 minute")
+		"replica count should be 10 after 2 minutes")
 }
 
 func testScaleIn(t *testing.T, kc *kubernetes.Clientset) {
 	// scale monitored deployment to 5 replicas
 	KubernetesScaleDeployment(t, kc, monitoredDeploymentName, 5, testNamespace)
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, sutDeploymentName, testNamespace, 5, 60, 2),
-		"replica count should be 5 after 1 minute")
+		"replica count should be 5 after 2 minutes")
 
 	// scale monitored deployment to 0 replicas
 	KubernetesScaleDeployment(t, kc, monitoredDeploymentName, 0, testNamespace)
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, sutDeploymentName, testNamespace, 0, 60, 2),
-		"replica count should be 0 after 1 minute")
+		"replica count should be 0 after 2 minutes")
 }
 
 func getTemplateData() (templateData, []Template) {
diff --git a/tests/scalers/metrics_api/metrics_api_test.go b/tests/scalers/metrics_api/metrics_api_test.go
index c3229502d..b339e5309 100644
--- a/tests/scalers/metrics_api/metrics_api_test.go
+++ b/tests/scalers/metrics_api/metrics_api_test.go
@@ -194,7 +194,7 @@ func TestScaler(t *testing.T) {
 	CreateKubernetesResources(t, kc, testNamespace, data, templates)
 
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, testNamespace, minReplicaCount, 180, 3),
-		"replica count should be %d after 3 minutes", minReplicaCount)
+		"replica count should be %d after 9 minutes", minReplicaCount)
 
 	// test scaling
 	testActivation(t, kc, data)
diff --git a/tests/scalers/mysql/mysql_test.go b/tests/scalers/mysql/mysql_test.go
index c192b5515..c1986fb50 100644
--- a/tests/scalers/mysql/mysql_test.go
+++ b/tests/scalers/mysql/mysql_test.go
@@ -291,9 +291,9 @@ func testScaleOut(t *testing.T, kc *kubernetes.Clientset, data templateData) {
 
 func testScaleIn(t *testing.T, kc *kubernetes.Clientset) {
 	t.Log("--- testing scale in ---")
-	// Check if deployment scale in to 0 after 5 minutes
+	// Check if deployment scale in to 0 after 6 minutes
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, testNamespace, 0, 360, 1),
-		"Replica count should be 0 after 5 minutes")
+		"Replica count should be 0 after 6 minutes")
 }
 
 func getTemplateData() (templateData, []Template) {
diff --git a/tests/scalers/redis/redis_standalone_streams_lag/redis_standalone_streams_lag_test.go b/tests/scalers/redis/redis_standalone_streams_lag/redis_standalone_streams_lag_test.go
index 4de773e5e..4571284f0 100644
--- a/tests/scalers/redis/redis_standalone_streams_lag/redis_standalone_streams_lag_test.go
+++ b/tests/scalers/redis/redis_standalone_streams_lag/redis_standalone_streams_lag_test.go
@@ -208,12 +208,12 @@ func testScaleOut(t *testing.T, kc *kubernetes.Clientset, data templateData, num
 	KubectlReplaceWithTemplate(t, data, "insertJobTemplate", insertJobTemplate)
 
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, testNamespace, maxReplicas, 60, 1),
-		"replica count should be %d after 3 minutes", maxReplicaCount)
+		"replica count should be %d after 1 minute", maxReplicaCount)
 }
 
 func testScaleIn(t *testing.T, kc *kubernetes.Clientset, minReplicas int) {
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, testNamespace, minReplicas, 60, 1),
-		"replica count should be %d after 3 minutes", minReplicaCount)
+		"replica count should be %d after 1 minute", minReplicaCount)
 }
 
 func testActivationValue(t *testing.T, kc *kubernetes.Clientset, data templateData, numMessages int) {
diff --git a/tests/scalers/splunk/splunk_test.go b/tests/scalers/splunk/splunk_test.go
index 399d07495..328803842 100644
--- a/tests/scalers/splunk/splunk_test.go
+++ b/tests/scalers/splunk/splunk_test.go
@@ -232,11 +232,11 @@ func TestSplunkScaler(t *testing.T) {
 
 	// Wait for splunk to start
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, "splunk", testNamespace, 1, 180, 3),
-		"replica count should be %d after 3 minutes", 1)
+		"replica count should be %d after 9 minutes", 1)
 
 	// Ensure nginx deployment is at min replica count
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, testNamespace, minReplicaCount, 180, 3),
-		"replica count should be %d after 3 minutes", minReplicaCount)
+		"replica count should be %d after 9 minutes", minReplicaCount)
 
 	// test scaling
 	testActivation(t, kc)
diff --git a/tests/scalers/sumologic/sumologic_test.go b/tests/scalers/sumologic/sumologic_test.go
index 989851aca..e3d145f07 100644
--- a/tests/scalers/sumologic/sumologic_test.go
+++ b/tests/scalers/sumologic/sumologic_test.go
@@ -172,7 +172,7 @@ func TestSumologicScaler(t *testing.T) {
 
 	// Ensure deployment is at min replica count
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, testNamespace, minReplicaCount, 180, 3),
-		"replica count should be %d after 3 minutes", minReplicaCount)
+		"replica count should be %d after 9 minutes", minReplicaCount)
 
 	// Test scaling
 	testActivation(t, kc)
diff --git a/tests/secret-providers/trigger_auth_bound_service_account_token/trigger_auth_bound_service_account_token_test.go b/tests/secret-providers/trigger_auth_bound_service_account_token/trigger_auth_bound_service_account_token_test.go
index 94a4dba01..0975f2cfa 100644
--- a/tests/secret-providers/trigger_auth_bound_service_account_token/trigger_auth_bound_service_account_token_test.go
+++ b/tests/secret-providers/trigger_auth_bound_service_account_token/trigger_auth_bound_service_account_token_test.go
@@ -344,7 +344,7 @@ func testScaleOut(t *testing.T, kc *kubernetes.Clientset, data templateData) {
 	KubectlReplaceWithTemplate(t, data, "updateMetricTemplate", updateMetricTemplate)
 
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, testNamespace, maxReplicaCount, 60, maxReplicaCount),
-		"replica count should be %d after 3 minutes", maxReplicaCount)
+		"replica count should be %d after 1 minute", maxReplicaCount)
 }
 
 func testScaleIn(t *testing.T, kc *kubernetes.Clientset, data templateData) {
diff --git a/tests/sequential/datadog_dca/datadog_dca_test.go b/tests/sequential/datadog_dca/datadog_dca_test.go
index 210003fb0..c4cb0bf2f 100644
--- a/tests/sequential/datadog_dca/datadog_dca_test.go
+++ b/tests/sequential/datadog_dca/datadog_dca_test.go
@@ -356,7 +356,7 @@ func TestDatadogScalerDCA(t *testing.T) {
 	KubectlApplyWithTemplate(t, data, "scaledObjectTemplate", scaledObjectTemplate)
 
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, testNamespace, minReplicaCount, 180, 3),
-		"replica count should be %d after 3 minutes", minReplicaCount)
+		"replica count should be %d after 9 minutes", minReplicaCount)
 
 	// test scaling
 	testActivation(t, kc, data)