diff --git a/pkg/apis/pipeline/v1beta1/when_types.go b/pkg/apis/pipeline/v1beta1/when_types.go
index 00fa3b3c5fe..ab5cf01d2dd 100644
--- a/pkg/apis/pipeline/v1beta1/when_types.go
+++ b/pkg/apis/pipeline/v1beta1/when_types.go
@@ -25,16 +25,61 @@ import (
 type WhenExpression struct {
 	// Input is the string for guard checking which can be a static input or an output from a parent Task
 	Input string `json:"input"`
+
+	// DeprecatedInput for backwards compatibility with <v0.17
+	// it is the string for guard checking which can be a static input or an output from a parent Task
+	// +optional
+	DeprecatedInput string `json:"Input,omitempty"`
+
 	// Operator that represents an Input's relationship to the values
 	Operator selection.Operator `json:"operator"`
+
+	// DeprecatedOperator for backwards compatibility with <v0.17
+	// it represents a DeprecatedInput's relationship to the DeprecatedValues
+	// +optional
+	DeprecatedOperator selection.Operator `json:"Operator,omitempty"`
+
 	// Values is an array of strings, which is compared against the input, for guard checking
 	// It must be non-empty
 	Values []string `json:"values"`
+
+	// DeprecatedValues for backwards compatibility with <v0.17
+	// it represents a DeprecatedInput's relationship to the DeprecatedValues
+	// +optional
+	DeprecatedValues []string `json:"Values,omitempty"`
+}
+
+// GetInput returns the input string for guard checking
+// based on DeprecatedInput (<v0.17) and Input
+func (we *WhenExpression) GetInput() string {
+	if we.Input == "" {
+		return we.DeprecatedInput
+	}
+	return we.Input
+}
+
+// GetOperator returns the relationship between input and values
+// based on DeprecatedOperator (<v0.17) and Operator
+func (we *WhenExpression) GetOperator() selection.Operator {
+	if we.Operator == "" {
+		return we.DeprecatedOperator
+	}
+	return we.Operator
+}
+
+// GetValues returns an array of strings which is compared against the input
+// based on DeprecatedValues (<v0.17) and Values
+func (we *WhenExpression) GetValues() []string {
+	if we.Values == nil {
+		return we.DeprecatedValues
+	}
+	return we.Values
 }
 
 func (we *WhenExpression) isInputInValues() bool {
-	for i := range we.Values {
-		if we.Values[i] == we.Input {
+	values := we.GetValues()
+	for i := range values {
+		if values[i] == we.GetInput() {
 			return true
 		}
 	}
@@ -42,7 +87,7 @@ func (we *WhenExpression) isInputInValues() bool {
 }
 
 func (we *WhenExpression) isTrue() bool {
-	if we.Operator == selection.In {
+	if we.GetOperator() == selection.In {
 		return we.isInputInValues()
 	}
 	// selection.NotIn
@@ -57,21 +102,21 @@ func (we *WhenExpression) hasVariable() bool {
 }
 
 func (we *WhenExpression) applyReplacements(replacements map[string]string) WhenExpression {
-	replacedInput := ApplyReplacements(we.Input, replacements)
+	replacedInput := ApplyReplacements(we.GetInput(), replacements)
 
 	var replacedValues []string
-	for _, val := range we.Values {
+	for _, val := range we.GetValues() {
 		replacedValues = append(replacedValues, ApplyReplacements(val, replacements))
 	}
 
-	return WhenExpression{Input: replacedInput, Operator: we.Operator, Values: replacedValues}
+	return WhenExpression{Input: replacedInput, Operator: we.GetOperator(), Values: replacedValues}
 }
 
 // GetVarSubstitutionExpressions extracts all the values between "$(" and ")" in a When Expression
 func (we *WhenExpression) GetVarSubstitutionExpressions() ([]string, bool) {
 	var allExpressions []string
-	allExpressions = append(allExpressions, validateString(we.Input)...)
-	for _, value := range we.Values {
+	allExpressions = append(allExpressions, validateString(we.GetInput())...)
+	for _, value := range we.GetValues() {
 		allExpressions = append(allExpressions, validateString(value)...)
 	}
 	return allExpressions, len(allExpressions) != 0
diff --git a/pkg/apis/pipeline/v1beta1/when_validation.go b/pkg/apis/pipeline/v1beta1/when_validation.go
index e9803017503..d543c430643 100644
--- a/pkg/apis/pipeline/v1beta1/when_validation.go
+++ b/pkg/apis/pipeline/v1beta1/when_validation.go
@@ -48,13 +48,26 @@ func (we *WhenExpression) validateWhenExpressionFields() *apis.FieldError {
 	if equality.Semantic.DeepEqual(we, &WhenExpression{}) || we == nil {
 		return apis.ErrMissingField(apis.CurrentField)
 	}
-	if !sets.NewString(validWhenOperators...).Has(string(we.Operator)) {
-		message := fmt.Sprintf("operator %q is not recognized. valid operators: %s", we.Operator, strings.Join(validWhenOperators, ","))
+	if !sets.NewString(validWhenOperators...).Has(string(we.GetOperator())) {
+		message := fmt.Sprintf("operator %q is not recognized. valid operators: %s", we.GetOperator(), strings.Join(validWhenOperators, ","))
 		return apis.ErrInvalidValue(message, apis.CurrentField)
 	}
-	if len(we.Values) == 0 {
+	if len(we.GetValues()) == 0 {
 		return apis.ErrInvalidValue("expecting non-empty values field", apis.CurrentField)
 	}
+	return validateWhenExpressionsDuplicateFields()
+}
+
+func (we *WhenExpression) validateWhenExpressionsDuplicateFields() *apis.FieldError {
+	if we.Input != "" && we.DeprecatedInput != "" {
+		return apis.ErrMultipleOneOf("input", "Input")
+	}
+	if we.Operator != "" && we.DeprecatedOperator != "" {
+		return apis.ErrMultipleOneOf("operator", "Operator")
+	}
+	if we.Values != nil && we.DeprecatedValues != nil {
+		return apis.ErrMultipleOneOf("values", "Values")
+	}
 	return nil
 }
 
@@ -77,8 +90,8 @@ func (wes WhenExpressions) validateTaskResultsVariables() *apis.FieldError {
 
 func (wes WhenExpressions) validatePipelineParametersVariables(prefix string, paramNames sets.String, arrayParamNames sets.String) (errs *apis.FieldError) {
 	for idx, we := range wes {
-		errs = errs.Also(validateStringVariable(we.Input, prefix, paramNames, arrayParamNames).ViaField("input").ViaFieldIndex("when", idx))
-		for _, val := range we.Values {
+		errs = errs.Also(validateStringVariable(we.GetInput(), prefix, paramNames, arrayParamNames).ViaField("input").ViaFieldIndex("when", idx))
+		for _, val := range we.GetValues() {
 			errs = errs.Also(validateStringVariable(val, prefix, paramNames, arrayParamNames).ViaField("values").ViaFieldIndex("when", idx))
 		}
 	}
diff --git a/pkg/apis/pipeline/v1beta1/zz_generated.deepcopy.go b/pkg/apis/pipeline/v1beta1/zz_generated.deepcopy.go
index 9919cb07854..ae8838ff3a6 100644
--- a/pkg/apis/pipeline/v1beta1/zz_generated.deepcopy.go
+++ b/pkg/apis/pipeline/v1beta1/zz_generated.deepcopy.go
@@ -1767,6 +1767,11 @@ func (in *WhenExpression) DeepCopyInto(out *WhenExpression) {
 		*out = make([]string, len(*in))
 		copy(*out, *in)
 	}
+	if in.DeprecatedValues != nil {
+		in, out := &in.DeprecatedValues, &out.DeprecatedValues
+		*out = make([]string, len(*in))
+		copy(*out, *in)
+	}
 	return
 }
 
diff --git a/pkg/reconciler/pipelinerun/resources/resultrefresolution.go b/pkg/reconciler/pipelinerun/resources/resultrefresolution.go
index 2830b175c14..1a43afca6f2 100644
--- a/pkg/reconciler/pipelinerun/resources/resultrefresolution.go
+++ b/pkg/reconciler/pipelinerun/resources/resultrefresolution.go
@@ -186,7 +186,7 @@ func convertWhenExpressions(whenExpressions []v1beta1.WhenExpression, pipelineRu
 		if ok {
 			resolvedResultRefs, err := extractResultRefs(expressions, pipelineRunState)
 			if err != nil {
-				return nil, fmt.Errorf("unable to find result referenced by when expression with input %q in task %q: %w", whenExpression.Input, name, err)
+				return nil, fmt.Errorf("unable to find result referenced by when expression with input %q in task %q: %w", whenExpression.GetInput(), name, err)
 			}
 			if resolvedResultRefs != nil {
 				resolvedWhenExpressions = append(resolvedWhenExpressions, resolvedResultRefs...)