Repository: tektoncd/operator
Pull request #656 (2022-03-07 03:42:05)

Rename the TektonChains CRD to TektonChain
This will fix the naming of TektonChains CRD.
Now the singular will be TektonChain instead of
TektonChains as it will be consistent with other CRDS
available

Follow up of #630 

# Submitter Checklist

These are the criteria that every PR should meet, please check them off as you
review them:

- [x] Includes [tests](https://github.com/tektoncd/community/blob/master/standards.md#principles) (if functionality changed/added)
- [x] Includes [docs](https://github.com/tektoncd/community/blob/master/standards.md#principles) (if user facing)
- [x] Commit messages follow [commit message best practices](https://github.com/tektoncd/community/blob/master/standards.md#commit-messages)

_See [the contribution guide](https://github.com/tektoncd/operator/blob/master/CONTRIBUTING.md) for more details._

# Release Notes

```release-note
Rename the TektonChains CRD to TektonChain
```



tekton-robot: [APPROVALNOTIFIER] This PR is **NOT APPROVED**

This pull-request has been approved by:
To complete the [pull request process](https://git.k8s.io/community/contributors/guide/owners.md#the-code-review-process), please assign **vincent-pli**
You can assign the PR to them by writing `/assign @vincent-pli` in a comment when ready.

The full list of commands accepted by this bot can be found [here](https://go.k8s.io/bot-commands?repo=tektoncd%2Foperator).

<details open>
Needs approval from an approver in each of these files:

- **[OWNERS](https://github.com/tektoncd/operator/blob/main/OWNERS)**

Approvers can indicate their approval by writing `/approve` in a comment
Approvers can cancel approval by writing `/approve cancel` in a comment
</details>
<!-- META={"approvers":["vincent-pli"]} -->
tekton-robot: The following is the coverage report on the affected files.
Say `/test pull-tekton-operator-go-coverage` to re-run this coverage report

File | Old Coverage | New Coverage | Delta
---- |:------------:|:------------:|:-----:
[pkg/apis/operator/v1alpha1/tektonchain_lifecycle.go](https://storage.cloud.google.com/tekton-prow/pr-logs/pull/tektoncd_operator/656/pull-tekton-operator-go-coverage/1500678227507548160/artifacts/line-cov.html#file1) | Do not exist | 43.8% | 
[pkg/apis/operator/v1alpha1/tektonchain_types.go](https://storage.cloud.google.com/tekton-prow/pr-logs/pull/tektoncd_operator/656/pull-tekton-operator-go-coverage/1500678227507548160/artifacts/line-cov.html#file2) | Do not exist | 0.0% | 
[pkg/apis/operator/v1alpha1/tektonchain_validation.go](https://storage.cloud.google.com/tekton-prow/pr-logs/pull/tektoncd_operator/656/pull-tekton-operator-go-coverage/1500678227507548160/artifacts/line-cov.html#file3) | Do not exist | 75.0% | 
[pkg/reconciler/shared/tektonconfig/chain/chain.go](https://storage.cloud.google.com/tekton-prow/pr-logs/pull/tektoncd_operator/656/pull-tekton-operator-go-coverage/1500678227507548160/artifacts/line-cov.html#file7) | Do not exist | 61.8% | 

sm43: /approve

tekton-robot: [APPROVALNOTIFIER] This PR is **APPROVED**

This pull-request has been approved by: *<a href="https://github.com/tektoncd/operator/pull/656#issuecomment-1060162920" title="Approved">sm43</a>*

The full list of commands accepted by this bot can be found [here](https://go.k8s.io/bot-commands?repo=tektoncd%2Foperator).

The pull request process is described [here](https://git.k8s.io/community/contributors/guide/owners.md#the-code-review-process)

<details >
Needs approval from an approver in each of these files:

- ~~[OWNERS](https://github.com/tektoncd/operator/blob/main/OWNERS)~~ [sm43]

Approvers can indicate their approval by writing `/approve` in a comment
Approvers can cancel approval by writing `/approve cancel` in a comment
</details>
<!-- META={"approvers":[]} -->
tekton-robot: @piyush-garg: The following test **failed**, say `/retest` to rerun them all:

Test name | Commit | Details | Rerun command
--- | --- | --- | ---
pull-tekton-operator-integration-tests | eaa4e759ac8d7f714c45d82573c36913c56cee9b | [link](https://tekton-releases.appspot.com/build/tekton-prow/pr-logs/pull/tektoncd_operator/656/pull-tekton-operator-integration-tests/1500678227507548161/) | `/test pull-tekton-operator-integration-tests`

[Full PR test history](https://tekton-releases.appspot.com/pr/tektoncd_operator/656). [Your PR dashboard](https://prow.tekton.dev/pr/piyush-garg).

<details>

Instructions for interacting with me using PR comments are available [here](https://git.k8s.io/community/contributors/guide/pull-requests.md).  If you have questions or suggestions related to my behavior, please file an issue against the [kubernetes/test-infra](https://github.com/kubernetes/test-infra/issues/new?title=Prow%20issue:) repository. I understand the commands that are listed [here](https://go.k8s.io/bot-commands).
</details>
<!-- test report -->
tekton-robot: @piyush-garg: The following test **failed**, say `/retest` to rerun them all:

Test name | Commit | Details | Rerun command
--- | --- | --- | ---
pull-tekton-operator-integration-tests | eaa4e759ac8d7f714c45d82573c36913c56cee9b | [link](https://tekton-releases.appspot.com/build/tekton-prow/pr-logs/pull/tektoncd_operator/656/pull-tekton-operator-integration-tests/1500678227507548161/) | `/test pull-tekton-operator-integration-tests`

[Full PR test history](https://tekton-releases.appspot.com/pr/tektoncd_operator/656). [Your PR dashboard](https://prow.tekton.dev/pr/piyush-garg).

<details>

Instructions for interacting with me using PR comments are available [here](https://git.k8s.io/community/contributors/guide/pull-requests.md).  If you have questions or suggestions related to my behavior, please file an issue against the [kubernetes/test-infra](https://github.com/kubernetes/test-infra/issues/new?title=Prow%20issue:) repository. I understand the commands that are listed [here](https://go.k8s.io/bot-commands).
</details>
<!-- test report -->
piyush-garg: /retest
savitaashture: /lgtm

:tada: 

Patch:
diff --git a/cmd/kubernetes/operator/main.go b/cmd/kubernetes/operator/main.go
index 181aa85dd..7693125ed 100644
--- a/cmd/kubernetes/operator/main.go
+++ b/cmd/kubernetes/operator/main.go
@@ -17,7 +17,7 @@ limitations under the License.
 package main
 
 import (
-	"github.com/tektoncd/operator/pkg/reconciler/kubernetes/tektonchains"
+	"github.com/tektoncd/operator/pkg/reconciler/kubernetes/tektonchain"
 	"github.com/tektoncd/operator/pkg/reconciler/kubernetes/tektonconfig"
 	"github.com/tektoncd/operator/pkg/reconciler/kubernetes/tektondashboard"
 	"github.com/tektoncd/operator/pkg/reconciler/kubernetes/tektonhub"
@@ -37,6 +37,6 @@ func main() {
 		tektonresult.NewController,
 		tektoninstallerset.NewController,
 		tektonhub.NewController,
-		tektonchains.NewController,
+		tektonchain.NewController,
 	)
 }
diff --git a/cmd/openshift/operator/main.go b/cmd/openshift/operator/main.go
index def786d94..942cb7c83 100644
--- a/cmd/openshift/operator/main.go
+++ b/cmd/openshift/operator/main.go
@@ -19,7 +19,7 @@ package main
 import (
 	"github.com/tektoncd/operator/pkg/reconciler/kubernetes/tektoninstallerset"
 	"github.com/tektoncd/operator/pkg/reconciler/openshift/tektonaddon"
-	"github.com/tektoncd/operator/pkg/reconciler/openshift/tektonchains"
+	"github.com/tektoncd/operator/pkg/reconciler/openshift/tektonchain"
 	"github.com/tektoncd/operator/pkg/reconciler/openshift/tektonconfig"
 	"github.com/tektoncd/operator/pkg/reconciler/openshift/tektonhub"
 	"github.com/tektoncd/operator/pkg/reconciler/openshift/tektonpipeline"
@@ -35,6 +35,6 @@ func main() {
 		tektonconfig.NewController,
 		tektoninstallerset.NewController,
 		tektonhub.NewController,
-		tektonchains.NewController,
+		tektonchain.NewController,
 	)
 }
diff --git a/config/base/300-operator_v1alpha1_chains_crd.yaml b/config/base/300-operator_v1alpha1_chain_crd.yaml
similarity index 90%
rename from config/base/300-operator_v1alpha1_chains_crd.yaml
rename to config/base/300-operator_v1alpha1_chain_crd.yaml
index 4765bdbaa..6308212d6 100644
--- a/config/base/300-operator_v1alpha1_chains_crd.yaml
+++ b/config/base/300-operator_v1alpha1_chain_crd.yaml
@@ -15,16 +15,17 @@
 apiVersion: apiextensions.k8s.io/v1
 kind: CustomResourceDefinition
 metadata:
-  name: tektonchainses.operator.tekton.dev
+  name: tektonchains.operator.tekton.dev
   labels:
     version: "devel"
     operator.tekton.dev/release: "devel"
 spec:
   group: operator.tekton.dev
   names:
-    kind: TektonChains
-    singular: tektonchains
-    plural: tektonchainses
+    kind: TektonChain
+    listKind: TektonChainList
+    singular: tektonchain
+    plural: tektonchains
   preserveUnknownFields: false
   scope: Cluster
   versions:
diff --git a/config/base/kustomization.yaml b/config/base/kustomization.yaml
index 01495bac7..5152ad591 100644
--- a/config/base/kustomization.yaml
+++ b/config/base/kustomization.yaml
@@ -18,7 +18,7 @@ resources:
 - 300-operator_v1alpha1_pipeline_crd.yaml
 - 300-operator_v1alpha1_trigger_crd.yaml
 - 300-operator_v1alpha1_config_crd.yaml
-- 300-operator_v1alpha1_chains_crd.yaml
+- 300-operator_v1alpha1_chain_crd.yaml
 - 300-operator_v1alpha1_installer_set_crd.yaml
 - 300-operator_v1alpha1_hub_crd.yaml
 - config-logging.yaml
diff --git a/config/crs/kubernetes/chains/operator_v1alpha1_chains_cr.yaml b/config/crs/kubernetes/chain/operator_v1alpha1_chain_cr.yaml
similarity index 95%
rename from config/crs/kubernetes/chains/operator_v1alpha1_chains_cr.yaml
rename to config/crs/kubernetes/chain/operator_v1alpha1_chain_cr.yaml
index 44cafdc91..9fdfe5631 100644
--- a/config/crs/kubernetes/chains/operator_v1alpha1_chains_cr.yaml
+++ b/config/crs/kubernetes/chain/operator_v1alpha1_chain_cr.yaml
@@ -13,8 +13,8 @@
 # limitations under the License.
 
 apiVersion: operator.tekton.dev/v1alpha1
-kind: TektonChains
+kind: TektonChain
 metadata:
-  name: chains
+  name: chain
 spec:
   targetNamespace: tekton-pipelines
diff --git a/config/crs/kubernetes/kustomization.yaml b/config/crs/kubernetes/kustomization.yaml
index 1494dc985..7671f70ec 100644
--- a/config/crs/kubernetes/kustomization.yaml
+++ b/config/crs/kubernetes/kustomization.yaml
@@ -7,4 +7,4 @@ resources:
 - trigger/operator_v1alpha1_trigger_cr.yaml
 - config/all/operator_v1alpha1_config_cr.yaml
 - installerset/operator_v1alpha1_installerset_cr.yaml
-- chains/operator_v1alpha1_chains_cr.yaml
+- chain/operator_v1alpha1_chain_cr.yaml
diff --git a/config/crs/openshift/chains/operator_v1alpha1_chains_cr.yaml b/config/crs/openshift/chain/operator_v1alpha1_chain_cr.yaml
similarity index 95%
rename from config/crs/openshift/chains/operator_v1alpha1_chains_cr.yaml
rename to config/crs/openshift/chain/operator_v1alpha1_chain_cr.yaml
index 8596dbdd7..adfe5309b 100644
--- a/config/crs/openshift/chains/operator_v1alpha1_chains_cr.yaml
+++ b/config/crs/openshift/chain/operator_v1alpha1_chain_cr.yaml
@@ -13,8 +13,8 @@
 # limitations under the License.
 
 apiVersion: operator.tekton.dev/v1alpha1
-kind: TektonChains
+kind: TektonChain
 metadata:
-  name: chains
+  name: chain
 spec:
   targetNamespace: openshift-pipelines
diff --git a/config/crs/openshift/kustomization.yaml b/config/crs/openshift/kustomization.yaml
index 58c68f68d..a8fa605a9 100644
--- a/config/crs/openshift/kustomization.yaml
+++ b/config/crs/openshift/kustomization.yaml
@@ -4,6 +4,6 @@ resources:
 - pipeline/operator_v1alpha1_pipeline_cr.yaml
 - trigger/operator_v1alpha1_trigger_cr.yaml
 - installerset/operator_v1alpha1_installerset_cr.yaml
-- chains/operator_v1alpha1_chains_cr.yaml
+- chain/operator_v1alpha1_chain_cr.yaml
 apiVersion: kustomize.config.k8s.io/v1beta1
 kind: Kustomization
diff --git a/docs/README.md b/docs/README.md
index 09c3f9686..e8070b8d9 100644
--- a/docs/README.md
+++ b/docs/README.md
@@ -47,8 +47,8 @@ Tekton Operator defines the following entities:
     <td>Configure the <a HREF="https://github.com/tektoncd/results">Tekton Result</a> component to be installed and managed.</td>
   </tr>
   <tr>
-    <td><code>TektonChains</code></td>
-    <td>Configure the <a HREF="https://github.com/tektoncd/chains">Tekton Chains</a> component to be installed and managed.</td>
+    <td><code>TektonChain</code></td>
+    <td>Configure the <a HREF="https://github.com/tektoncd/chains">Tekton Chain</a> component to be installed and managed.</td>
   </tr>
   <tr>
     <td><code>TektonAddon</code></td>
@@ -94,7 +94,7 @@ You can find more about the Resources and its available configurations in their
 - [TektonTrigger](./TektonTrigger.md)
 - [TektonDashboard](./TektonDashboard.md)
 - [TektonResult](./TektonResult.md)
-- [TektonChains](./TektonChains.md)
+- [TektonChain](./TektonChain.md)
 - [TektonAddon](./TektonAddon.md)
 
 To understand how Tekton Operator works, you can find the details [here](TektonOperator.md)
diff --git a/docs/TektonChains.md b/docs/TektonChain.md
similarity index 65%
rename from docs/TektonChains.md
rename to docs/TektonChain.md
index e9c4471de..806e58138 100644
--- a/docs/TektonChains.md
+++ b/docs/TektonChain.md
@@ -1,21 +1,21 @@
 <!--
 ---
-linkTitle: "TektonChains"
+linkTitle: "TektonChain"
 weight: 9
 ---
 -->
-# Tekton Chains
+# Tekton Chain
 
-TektonChains custom resource allows user to install and manage [Tekton Chains][chains]. 
+TektonChain custom resource allows user to install and manage [Tekton Chains][chains].
 
 It is recommended to install the components through [TektonConfig](./TektonConfig.md).
 
-The TektonChains CR is as below:
+The TektonChain CR is as below:
 ```yaml
 apiVersion: operator.tekton.dev/v1alpha1
-kind: TektonChains
+kind: TektonChain
 metadata:
-  name: chains
+  name: chain
 spec:
   targetNamespace: tekton-pipelines
 ```
diff --git a/docs/TektonConfig.md b/docs/TektonConfig.md
index cec82e5ec..4dddcb414 100644
--- a/docs/TektonConfig.md
+++ b/docs/TektonConfig.md
@@ -13,7 +13,7 @@ Operator provides support for installing and managing following operator compone
 
 - [TektonPipeline](./TektonPipeline.md)
 - [TektonTrigger](./TektonTrigger.md)
-- [TektonChains](./TektonChains.md)
+- [TektonChain](./TektonChain.md)
 
 Other than the above components depending on the platform operator also provides support for
 
@@ -74,7 +74,7 @@ By default, namespace would be `tekton-pipelines` for Kubernetes and `openshift-
 
 This allows user to choose which all components to install on the cluster.
 There are 3 profiles available:
-- `all`: This profile will install all components (TektonPipeline, TektonTrigger and TektonChains)
+- `all`: This profile will install all components (TektonPipeline, TektonTrigger and TektonChain)
 - `basic`:  This profile will install only TektonPipeline and TektonTrigger component
 - `lite`: This profile will install only TektonPipeline component
 
diff --git a/hack/fetch-releases.sh b/hack/fetch-releases.sh
index 1a3eb51e9..262d23778 100755
--- a/hack/fetch-releases.sh
+++ b/hack/fetch-releases.sh
@@ -159,7 +159,7 @@ release_yaml_hub() {
   done
 }
 
-#Args: <target-platform> <pipelines version> <triggers version> <dashboard version> <results version> <pac version> <hub version> <chains version>
+#Args: <target-platform> <pipelines version> <triggers version> <dashboard version> <results version> <pac version> <hub version> <chain version>
 main() {
   TARGET=$1
   p_version=${2}
diff --git a/pkg/apis/operator/v1alpha1/const.go b/pkg/apis/operator/v1alpha1/const.go
index 42df244d1..9f2d4192c 100644
--- a/pkg/apis/operator/v1alpha1/const.go
+++ b/pkg/apis/operator/v1alpha1/const.go
@@ -98,5 +98,5 @@ var (
 	ConfigResourceName    = "config"
 	ResultResourceName    = "result"
 	HubResourceName       = "hub"
-	ChainsResourceName    = "chains"
+	ChainResourceName     = "chain"
 )
diff --git a/pkg/apis/operator/v1alpha1/register.go b/pkg/apis/operator/v1alpha1/register.go
index f72c1bfed..0bdfcfee3 100644
--- a/pkg/apis/operator/v1alpha1/register.go
+++ b/pkg/apis/operator/v1alpha1/register.go
@@ -53,8 +53,8 @@ const (
 	// KindTektonHub is the Kind of TektonHub in a GVK context.
 	KindTektonHub = "TektonHub"
 
-	// KindTektonChains is the Kind of Tekton Chains in a GVK context.
-	KindTektonChains = "TektonChains"
+	// KindTektonChain is the Kind of Tekton Chain in a GVK context.
+	KindTektonChain = "TektonChain"
 )
 
 // Resource takes an unqualified resource and returns a Group qualified GroupResource
@@ -82,8 +82,8 @@ func addKnownTypes(s *runtime.Scheme) error {
 		&TektonInstallerSetList{},
 		&TektonHub{},
 		&TektonHubList{},
-		&TektonChains{},
-		&TektonChainsList{},
+		&TektonChain{},
+		&TektonChainList{},
 	)
 	metav1.AddToGroupVersion(s, SchemeGroupVersion)
 	return nil
diff --git a/pkg/apis/operator/v1alpha1/tektonchains_lifecycle.go b/pkg/apis/operator/v1alpha1/tektonchain_lifecycle.go
similarity index 51%
rename from pkg/apis/operator/v1alpha1/tektonchains_lifecycle.go
rename to pkg/apis/operator/v1alpha1/tektonchain_lifecycle.go
index e1b578f71..0ba404dbb 100644
--- a/pkg/apis/operator/v1alpha1/tektonchains_lifecycle.go
+++ b/pkg/apis/operator/v1alpha1/tektonchain_lifecycle.go
@@ -22,9 +22,9 @@ import (
 )
 
 var (
-	_ TektonComponentStatus = (*TektonChainsStatus)(nil)
+	_ TektonComponentStatus = (*TektonChainStatus)(nil)
 
-	chainsCondSet = apis.NewLivingConditionSet(
+	chainCondSet = apis.NewLivingConditionSet(
 		DependenciesInstalled,
 		PreReconciler,
 		InstallerSetAvailable,
@@ -33,85 +33,85 @@ var (
 	)
 )
 
-// GroupVersionKind returns SchemeGroupVersion of a TektonChains
-func (tc *TektonChains) GroupVersionKind() schema.GroupVersionKind {
-	return SchemeGroupVersion.WithKind(KindTektonChains)
+// GroupVersionKind returns SchemeGroupVersion of a TektonChain
+func (tc *TektonChain) GroupVersionKind() schema.GroupVersionKind {
+	return SchemeGroupVersion.WithKind(KindTektonChain)
 }
 
-func (tc *TektonChains) GetGroupVersionKind() schema.GroupVersionKind {
-	return SchemeGroupVersion.WithKind(KindTektonChains)
+func (tc *TektonChain) GetGroupVersionKind() schema.GroupVersionKind {
+	return SchemeGroupVersion.WithKind(KindTektonChain)
 }
 
 // GetCondition returns the current condition of a given condition type
-func (tcs *TektonChainsStatus) GetCondition(t apis.ConditionType) *apis.Condition {
-	return chainsCondSet.Manage(tcs).GetCondition(t)
+func (tcs *TektonChainStatus) GetCondition(t apis.ConditionType) *apis.Condition {
+	return chainCondSet.Manage(tcs).GetCondition(t)
 }
 
-// InitializeConditions initializes conditions of an TektonChainsStatus
-func (tcs *TektonChainsStatus) InitializeConditions() {
-	chainsCondSet.Manage(tcs).InitializeConditions()
+// InitializeConditions initializes conditions of an TektonChainStatus
+func (tcs *TektonChainStatus) InitializeConditions() {
+	chainCondSet.Manage(tcs).InitializeConditions()
 }
 
 // IsReady looks at the conditions returns true if they are all true.
-func (tcs *TektonChainsStatus) IsReady() bool {
-	return chainsCondSet.Manage(tcs).IsHappy()
+func (tcs *TektonChainStatus) IsReady() bool {
+	return chainCondSet.Manage(tcs).IsHappy()
 }
 
-func (tcs *TektonChainsStatus) MarkPreReconcilerComplete() {
-	chainsCondSet.Manage(tcs).MarkTrue(PreReconciler)
+func (tcs *TektonChainStatus) MarkPreReconcilerComplete() {
+	chainCondSet.Manage(tcs).MarkTrue(PreReconciler)
 }
 
-func (tcs *TektonChainsStatus) MarkInstallerSetAvailable() {
-	chainsCondSet.Manage(tcs).MarkTrue(InstallerSetAvailable)
+func (tcs *TektonChainStatus) MarkInstallerSetAvailable() {
+	chainCondSet.Manage(tcs).MarkTrue(InstallerSetAvailable)
 }
 
-func (tcs *TektonChainsStatus) MarkInstallerSetReady() {
-	chainsCondSet.Manage(tcs).MarkTrue(InstallerSetReady)
+func (tcs *TektonChainStatus) MarkInstallerSetReady() {
+	chainCondSet.Manage(tcs).MarkTrue(InstallerSetReady)
 }
 
-func (tcs *TektonChainsStatus) MarkPostReconcilerComplete() {
-	chainsCondSet.Manage(tcs).MarkTrue(PostReconciler)
+func (tcs *TektonChainStatus) MarkPostReconcilerComplete() {
+	chainCondSet.Manage(tcs).MarkTrue(PostReconciler)
 }
 
 // MarkDependenciesInstalled marks the DependenciesInstalled status as true.
-func (tcs *TektonChainsStatus) MarkDependenciesInstalled() {
-	chainsCondSet.Manage(tcs).MarkTrue(DependenciesInstalled)
+func (tcs *TektonChainStatus) MarkDependenciesInstalled() {
+	chainCondSet.Manage(tcs).MarkTrue(DependenciesInstalled)
 }
 
-func (tcs *TektonChainsStatus) MarkNotReady(msg string) {
-	chainsCondSet.Manage(tcs).MarkFalse(
+func (tcs *TektonChainStatus) MarkNotReady(msg string) {
+	chainCondSet.Manage(tcs).MarkFalse(
 		apis.ConditionReady,
 		"Error",
 		"Ready: %s", msg)
 }
 
-func (tcs *TektonChainsStatus) MarkPreReconcilerFailed(msg string) {
+func (tcs *TektonChainStatus) MarkPreReconcilerFailed(msg string) {
 	tcs.MarkNotReady("PreReconciliation failed")
-	chainsCondSet.Manage(tcs).MarkFalse(
+	chainCondSet.Manage(tcs).MarkFalse(
 		PreReconciler,
 		"Error",
 		"PreReconciliation failed with message: %s", msg)
 }
 
-func (tcs *TektonChainsStatus) MarkInstallerSetNotAvailable(msg string) {
+func (tcs *TektonChainStatus) MarkInstallerSetNotAvailable(msg string) {
 	tcs.MarkNotReady("TektonInstallerSet not ready")
-	chainsCondSet.Manage(tcs).MarkFalse(
+	chainCondSet.Manage(tcs).MarkFalse(
 		InstallerSetAvailable,
 		"Error",
 		"Installer set not ready: %s", msg)
 }
 
-func (tcs *TektonChainsStatus) MarkInstallerSetNotReady(msg string) {
+func (tcs *TektonChainStatus) MarkInstallerSetNotReady(msg string) {
 	tcs.MarkNotReady("TektonInstallerSet not ready")
-	chainsCondSet.Manage(tcs).MarkFalse(
+	chainCondSet.Manage(tcs).MarkFalse(
 		InstallerSetReady,
 		"Error",
 		"Installer set not ready: %s", msg)
 }
 
-func (tcs *TektonChainsStatus) MarkPostReconcilerFailed(msg string) {
+func (tcs *TektonChainStatus) MarkPostReconcilerFailed(msg string) {
 	tcs.MarkNotReady("PostReconciliation failed")
-	chainsCondSet.Manage(tcs).MarkFalse(
+	chainCondSet.Manage(tcs).MarkFalse(
 		PostReconciler,
 		"Error",
 		"PostReconciliation failed with message: %s", msg)
@@ -119,9 +119,9 @@ func (tcs *TektonChainsStatus) MarkPostReconcilerFailed(msg string) {
 
 // MarkDependencyInstalling marks the DependenciesInstalled status as false with the
 // given message.
-func (tcs *TektonChainsStatus) MarkDependencyInstalling(msg string) {
+func (tcs *TektonChainStatus) MarkDependencyInstalling(msg string) {
 	tcs.MarkNotReady("Dependencies installing")
-	chainsCondSet.Manage(tcs).MarkFalse(
+	chainCondSet.Manage(tcs).MarkFalse(
 		DependenciesInstalled,
 		"Error",
 		"Dependency installing: %s", msg)
@@ -129,55 +129,54 @@ func (tcs *TektonChainsStatus) MarkDependencyInstalling(msg string) {
 
 // MarkDependencyMissing marks the DependenciesInstalled status as false with the
 // given message.
-func (tcs *TektonChainsStatus) MarkDependencyMissing(msg string) {
-	tcs.MarkNotReady("Missing Dependencies for TektonChains")
-	chainsCondSet.Manage(tcs).MarkFalse(
+func (tcs *TektonChainStatus) MarkDependencyMissing(msg string) {
+	tcs.MarkNotReady("Missing Dependencies for TektonChain")
+	chainCondSet.Manage(tcs).MarkFalse(
 		DependenciesInstalled,
 		"Error",
 		"Dependency missing: %s", msg)
 }
 
-func (tcs *TektonChainsStatus) GetTektonInstallerSet() string {
+func (tcs *TektonChainStatus) GetTektonInstallerSet() string {
 	return tcs.TektonInstallerSet
 }
 
-func (tcs *TektonChainsStatus) SetTektonInstallerSet(installerSet string) {
+func (tcs *TektonChainStatus) SetTektonInstallerSet(installerSet string) {
 	tcs.TektonInstallerSet = installerSet
 }
 
 // GetVersion gets the currently installed version of the component.
-func (tcs *TektonChainsStatus) GetVersion() string {
+func (tcs *TektonChainStatus) GetVersion() string {
 	return tcs.Version
 }
 
 // SetVersion sets the currently installed version of the component.
-func (tcs *TektonChainsStatus) SetVersion(version string) {
+func (tcs *TektonChainStatus) SetVersion(version string) {
 	tcs.Version = version
 }
 
 // MarkInstallSucceeded marks the InstallationSucceeded status as true.
-func (tcs *TektonChainsStatus) MarkInstallSucceeded() {
+func (tcs *TektonChainStatus) MarkInstallSucceeded() {
 	panic("implement me")
 }
 
-// MarkInstallFailed marks the InstallationSucceeded status as false with the given
-// message.
-func (tcs *TektonChainsStatus) MarkInstallFailed(msg string) {
+// MarkInstallFailed marks the InstallationSucceeded status as false with the given message.
+func (tcs *TektonChainStatus) MarkInstallFailed(msg string) {
 	panic("implement me")
 }
 
 // MarkDeploymentsAvailable marks the DeploymentsAvailable status as true.
-func (tcs *TektonChainsStatus) MarkDeploymentsAvailable() {
+func (tcs *TektonChainStatus) MarkDeploymentsAvailable() {
 	panic("implement me")
 }
 
 // MarkDeploymentsNotReady marks the DeploymentsAvailable status as false and calls out
 // it's waiting for deployments.
-func (tcs *TektonChainsStatus) MarkDeploymentsNotReady() {
+func (tcs *TektonChainStatus) MarkDeploymentsNotReady() {
 	panic("implement me")
 }
 
 // GetManifests gets the url links of the manifests.
-func (tcs *TektonChainsStatus) GetManifests() []string {
+func (tcs *TektonChainStatus) GetManifests() []string {
 	panic("implement me")
 }
diff --git a/pkg/apis/operator/v1alpha1/tektonchains_types.go b/pkg/apis/operator/v1alpha1/tektonchain_types.go
similarity index 66%
rename from pkg/apis/operator/v1alpha1/tektonchains_types.go
rename to pkg/apis/operator/v1alpha1/tektonchain_types.go
index bc1351b06..703778939 100644
--- a/pkg/apis/operator/v1alpha1/tektonchains_types.go
+++ b/pkg/apis/operator/v1alpha1/tektonchain_types.go
@@ -22,58 +22,58 @@ import (
 )
 
 var (
-	_ TektonComponent     = (*TektonChains)(nil)
-	_ TektonComponentSpec = (*TektonChainsSpec)(nil)
+	_ TektonComponent     = (*TektonChain)(nil)
+	_ TektonComponentSpec = (*TektonChainSpec)(nil)
 )
 
-// TektonChains is the Schema for the tektonchains API
+// TektonChain is the Schema for the tektonchain API
 // +genclient
 // +genreconciler:krshapedlogic=false
 // +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
 // +genclient:nonNamespaced
-type TektonChains struct {
+type TektonChain struct {
 	metav1.TypeMeta   `json:",inline"`
 	metav1.ObjectMeta `json:"metadata,omitempty"`
 
-	Spec   TektonChainsSpec   `json:"spec,omitempty"`
-	Status TektonChainsStatus `json:"status,omitempty"`
+	Spec   TektonChainSpec   `json:"spec,omitempty"`
+	Status TektonChainStatus `json:"status,omitempty"`
 }
 
 // GetSpec implements TektonComponent
-func (tc *TektonChains) GetSpec() TektonComponentSpec {
+func (tc *TektonChain) GetSpec() TektonComponentSpec {
 	return &tc.Spec
 }
 
 // GetStatus implements TektonComponent
-func (tc *TektonChains) GetStatus() TektonComponentStatus {
+func (tc *TektonChain) GetStatus() TektonComponentStatus {
 	return &tc.Status
 }
 
-// TektonChainsSpec defines the desired state of TektonChains
-type TektonChainsSpec struct {
+// TektonChainSpec defines the desired state of TektonChain
+type TektonChainSpec struct {
 	CommonSpec `json:",inline"`
-	// Config holds the configuration for resources created by TektonChains
+	// Config holds the configuration for resources created by TektonChain
 	// +optional
 	Config Config `json:"config,omitempty"`
 }
 
-// TektonChainsStatus defines the observed state of TektonChains
-type TektonChainsStatus struct {
+// TektonChainStatus defines the observed state of TektonChain
+type TektonChainStatus struct {
 	duckv1.Status `json:",inline"`
 
 	// The version of the installed release
 	// +optional
 	Version string `json:"version,omitempty"`
 
-	// The current installer set name for TektonChains
+	// The current installer set name for TektonChain
 	// +optional
 	TektonInstallerSet string `json:"tektonInstallerSet,omitempty"`
 }
 
-// TektonChainsList contains a list of TektonChains
+// TektonChainList contains a list of TektonChain
 // +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
-type TektonChainsList struct {
+type TektonChainList struct {
 	metav1.TypeMeta `json:",inline"`
 	metav1.ListMeta `json:"metadata,omitempty"`
-	Items           []TektonChains `json:"items"`
+	Items           []TektonChain `json:"items"`
 }
diff --git a/pkg/apis/operator/v1alpha1/tektonchains_validation.go b/pkg/apis/operator/v1alpha1/tektonchain_validation.go
similarity index 79%
rename from pkg/apis/operator/v1alpha1/tektonchains_validation.go
rename to pkg/apis/operator/v1alpha1/tektonchain_validation.go
index 778edbdf7..d12f60fb6 100644
--- a/pkg/apis/operator/v1alpha1/tektonchains_validation.go
+++ b/pkg/apis/operator/v1alpha1/tektonchain_validation.go
@@ -23,14 +23,14 @@ import (
 	"knative.dev/pkg/apis"
 )
 
-func (tc *TektonChains) Validate(ctx context.Context) (errs *apis.FieldError) {
+func (tc *TektonChain) Validate(ctx context.Context) (errs *apis.FieldError) {
 
 	if apis.IsInDelete(ctx) {
 		return nil
 	}
 
-	if tc.GetName() != ChainsResourceName {
-		errMsg := fmt.Sprintf("metadata.name, Only one instance of TektonChains is allowed by name, %s", ChainsResourceName)
+	if tc.GetName() != ChainResourceName {
+		errMsg := fmt.Sprintf("metadata.name, Only one instance of TektonChain is allowed by name, %s", ChainResourceName)
 		errs = errs.Also(apis.ErrInvalidValue(tc.GetName(), errMsg))
 	}
 
@@ -41,5 +41,5 @@ func (tc *TektonChains) Validate(ctx context.Context) (errs *apis.FieldError) {
 	return errs
 }
 
-func (tc *TektonChains) SetDefaults(ctx context.Context) {
+func (tc *TektonChain) SetDefaults(ctx context.Context) {
 }
diff --git a/pkg/apis/operator/v1alpha1/zz_generated.deepcopy.go b/pkg/apis/operator/v1alpha1/zz_generated.deepcopy.go
index c53b6d119..b4087869d 100644
--- a/pkg/apis/operator/v1alpha1/zz_generated.deepcopy.go
+++ b/pkg/apis/operator/v1alpha1/zz_generated.deepcopy.go
@@ -496,7 +496,7 @@ func (in *TektonAddonStatus) DeepCopy() *TektonAddonStatus {
 }
 
 // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
-func (in *TektonChains) DeepCopyInto(out *TektonChains) {
+func (in *TektonChain) DeepCopyInto(out *TektonChain) {
 	*out = *in
 	out.TypeMeta = in.TypeMeta
 	in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
@@ -505,18 +505,18 @@ func (in *TektonChains) DeepCopyInto(out *TektonChains) {
 	return
 }
 
-// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new TektonChains.
-func (in *TektonChains) DeepCopy() *TektonChains {
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new TektonChain.
+func (in *TektonChain) DeepCopy() *TektonChain {
 	if in == nil {
 		return nil
 	}
-	out := new(TektonChains)
+	out := new(TektonChain)
 	in.DeepCopyInto(out)
 	return out
 }
 
 // DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
-func (in *TektonChains) DeepCopyObject() runtime.Object {
+func (in *TektonChain) DeepCopyObject() runtime.Object {
 	if c := in.DeepCopy(); c != nil {
 		return c
 	}
@@ -524,13 +524,13 @@ func (in *TektonChains) DeepCopyObject() runtime.Object {
 }
 
 // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
-func (in *TektonChainsList) DeepCopyInto(out *TektonChainsList) {
+func (in *TektonChainList) DeepCopyInto(out *TektonChainList) {
 	*out = *in
 	out.TypeMeta = in.TypeMeta
 	in.ListMeta.DeepCopyInto(&out.ListMeta)
 	if in.Items != nil {
 		in, out := &in.Items, &out.Items
-		*out = make([]TektonChains, len(*in))
+		*out = make([]TektonChain, len(*in))
 		for i := range *in {
 			(*in)[i].DeepCopyInto(&(*out)[i])
 		}
@@ -538,18 +538,18 @@ func (in *TektonChainsList) DeepCopyInto(out *TektonChainsList) {
 	return
 }
 
-// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new TektonChainsList.
-func (in *TektonChainsList) DeepCopy() *TektonChainsList {
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new TektonChainList.
+func (in *TektonChainList) DeepCopy() *TektonChainList {
 	if in == nil {
 		return nil
 	}
-	out := new(TektonChainsList)
+	out := new(TektonChainList)
 	in.DeepCopyInto(out)
 	return out
 }
 
 // DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
-func (in *TektonChainsList) DeepCopyObject() runtime.Object {
+func (in *TektonChainList) DeepCopyObject() runtime.Object {
 	if c := in.DeepCopy(); c != nil {
 		return c
 	}
@@ -557,36 +557,36 @@ func (in *TektonChainsList) DeepCopyObject() runtime.Object {
 }
 
 // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
-func (in *TektonChainsSpec) DeepCopyInto(out *TektonChainsSpec) {
+func (in *TektonChainSpec) DeepCopyInto(out *TektonChainSpec) {
 	*out = *in
 	out.CommonSpec = in.CommonSpec
 	in.Config.DeepCopyInto(&out.Config)
 	return
 }
 
-// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new TektonChainsSpec.
-func (in *TektonChainsSpec) DeepCopy() *TektonChainsSpec {
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new TektonChainSpec.
+func (in *TektonChainSpec) DeepCopy() *TektonChainSpec {
 	if in == nil {
 		return nil
 	}
-	out := new(TektonChainsSpec)
+	out := new(TektonChainSpec)
 	in.DeepCopyInto(out)
 	return out
 }
 
 // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
-func (in *TektonChainsStatus) DeepCopyInto(out *TektonChainsStatus) {
+func (in *TektonChainStatus) DeepCopyInto(out *TektonChainStatus) {
 	*out = *in
 	in.Status.DeepCopyInto(&out.Status)
 	return
 }
 
-// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new TektonChainsStatus.
-func (in *TektonChainsStatus) DeepCopy() *TektonChainsStatus {
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new TektonChainStatus.
+func (in *TektonChainStatus) DeepCopy() *TektonChainStatus {
 	if in == nil {
 		return nil
 	}
-	out := new(TektonChainsStatus)
+	out := new(TektonChainStatus)
 	in.DeepCopyInto(out)
 	return out
 }
diff --git a/pkg/client/clientset/versioned/typed/operator/v1alpha1/fake/fake_operator_client.go b/pkg/client/clientset/versioned/typed/operator/v1alpha1/fake/fake_operator_client.go
index 2fc52bca8..59de0dfda 100644
--- a/pkg/client/clientset/versioned/typed/operator/v1alpha1/fake/fake_operator_client.go
+++ b/pkg/client/clientset/versioned/typed/operator/v1alpha1/fake/fake_operator_client.go
@@ -32,8 +32,8 @@ func (c *FakeOperatorV1alpha1) TektonAddons() v1alpha1.TektonAddonInterface {
 	return &FakeTektonAddons{c}
 }
 
-func (c *FakeOperatorV1alpha1) TektonChainses() v1alpha1.TektonChainsInterface {
-	return &FakeTektonChainses{c}
+func (c *FakeOperatorV1alpha1) TektonChains() v1alpha1.TektonChainInterface {
+	return &FakeTektonChains{c}
 }
 
 func (c *FakeOperatorV1alpha1) TektonConfigs() v1alpha1.TektonConfigInterface {
diff --git a/pkg/client/clientset/versioned/typed/operator/v1alpha1/fake/fake_tektonchain.go b/pkg/client/clientset/versioned/typed/operator/v1alpha1/fake/fake_tektonchain.go
new file mode 100644
index 000000000..4938cccd8
--- /dev/null
+++ b/pkg/client/clientset/versioned/typed/operator/v1alpha1/fake/fake_tektonchain.go
@@ -0,0 +1,133 @@
+/*
+Copyright 2020 The Tekton Authors
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Code generated by client-gen. DO NOT EDIT.
+
+package fake
+
+import (
+	"context"
+
+	v1alpha1 "github.com/tektoncd/operator/pkg/apis/operator/v1alpha1"
+	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	labels "k8s.io/apimachinery/pkg/labels"
+	schema "k8s.io/apimachinery/pkg/runtime/schema"
+	types "k8s.io/apimachinery/pkg/types"
+	watch "k8s.io/apimachinery/pkg/watch"
+	testing "k8s.io/client-go/testing"
+)
+
+// FakeTektonChains implements TektonChainInterface
+type FakeTektonChains struct {
+	Fake *FakeOperatorV1alpha1
+}
+
+var tektonchainsResource = schema.GroupVersionResource{Group: "operator.tekton.dev", Version: "v1alpha1", Resource: "tektonchains"}
+
+var tektonchainsKind = schema.GroupVersionKind{Group: "operator.tekton.dev", Version: "v1alpha1", Kind: "TektonChain"}
+
+// Get takes name of the tektonChain, and returns the corresponding tektonChain object, and an error if there is any.
+func (c *FakeTektonChains) Get(ctx context.Context, name string, options v1.GetOptions) (result *v1alpha1.TektonChain, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootGetAction(tektonchainsResource, name), &v1alpha1.TektonChain{})
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1alpha1.TektonChain), err
+}
+
+// List takes label and field selectors, and returns the list of TektonChains that match those selectors.
+func (c *FakeTektonChains) List(ctx context.Context, opts v1.ListOptions) (result *v1alpha1.TektonChainList, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootListAction(tektonchainsResource, tektonchainsKind, opts), &v1alpha1.TektonChainList{})
+	if obj == nil {
+		return nil, err
+	}
+
+	label, _, _ := testing.ExtractFromListOptions(opts)
+	if label == nil {
+		label = labels.Everything()
+	}
+	list := &v1alpha1.TektonChainList{ListMeta: obj.(*v1alpha1.TektonChainList).ListMeta}
+	for _, item := range obj.(*v1alpha1.TektonChainList).Items {
+		if label.Matches(labels.Set(item.Labels)) {
+			list.Items = append(list.Items, item)
+		}
+	}
+	return list, err
+}
+
+// Watch returns a watch.Interface that watches the requested tektonChains.
+func (c *FakeTektonChains) Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) {
+	return c.Fake.
+		InvokesWatch(testing.NewRootWatchAction(tektonchainsResource, opts))
+}
+
+// Create takes the representation of a tektonChain and creates it.  Returns the server's representation of the tektonChain, and an error, if there is any.
+func (c *FakeTektonChains) Create(ctx context.Context, tektonChain *v1alpha1.TektonChain, opts v1.CreateOptions) (result *v1alpha1.TektonChain, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootCreateAction(tektonchainsResource, tektonChain), &v1alpha1.TektonChain{})
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1alpha1.TektonChain), err
+}
+
+// Update takes the representation of a tektonChain and updates it. Returns the server's representation of the tektonChain, and an error, if there is any.
+func (c *FakeTektonChains) Update(ctx context.Context, tektonChain *v1alpha1.TektonChain, opts v1.UpdateOptions) (result *v1alpha1.TektonChain, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootUpdateAction(tektonchainsResource, tektonChain), &v1alpha1.TektonChain{})
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1alpha1.TektonChain), err
+}
+
+// UpdateStatus was generated because the type contains a Status member.
+// Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus().
+func (c *FakeTektonChains) UpdateStatus(ctx context.Context, tektonChain *v1alpha1.TektonChain, opts v1.UpdateOptions) (*v1alpha1.TektonChain, error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootUpdateSubresourceAction(tektonchainsResource, "status", tektonChain), &v1alpha1.TektonChain{})
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1alpha1.TektonChain), err
+}
+
+// Delete takes name of the tektonChain and deletes it. Returns an error if one occurs.
+func (c *FakeTektonChains) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error {
+	_, err := c.Fake.
+		Invokes(testing.NewRootDeleteAction(tektonchainsResource, name), &v1alpha1.TektonChain{})
+	return err
+}
+
+// DeleteCollection deletes a collection of objects.
+func (c *FakeTektonChains) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error {
+	action := testing.NewRootDeleteCollectionAction(tektonchainsResource, listOpts)
+
+	_, err := c.Fake.Invokes(action, &v1alpha1.TektonChainList{})
+	return err
+}
+
+// Patch applies the patch and returns the patched tektonChain.
+func (c *FakeTektonChains) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *v1alpha1.TektonChain, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootPatchSubresourceAction(tektonchainsResource, name, pt, data, subresources...), &v1alpha1.TektonChain{})
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1alpha1.TektonChain), err
+}
diff --git a/pkg/client/clientset/versioned/typed/operator/v1alpha1/fake/fake_tektonchains.go b/pkg/client/clientset/versioned/typed/operator/v1alpha1/fake/fake_tektonchains.go
deleted file mode 100644
index 72d70eec6..000000000
--- a/pkg/client/clientset/versioned/typed/operator/v1alpha1/fake/fake_tektonchains.go
+++ /dev/null
@@ -1,133 +0,0 @@
-/*
-Copyright 2020 The Tekton Authors
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-// Code generated by client-gen. DO NOT EDIT.
-
-package fake
-
-import (
-	"context"
-
-	v1alpha1 "github.com/tektoncd/operator/pkg/apis/operator/v1alpha1"
-	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	labels "k8s.io/apimachinery/pkg/labels"
-	schema "k8s.io/apimachinery/pkg/runtime/schema"
-	types "k8s.io/apimachinery/pkg/types"
-	watch "k8s.io/apimachinery/pkg/watch"
-	testing "k8s.io/client-go/testing"
-)
-
-// FakeTektonChainses implements TektonChainsInterface
-type FakeTektonChainses struct {
-	Fake *FakeOperatorV1alpha1
-}
-
-var tektonchainsesResource = schema.GroupVersionResource{Group: "operator.tekton.dev", Version: "v1alpha1", Resource: "tektonchainses"}
-
-var tektonchainsesKind = schema.GroupVersionKind{Group: "operator.tekton.dev", Version: "v1alpha1", Kind: "TektonChains"}
-
-// Get takes name of the tektonChains, and returns the corresponding tektonChains object, and an error if there is any.
-func (c *FakeTektonChainses) Get(ctx context.Context, name string, options v1.GetOptions) (result *v1alpha1.TektonChains, err error) {
-	obj, err := c.Fake.
-		Invokes(testing.NewRootGetAction(tektonchainsesResource, name), &v1alpha1.TektonChains{})
-	if obj == nil {
-		return nil, err
-	}
-	return obj.(*v1alpha1.TektonChains), err
-}
-
-// List takes label and field selectors, and returns the list of TektonChainses that match those selectors.
-func (c *FakeTektonChainses) List(ctx context.Context, opts v1.ListOptions) (result *v1alpha1.TektonChainsList, err error) {
-	obj, err := c.Fake.
-		Invokes(testing.NewRootListAction(tektonchainsesResource, tektonchainsesKind, opts), &v1alpha1.TektonChainsList{})
-	if obj == nil {
-		return nil, err
-	}
-
-	label, _, _ := testing.ExtractFromListOptions(opts)
-	if label == nil {
-		label = labels.Everything()
-	}
-	list := &v1alpha1.TektonChainsList{ListMeta: obj.(*v1alpha1.TektonChainsList).ListMeta}
-	for _, item := range obj.(*v1alpha1.TektonChainsList).Items {
-		if label.Matches(labels.Set(item.Labels)) {
-			list.Items = append(list.Items, item)
-		}
-	}
-	return list, err
-}
-
-// Watch returns a watch.Interface that watches the requested tektonChainses.
-func (c *FakeTektonChainses) Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) {
-	return c.Fake.
-		InvokesWatch(testing.NewRootWatchAction(tektonchainsesResource, opts))
-}
-
-// Create takes the representation of a tektonChains and creates it.  Returns the server's representation of the tektonChains, and an error, if there is any.
-func (c *FakeTektonChainses) Create(ctx context.Context, tektonChains *v1alpha1.TektonChains, opts v1.CreateOptions) (result *v1alpha1.TektonChains, err error) {
-	obj, err := c.Fake.
-		Invokes(testing.NewRootCreateAction(tektonchainsesResource, tektonChains), &v1alpha1.TektonChains{})
-	if obj == nil {
-		return nil, err
-	}
-	return obj.(*v1alpha1.TektonChains), err
-}
-
-// Update takes the representation of a tektonChains and updates it. Returns the server's representation of the tektonChains, and an error, if there is any.
-func (c *FakeTektonChainses) Update(ctx context.Context, tektonChains *v1alpha1.TektonChains, opts v1.UpdateOptions) (result *v1alpha1.TektonChains, err error) {
-	obj, err := c.Fake.
-		Invokes(testing.NewRootUpdateAction(tektonchainsesResource, tektonChains), &v1alpha1.TektonChains{})
-	if obj == nil {
-		return nil, err
-	}
-	return obj.(*v1alpha1.TektonChains), err
-}
-
-// UpdateStatus was generated because the type contains a Status member.
-// Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus().
-func (c *FakeTektonChainses) UpdateStatus(ctx context.Context, tektonChains *v1alpha1.TektonChains, opts v1.UpdateOptions) (*v1alpha1.TektonChains, error) {
-	obj, err := c.Fake.
-		Invokes(testing.NewRootUpdateSubresourceAction(tektonchainsesResource, "status", tektonChains), &v1alpha1.TektonChains{})
-	if obj == nil {
-		return nil, err
-	}
-	return obj.(*v1alpha1.TektonChains), err
-}
-
-// Delete takes name of the tektonChains and deletes it. Returns an error if one occurs.
-func (c *FakeTektonChainses) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error {
-	_, err := c.Fake.
-		Invokes(testing.NewRootDeleteAction(tektonchainsesResource, name), &v1alpha1.TektonChains{})
-	return err
-}
-
-// DeleteCollection deletes a collection of objects.
-func (c *FakeTektonChainses) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error {
-	action := testing.NewRootDeleteCollectionAction(tektonchainsesResource, listOpts)
-
-	_, err := c.Fake.Invokes(action, &v1alpha1.TektonChainsList{})
-	return err
-}
-
-// Patch applies the patch and returns the patched tektonChains.
-func (c *FakeTektonChainses) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *v1alpha1.TektonChains, err error) {
-	obj, err := c.Fake.
-		Invokes(testing.NewRootPatchSubresourceAction(tektonchainsesResource, name, pt, data, subresources...), &v1alpha1.TektonChains{})
-	if obj == nil {
-		return nil, err
-	}
-	return obj.(*v1alpha1.TektonChains), err
-}
diff --git a/pkg/client/clientset/versioned/typed/operator/v1alpha1/generated_expansion.go b/pkg/client/clientset/versioned/typed/operator/v1alpha1/generated_expansion.go
index 9108de871..e2437abdd 100644
--- a/pkg/client/clientset/versioned/typed/operator/v1alpha1/generated_expansion.go
+++ b/pkg/client/clientset/versioned/typed/operator/v1alpha1/generated_expansion.go
@@ -20,7 +20,7 @@ package v1alpha1
 
 type TektonAddonExpansion interface{}
 
-type TektonChainsExpansion interface{}
+type TektonChainExpansion interface{}
 
 type TektonConfigExpansion interface{}
 
diff --git a/pkg/client/clientset/versioned/typed/operator/v1alpha1/operator_client.go b/pkg/client/clientset/versioned/typed/operator/v1alpha1/operator_client.go
index d5bd292dc..b38f5a330 100644
--- a/pkg/client/clientset/versioned/typed/operator/v1alpha1/operator_client.go
+++ b/pkg/client/clientset/versioned/typed/operator/v1alpha1/operator_client.go
@@ -27,7 +27,7 @@ import (
 type OperatorV1alpha1Interface interface {
 	RESTClient() rest.Interface
 	TektonAddonsGetter
-	TektonChainsesGetter
+	TektonChainsGetter
 	TektonConfigsGetter
 	TektonDashboardsGetter
 	TektonHubsGetter
@@ -46,8 +46,8 @@ func (c *OperatorV1alpha1Client) TektonAddons() TektonAddonInterface {
 	return newTektonAddons(c)
 }
 
-func (c *OperatorV1alpha1Client) TektonChainses() TektonChainsInterface {
-	return newTektonChainses(c)
+func (c *OperatorV1alpha1Client) TektonChains() TektonChainInterface {
+	return newTektonChains(c)
 }
 
 func (c *OperatorV1alpha1Client) TektonConfigs() TektonConfigInterface {
diff --git a/pkg/client/clientset/versioned/typed/operator/v1alpha1/tektonchain.go b/pkg/client/clientset/versioned/typed/operator/v1alpha1/tektonchain.go
new file mode 100644
index 000000000..afef71a82
--- /dev/null
+++ b/pkg/client/clientset/versioned/typed/operator/v1alpha1/tektonchain.go
@@ -0,0 +1,184 @@
+/*
+Copyright 2020 The Tekton Authors
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Code generated by client-gen. DO NOT EDIT.
+
+package v1alpha1
+
+import (
+	"context"
+	"time"
+
+	v1alpha1 "github.com/tektoncd/operator/pkg/apis/operator/v1alpha1"
+	scheme "github.com/tektoncd/operator/pkg/client/clientset/versioned/scheme"
+	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	types "k8s.io/apimachinery/pkg/types"
+	watch "k8s.io/apimachinery/pkg/watch"
+	rest "k8s.io/client-go/rest"
+)
+
+// TektonChainsGetter has a method to return a TektonChainInterface.
+// A group's client should implement this interface.
+type TektonChainsGetter interface {
+	TektonChains() TektonChainInterface
+}
+
+// TektonChainInterface has methods to work with TektonChain resources.
+type TektonChainInterface interface {
+	Create(ctx context.Context, tektonChain *v1alpha1.TektonChain, opts v1.CreateOptions) (*v1alpha1.TektonChain, error)
+	Update(ctx context.Context, tektonChain *v1alpha1.TektonChain, opts v1.UpdateOptions) (*v1alpha1.TektonChain, error)
+	UpdateStatus(ctx context.Context, tektonChain *v1alpha1.TektonChain, opts v1.UpdateOptions) (*v1alpha1.TektonChain, error)
+	Delete(ctx context.Context, name string, opts v1.DeleteOptions) error
+	DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error
+	Get(ctx context.Context, name string, opts v1.GetOptions) (*v1alpha1.TektonChain, error)
+	List(ctx context.Context, opts v1.ListOptions) (*v1alpha1.TektonChainList, error)
+	Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error)
+	Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *v1alpha1.TektonChain, err error)
+	TektonChainExpansion
+}
+
+// tektonChains implements TektonChainInterface
+type tektonChains struct {
+	client rest.Interface
+}
+
+// newTektonChains returns a TektonChains
+func newTektonChains(c *OperatorV1alpha1Client) *tektonChains {
+	return &tektonChains{
+		client: c.RESTClient(),
+	}
+}
+
+// Get takes name of the tektonChain, and returns the corresponding tektonChain object, and an error if there is any.
+func (c *tektonChains) Get(ctx context.Context, name string, options v1.GetOptions) (result *v1alpha1.TektonChain, err error) {
+	result = &v1alpha1.TektonChain{}
+	err = c.client.Get().
+		Resource("tektonchains").
+		Name(name).
+		VersionedParams(&options, scheme.ParameterCodec).
+		Do(ctx).
+		Into(result)
+	return
+}
+
+// List takes label and field selectors, and returns the list of TektonChains that match those selectors.
+func (c *tektonChains) List(ctx context.Context, opts v1.ListOptions) (result *v1alpha1.TektonChainList, err error) {
+	var timeout time.Duration
+	if opts.TimeoutSeconds != nil {
+		timeout = time.Duration(*opts.TimeoutSeconds) * time.Second
+	}
+	result = &v1alpha1.TektonChainList{}
+	err = c.client.Get().
+		Resource("tektonchains").
+		VersionedParams(&opts, scheme.ParameterCodec).
+		Timeout(timeout).
+		Do(ctx).
+		Into(result)
+	return
+}
+
+// Watch returns a watch.Interface that watches the requested tektonChains.
+func (c *tektonChains) Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) {
+	var timeout time.Duration
+	if opts.TimeoutSeconds != nil {
+		timeout = time.Duration(*opts.TimeoutSeconds) * time.Second
+	}
+	opts.Watch = true
+	return c.client.Get().
+		Resource("tektonchains").
+		VersionedParams(&opts, scheme.ParameterCodec).
+		Timeout(timeout).
+		Watch(ctx)
+}
+
+// Create takes the representation of a tektonChain and creates it.  Returns the server's representation of the tektonChain, and an error, if there is any.
+func (c *tektonChains) Create(ctx context.Context, tektonChain *v1alpha1.TektonChain, opts v1.CreateOptions) (result *v1alpha1.TektonChain, err error) {
+	result = &v1alpha1.TektonChain{}
+	err = c.client.Post().
+		Resource("tektonchains").
+		VersionedParams(&opts, scheme.ParameterCodec).
+		Body(tektonChain).
+		Do(ctx).
+		Into(result)
+	return
+}
+
+// Update takes the representation of a tektonChain and updates it. Returns the server's representation of the tektonChain, and an error, if there is any.
+func (c *tektonChains) Update(ctx context.Context, tektonChain *v1alpha1.TektonChain, opts v1.UpdateOptions) (result *v1alpha1.TektonChain, err error) {
+	result = &v1alpha1.TektonChain{}
+	err = c.client.Put().
+		Resource("tektonchains").
+		Name(tektonChain.Name).
+		VersionedParams(&opts, scheme.ParameterCodec).
+		Body(tektonChain).
+		Do(ctx).
+		Into(result)
+	return
+}
+
+// UpdateStatus was generated because the type contains a Status member.
+// Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus().
+func (c *tektonChains) UpdateStatus(ctx context.Context, tektonChain *v1alpha1.TektonChain, opts v1.UpdateOptions) (result *v1alpha1.TektonChain, err error) {
+	result = &v1alpha1.TektonChain{}
+	err = c.client.Put().
+		Resource("tektonchains").
+		Name(tektonChain.Name).
+		SubResource("status").
+		VersionedParams(&opts, scheme.ParameterCodec).
+		Body(tektonChain).
+		Do(ctx).
+		Into(result)
+	return
+}
+
+// Delete takes name of the tektonChain and deletes it. Returns an error if one occurs.
+func (c *tektonChains) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error {
+	return c.client.Delete().
+		Resource("tektonchains").
+		Name(name).
+		Body(&opts).
+		Do(ctx).
+		Error()
+}
+
+// DeleteCollection deletes a collection of objects.
+func (c *tektonChains) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error {
+	var timeout time.Duration
+	if listOpts.TimeoutSeconds != nil {
+		timeout = time.Duration(*listOpts.TimeoutSeconds) * time.Second
+	}
+	return c.client.Delete().
+		Resource("tektonchains").
+		VersionedParams(&listOpts, scheme.ParameterCodec).
+		Timeout(timeout).
+		Body(&opts).
+		Do(ctx).
+		Error()
+}
+
+// Patch applies the patch and returns the patched tektonChain.
+func (c *tektonChains) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *v1alpha1.TektonChain, err error) {
+	result = &v1alpha1.TektonChain{}
+	err = c.client.Patch(pt).
+		Resource("tektonchains").
+		Name(name).
+		SubResource(subresources...).
+		VersionedParams(&opts, scheme.ParameterCodec).
+		Body(data).
+		Do(ctx).
+		Into(result)
+	return
+}
diff --git a/pkg/client/clientset/versioned/typed/operator/v1alpha1/tektonchains.go b/pkg/client/clientset/versioned/typed/operator/v1alpha1/tektonchains.go
deleted file mode 100644
index f89797e4a..000000000
--- a/pkg/client/clientset/versioned/typed/operator/v1alpha1/tektonchains.go
+++ /dev/null
@@ -1,184 +0,0 @@
-/*
-Copyright 2020 The Tekton Authors
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-// Code generated by client-gen. DO NOT EDIT.
-
-package v1alpha1
-
-import (
-	"context"
-	"time"
-
-	v1alpha1 "github.com/tektoncd/operator/pkg/apis/operator/v1alpha1"
-	scheme "github.com/tektoncd/operator/pkg/client/clientset/versioned/scheme"
-	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	types "k8s.io/apimachinery/pkg/types"
-	watch "k8s.io/apimachinery/pkg/watch"
-	rest "k8s.io/client-go/rest"
-)
-
-// TektonChainsesGetter has a method to return a TektonChainsInterface.
-// A group's client should implement this interface.
-type TektonChainsesGetter interface {
-	TektonChainses() TektonChainsInterface
-}
-
-// TektonChainsInterface has methods to work with TektonChains resources.
-type TektonChainsInterface interface {
-	Create(ctx context.Context, tektonChains *v1alpha1.TektonChains, opts v1.CreateOptions) (*v1alpha1.TektonChains, error)
-	Update(ctx context.Context, tektonChains *v1alpha1.TektonChains, opts v1.UpdateOptions) (*v1alpha1.TektonChains, error)
-	UpdateStatus(ctx context.Context, tektonChains *v1alpha1.TektonChains, opts v1.UpdateOptions) (*v1alpha1.TektonChains, error)
-	Delete(ctx context.Context, name string, opts v1.DeleteOptions) error
-	DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error
-	Get(ctx context.Context, name string, opts v1.GetOptions) (*v1alpha1.TektonChains, error)
-	List(ctx context.Context, opts v1.ListOptions) (*v1alpha1.TektonChainsList, error)
-	Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error)
-	Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *v1alpha1.TektonChains, err error)
-	TektonChainsExpansion
-}
-
-// tektonChainses implements TektonChainsInterface
-type tektonChainses struct {
-	client rest.Interface
-}
-
-// newTektonChainses returns a TektonChainses
-func newTektonChainses(c *OperatorV1alpha1Client) *tektonChainses {
-	return &tektonChainses{
-		client: c.RESTClient(),
-	}
-}
-
-// Get takes name of the tektonChains, and returns the corresponding tektonChains object, and an error if there is any.
-func (c *tektonChainses) Get(ctx context.Context, name string, options v1.GetOptions) (result *v1alpha1.TektonChains, err error) {
-	result = &v1alpha1.TektonChains{}
-	err = c.client.Get().
-		Resource("tektonchainses").
-		Name(name).
-		VersionedParams(&options, scheme.ParameterCodec).
-		Do(ctx).
-		Into(result)
-	return
-}
-
-// List takes label and field selectors, and returns the list of TektonChainses that match those selectors.
-func (c *tektonChainses) List(ctx context.Context, opts v1.ListOptions) (result *v1alpha1.TektonChainsList, err error) {
-	var timeout time.Duration
-	if opts.TimeoutSeconds != nil {
-		timeout = time.Duration(*opts.TimeoutSeconds) * time.Second
-	}
-	result = &v1alpha1.TektonChainsList{}
-	err = c.client.Get().
-		Resource("tektonchainses").
-		VersionedParams(&opts, scheme.ParameterCodec).
-		Timeout(timeout).
-		Do(ctx).
-		Into(result)
-	return
-}
-
-// Watch returns a watch.Interface that watches the requested tektonChainses.
-func (c *tektonChainses) Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) {
-	var timeout time.Duration
-	if opts.TimeoutSeconds != nil {
-		timeout = time.Duration(*opts.TimeoutSeconds) * time.Second
-	}
-	opts.Watch = true
-	return c.client.Get().
-		Resource("tektonchainses").
-		VersionedParams(&opts, scheme.ParameterCodec).
-		Timeout(timeout).
-		Watch(ctx)
-}
-
-// Create takes the representation of a tektonChains and creates it.  Returns the server's representation of the tektonChains, and an error, if there is any.
-func (c *tektonChainses) Create(ctx context.Context, tektonChains *v1alpha1.TektonChains, opts v1.CreateOptions) (result *v1alpha1.TektonChains, err error) {
-	result = &v1alpha1.TektonChains{}
-	err = c.client.Post().
-		Resource("tektonchainses").
-		VersionedParams(&opts, scheme.ParameterCodec).
-		Body(tektonChains).
-		Do(ctx).
-		Into(result)
-	return
-}
-
-// Update takes the representation of a tektonChains and updates it. Returns the server's representation of the tektonChains, and an error, if there is any.
-func (c *tektonChainses) Update(ctx context.Context, tektonChains *v1alpha1.TektonChains, opts v1.UpdateOptions) (result *v1alpha1.TektonChains, err error) {
-	result = &v1alpha1.TektonChains{}
-	err = c.client.Put().
-		Resource("tektonchainses").
-		Name(tektonChains.Name).
-		VersionedParams(&opts, scheme.ParameterCodec).
-		Body(tektonChains).
-		Do(ctx).
-		Into(result)
-	return
-}
-
-// UpdateStatus was generated because the type contains a Status member.
-// Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus().
-func (c *tektonChainses) UpdateStatus(ctx context.Context, tektonChains *v1alpha1.TektonChains, opts v1.UpdateOptions) (result *v1alpha1.TektonChains, err error) {
-	result = &v1alpha1.TektonChains{}
-	err = c.client.Put().
-		Resource("tektonchainses").
-		Name(tektonChains.Name).
-		SubResource("status").
-		VersionedParams(&opts, scheme.ParameterCodec).
-		Body(tektonChains).
-		Do(ctx).
-		Into(result)
-	return
-}
-
-// Delete takes name of the tektonChains and deletes it. Returns an error if one occurs.
-func (c *tektonChainses) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error {
-	return c.client.Delete().
-		Resource("tektonchainses").
-		Name(name).
-		Body(&opts).
-		Do(ctx).
-		Error()
-}
-
-// DeleteCollection deletes a collection of objects.
-func (c *tektonChainses) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error {
-	var timeout time.Duration
-	if listOpts.TimeoutSeconds != nil {
-		timeout = time.Duration(*listOpts.TimeoutSeconds) * time.Second
-	}
-	return c.client.Delete().
-		Resource("tektonchainses").
-		VersionedParams(&listOpts, scheme.ParameterCodec).
-		Timeout(timeout).
-		Body(&opts).
-		Do(ctx).
-		Error()
-}
-
-// Patch applies the patch and returns the patched tektonChains.
-func (c *tektonChainses) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *v1alpha1.TektonChains, err error) {
-	result = &v1alpha1.TektonChains{}
-	err = c.client.Patch(pt).
-		Resource("tektonchainses").
-		Name(name).
-		SubResource(subresources...).
-		VersionedParams(&opts, scheme.ParameterCodec).
-		Body(data).
-		Do(ctx).
-		Into(result)
-	return
-}
diff --git a/pkg/client/informers/externalversions/generic.go b/pkg/client/informers/externalversions/generic.go
index faf0f30b1..1464bb83e 100644
--- a/pkg/client/informers/externalversions/generic.go
+++ b/pkg/client/informers/externalversions/generic.go
@@ -55,8 +55,8 @@ func (f *sharedInformerFactory) ForResource(resource schema.GroupVersionResource
 	// Group=operator.tekton.dev, Version=v1alpha1
 	case v1alpha1.SchemeGroupVersion.WithResource("tektonaddons"):
 		return &genericInformer{resource: resource.GroupResource(), informer: f.Operator().V1alpha1().TektonAddons().Informer()}, nil
-	case v1alpha1.SchemeGroupVersion.WithResource("tektonchainses"):
-		return &genericInformer{resource: resource.GroupResource(), informer: f.Operator().V1alpha1().TektonChainses().Informer()}, nil
+	case v1alpha1.SchemeGroupVersion.WithResource("tektonchains"):
+		return &genericInformer{resource: resource.GroupResource(), informer: f.Operator().V1alpha1().TektonChains().Informer()}, nil
 	case v1alpha1.SchemeGroupVersion.WithResource("tektonconfigs"):
 		return &genericInformer{resource: resource.GroupResource(), informer: f.Operator().V1alpha1().TektonConfigs().Informer()}, nil
 	case v1alpha1.SchemeGroupVersion.WithResource("tektondashboards"):
diff --git a/pkg/client/informers/externalversions/operator/v1alpha1/interface.go b/pkg/client/informers/externalversions/operator/v1alpha1/interface.go
index 0c18da3ae..3ea6e60fb 100644
--- a/pkg/client/informers/externalversions/operator/v1alpha1/interface.go
+++ b/pkg/client/informers/externalversions/operator/v1alpha1/interface.go
@@ -26,8 +26,8 @@ import (
 type Interface interface {
 	// TektonAddons returns a TektonAddonInformer.
 	TektonAddons() TektonAddonInformer
-	// TektonChainses returns a TektonChainsInformer.
-	TektonChainses() TektonChainsInformer
+	// TektonChains returns a TektonChainInformer.
+	TektonChains() TektonChainInformer
 	// TektonConfigs returns a TektonConfigInformer.
 	TektonConfigs() TektonConfigInformer
 	// TektonDashboards returns a TektonDashboardInformer.
@@ -60,9 +60,9 @@ func (v *version) TektonAddons() TektonAddonInformer {
 	return &tektonAddonInformer{factory: v.factory, tweakListOptions: v.tweakListOptions}
 }
 
-// TektonChainses returns a TektonChainsInformer.
-func (v *version) TektonChainses() TektonChainsInformer {
-	return &tektonChainsInformer{factory: v.factory, tweakListOptions: v.tweakListOptions}
+// TektonChains returns a TektonChainInformer.
+func (v *version) TektonChains() TektonChainInformer {
+	return &tektonChainInformer{factory: v.factory, tweakListOptions: v.tweakListOptions}
 }
 
 // TektonConfigs returns a TektonConfigInformer.
diff --git a/pkg/client/informers/externalversions/operator/v1alpha1/tektonchains.go b/pkg/client/informers/externalversions/operator/v1alpha1/tektonchain.go
similarity index 57%
rename from pkg/client/informers/externalversions/operator/v1alpha1/tektonchains.go
rename to pkg/client/informers/externalversions/operator/v1alpha1/tektonchain.go
index 1dd25b061..45ff4d64f 100644
--- a/pkg/client/informers/externalversions/operator/v1alpha1/tektonchains.go
+++ b/pkg/client/informers/externalversions/operator/v1alpha1/tektonchain.go
@@ -32,58 +32,58 @@ import (
 	cache "k8s.io/client-go/tools/cache"
 )
 
-// TektonChainsInformer provides access to a shared informer and lister for
-// TektonChainses.
-type TektonChainsInformer interface {
+// TektonChainInformer provides access to a shared informer and lister for
+// TektonChains.
+type TektonChainInformer interface {
 	Informer() cache.SharedIndexInformer
-	Lister() v1alpha1.TektonChainsLister
+	Lister() v1alpha1.TektonChainLister
 }
 
-type tektonChainsInformer struct {
+type tektonChainInformer struct {
 	factory          internalinterfaces.SharedInformerFactory
 	tweakListOptions internalinterfaces.TweakListOptionsFunc
 }
 
-// NewTektonChainsInformer constructs a new informer for TektonChains type.
+// NewTektonChainInformer constructs a new informer for TektonChain type.
 // Always prefer using an informer factory to get a shared informer instead of getting an independent
 // one. This reduces memory footprint and number of connections to the server.
-func NewTektonChainsInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer {
-	return NewFilteredTektonChainsInformer(client, resyncPeriod, indexers, nil)
+func NewTektonChainInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer {
+	return NewFilteredTektonChainInformer(client, resyncPeriod, indexers, nil)
 }
 
-// NewFilteredTektonChainsInformer constructs a new informer for TektonChains type.
+// NewFilteredTektonChainInformer constructs a new informer for TektonChain type.
 // Always prefer using an informer factory to get a shared informer instead of getting an independent
 // one. This reduces memory footprint and number of connections to the server.
-func NewFilteredTektonChainsInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer {
+func NewFilteredTektonChainInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer {
 	return cache.NewSharedIndexInformer(
 		&cache.ListWatch{
 			ListFunc: func(options v1.ListOptions) (runtime.Object, error) {
 				if tweakListOptions != nil {
 					tweakListOptions(&options)
 				}
-				return client.OperatorV1alpha1().TektonChainses().List(context.TODO(), options)
+				return client.OperatorV1alpha1().TektonChains().List(context.TODO(), options)
 			},
 			WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
 				if tweakListOptions != nil {
 					tweakListOptions(&options)
 				}
-				return client.OperatorV1alpha1().TektonChainses().Watch(context.TODO(), options)
+				return client.OperatorV1alpha1().TektonChains().Watch(context.TODO(), options)
 			},
 		},
-		&operatorv1alpha1.TektonChains{},
+		&operatorv1alpha1.TektonChain{},
 		resyncPeriod,
 		indexers,
 	)
 }
 
-func (f *tektonChainsInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
-	return NewFilteredTektonChainsInformer(client, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions)
+func (f *tektonChainInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
+	return NewFilteredTektonChainInformer(client, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions)
 }
 
-func (f *tektonChainsInformer) Informer() cache.SharedIndexInformer {
-	return f.factory.InformerFor(&operatorv1alpha1.TektonChains{}, f.defaultInformer)
+func (f *tektonChainInformer) Informer() cache.SharedIndexInformer {
+	return f.factory.InformerFor(&operatorv1alpha1.TektonChain{}, f.defaultInformer)
 }
 
-func (f *tektonChainsInformer) Lister() v1alpha1.TektonChainsLister {
-	return v1alpha1.NewTektonChainsLister(f.Informer().GetIndexer())
+func (f *tektonChainInformer) Lister() v1alpha1.TektonChainLister {
+	return v1alpha1.NewTektonChainLister(f.Informer().GetIndexer())
 }
diff --git a/pkg/client/injection/client/client.go b/pkg/client/injection/client/client.go
index 4d03a651e..caed4e34d 100644
--- a/pkg/client/injection/client/client.go
+++ b/pkg/client/injection/client/client.go
@@ -238,27 +238,27 @@ func (w *wrapOperatorV1alpha1TektonAddonImpl) Watch(ctx context.Context, opts v1
 	return nil, errors.New("NYI: Watch")
 }
 
-func (w *wrapOperatorV1alpha1) TektonChainses() typedoperatorv1alpha1.TektonChainsInterface {
-	return &wrapOperatorV1alpha1TektonChainsImpl{
+func (w *wrapOperatorV1alpha1) TektonChains() typedoperatorv1alpha1.TektonChainInterface {
+	return &wrapOperatorV1alpha1TektonChainImpl{
 		dyn: w.dyn.Resource(schema.GroupVersionResource{
 			Group:    "operator.tekton.dev",
 			Version:  "v1alpha1",
-			Resource: "tektonchainses",
+			Resource: "tektonchains",
 		}),
 	}
 }
 
-type wrapOperatorV1alpha1TektonChainsImpl struct {
+type wrapOperatorV1alpha1TektonChainImpl struct {
 	dyn dynamic.NamespaceableResourceInterface
 }
 
-var _ typedoperatorv1alpha1.TektonChainsInterface = (*wrapOperatorV1alpha1TektonChainsImpl)(nil)
+var _ typedoperatorv1alpha1.TektonChainInterface = (*wrapOperatorV1alpha1TektonChainImpl)(nil)
 
-func (w *wrapOperatorV1alpha1TektonChainsImpl) Create(ctx context.Context, in *v1alpha1.TektonChains, opts v1.CreateOptions) (*v1alpha1.TektonChains, error) {
+func (w *wrapOperatorV1alpha1TektonChainImpl) Create(ctx context.Context, in *v1alpha1.TektonChain, opts v1.CreateOptions) (*v1alpha1.TektonChain, error) {
 	in.SetGroupVersionKind(schema.GroupVersionKind{
 		Group:   "operator.tekton.dev",
 		Version: "v1alpha1",
-		Kind:    "TektonChains",
+		Kind:    "TektonChain",
 	})
 	uo := &unstructured.Unstructured{}
 	if err := convert(in, uo); err != nil {
@@ -268,62 +268,62 @@ func (w *wrapOperatorV1alpha1TektonChainsImpl) Create(ctx context.Context, in *v
 	if err != nil {
 		return nil, err
 	}
-	out := &v1alpha1.TektonChains{}
+	out := &v1alpha1.TektonChain{}
 	if err := convert(uo, out); err != nil {
 		return nil, err
 	}
 	return out, nil
 }
 
-func (w *wrapOperatorV1alpha1TektonChainsImpl) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error {
+func (w *wrapOperatorV1alpha1TektonChainImpl) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error {
 	return w.dyn.Delete(ctx, name, opts)
 }
 
-func (w *wrapOperatorV1alpha1TektonChainsImpl) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error {
+func (w *wrapOperatorV1alpha1TektonChainImpl) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error {
 	return w.dyn.DeleteCollection(ctx, opts, listOpts)
 }
 
-func (w *wrapOperatorV1alpha1TektonChainsImpl) Get(ctx context.Context, name string, opts v1.GetOptions) (*v1alpha1.TektonChains, error) {
+func (w *wrapOperatorV1alpha1TektonChainImpl) Get(ctx context.Context, name string, opts v1.GetOptions) (*v1alpha1.TektonChain, error) {
 	uo, err := w.dyn.Get(ctx, name, opts)
 	if err != nil {
 		return nil, err
 	}
-	out := &v1alpha1.TektonChains{}
+	out := &v1alpha1.TektonChain{}
 	if err := convert(uo, out); err != nil {
 		return nil, err
 	}
 	return out, nil
 }
 
-func (w *wrapOperatorV1alpha1TektonChainsImpl) List(ctx context.Context, opts v1.ListOptions) (*v1alpha1.TektonChainsList, error) {
+func (w *wrapOperatorV1alpha1TektonChainImpl) List(ctx context.Context, opts v1.ListOptions) (*v1alpha1.TektonChainList, error) {
 	uo, err := w.dyn.List(ctx, opts)
 	if err != nil {
 		return nil, err
 	}
-	out := &v1alpha1.TektonChainsList{}
+	out := &v1alpha1.TektonChainList{}
 	if err := convert(uo, out); err != nil {
 		return nil, err
 	}
 	return out, nil
 }
 
-func (w *wrapOperatorV1alpha1TektonChainsImpl) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *v1alpha1.TektonChains, err error) {
+func (w *wrapOperatorV1alpha1TektonChainImpl) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *v1alpha1.TektonChain, err error) {
 	uo, err := w.dyn.Patch(ctx, name, pt, data, opts)
 	if err != nil {
 		return nil, err
 	}
-	out := &v1alpha1.TektonChains{}
+	out := &v1alpha1.TektonChain{}
 	if err := convert(uo, out); err != nil {
 		return nil, err
 	}
 	return out, nil
 }
 
-func (w *wrapOperatorV1alpha1TektonChainsImpl) Update(ctx context.Context, in *v1alpha1.TektonChains, opts v1.UpdateOptions) (*v1alpha1.TektonChains, error) {
+func (w *wrapOperatorV1alpha1TektonChainImpl) Update(ctx context.Context, in *v1alpha1.TektonChain, opts v1.UpdateOptions) (*v1alpha1.TektonChain, error) {
 	in.SetGroupVersionKind(schema.GroupVersionKind{
 		Group:   "operator.tekton.dev",
 		Version: "v1alpha1",
-		Kind:    "TektonChains",
+		Kind:    "TektonChain",
 	})
 	uo := &unstructured.Unstructured{}
 	if err := convert(in, uo); err != nil {
@@ -333,18 +333,18 @@ func (w *wrapOperatorV1alpha1TektonChainsImpl) Update(ctx context.Context, in *v
 	if err != nil {
 		return nil, err
 	}
-	out := &v1alpha1.TektonChains{}
+	out := &v1alpha1.TektonChain{}
 	if err := convert(uo, out); err != nil {
 		return nil, err
 	}
 	return out, nil
 }
 
-func (w *wrapOperatorV1alpha1TektonChainsImpl) UpdateStatus(ctx context.Context, in *v1alpha1.TektonChains, opts v1.UpdateOptions) (*v1alpha1.TektonChains, error) {
+func (w *wrapOperatorV1alpha1TektonChainImpl) UpdateStatus(ctx context.Context, in *v1alpha1.TektonChain, opts v1.UpdateOptions) (*v1alpha1.TektonChain, error) {
 	in.SetGroupVersionKind(schema.GroupVersionKind{
 		Group:   "operator.tekton.dev",
 		Version: "v1alpha1",
-		Kind:    "TektonChains",
+		Kind:    "TektonChain",
 	})
 	uo := &unstructured.Unstructured{}
 	if err := convert(in, uo); err != nil {
@@ -354,14 +354,14 @@ func (w *wrapOperatorV1alpha1TektonChainsImpl) UpdateStatus(ctx context.Context,
 	if err != nil {
 		return nil, err
 	}
-	out := &v1alpha1.TektonChains{}
+	out := &v1alpha1.TektonChain{}
 	if err := convert(uo, out); err != nil {
 		return nil, err
 	}
 	return out, nil
 }
 
-func (w *wrapOperatorV1alpha1TektonChainsImpl) Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) {
+func (w *wrapOperatorV1alpha1TektonChainImpl) Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) {
 	return nil, errors.New("NYI: Watch")
 }
 
diff --git a/pkg/client/injection/informers/operator/v1alpha1/tektonchains/fake/fake.go b/pkg/client/injection/informers/operator/v1alpha1/tektonchain/fake/fake.go
similarity index 79%
rename from pkg/client/injection/informers/operator/v1alpha1/tektonchains/fake/fake.go
rename to pkg/client/injection/informers/operator/v1alpha1/tektonchain/fake/fake.go
index f702a517f..485eaaafe 100644
--- a/pkg/client/injection/informers/operator/v1alpha1/tektonchains/fake/fake.go
+++ b/pkg/client/injection/informers/operator/v1alpha1/tektonchain/fake/fake.go
@@ -22,12 +22,12 @@ import (
 	context "context"
 
 	fake "github.com/tektoncd/operator/pkg/client/injection/informers/factory/fake"
-	tektonchains "github.com/tektoncd/operator/pkg/client/injection/informers/operator/v1alpha1/tektonchains"
+	tektonchain "github.com/tektoncd/operator/pkg/client/injection/informers/operator/v1alpha1/tektonchain"
 	controller "knative.dev/pkg/controller"
 	injection "knative.dev/pkg/injection"
 )
 
-var Get = tektonchains.Get
+var Get = tektonchain.Get
 
 func init() {
 	injection.Fake.RegisterInformer(withInformer)
@@ -35,6 +35,6 @@ func init() {
 
 func withInformer(ctx context.Context) (context.Context, controller.Informer) {
 	f := fake.Get(ctx)
-	inf := f.Operator().V1alpha1().TektonChainses()
-	return context.WithValue(ctx, tektonchains.Key{}, inf), inf.Informer()
+	inf := f.Operator().V1alpha1().TektonChains()
+	return context.WithValue(ctx, tektonchain.Key{}, inf), inf.Informer()
 }
diff --git a/pkg/client/injection/informers/operator/v1alpha1/tektonchains/filtered/fake/fake.go b/pkg/client/injection/informers/operator/v1alpha1/tektonchain/filtered/fake/fake.go
similarity index 94%
rename from pkg/client/injection/informers/operator/v1alpha1/tektonchains/filtered/fake/fake.go
rename to pkg/client/injection/informers/operator/v1alpha1/tektonchain/filtered/fake/fake.go
index faea7034e..fd7a25f26 100644
--- a/pkg/client/injection/informers/operator/v1alpha1/tektonchains/filtered/fake/fake.go
+++ b/pkg/client/injection/informers/operator/v1alpha1/tektonchain/filtered/fake/fake.go
@@ -22,7 +22,7 @@ import (
 	context "context"
 
 	factoryfiltered "github.com/tektoncd/operator/pkg/client/injection/informers/factory/filtered"
-	filtered "github.com/tektoncd/operator/pkg/client/injection/informers/operator/v1alpha1/tektonchains/filtered"
+	filtered "github.com/tektoncd/operator/pkg/client/injection/informers/operator/v1alpha1/tektonchain/filtered"
 	controller "knative.dev/pkg/controller"
 	injection "knative.dev/pkg/injection"
 	logging "knative.dev/pkg/logging"
@@ -44,7 +44,7 @@ func withInformer(ctx context.Context) (context.Context, []controller.Informer)
 	infs := []controller.Informer{}
 	for _, selector := range labelSelectors {
 		f := factoryfiltered.Get(ctx, selector)
-		inf := f.Operator().V1alpha1().TektonChainses()
+		inf := f.Operator().V1alpha1().TektonChains()
 		ctx = context.WithValue(ctx, filtered.Key{Selector: selector}, inf)
 		infs = append(infs, inf.Informer())
 	}
diff --git a/pkg/client/injection/informers/operator/v1alpha1/tektonchains/filtered/tektonchains.go b/pkg/client/injection/informers/operator/v1alpha1/tektonchain/filtered/tektonchain.go
similarity index 84%
rename from pkg/client/injection/informers/operator/v1alpha1/tektonchains/filtered/tektonchains.go
rename to pkg/client/injection/informers/operator/v1alpha1/tektonchain/filtered/tektonchain.go
index 035830de0..744272376 100644
--- a/pkg/client/injection/informers/operator/v1alpha1/tektonchains/filtered/tektonchains.go
+++ b/pkg/client/injection/informers/operator/v1alpha1/tektonchain/filtered/tektonchain.go
@@ -55,7 +55,7 @@ func withInformer(ctx context.Context) (context.Context, []controller.Informer)
 	infs := []controller.Informer{}
 	for _, selector := range labelSelectors {
 		f := filtered.Get(ctx, selector)
-		inf := f.Operator().V1alpha1().TektonChainses()
+		inf := f.Operator().V1alpha1().TektonChains()
 		ctx = context.WithValue(ctx, Key{Selector: selector}, inf)
 		infs = append(infs, inf.Informer())
 	}
@@ -77,13 +77,13 @@ func withDynamicInformer(ctx context.Context) context.Context {
 }
 
 // Get extracts the typed informer from the context.
-func Get(ctx context.Context, selector string) v1alpha1.TektonChainsInformer {
+func Get(ctx context.Context, selector string) v1alpha1.TektonChainInformer {
 	untyped := ctx.Value(Key{Selector: selector})
 	if untyped == nil {
 		logging.FromContext(ctx).Panicf(
-			"Unable to fetch github.com/tektoncd/operator/pkg/client/informers/externalversions/operator/v1alpha1.TektonChainsInformer with selector %s from context.", selector)
+			"Unable to fetch github.com/tektoncd/operator/pkg/client/informers/externalversions/operator/v1alpha1.TektonChainInformer with selector %s from context.", selector)
 	}
-	return untyped.(v1alpha1.TektonChainsInformer)
+	return untyped.(v1alpha1.TektonChainInformer)
 }
 
 type wrapper struct {
@@ -92,24 +92,24 @@ type wrapper struct {
 	selector string
 }
 
-var _ v1alpha1.TektonChainsInformer = (*wrapper)(nil)
-var _ operatorv1alpha1.TektonChainsLister = (*wrapper)(nil)
+var _ v1alpha1.TektonChainInformer = (*wrapper)(nil)
+var _ operatorv1alpha1.TektonChainLister = (*wrapper)(nil)
 
 func (w *wrapper) Informer() cache.SharedIndexInformer {
-	return cache.NewSharedIndexInformer(nil, &apisoperatorv1alpha1.TektonChains{}, 0, nil)
+	return cache.NewSharedIndexInformer(nil, &apisoperatorv1alpha1.TektonChain{}, 0, nil)
 }
 
-func (w *wrapper) Lister() operatorv1alpha1.TektonChainsLister {
+func (w *wrapper) Lister() operatorv1alpha1.TektonChainLister {
 	return w
 }
 
-func (w *wrapper) List(selector labels.Selector) (ret []*apisoperatorv1alpha1.TektonChains, err error) {
+func (w *wrapper) List(selector labels.Selector) (ret []*apisoperatorv1alpha1.TektonChain, err error) {
 	reqs, err := labels.ParseToRequirements(w.selector)
 	if err != nil {
 		return nil, err
 	}
 	selector = selector.Add(reqs...)
-	lo, err := w.client.OperatorV1alpha1().TektonChainses().List(context.TODO(), v1.ListOptions{
+	lo, err := w.client.OperatorV1alpha1().TektonChains().List(context.TODO(), v1.ListOptions{
 		LabelSelector: selector.String(),
 		// TODO(mattmoor): Incorporate resourceVersion bounds based on staleness criteria.
 	})
@@ -122,9 +122,9 @@ func (w *wrapper) List(selector labels.Selector) (ret []*apisoperatorv1alpha1.Te
 	return ret, nil
 }
 
-func (w *wrapper) Get(name string) (*apisoperatorv1alpha1.TektonChains, error) {
+func (w *wrapper) Get(name string) (*apisoperatorv1alpha1.TektonChain, error) {
 	// TODO(mattmoor): Check that the fetched object matches the selector.
-	return w.client.OperatorV1alpha1().TektonChainses().Get(context.TODO(), name, v1.GetOptions{
+	return w.client.OperatorV1alpha1().TektonChains().Get(context.TODO(), name, v1.GetOptions{
 		// TODO(mattmoor): Incorporate resourceVersion bounds based on staleness criteria.
 	})
 }
diff --git a/pkg/client/injection/informers/operator/v1alpha1/tektonchains/tektonchains.go b/pkg/client/injection/informers/operator/v1alpha1/tektonchain/tektonchain.go
similarity index 81%
rename from pkg/client/injection/informers/operator/v1alpha1/tektonchains/tektonchains.go
rename to pkg/client/injection/informers/operator/v1alpha1/tektonchain/tektonchain.go
index 0c0ab53ba..55ad9e30d 100644
--- a/pkg/client/injection/informers/operator/v1alpha1/tektonchains/tektonchains.go
+++ b/pkg/client/injection/informers/operator/v1alpha1/tektonchain/tektonchain.go
@@ -16,7 +16,7 @@ limitations under the License.
 
 // Code generated by injection-gen. DO NOT EDIT.
 
-package tektonchains
+package tektonchain
 
 import (
 	context "context"
@@ -45,7 +45,7 @@ type Key struct{}
 
 func withInformer(ctx context.Context) (context.Context, controller.Informer) {
 	f := factory.Get(ctx)
-	inf := f.Operator().V1alpha1().TektonChainses()
+	inf := f.Operator().V1alpha1().TektonChains()
 	return context.WithValue(ctx, Key{}, inf), inf.Informer()
 }
 
@@ -55,13 +55,13 @@ func withDynamicInformer(ctx context.Context) context.Context {
 }
 
 // Get extracts the typed informer from the context.
-func Get(ctx context.Context) v1alpha1.TektonChainsInformer {
+func Get(ctx context.Context) v1alpha1.TektonChainInformer {
 	untyped := ctx.Value(Key{})
 	if untyped == nil {
 		logging.FromContext(ctx).Panic(
-			"Unable to fetch github.com/tektoncd/operator/pkg/client/informers/externalversions/operator/v1alpha1.TektonChainsInformer from context.")
+			"Unable to fetch github.com/tektoncd/operator/pkg/client/informers/externalversions/operator/v1alpha1.TektonChainInformer from context.")
 	}
-	return untyped.(v1alpha1.TektonChainsInformer)
+	return untyped.(v1alpha1.TektonChainInformer)
 }
 
 type wrapper struct {
@@ -70,14 +70,14 @@ type wrapper struct {
 	resourceVersion string
 }
 
-var _ v1alpha1.TektonChainsInformer = (*wrapper)(nil)
-var _ operatorv1alpha1.TektonChainsLister = (*wrapper)(nil)
+var _ v1alpha1.TektonChainInformer = (*wrapper)(nil)
+var _ operatorv1alpha1.TektonChainLister = (*wrapper)(nil)
 
 func (w *wrapper) Informer() cache.SharedIndexInformer {
-	return cache.NewSharedIndexInformer(nil, &apisoperatorv1alpha1.TektonChains{}, 0, nil)
+	return cache.NewSharedIndexInformer(nil, &apisoperatorv1alpha1.TektonChain{}, 0, nil)
 }
 
-func (w *wrapper) Lister() operatorv1alpha1.TektonChainsLister {
+func (w *wrapper) Lister() operatorv1alpha1.TektonChainLister {
 	return w
 }
 
@@ -89,8 +89,8 @@ func (w *wrapper) SetResourceVersion(resourceVersion string) {
 	w.resourceVersion = resourceVersion
 }
 
-func (w *wrapper) List(selector labels.Selector) (ret []*apisoperatorv1alpha1.TektonChains, err error) {
-	lo, err := w.client.OperatorV1alpha1().TektonChainses().List(context.TODO(), v1.ListOptions{
+func (w *wrapper) List(selector labels.Selector) (ret []*apisoperatorv1alpha1.TektonChain, err error) {
+	lo, err := w.client.OperatorV1alpha1().TektonChains().List(context.TODO(), v1.ListOptions{
 		LabelSelector:   selector.String(),
 		ResourceVersion: w.resourceVersion,
 	})
@@ -103,8 +103,8 @@ func (w *wrapper) List(selector labels.Selector) (ret []*apisoperatorv1alpha1.Te
 	return ret, nil
 }
 
-func (w *wrapper) Get(name string) (*apisoperatorv1alpha1.TektonChains, error) {
-	return w.client.OperatorV1alpha1().TektonChainses().Get(context.TODO(), name, v1.GetOptions{
+func (w *wrapper) Get(name string) (*apisoperatorv1alpha1.TektonChain, error) {
+	return w.client.OperatorV1alpha1().TektonChains().Get(context.TODO(), name, v1.GetOptions{
 		ResourceVersion: w.resourceVersion,
 	})
 }
diff --git a/pkg/client/injection/reconciler/operator/v1alpha1/tektonchains/controller.go b/pkg/client/injection/reconciler/operator/v1alpha1/tektonchain/controller.go
similarity index 91%
rename from pkg/client/injection/reconciler/operator/v1alpha1/tektonchains/controller.go
rename to pkg/client/injection/reconciler/operator/v1alpha1/tektonchain/controller.go
index 76cf35f23..363977369 100644
--- a/pkg/client/injection/reconciler/operator/v1alpha1/tektonchains/controller.go
+++ b/pkg/client/injection/reconciler/operator/v1alpha1/tektonchain/controller.go
@@ -16,7 +16,7 @@ limitations under the License.
 
 // Code generated by injection-gen. DO NOT EDIT.
 
-package tektonchains
+package tektonchain
 
 import (
 	context "context"
@@ -26,7 +26,7 @@ import (
 
 	versionedscheme "github.com/tektoncd/operator/pkg/client/clientset/versioned/scheme"
 	client "github.com/tektoncd/operator/pkg/client/injection/client"
-	tektonchains "github.com/tektoncd/operator/pkg/client/injection/informers/operator/v1alpha1/tektonchains"
+	tektonchain "github.com/tektoncd/operator/pkg/client/injection/informers/operator/v1alpha1/tektonchain"
 	zap "go.uber.org/zap"
 	corev1 "k8s.io/api/core/v1"
 	labels "k8s.io/apimachinery/pkg/labels"
@@ -43,8 +43,8 @@ import (
 )
 
 const (
-	defaultControllerAgentName = "tektonchains-controller"
-	defaultFinalizerName       = "tektonchainses.operator.tekton.dev"
+	defaultControllerAgentName = "tektonchain-controller"
+	defaultFinalizerName       = "tektonchains.operator.tekton.dev"
 )
 
 // NewImpl returns a controller.Impl that handles queuing and feeding work from
@@ -59,9 +59,9 @@ func NewImpl(ctx context.Context, r Interface, optionsFns ...controller.OptionsF
 		logger.Fatal("Up to one options function is supported, found: ", len(optionsFns))
 	}
 
-	tektonchainsInformer := tektonchains.Get(ctx)
+	tektonchainInformer := tektonchain.Get(ctx)
 
-	lister := tektonchainsInformer.Lister()
+	lister := tektonchainInformer.Lister()
 
 	var promoteFilterFunc func(obj interface{}) bool
 
@@ -98,7 +98,7 @@ func NewImpl(ctx context.Context, r Interface, optionsFns ...controller.OptionsF
 
 	logger = logger.With(
 		zap.String(logkey.ControllerType, ctrTypeName),
-		zap.String(logkey.Kind, "operator.tekton.dev.TektonChains"),
+		zap.String(logkey.Kind, "operator.tekton.dev.TektonChain"),
 	)
 
 	impl := controller.NewContext(ctx, rec, controller.ControllerOptions{WorkQueueName: ctrTypeName, Logger: logger})
diff --git a/pkg/client/injection/reconciler/operator/v1alpha1/tektonchains/reconciler.go b/pkg/client/injection/reconciler/operator/v1alpha1/tektonchain/reconciler.go
similarity index 92%
rename from pkg/client/injection/reconciler/operator/v1alpha1/tektonchains/reconciler.go
rename to pkg/client/injection/reconciler/operator/v1alpha1/tektonchain/reconciler.go
index 4a3977a0b..7169cf385 100644
--- a/pkg/client/injection/reconciler/operator/v1alpha1/tektonchains/reconciler.go
+++ b/pkg/client/injection/reconciler/operator/v1alpha1/tektonchain/reconciler.go
@@ -16,7 +16,7 @@ limitations under the License.
 
 // Code generated by injection-gen. DO NOT EDIT.
 
-package tektonchains
+package tektonchain
 
 import (
 	context "context"
@@ -42,40 +42,40 @@ import (
 )
 
 // Interface defines the strongly typed interfaces to be implemented by a
-// controller reconciling v1alpha1.TektonChains.
+// controller reconciling v1alpha1.TektonChain.
 type Interface interface {
-	// ReconcileKind implements custom logic to reconcile v1alpha1.TektonChains. Any changes
+	// ReconcileKind implements custom logic to reconcile v1alpha1.TektonChain. Any changes
 	// to the objects .Status or .Finalizers will be propagated to the stored
 	// object. It is recommended that implementors do not call any update calls
 	// for the Kind inside of ReconcileKind, it is the responsibility of the calling
 	// controller to propagate those properties. The resource passed to ReconcileKind
 	// will always have an empty deletion timestamp.
-	ReconcileKind(ctx context.Context, o *v1alpha1.TektonChains) reconciler.Event
+	ReconcileKind(ctx context.Context, o *v1alpha1.TektonChain) reconciler.Event
 }
 
 // Finalizer defines the strongly typed interfaces to be implemented by a
-// controller finalizing v1alpha1.TektonChains.
+// controller finalizing v1alpha1.TektonChain.
 type Finalizer interface {
-	// FinalizeKind implements custom logic to finalize v1alpha1.TektonChains. Any changes
+	// FinalizeKind implements custom logic to finalize v1alpha1.TektonChain. Any changes
 	// to the objects .Status or .Finalizers will be ignored. Returning a nil or
 	// Normal type reconciler.Event will allow the finalizer to be deleted on
 	// the resource. The resource passed to FinalizeKind will always have a set
 	// deletion timestamp.
-	FinalizeKind(ctx context.Context, o *v1alpha1.TektonChains) reconciler.Event
+	FinalizeKind(ctx context.Context, o *v1alpha1.TektonChain) reconciler.Event
 }
 
 // ReadOnlyInterface defines the strongly typed interfaces to be implemented by a
-// controller reconciling v1alpha1.TektonChains if they want to process resources for which
+// controller reconciling v1alpha1.TektonChain if they want to process resources for which
 // they are not the leader.
 type ReadOnlyInterface interface {
-	// ObserveKind implements logic to observe v1alpha1.TektonChains.
+	// ObserveKind implements logic to observe v1alpha1.TektonChain.
 	// This method should not write to the API.
-	ObserveKind(ctx context.Context, o *v1alpha1.TektonChains) reconciler.Event
+	ObserveKind(ctx context.Context, o *v1alpha1.TektonChain) reconciler.Event
 }
 
-type doReconcile func(ctx context.Context, o *v1alpha1.TektonChains) reconciler.Event
+type doReconcile func(ctx context.Context, o *v1alpha1.TektonChain) reconciler.Event
 
-// reconcilerImpl implements controller.Reconciler for v1alpha1.TektonChains resources.
+// reconcilerImpl implements controller.Reconciler for v1alpha1.TektonChain resources.
 type reconcilerImpl struct {
 	// LeaderAwareFuncs is inlined to help us implement reconciler.LeaderAware.
 	reconciler.LeaderAwareFuncs
@@ -84,7 +84,7 @@ type reconcilerImpl struct {
 	Client versioned.Interface
 
 	// Listers index properties about resources.
-	Lister operatorv1alpha1.TektonChainsLister
+	Lister operatorv1alpha1.TektonChainLister
 
 	// Recorder is an event recorder for recording Event resources to the
 	// Kubernetes API.
@@ -111,7 +111,7 @@ var _ controller.Reconciler = (*reconcilerImpl)(nil)
 // Check that our generated Reconciler is always LeaderAware.
 var _ reconciler.LeaderAware = (*reconcilerImpl)(nil)
 
-func NewReconciler(ctx context.Context, logger *zap.SugaredLogger, client versioned.Interface, lister operatorv1alpha1.TektonChainsLister, recorder record.EventRecorder, r Interface, options ...controller.Options) controller.Reconciler {
+func NewReconciler(ctx context.Context, logger *zap.SugaredLogger, client versioned.Interface, lister operatorv1alpha1.TektonChainLister, recorder record.EventRecorder, r Interface, options ...controller.Options) controller.Reconciler {
 	// Check the options function input. It should be 0 or 1.
 	if len(options) > 1 {
 		logger.Fatal("Up to one options struct is supported, found: ", len(options))
@@ -300,13 +300,13 @@ func (r *reconcilerImpl) Reconcile(ctx context.Context, key string) error {
 	return nil
 }
 
-func (r *reconcilerImpl) updateStatus(ctx context.Context, existing *v1alpha1.TektonChains, desired *v1alpha1.TektonChains) error {
+func (r *reconcilerImpl) updateStatus(ctx context.Context, existing *v1alpha1.TektonChain, desired *v1alpha1.TektonChain) error {
 	existing = existing.DeepCopy()
 	return reconciler.RetryUpdateConflicts(func(attempts int) (err error) {
 		// The first iteration tries to use the injectionInformer's state, subsequent attempts fetch the latest state via API.
 		if attempts > 0 {
 
-			getter := r.Client.OperatorV1alpha1().TektonChainses()
+			getter := r.Client.OperatorV1alpha1().TektonChains()
 
 			existing, err = getter.Get(ctx, desired.Name, metav1.GetOptions{})
 			if err != nil {
@@ -325,7 +325,7 @@ func (r *reconcilerImpl) updateStatus(ctx context.Context, existing *v1alpha1.Te
 
 		existing.Status = desired.Status
 
-		updater := r.Client.OperatorV1alpha1().TektonChainses()
+		updater := r.Client.OperatorV1alpha1().TektonChains()
 
 		_, err = updater.UpdateStatus(ctx, existing, metav1.UpdateOptions{})
 		return err
@@ -335,7 +335,7 @@ func (r *reconcilerImpl) updateStatus(ctx context.Context, existing *v1alpha1.Te
 // updateFinalizersFiltered will update the Finalizers of the resource.
 // TODO: this method could be generic and sync all finalizers. For now it only
 // updates defaultFinalizerName or its override.
-func (r *reconcilerImpl) updateFinalizersFiltered(ctx context.Context, resource *v1alpha1.TektonChains) (*v1alpha1.TektonChains, error) {
+func (r *reconcilerImpl) updateFinalizersFiltered(ctx context.Context, resource *v1alpha1.TektonChain) (*v1alpha1.TektonChain, error) {
 
 	getter := r.Lister
 
@@ -382,7 +382,7 @@ func (r *reconcilerImpl) updateFinalizersFiltered(ctx context.Context, resource
 		return resource, err
 	}
 
-	patcher := r.Client.OperatorV1alpha1().TektonChainses()
+	patcher := r.Client.OperatorV1alpha1().TektonChains()
 
 	resourceName := resource.Name
 	updated, err := patcher.Patch(ctx, resourceName, types.MergePatchType, patch, metav1.PatchOptions{})
@@ -396,7 +396,7 @@ func (r *reconcilerImpl) updateFinalizersFiltered(ctx context.Context, resource
 	return updated, err
 }
 
-func (r *reconcilerImpl) setFinalizerIfFinalizer(ctx context.Context, resource *v1alpha1.TektonChains) (*v1alpha1.TektonChains, error) {
+func (r *reconcilerImpl) setFinalizerIfFinalizer(ctx context.Context, resource *v1alpha1.TektonChain) (*v1alpha1.TektonChain, error) {
 	if _, ok := r.reconciler.(Finalizer); !ok {
 		return resource, nil
 	}
@@ -414,7 +414,7 @@ func (r *reconcilerImpl) setFinalizerIfFinalizer(ctx context.Context, resource *
 	return r.updateFinalizersFiltered(ctx, resource)
 }
 
-func (r *reconcilerImpl) clearFinalizer(ctx context.Context, resource *v1alpha1.TektonChains, reconcileEvent reconciler.Event) (*v1alpha1.TektonChains, error) {
+func (r *reconcilerImpl) clearFinalizer(ctx context.Context, resource *v1alpha1.TektonChain, reconcileEvent reconciler.Event) (*v1alpha1.TektonChain, error) {
 	if _, ok := r.reconciler.(Finalizer); !ok {
 		return resource, nil
 	}
diff --git a/pkg/client/injection/reconciler/operator/v1alpha1/tektonchains/state.go b/pkg/client/injection/reconciler/operator/v1alpha1/tektonchain/state.go
similarity index 96%
rename from pkg/client/injection/reconciler/operator/v1alpha1/tektonchains/state.go
rename to pkg/client/injection/reconciler/operator/v1alpha1/tektonchain/state.go
index cdfe58f49..ad012e9a2 100644
--- a/pkg/client/injection/reconciler/operator/v1alpha1/tektonchains/state.go
+++ b/pkg/client/injection/reconciler/operator/v1alpha1/tektonchain/state.go
@@ -16,7 +16,7 @@ limitations under the License.
 
 // Code generated by injection-gen. DO NOT EDIT.
 
-package tektonchains
+package tektonchain
 
 import (
 	fmt "fmt"
@@ -83,7 +83,7 @@ func (s *state) isNotLeaderNorObserver() bool {
 	return false
 }
 
-func (s *state) reconcileMethodFor(o *v1alpha1.TektonChains) (string, doReconcile) {
+func (s *state) reconcileMethodFor(o *v1alpha1.TektonChain) (string, doReconcile) {
 	if o.GetDeletionTimestamp().IsZero() {
 		if s.isLeader {
 			return reconciler.DoReconcileKind, s.reconciler.ReconcileKind
diff --git a/pkg/client/listers/operator/v1alpha1/expansion_generated.go b/pkg/client/listers/operator/v1alpha1/expansion_generated.go
index 4d96ff707..88701b8f4 100644
--- a/pkg/client/listers/operator/v1alpha1/expansion_generated.go
+++ b/pkg/client/listers/operator/v1alpha1/expansion_generated.go
@@ -22,9 +22,9 @@ package v1alpha1
 // TektonAddonLister.
 type TektonAddonListerExpansion interface{}
 
-// TektonChainsListerExpansion allows custom methods to be added to
-// TektonChainsLister.
-type TektonChainsListerExpansion interface{}
+// TektonChainListerExpansion allows custom methods to be added to
+// TektonChainLister.
+type TektonChainListerExpansion interface{}
 
 // TektonConfigListerExpansion allows custom methods to be added to
 // TektonConfigLister.
diff --git a/pkg/client/listers/operator/v1alpha1/tektonchains.go b/pkg/client/listers/operator/v1alpha1/tektonchain.go
similarity index 52%
rename from pkg/client/listers/operator/v1alpha1/tektonchains.go
rename to pkg/client/listers/operator/v1alpha1/tektonchain.go
index 86f1c3573..fd358db11 100644
--- a/pkg/client/listers/operator/v1alpha1/tektonchains.go
+++ b/pkg/client/listers/operator/v1alpha1/tektonchain.go
@@ -25,44 +25,44 @@ import (
 	"k8s.io/client-go/tools/cache"
 )
 
-// TektonChainsLister helps list TektonChainses.
+// TektonChainLister helps list TektonChains.
 // All objects returned here must be treated as read-only.
-type TektonChainsLister interface {
-	// List lists all TektonChainses in the indexer.
+type TektonChainLister interface {
+	// List lists all TektonChains in the indexer.
 	// Objects returned here must be treated as read-only.
-	List(selector labels.Selector) (ret []*v1alpha1.TektonChains, err error)
-	// Get retrieves the TektonChains from the index for a given name.
+	List(selector labels.Selector) (ret []*v1alpha1.TektonChain, err error)
+	// Get retrieves the TektonChain from the index for a given name.
 	// Objects returned here must be treated as read-only.
-	Get(name string) (*v1alpha1.TektonChains, error)
-	TektonChainsListerExpansion
+	Get(name string) (*v1alpha1.TektonChain, error)
+	TektonChainListerExpansion
 }
 
-// tektonChainsLister implements the TektonChainsLister interface.
-type tektonChainsLister struct {
+// tektonChainLister implements the TektonChainLister interface.
+type tektonChainLister struct {
 	indexer cache.Indexer
 }
 
-// NewTektonChainsLister returns a new TektonChainsLister.
-func NewTektonChainsLister(indexer cache.Indexer) TektonChainsLister {
-	return &tektonChainsLister{indexer: indexer}
+// NewTektonChainLister returns a new TektonChainLister.
+func NewTektonChainLister(indexer cache.Indexer) TektonChainLister {
+	return &tektonChainLister{indexer: indexer}
 }
 
-// List lists all TektonChainses in the indexer.
-func (s *tektonChainsLister) List(selector labels.Selector) (ret []*v1alpha1.TektonChains, err error) {
+// List lists all TektonChains in the indexer.
+func (s *tektonChainLister) List(selector labels.Selector) (ret []*v1alpha1.TektonChain, err error) {
 	err = cache.ListAll(s.indexer, selector, func(m interface{}) {
-		ret = append(ret, m.(*v1alpha1.TektonChains))
+		ret = append(ret, m.(*v1alpha1.TektonChain))
 	})
 	return ret, err
 }
 
-// Get retrieves the TektonChains from the index for a given name.
-func (s *tektonChainsLister) Get(name string) (*v1alpha1.TektonChains, error) {
+// Get retrieves the TektonChain from the index for a given name.
+func (s *tektonChainLister) Get(name string) (*v1alpha1.TektonChain, error) {
 	obj, exists, err := s.indexer.GetByKey(name)
 	if err != nil {
 		return nil, err
 	}
 	if !exists {
-		return nil, errors.NewNotFound(v1alpha1.Resource("tektonchains"), name)
+		return nil, errors.NewNotFound(v1alpha1.Resource("tektonchain"), name)
 	}
-	return obj.(*v1alpha1.TektonChains), nil
+	return obj.(*v1alpha1.TektonChain), nil
 }
diff --git a/pkg/reconciler/common/initcontroller.go b/pkg/reconciler/common/initcontroller.go
index c97ba5f9b..ac2574f7d 100644
--- a/pkg/reconciler/common/initcontroller.go
+++ b/pkg/reconciler/common/initcontroller.go
@@ -109,8 +109,8 @@ func (ctrl Controller) fetchSourceManifests(ctx context.Context, opts PayloadOpt
 		dashboard.Spec.Readonly = false
 		return AppendTarget(ctx, ctrl.Manifest, &dashboard)
 	case strings.Contains(ctrl.VersionConfigMap, "chains"):
-		var chains v1alpha1.TektonChains
-		return AppendTarget(ctx, ctrl.Manifest, &chains)
+		var chain v1alpha1.TektonChain
+		return AppendTarget(ctx, ctrl.Manifest, &chain)
 	}
 
 	return nil
diff --git a/pkg/reconciler/common/releases.go b/pkg/reconciler/common/releases.go
index 7e7dd1538..6db2cee23 100644
--- a/pkg/reconciler/common/releases.go
+++ b/pkg/reconciler/common/releases.go
@@ -94,7 +94,7 @@ func ComponentDir(instance v1alpha1.TektonComponent) string {
 		return filepath.Join(koDataDir, "tekton-results")
 	case *v1alpha1.TektonHub:
 		return filepath.Join(koDataDir, "tekton-hub")
-	case *v1alpha1.TektonChains:
+	case *v1alpha1.TektonChain:
 		return filepath.Join(koDataDir, "tekton-chains")
 	}
 	return ""
diff --git a/pkg/reconciler/kubernetes/tektonchains/controller.go b/pkg/reconciler/kubernetes/tektonchain/controller.go
similarity index 80%
rename from pkg/reconciler/kubernetes/tektonchains/controller.go
rename to pkg/reconciler/kubernetes/tektonchain/controller.go
index f5a4453f2..2b4076cd1 100644
--- a/pkg/reconciler/kubernetes/tektonchains/controller.go
+++ b/pkg/reconciler/kubernetes/tektonchain/controller.go
@@ -14,17 +14,17 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package tektonchains
+package tektonchain
 
 import (
 	"context"
 
 	"github.com/tektoncd/operator/pkg/apis/operator/v1alpha1"
 	operatorclient "github.com/tektoncd/operator/pkg/client/injection/client"
-	tektonChainsinformer "github.com/tektoncd/operator/pkg/client/injection/informers/operator/v1alpha1/tektonchains"
+	tektonChaininformer "github.com/tektoncd/operator/pkg/client/injection/informers/operator/v1alpha1/tektonchain"
 	tektonInstallerinformer "github.com/tektoncd/operator/pkg/client/injection/informers/operator/v1alpha1/tektoninstallerset"
 	tektonPipelineinformer "github.com/tektoncd/operator/pkg/client/injection/informers/operator/v1alpha1/tektonpipeline"
-	tektonChainsreconciler "github.com/tektoncd/operator/pkg/client/injection/reconciler/operator/v1alpha1/tektonchains"
+	tektonChainreconciler "github.com/tektoncd/operator/pkg/client/injection/reconciler/operator/v1alpha1/tektonchain"
 	"github.com/tektoncd/operator/pkg/reconciler/common"
 	"k8s.io/client-go/tools/cache"
 	//kubeclient "knative.dev/pkg/client/injection/kube/client"
@@ -53,9 +53,9 @@ func NewExtendedController(generator common.ExtensionGenerator) injection.Contro
 			VersionConfigMap: versionConfigMap,
 		}
 
-		manifest, chainsVer := ctrl.InitController(ctx, common.PayloadOptions{})
-		if chainsVer == common.ReleaseVersionUnknown {
-			chainsVer = "devel"
+		manifest, chainVer := ctrl.InitController(ctx, common.PayloadOptions{})
+		if chainVer == common.ReleaseVersionUnknown {
+			chainVer = "devel"
 		}
 
 		operatorVer, err := common.OperatorVersion(ctx)
@@ -69,19 +69,19 @@ func NewExtendedController(generator common.ExtensionGenerator) injection.Contro
 			manifest:          manifest,
 			pipelineInformer:  tektonPipelineinformer.Get(ctx),
 			operatorVersion:   operatorVer,
-			chainsVersion:     chainsVer,
+			chainVersion:      chainVer,
 		}
-		impl := tektonChainsreconciler.NewImpl(ctx, c)
+		impl := tektonChainreconciler.NewImpl(ctx, c)
 
 		// Add enqueue func in reconciler
 		c.enqueueAfter = impl.EnqueueAfter
 
-		logger.Info("Setting up event handlers for Tekton Chains")
+		logger.Info("Setting up event handlers for Tekton Chain")
 
-		tektonChainsinformer.Get(ctx).Informer().AddEventHandler(controller.HandleAll(impl.Enqueue))
+		tektonChaininformer.Get(ctx).Informer().AddEventHandler(controller.HandleAll(impl.Enqueue))
 
 		tektonInstallerinformer.Get(ctx).Informer().AddEventHandler(cache.FilteringResourceEventHandler{
-			FilterFunc: controller.FilterController(&v1alpha1.TektonChains{}),
+			FilterFunc: controller.FilterController(&v1alpha1.TektonChain{}),
 			Handler:    controller.HandleAll(impl.EnqueueControllerOf),
 		})
 
diff --git a/pkg/reconciler/kubernetes/tektonchains/tektonchains.go b/pkg/reconciler/kubernetes/tektonchain/tektonchain.go
similarity index 85%
rename from pkg/reconciler/kubernetes/tektonchains/tektonchains.go
rename to pkg/reconciler/kubernetes/tektonchain/tektonchain.go
index 420f85c6d..45ef6b56a 100644
--- a/pkg/reconciler/kubernetes/tektonchains/tektonchains.go
+++ b/pkg/reconciler/kubernetes/tektonchain/tektonchain.go
@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package tektonchains
+package tektonchain
 
 import (
 	"context"
@@ -25,7 +25,7 @@ import (
 	"github.com/tektoncd/operator/pkg/apis/operator/v1alpha1"
 	clientset "github.com/tektoncd/operator/pkg/client/clientset/versioned"
 	pipelineinformer "github.com/tektoncd/operator/pkg/client/informers/externalversions/operator/v1alpha1"
-	tektonchainsreconciler "github.com/tektoncd/operator/pkg/client/injection/reconciler/operator/v1alpha1/tektonchains"
+	tektonchainreconciler "github.com/tektoncd/operator/pkg/client/injection/reconciler/operator/v1alpha1/tektonchain"
 	"github.com/tektoncd/operator/pkg/reconciler/common"
 	"github.com/tektoncd/operator/pkg/reconciler/kubernetes/tektoninstallerset"
 	"github.com/tektoncd/operator/pkg/reconciler/shared/hash"
@@ -37,7 +37,7 @@ import (
 	pkgreconciler "knative.dev/pkg/reconciler"
 )
 
-// Reconciler implements controller.Reconciler for TektonChains resources.
+// Reconciler implements controller.Reconciler for TektonChain resources.
 type Reconciler struct {
 	// operatorClientSet allows us to configure operator objects
 	operatorClientSet clientset.Interface
@@ -48,8 +48,8 @@ type Reconciler struct {
 	// enqueueAfter enqueues a obj after a duration
 	enqueueAfter func(obj interface{}, after time.Duration)
 	extension    common.Extension
-	// chainsVersion describes the current chains version
-	chainsVersion   string
+	// chainVersion describes the current chain version
+	chainVersion    string
 	operatorVersion string
 	// pipelineInformer provides access to a shared informer and lister for
 	// TektonPipelines
@@ -57,32 +57,32 @@ type Reconciler struct {
 }
 
 // Check that our Reconciler implements controller.Reconciler
-var _ tektonchainsreconciler.Interface = (*Reconciler)(nil)
-var _ tektonchainsreconciler.Finalizer = (*Reconciler)(nil)
+var _ tektonchainreconciler.Interface = (*Reconciler)(nil)
+var _ tektonchainreconciler.Finalizer = (*Reconciler)(nil)
 
-const createdByValue = "TektonChains"
+const createdByValue = "TektonChain"
 
 var (
 	ls = metav1.LabelSelector{
 		MatchLabels: map[string]string{
 			v1alpha1.CreatedByKey:     createdByValue,
-			v1alpha1.InstallerSetType: v1alpha1.ChainsResourceName,
+			v1alpha1.InstallerSetType: v1alpha1.ChainResourceName,
 		},
 	}
 )
 
 // ReconcileKind compares the actual state with the desired, and attempts to
 // converge the two.
-func (r *Reconciler) ReconcileKind(ctx context.Context, tc *v1alpha1.TektonChains) pkgreconciler.Event {
+func (r *Reconciler) ReconcileKind(ctx context.Context, tc *v1alpha1.TektonChain) pkgreconciler.Event {
 	logger := logging.FromContext(ctx)
 	tc.Status.InitializeConditions()
 	tc.Status.ObservedGeneration = tc.Generation
 
-	logger.Infow("Reconciling TektonChains", "status", tc.Status)
+	logger.Infow("Reconciling TektonChain", "status", tc.Status)
 
-	if tc.GetName() != v1alpha1.ChainsResourceName {
+	if tc.GetName() != v1alpha1.ChainResourceName {
 		msg := fmt.Sprintf("Resource ignored, Expected Name: %s, Got Name: %s",
-			v1alpha1.ChainsResourceName,
+			v1alpha1.ChainResourceName,
 			tc.GetName(),
 		)
 		logger.Error(msg)
@@ -106,7 +106,7 @@ func (r *Reconciler) ReconcileKind(ctx context.Context, tc *v1alpha1.TektonChain
 	// Pass the object through defaulting
 	tc.SetDefaults(ctx)
 
-	// Mark TektonChains Instance as Not Ready if an upgrade is needed
+	// Mark TektonChain Instance as Not Ready if an upgrade is needed
 	if err := r.markUpgrade(ctx, tc); err != nil {
 		return err
 	}
@@ -129,14 +129,14 @@ func (r *Reconciler) ReconcileKind(ctx context.Context, tc *v1alpha1.TektonChain
 		return err
 	}
 	if existingInstallerSet == "" {
-		tc.Status.MarkInstallerSetNotAvailable("Chains InstallerSet not available")
+		tc.Status.MarkInstallerSetNotAvailable("Chain InstallerSet not available")
 
 		createdIs, err := r.createInstallerSet(ctx, tc)
 		if err != nil {
 			return err
 		}
 
-		return r.updateTektonChainsStatus(ctx, tc, createdIs)
+		return r.updateTektonChainStatus(tc, createdIs)
 	}
 
 	// If exists, then fetch the InstallerSet
@@ -148,7 +148,7 @@ func (r *Reconciler) ReconcileKind(ctx context.Context, tc *v1alpha1.TektonChain
 			if err != nil {
 				return err
 			}
-			return r.updateTektonChainsStatus(ctx, tc, createdIs)
+			return r.updateTektonChainStatus(tc, createdIs)
 		}
 		logger.Error("failed to get InstallerSet: %s", err)
 		return err
@@ -186,11 +186,11 @@ func (r *Reconciler) ReconcileKind(ctx context.Context, tc *v1alpha1.TektonChain
 		return nil
 
 	} else {
-		// If target namespace and version are not changed then check if Chains
+		// If target namespace and version are not changed then check if Chain
 		// spec is changed by checking hash stored as annotation on
-		// TektonInstallerSet with computing new hash of TektonChains Spec
+		// TektonInstallerSet with computing new hash of TektonChain Spec
 
-		// Hash of TektonChains Spec
+		// Hash of TektonChain Spec
 		expectedSpecHash, err := hash.Compute(tc.Spec)
 		if err != nil {
 			return err
@@ -270,22 +270,22 @@ func (r *Reconciler) ReconcileKind(ctx context.Context, tc *v1alpha1.TektonChain
 	tc.Status.MarkPostReconcilerComplete()
 
 	// Update the object for any spec changes
-	if _, err := r.operatorClientSet.OperatorV1alpha1().TektonChainses().Update(ctx, tc, metav1.UpdateOptions{}); err != nil {
+	if _, err := r.operatorClientSet.OperatorV1alpha1().TektonChains().Update(ctx, tc, metav1.UpdateOptions{}); err != nil {
 		return err
 	}
 
 	return nil
 }
 
-// FinalizeKind removes all resources after deletion of a TektonChains.
-func (r *Reconciler) FinalizeKind(ctx context.Context, original *v1alpha1.TektonChains) pkgreconciler.Event {
+// FinalizeKind removes all resources after deletion of a TektonChain.
+func (r *Reconciler) FinalizeKind(ctx context.Context, original *v1alpha1.TektonChain) pkgreconciler.Event {
 	logger := logging.FromContext(ctx)
 
 	// Delete CRDs before deleting rest of resources so that any instance
 	// of CRDs which has finalizer set will get deleted before we remove
 	// the controller's deployment for it
 	if err := r.manifest.Filter(mf.CRDs).Delete(); err != nil {
-		logger.Error("Failed to deleted CRDs for TektonChains")
+		logger.Error("Failed to deleted CRDs for TektonChain")
 		return err
 	}
 
@@ -297,7 +297,7 @@ func (r *Reconciler) FinalizeKind(ctx context.Context, original *v1alpha1.Tekton
 		DeleteCollection(ctx, metav1.DeleteOptions{}, metav1.ListOptions{
 			LabelSelector: labelSelector,
 		}); err != nil {
-		logger.Error("Failed to delete installer set created by TektonChains", err)
+		logger.Error("Failed to delete installer set created by TektonChain", err)
 		return err
 	}
 
@@ -308,10 +308,10 @@ func (r *Reconciler) FinalizeKind(ctx context.Context, original *v1alpha1.Tekton
 	return nil
 }
 
-func (r *Reconciler) updateTektonChainsStatus(ctx context.Context, tc *v1alpha1.TektonChains, createdIs *v1alpha1.TektonInstallerSet) error {
+func (r *Reconciler) updateTektonChainStatus(tc *v1alpha1.TektonChain, createdIs *v1alpha1.TektonInstallerSet) error {
 	// update the tc with TektonInstallerSet and releaseVersion
 	tc.Status.SetTektonInstallerSet(createdIs.Name)
-	tc.Status.SetVersion(r.chainsVersion)
+	tc.Status.SetVersion(r.chainVersion)
 
 	return v1alpha1.RECONCILE_AGAIN_ERR
 }
@@ -319,18 +319,18 @@ func (r *Reconciler) updateTektonChainsStatus(ctx context.Context, tc *v1alpha1.
 // transform mutates the passed manifest to one with common, component
 // and platform transformations applied
 func (r *Reconciler) transform(ctx context.Context, manifest *mf.Manifest, comp v1alpha1.TektonComponent) error {
-	instance := comp.(*v1alpha1.TektonChains)
-	chainsImages := common.ToLowerCaseKeys(common.ImagesFromEnv(common.ChainsImagePrefix))
+	instance := comp.(*v1alpha1.TektonChain)
+	chainImages := common.ToLowerCaseKeys(common.ImagesFromEnv(common.ChainsImagePrefix))
 	extra := []mf.Transformer{
 		common.ApplyProxySettings,
-		common.DeploymentImages(chainsImages),
+		common.DeploymentImages(chainImages),
 		common.AddConfiguration(instance.Spec.Config),
 	}
 	extra = append(extra, r.extension.Transformers(instance)...)
 	return common.Transform(ctx, manifest, instance, extra...)
 }
 
-func (r *Reconciler) createInstallerSet(ctx context.Context, tc *v1alpha1.TektonChains) (*v1alpha1.TektonInstallerSet, error) {
+func (r *Reconciler) createInstallerSet(ctx context.Context, tc *v1alpha1.TektonChain) (*v1alpha1.TektonInstallerSet, error) {
 
 	manifest := r.manifest
 	// installerSet adds it's owner as namespace's owner
@@ -348,7 +348,7 @@ func (r *Reconciler) createInstallerSet(ctx context.Context, tc *v1alpha1.Tekton
 		return nil, err
 	}
 
-	// compute the hash of tektonchains spec and store as an annotation
+	// compute the hash of tektonchain spec and store as an annotation
 	// in further reconciliation we compute hash of tc spec and check with
 	// annotation, if they are same then we skip updating the object
 	// otherwise we update the manifest
@@ -367,15 +367,15 @@ func (r *Reconciler) createInstallerSet(ctx context.Context, tc *v1alpha1.Tekton
 	return createdIs, nil
 }
 
-func makeInstallerSet(tc *v1alpha1.TektonChains, manifest mf.Manifest, tdSpecHash, releaseVersion string) *v1alpha1.TektonInstallerSet {
+func makeInstallerSet(tc *v1alpha1.TektonChain, manifest mf.Manifest, tdSpecHash, releaseVersion string) *v1alpha1.TektonInstallerSet {
 	ownerRef := *metav1.NewControllerRef(tc, tc.GetGroupVersionKind())
 	return &v1alpha1.TektonInstallerSet{
 		ObjectMeta: metav1.ObjectMeta{
-			GenerateName: fmt.Sprintf("%s-", v1alpha1.ChainsResourceName),
+			GenerateName: fmt.Sprintf("%s-", v1alpha1.ChainResourceName),
 			Labels: map[string]string{
 				v1alpha1.CreatedByKey:      createdByValue,
 				v1alpha1.ReleaseVersionKey: releaseVersion,
-				v1alpha1.InstallerSetType:  v1alpha1.ChainsResourceName,
+				v1alpha1.InstallerSetType:  v1alpha1.ChainResourceName,
 			},
 			Annotations: map[string]string{
 				v1alpha1.TargetNamespaceKey: tc.Spec.TargetNamespace,
@@ -389,7 +389,7 @@ func makeInstallerSet(tc *v1alpha1.TektonChains, manifest mf.Manifest, tdSpecHas
 	}
 }
 
-func (r *Reconciler) markUpgrade(ctx context.Context, tc *v1alpha1.TektonChains) error {
+func (r *Reconciler) markUpgrade(ctx context.Context, tc *v1alpha1.TektonChain) error {
 	labels := tc.GetLabels()
 	ver, ok := labels[v1alpha1.ReleaseVersionKey]
 	if ok && ver == r.operatorVersion {
@@ -407,7 +407,7 @@ func (r *Reconciler) markUpgrade(ctx context.Context, tc *v1alpha1.TektonChains)
 	labels[v1alpha1.ReleaseVersionKey] = r.operatorVersion
 	tc.SetLabels(labels)
 
-	if _, err := r.operatorClientSet.OperatorV1alpha1().TektonChainses().Update(ctx,
+	if _, err := r.operatorClientSet.OperatorV1alpha1().TektonChains().Update(ctx,
 		tc, metav1.UpdateOptions{}); err != nil {
 		return err
 	}
diff --git a/pkg/reconciler/openshift/tektonchains/controller.go b/pkg/reconciler/openshift/tektonchain/controller.go
similarity index 96%
rename from pkg/reconciler/openshift/tektonchains/controller.go
rename to pkg/reconciler/openshift/tektonchain/controller.go
index df48ab816..2fe2c9f16 100644
--- a/pkg/reconciler/openshift/tektonchains/controller.go
+++ b/pkg/reconciler/openshift/tektonchain/controller.go
@@ -14,12 +14,12 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package tektonchains
+package tektonchain
 
 import (
 	"context"
 
-	k8s_ctrl "github.com/tektoncd/operator/pkg/reconciler/kubernetes/tektonchains"
+	k8s_ctrl "github.com/tektoncd/operator/pkg/reconciler/kubernetes/tektonchain"
 	"knative.dev/pkg/configmap"
 	"knative.dev/pkg/controller"
 )
diff --git a/pkg/reconciler/openshift/tektonchains/extension.go b/pkg/reconciler/openshift/tektonchain/extension.go
similarity index 98%
rename from pkg/reconciler/openshift/tektonchains/extension.go
rename to pkg/reconciler/openshift/tektonchain/extension.go
index b9ac87409..fdd1da6e4 100644
--- a/pkg/reconciler/openshift/tektonchains/extension.go
+++ b/pkg/reconciler/openshift/tektonchain/extension.go
@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package tektonchains
+package tektonchain
 
 import (
 	"context"
diff --git a/pkg/reconciler/shared/tektonconfig/chains/chains.go b/pkg/reconciler/shared/tektonconfig/chain/chain.go
similarity index 62%
rename from pkg/reconciler/shared/tektonconfig/chains/chains.go
rename to pkg/reconciler/shared/tektonconfig/chain/chain.go
index ee94a46dc..5b0786f73 100644
--- a/pkg/reconciler/shared/tektonconfig/chains/chains.go
+++ b/pkg/reconciler/shared/tektonconfig/chain/chain.go
@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package chains
+package chain
 
 import (
 	"context"
@@ -30,28 +30,28 @@ import (
 	"k8s.io/apimachinery/pkg/util/wait"
 )
 
-func EnsureTektonChainsExists(ctx context.Context, clients op.TektonChainsInterface, config *v1alpha1.TektonConfig) (*v1alpha1.TektonChains, error) {
-	tcCR, err := GetChains(ctx, clients, v1alpha1.ChainsResourceName)
+func EnsureTektonChainExists(ctx context.Context, clients op.TektonChainInterface, config *v1alpha1.TektonConfig) (*v1alpha1.TektonChain, error) {
+	tcCR, err := GetChain(ctx, clients, v1alpha1.ChainResourceName)
 	if err != nil {
 		if !apierrs.IsNotFound(err) {
 			return nil, err
 		}
-		// if TektonChains CR is not found in the cluster, then create one
-		_, err = CreateChains(ctx, clients, config)
+		// if TektonChain CR is not found in the cluster, then create one
+		_, err = CreateChain(ctx, clients, config)
 		if err != nil {
 			return nil, err
 		}
 		return nil, v1alpha1.RECONCILE_AGAIN_ERR
 	}
 
-	// so TektonChains CR does exist in the cluster, checking if any updates are required.
-	// if the chains spec is changed then update the instance
-	tcCR, err = UpdateChains(ctx, tcCR, config, clients)
+	// so TektonChain CR does exist in the cluster, checking if any updates are required.
+	// if the chain spec is changed then update the instance
+	tcCR, err = UpdateChain(ctx, tcCR, config, clients)
 	if err != nil {
 		return nil, err
 	}
 
-	ok, err := isTektonChainsReady(tcCR, err)
+	ok, err := isTektonChainReady(tcCR, err)
 	if err != nil {
 		return nil, err
 	}
@@ -62,18 +62,18 @@ func EnsureTektonChainsExists(ctx context.Context, clients op.TektonChainsInterf
 	return tcCR, err
 }
 
-func GetChains(ctx context.Context, clients op.TektonChainsInterface, name string) (*v1alpha1.TektonChains, error) {
+func GetChain(ctx context.Context, clients op.TektonChainInterface, name string) (*v1alpha1.TektonChain, error) {
 	return clients.Get(ctx, name, metav1.GetOptions{})
 }
 
-func CreateChains(ctx context.Context, clients op.TektonChainsInterface, config *v1alpha1.TektonConfig) (*v1alpha1.TektonChains, error) {
+func CreateChain(ctx context.Context, clients op.TektonChainInterface, config *v1alpha1.TektonConfig) (*v1alpha1.TektonChain, error) {
 	ownerRef := *metav1.NewControllerRef(config, config.GroupVersionKind())
-	tcCR := &v1alpha1.TektonChains{
+	tcCR := &v1alpha1.TektonChain{
 		ObjectMeta: metav1.ObjectMeta{
-			Name:            v1alpha1.ChainsResourceName,
+			Name:            v1alpha1.ChainResourceName,
 			OwnerReferences: []metav1.OwnerReference{ownerRef},
 		},
-		Spec: v1alpha1.TektonChainsSpec{
+		Spec: v1alpha1.TektonChainSpec{
 			CommonSpec: v1alpha1.CommonSpec{
 				TargetNamespace: config.Spec.TargetNamespace,
 			},
@@ -87,8 +87,8 @@ func CreateChains(ctx context.Context, clients op.TektonChainsInterface, config
 	return tcCR, err
 }
 
-func UpdateChains(ctx context.Context, tcCR *v1alpha1.TektonChains, config *v1alpha1.TektonConfig, clients op.TektonChainsInterface) (*v1alpha1.TektonChains, error) {
-	// if the chains spec is changed then update the instance
+func UpdateChain(ctx context.Context, tcCR *v1alpha1.TektonChain, config *v1alpha1.TektonConfig, clients op.TektonChainInterface) (*v1alpha1.TektonChain, error) {
+	// if the chain spec is changed then update the instance
 	updated := false
 
 	if config.Spec.TargetNamespace != tcCR.Spec.TargetNamespace {
@@ -117,8 +117,8 @@ func UpdateChains(ctx context.Context, tcCR *v1alpha1.TektonChains, config *v1al
 	return tcCR, nil
 }
 
-// isTektonChainsReady will check the status conditions of the TektonChains and return true if the TektonChains is ready.
-func isTektonChainsReady(s *v1alpha1.TektonChains, err error) (bool, error) {
+// isTektonChainReady will check the status conditions of the TektonChain and return true if the TektonChain is ready.
+func isTektonChainReady(s *v1alpha1.TektonChain, err error) (bool, error) {
 	upgradePending, errInternal := common.CheckUpgradePending(s)
 	if err != nil {
 		return false, errInternal
@@ -129,9 +129,9 @@ func isTektonChainsReady(s *v1alpha1.TektonChains, err error) (bool, error) {
 	return s.Status.IsReady(), err
 }
 
-// TektonChainsCRDelete deletes TektonChains CR to see if all resources will be deleted
-func TektonChainsCRDelete(ctx context.Context, clients op.TektonChainsInterface, name string) error {
-	if _, err := GetChains(ctx, clients, v1alpha1.ChainsResourceName); err != nil {
+// TektonChainCRDelete deletes TektonChain CR to see if all resources will be deleted
+func TektonChainCRDelete(ctx context.Context, clients op.TektonChainInterface, name string) error {
+	if _, err := GetChain(ctx, clients, v1alpha1.ChainResourceName); err != nil {
 		// nothing to delete if CR does not exist in the cluster
 		if apierrs.IsNotFound(err) {
 			return nil
@@ -139,7 +139,7 @@ func TektonChainsCRDelete(ctx context.Context, clients op.TektonChainsInterface,
 		return err
 	}
 	if err := clients.Delete(ctx, name, metav1.DeleteOptions{}); err != nil {
-		return fmt.Errorf("TektonChains %q failed to delete: %v", name, err)
+		return fmt.Errorf("TektonChain %q failed to delete: %v", name, err)
 	}
 	err := wait.PollImmediate(common.Interval, common.Timeout, func() (bool, error) {
 		_, err := clients.Get(ctx, name, metav1.GetOptions{})
@@ -149,18 +149,18 @@ func TektonChainsCRDelete(ctx context.Context, clients op.TektonChainsInterface,
 		return false, err
 	})
 	if err != nil {
-		return fmt.Errorf("Timed out waiting on TektonChains to delete %v", err)
+		return fmt.Errorf("Timed out waiting on TektonChain to delete %v", err)
 	}
-	return verifyNoTektonChainsCR(ctx, clients)
+	return verifyNoTektonChainCR(ctx, clients)
 }
 
-func verifyNoTektonChainsCR(ctx context.Context, clients op.TektonChainsInterface) error {
-	chainses, err := clients.List(ctx, metav1.ListOptions{})
+func verifyNoTektonChainCR(ctx context.Context, clients op.TektonChainInterface) error {
+	chains, err := clients.List(ctx, metav1.ListOptions{})
 	if err != nil {
 		return err
 	}
-	if len(chainses.Items) > 0 {
-		return errors.New("Unable to verify cluster-scoped resources are deleted if any TektonChains exists")
+	if len(chains.Items) > 0 {
+		return errors.New("Unable to verify cluster-scoped resources are deleted if any TektonChain exists")
 	}
 	return nil
 }
diff --git a/pkg/reconciler/shared/tektonconfig/controller.go b/pkg/reconciler/shared/tektonconfig/controller.go
index 97237f487..bb308d29c 100644
--- a/pkg/reconciler/shared/tektonconfig/controller.go
+++ b/pkg/reconciler/shared/tektonconfig/controller.go
@@ -22,29 +22,26 @@ import (
 	"regexp"
 
 	"github.com/go-logr/zapr"
-	mf "github.com/manifestival/manifestival"
-	"go.uber.org/zap"
-
-	"knative.dev/pkg/kmeta"
-
-	"k8s.io/apimachinery/pkg/types"
-	namespaceinformer "knative.dev/pkg/client/injection/kube/informers/core/v1/namespace"
-
 	mfc "github.com/manifestival/client-go-client"
+	mf "github.com/manifestival/manifestival"
 	"github.com/tektoncd/operator/pkg/apis/operator/v1alpha1"
 	operatorclient "github.com/tektoncd/operator/pkg/client/injection/client"
-	tektonChainsinformer "github.com/tektoncd/operator/pkg/client/injection/informers/operator/v1alpha1/tektonchains"
+	tektonChaininformer "github.com/tektoncd/operator/pkg/client/injection/informers/operator/v1alpha1/tektonchain"
 	tektonConfiginformer "github.com/tektoncd/operator/pkg/client/injection/informers/operator/v1alpha1/tektonconfig"
 	tektonInstallerinformer "github.com/tektoncd/operator/pkg/client/injection/informers/operator/v1alpha1/tektoninstallerset"
 	tektonPipelineinformer "github.com/tektoncd/operator/pkg/client/injection/informers/operator/v1alpha1/tektonpipeline"
 	tektonTriggerinformer "github.com/tektoncd/operator/pkg/client/injection/informers/operator/v1alpha1/tektontrigger"
 	tektonConfigreconciler "github.com/tektoncd/operator/pkg/client/injection/reconciler/operator/v1alpha1/tektonconfig"
 	"github.com/tektoncd/operator/pkg/reconciler/common"
+	"go.uber.org/zap"
+	"k8s.io/apimachinery/pkg/types"
 	"k8s.io/client-go/tools/cache"
 	kubeclient "knative.dev/pkg/client/injection/kube/client"
+	namespaceinformer "knative.dev/pkg/client/injection/kube/informers/core/v1/namespace"
 	"knative.dev/pkg/configmap"
 	"knative.dev/pkg/controller"
 	"knative.dev/pkg/injection"
+	"knative.dev/pkg/kmeta"
 	"knative.dev/pkg/logging"
 )
 
@@ -95,7 +92,7 @@ func NewExtensibleController(generator common.ExtensionGenerator) injection.Cont
 			Handler:    controller.HandleAll(impl.EnqueueControllerOf),
 		})
 
-		tektonChainsinformer.Get(ctx).Informer().AddEventHandler(cache.FilteringResourceEventHandler{
+		tektonChaininformer.Get(ctx).Informer().AddEventHandler(cache.FilteringResourceEventHandler{
 			FilterFunc: controller.FilterController(&v1alpha1.TektonConfig{}),
 			Handler:    controller.HandleAll(impl.EnqueueControllerOf),
 		})
diff --git a/pkg/reconciler/shared/tektonconfig/tektonconfig.go b/pkg/reconciler/shared/tektonconfig/tektonconfig.go
index 25ac5402f..55fdc750b 100644
--- a/pkg/reconciler/shared/tektonconfig/tektonconfig.go
+++ b/pkg/reconciler/shared/tektonconfig/tektonconfig.go
@@ -26,7 +26,7 @@ import (
 	clientset "github.com/tektoncd/operator/pkg/client/clientset/versioned"
 	tektonConfigreconciler "github.com/tektoncd/operator/pkg/client/injection/reconciler/operator/v1alpha1/tektonconfig"
 	"github.com/tektoncd/operator/pkg/reconciler/common"
-	"github.com/tektoncd/operator/pkg/reconciler/shared/tektonconfig/chains"
+	"github.com/tektoncd/operator/pkg/reconciler/shared/tektonconfig/chain"
 	"github.com/tektoncd/operator/pkg/reconciler/shared/tektonconfig/pipeline"
 	"github.com/tektoncd/operator/pkg/reconciler/shared/tektonconfig/trigger"
 	"k8s.io/apimachinery/pkg/api/errors"
@@ -145,16 +145,16 @@ func (r *Reconciler) ReconcileKind(ctx context.Context, tc *v1alpha1.TektonConfi
 		}
 	}
 
-	// Create TektonChains CR if profile is all
+	// Create TektonChain CR if profile is all
 	if tc.Spec.Profile == v1alpha1.ProfileAll {
-		if _, err := chains.EnsureTektonChainsExists(ctx, r.operatorClientSet.OperatorV1alpha1().TektonChainses(), tc); err != nil {
-			tc.Status.MarkComponentNotReady(fmt.Sprintf("TektonChains: %s", err.Error()))
+		if _, err := chain.EnsureTektonChainExists(ctx, r.operatorClientSet.OperatorV1alpha1().TektonChains(), tc); err != nil {
+			tc.Status.MarkComponentNotReady(fmt.Sprintf("TektonChain: %s", err.Error()))
 			r.enqueueAfter(tc, 10*time.Second)
 			return err
 		}
 	} else {
-		if err := chains.TektonChainsCRDelete(ctx, r.operatorClientSet.OperatorV1alpha1().TektonChainses(), v1alpha1.ChainsResourceName); err != nil {
-			tc.Status.MarkComponentNotReady(fmt.Sprintf("TektonChains: %s", err.Error()))
+		if err := chain.TektonChainCRDelete(ctx, r.operatorClientSet.OperatorV1alpha1().TektonChains(), v1alpha1.ChainResourceName); err != nil {
+			tc.Status.MarkComponentNotReady(fmt.Sprintf("TektonChain: %s", err.Error()))
 			r.enqueueAfter(tc, 10*time.Second)
 			return err
 		}
diff --git a/pkg/webhook/webhook.go b/pkg/webhook/webhook.go
index 41a45598d..3915a9cf8 100644
--- a/pkg/webhook/webhook.go
+++ b/pkg/webhook/webhook.go
@@ -35,7 +35,7 @@ var types = map[schema.GroupVersionKind]resourcesemantics.GenericCRD{
 	v1alpha1.SchemeGroupVersion.WithKind("TektonPipeline"): &v1alpha1.TektonPipeline{},
 	v1alpha1.SchemeGroupVersion.WithKind("TektonTrigger"):  &v1alpha1.TektonTrigger{},
 	v1alpha1.SchemeGroupVersion.WithKind("TektonHub"):      &v1alpha1.TektonHub{},
-	v1alpha1.SchemeGroupVersion.WithKind("TektonChains"):   &v1alpha1.TektonChains{},
+	v1alpha1.SchemeGroupVersion.WithKind("TektonChain"):    &v1alpha1.TektonChain{},
 }
 
 func SetTypes(platform string) {


Test patch:
diff --git a/pkg/apis/operator/v1alpha1/tektonchains_lifecycle_test.go b/pkg/apis/operator/v1alpha1/tektonchain_lifecycle_test.go
similarity index 92%
rename from pkg/apis/operator/v1alpha1/tektonchains_lifecycle_test.go
rename to pkg/apis/operator/v1alpha1/tektonchain_lifecycle_test.go
index 4775ecb8b..bc088fdb2 100644
--- a/pkg/apis/operator/v1alpha1/tektonchains_lifecycle_test.go
+++ b/pkg/apis/operator/v1alpha1/tektonchain_lifecycle_test.go
@@ -23,20 +23,20 @@ import (
 	apistest "knative.dev/pkg/apis/testing"
 )
 
-func TestTektonChainsGroupVersionKind(t *testing.T) {
-	r := &TektonChains{}
+func TestTektonChainGroupVersionKind(t *testing.T) {
+	r := &TektonChain{}
 	want := schema.GroupVersionKind{
 		Group:   GroupName,
 		Version: SchemaVersion,
-		Kind:    KindTektonChains,
+		Kind:    KindTektonChain,
 	}
 	if got := r.GetGroupVersionKind(); got != want {
 		t.Errorf("got: %v, want: %v", got, want)
 	}
 }
 
-func TestTektonChainsHappyPath(t *testing.T) {
-	tt := &TektonChainsStatus{}
+func TestTektonChainHappyPath(t *testing.T) {
+	tt := &TektonChainStatus{}
 	tt.InitializeConditions()
 
 	apistest.CheckConditionOngoing(tt, DependenciesInstalled, t)
@@ -73,8 +73,8 @@ func TestTektonChainsHappyPath(t *testing.T) {
 	}
 }
 
-func TestTektonChainsErrorPath(t *testing.T) {
-	tr := &TektonChainsStatus{}
+func TestTektonChainErrorPath(t *testing.T) {
+	tr := &TektonChainStatus{}
 	tr.InitializeConditions()
 
 	apistest.CheckConditionOngoing(tr, DependenciesInstalled, t)
@@ -121,8 +121,8 @@ func TestTektonChainsErrorPath(t *testing.T) {
 
 }
 
-func TestTektonChainsExternalDependency(t *testing.T) {
-	tt := &TektonChainsStatus{}
+func TestTektonChainExternalDependency(t *testing.T) {
+	tt := &TektonChainStatus{}
 	tt.InitializeConditions()
 
 	// External marks dependency as failed.
diff --git a/pkg/apis/operator/v1alpha1/tektonchains_validation_test.go b/pkg/apis/operator/v1alpha1/tektonchain_validation_test.go
similarity index 75%
rename from pkg/apis/operator/v1alpha1/tektonchains_validation_test.go
rename to pkg/apis/operator/v1alpha1/tektonchain_validation_test.go
index ec0669ed2..f80b32b53 100644
--- a/pkg/apis/operator/v1alpha1/tektonchains_validation_test.go
+++ b/pkg/apis/operator/v1alpha1/tektonchain_validation_test.go
@@ -25,28 +25,28 @@ import (
 	"knative.dev/pkg/apis"
 )
 
-func Test_ValidateTektonChains_MissingTargetNamespace(t *testing.T) {
+func Test_ValidateTektonChain_MissingTargetNamespace(t *testing.T) {
 
-	td := &TektonChains{
+	td := &TektonChain{
 		ObjectMeta: metav1.ObjectMeta{
-			Name:      "chains",
+			Name:      "chain",
 			Namespace: "namespace",
 		},
-		Spec: TektonChainsSpec{},
+		Spec: TektonChainSpec{},
 	}
 
 	err := td.Validate(context.TODO())
 	assert.Equal(t, "missing field(s): spec.targetNamespace", err.Error())
 }
 
-func Test_ValidateTektonChains_OnDelete(t *testing.T) {
+func Test_ValidateTektonChain_OnDelete(t *testing.T) {
 
-	td := &TektonChains{
+	td := &TektonChain{
 		ObjectMeta: metav1.ObjectMeta{
 			Name:      "name",
 			Namespace: "namespace",
 		},
-		Spec: TektonChainsSpec{
+		Spec: TektonChainSpec{
 			CommonSpec: CommonSpec{
 				TargetNamespace: "namespace",
 			},
@@ -55,6 +55,6 @@ func Test_ValidateTektonChains_OnDelete(t *testing.T) {
 
 	err := td.Validate(apis.WithinDelete(context.Background()))
 	if err != nil {
-		t.Errorf("ValidateTektonChains.Validate() on Delete expected no error, but got one, ValidateTektonChains: %v", err)
+		t.Errorf("ValidateTektonChain.Validate() on Delete expected no error, but got one, ValidateTektonChain: %v", err)
 	}
 }
diff --git a/pkg/reconciler/shared/tektonconfig/chains/chains_test.go b/pkg/reconciler/shared/tektonconfig/chain/chain_test.go
similarity index 68%
rename from pkg/reconciler/shared/tektonconfig/chains/chains_test.go
rename to pkg/reconciler/shared/tektonconfig/chain/chain_test.go
index c5748f20a..e2f2e546c 100644
--- a/pkg/reconciler/shared/tektonconfig/chains/chains_test.go
+++ b/pkg/reconciler/shared/tektonconfig/chain/chain_test.go
@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package chains
+package chain
 
 import (
 	"testing"
@@ -25,22 +25,22 @@ import (
 	ts "knative.dev/pkg/reconciler/testing"
 )
 
-func TestTektonChainsCreateAndDeleteCR(t *testing.T) {
+func TestTektonChainCreateAndDeleteCR(t *testing.T) {
 	ctx, _, _ := ts.SetupFakeContextWithCancel(t)
 	c := fake.Get(ctx)
 	tConfig := GetTektonConfig()
-	_, err := EnsureTektonChainsExists(ctx, c.OperatorV1alpha1().TektonChainses(), tConfig)
+	_, err := EnsureTektonChainExists(ctx, c.OperatorV1alpha1().TektonChains(), tConfig)
 	util.AssertNotEqual(t, err, nil)
-	// recheck chains creation
-	_, err = EnsureTektonChainsExists(ctx, c.OperatorV1alpha1().TektonChainses(), tConfig)
+	// recheck chain creation
+	_, err = EnsureTektonChainExists(ctx, c.OperatorV1alpha1().TektonChains(), tConfig)
 	util.AssertNotEqual(t, err, nil)
-	err = TektonChainsCRDelete(ctx, c.OperatorV1alpha1().TektonChainses(), v1alpha1.ChainsResourceName)
+	err = TektonChainCRDelete(ctx, c.OperatorV1alpha1().TektonChains(), v1alpha1.ChainResourceName)
 	util.AssertEqual(t, err, nil)
 }
 
-func TestTektonChainsCRDelete(t *testing.T) {
+func TestTektonChainCRDelete(t *testing.T) {
 	ctx, _, _ := ts.SetupFakeContextWithCancel(t)
 	c := fake.Get(ctx)
-	err := TektonChainsCRDelete(ctx, c.OperatorV1alpha1().TektonChainses(), v1alpha1.ChainsResourceName)
+	err := TektonChainCRDelete(ctx, c.OperatorV1alpha1().TektonChains(), v1alpha1.ChainResourceName)
 	util.AssertEqual(t, err, nil)
 }
diff --git a/test/e2e/common/00_tektonconfigdeployment_test.go b/test/e2e/common/00_tektonconfigdeployment_test.go
index e12725fb8..c5647275f 100644
--- a/test/e2e/common/00_tektonconfigdeployment_test.go
+++ b/test/e2e/common/00_tektonconfigdeployment_test.go
@@ -121,9 +121,9 @@ func runFeatureTest(t *testing.T, clients *utils.Clients, tc *v1alpha1.TektonCon
 			}
 		}
 
-		// make sure chains is created
-		if _, err := clients.Operator.TektonChainses().Get(context.TODO(), v1alpha1.ChainsResourceName, metav1.GetOptions{}); err != nil {
-			t.Fatalf("failed to get tektonchains")
+		// make sure chain is created
+		if _, err := clients.Operator.TektonChains().Get(context.TODO(), v1alpha1.ChainResourceName, metav1.GetOptions{}); err != nil {
+			t.Fatalf("failed to get tektonchain")
 		}
 
 		// change the profile and make sure it is reflected on the cluster
@@ -154,9 +154,9 @@ func runFeatureTest(t *testing.T, clients *utils.Clients, tc *v1alpha1.TektonCon
 			}
 		}
 
-		// make sure chains is deleted
-		if _, err := clients.Operator.TektonChainses().Get(context.TODO(), v1alpha1.ChainsResourceName, metav1.GetOptions{}); err == nil {
-			t.Fatalf("expected error but got nil, tektonchains not deleted")
+		// make sure chain is deleted
+		if _, err := clients.Operator.TektonChains().Get(context.TODO(), v1alpha1.ChainResourceName, metav1.GetOptions{}); err == nil {
+			t.Fatalf("expected error but got nil, tektonchain not deleted")
 		}
 	})
 
diff --git a/test/e2e/common/03_tektonchainsdeployment_test.go b/test/e2e/common/03_tektonchaindeployment_test.go
similarity index 63%
rename from test/e2e/common/03_tektonchainsdeployment_test.go
rename to test/e2e/common/03_tektonchaindeployment_test.go
index 8a9574899..ec194b828 100644
--- a/test/e2e/common/03_tektonchainsdeployment_test.go
+++ b/test/e2e/common/03_tektonchaindeployment_test.go
@@ -27,14 +27,14 @@ import (
 	"github.com/tektoncd/operator/test/utils"
 )
 
-// TestTektonChainsDeployment verifies the TektonChains creation, deployment recreation, and TektonChains deletion.
-func TestTektonChainsDeployment(t *testing.T) {
+// TestTektonChainDeployment verifies the TektonChain creation, deployment recreation, and TektonChain deletion.
+func TestTektonChainDeployment(t *testing.T) {
 	clients := client.Setup(t)
 
 	crNames := utils.ResourceNames{
 		TektonConfig:    "config",
 		TektonPipeline:  "pipeline",
-		TektonChains:    "chains",
+		TektonChain:     "chain",
 		TargetNamespace: "tekton-pipelines",
 	}
 
@@ -45,8 +45,8 @@ func TestTektonChainsDeployment(t *testing.T) {
 	utils.CleanupOnInterrupt(func() { utils.TearDownPipeline(clients, crNames.TektonPipeline) })
 	defer utils.TearDownPipeline(clients, crNames.TektonPipeline)
 
-	utils.CleanupOnInterrupt(func() { utils.TearDownChains(clients, crNames.TektonChains) })
-	defer utils.TearDownChains(clients, crNames.TektonChains)
+	utils.CleanupOnInterrupt(func() { utils.TearDownChain(clients, crNames.TektonChain) })
+	defer utils.TearDownChain(clients, crNames.TektonChain)
 
 	resources.EnsureNoTektonConfigInstance(t, clients, crNames)
 
@@ -60,27 +60,27 @@ func TestTektonChainsDeployment(t *testing.T) {
 		resources.AssertTektonPipelineCRReadyStatus(t, clients, crNames)
 	})
 
-	// Create a TektonChains
-	if _, err := resources.EnsureTektonChainsExists(clients.TektonChains(), crNames); err != nil {
-		t.Fatalf("TektonChains %q failed to create: %v", crNames.TektonChains, err)
+	// Create a TektonChain
+	if _, err := resources.EnsureTektonChainExists(clients.TektonChains(), crNames); err != nil {
+		t.Fatalf("TektonChain %q failed to create: %v", crNames.TektonChain, err)
 	}
 
-	// Test if TektonChains can reach the READY status
-	t.Run("create-chains", func(t *testing.T) {
-		resources.AssertTektonChainsCRReadyStatus(t, clients, crNames)
+	// Test if TektonChain can reach the READY status
+	t.Run("create-chain", func(t *testing.T) {
+		resources.AssertTektonChainCRReadyStatus(t, clients, crNames)
 	})
 
 	// Delete the deployments one by one to see if they will be recreated.
-	t.Run("restore-chains-deployments", func(t *testing.T) {
-		resources.AssertTektonChainsCRReadyStatus(t, clients, crNames)
-		resources.DeleteAndVerifyDeployments(t, clients, crNames.TargetNamespace, utils.TektonChainsDeploymentLabel)
-		resources.AssertTektonChainsCRReadyStatus(t, clients, crNames)
+	t.Run("restore-chain-deployments", func(t *testing.T) {
+		resources.AssertTektonChainCRReadyStatus(t, clients, crNames)
+		resources.DeleteAndVerifyDeployments(t, clients, crNames.TargetNamespace, utils.TektonChainDeploymentLabel)
+		resources.AssertTektonChainCRReadyStatus(t, clients, crNames)
 	})
 
-	// Delete the TektonChains CR instance to see if all resources will be removed
-	t.Run("delete-chains", func(t *testing.T) {
-		resources.AssertTektonChainsCRReadyStatus(t, clients, crNames)
-		resources.TektonChainsCRDelete(t, clients, crNames)
+	// Delete the TektonChain CR instance to see if all resources will be removed
+	t.Run("delete-chain", func(t *testing.T) {
+		resources.AssertTektonChainCRReadyStatus(t, clients, crNames)
+		resources.TektonChainCRDelete(t, clients, crNames)
 	})
 
 	// Delete the TektonPipeline CR instance to see if all resources will be removed
diff --git a/test/resources/tektonchains.go b/test/resources/tektonchains.go
index 546c60769..07be0dacb 100644
--- a/test/resources/tektonchains.go
+++ b/test/resources/tektonchains.go
@@ -35,16 +35,16 @@ import (
 	"knative.dev/pkg/test/logging"
 )
 
-// EnsureTektonChainsExists creates a TektonChains with the name names.TektonChains, if it does not exist.
-func EnsureTektonChainsExists(clients typedv1alpha1.TektonChainsInterface, names utils.ResourceNames) (*v1alpha1.TektonChains, error) {
+// EnsureTektonChainExists creates a TektonChain with the name names.TektonChain, if it does not exist.
+func EnsureTektonChainExists(clients typedv1alpha1.TektonChainInterface, names utils.ResourceNames) (*v1alpha1.TektonChain, error) {
 	// If this function is called by the upgrade tests, we only create the custom resource, if it does not exist.
-	ks, err := clients.Get(context.TODO(), names.TektonChains, metav1.GetOptions{})
+	ks, err := clients.Get(context.TODO(), names.TektonChain, metav1.GetOptions{})
 	if apierrs.IsNotFound(err) {
-		ks := &v1alpha1.TektonChains{
+		ks := &v1alpha1.TektonChain{
 			ObjectMeta: metav1.ObjectMeta{
-				Name: names.TektonChains,
+				Name: names.TektonChain,
 			},
-			Spec: v1alpha1.TektonChainsSpec{
+			Spec: v1alpha1.TektonChainSpec{
 				CommonSpec: v1alpha1.CommonSpec{
 					TargetNamespace: names.TargetNamespace,
 				},
@@ -55,60 +55,60 @@ func EnsureTektonChainsExists(clients typedv1alpha1.TektonChainsInterface, names
 	return ks, err
 }
 
-// WaitForTektonChainsState polls the status of the TektonChains called name
+// WaitForTektonChainState polls the status of the TektonChain called name
 // from client every `interval` until `inState` returns `true` indicating it
 // is done, returns an error or timeout.
-func WaitForTektonChainsState(clients typedv1alpha1.TektonChainsInterface, name string,
-	inState func(s *v1alpha1.TektonChains, err error) (bool, error)) (*v1alpha1.TektonChains, error) {
-	span := logging.GetEmitableSpan(context.Background(), fmt.Sprintf("WaitForTektonChainsState/%s/%s", name, "TektonChainsIsReady"))
+func WaitForTektonChainState(clients typedv1alpha1.TektonChainInterface, name string,
+	inState func(s *v1alpha1.TektonChain, err error) (bool, error)) (*v1alpha1.TektonChain, error) {
+	span := logging.GetEmitableSpan(context.Background(), fmt.Sprintf("WaitForTektonChainState/%s/%s", name, "TektonChainIsReady"))
 	defer span.End()
 
-	var lastState *v1alpha1.TektonChains
+	var lastState *v1alpha1.TektonChain
 	waitErr := wait.PollImmediate(Interval, Timeout, func() (bool, error) {
 		lastState, err := clients.Get(context.TODO(), name, metav1.GetOptions{})
 		return inState(lastState, err)
 	})
 
 	if waitErr != nil {
-		return lastState, fmt.Errorf("tektonchains %s is not in desired state, got: %+v: %w", name, lastState, waitErr)
+		return lastState, fmt.Errorf("tektonchain %s is not in desired state, got: %+v: %w", name, lastState, waitErr)
 	}
 	return lastState, nil
 }
 
-// IsTektonChainsReady will check the status conditions of the TektonChains and return true if the TektonChains is ready.
-func IsTektonChainsReady(s *v1alpha1.TektonChains, err error) (bool, error) {
+// IsTektonChainReady will check the status conditions of the TektonChain and return true if the TektonChain is ready.
+func IsTektonChainReady(s *v1alpha1.TektonChain, err error) (bool, error) {
 	return s.Status.IsReady(), err
 }
 
-// AssertTektonChainsCRReadyStatus verifies if the TektonChains reaches the READY status.
-func AssertTektonChainsCRReadyStatus(t *testing.T, clients *utils.Clients, names utils.ResourceNames) {
-	if _, err := WaitForTektonChainsState(clients.TektonChains(), names.TektonChains,
-		IsTektonChainsReady); err != nil {
-		t.Fatalf("TektonChainsCR %q failed to get to the READY status: %v", names.TektonChains, err)
+// AssertTektonChainCRReadyStatus verifies if the TektonChain reaches the READY status.
+func AssertTektonChainCRReadyStatus(t *testing.T, clients *utils.Clients, names utils.ResourceNames) {
+	if _, err := WaitForTektonChainState(clients.TektonChains(), names.TektonChain,
+		IsTektonChainReady); err != nil {
+		t.Fatalf("TektonChainCR %q failed to get to the READY status: %v", names.TektonChain, err)
 	}
 }
 
-// TektonChainsCRDelete deletes tha TektonChains to see if all resources will be deleted
-func TektonChainsCRDelete(t *testing.T, clients *utils.Clients, crNames utils.ResourceNames) {
-	if err := clients.TektonChains().Delete(context.TODO(), crNames.TektonChains, metav1.DeleteOptions{}); err != nil {
-		t.Fatalf("TektonChains %q failed to delete: %v", crNames.TektonChains, err)
+// TektonChainCRDelete deletes tha TektonChain to see if all resources will be deleted
+func TektonChainCRDelete(t *testing.T, clients *utils.Clients, crNames utils.ResourceNames) {
+	if err := clients.TektonChains().Delete(context.TODO(), crNames.TektonChain, metav1.DeleteOptions{}); err != nil {
+		t.Fatalf("TektonChain %q failed to delete: %v", crNames.TektonChain, err)
 	}
 	err := wait.PollImmediate(Interval, Timeout, func() (bool, error) {
-		_, err := clients.TektonChains().Get(context.TODO(), crNames.TektonChains, metav1.GetOptions{})
+		_, err := clients.TektonChains().Get(context.TODO(), crNames.TektonChain, metav1.GetOptions{})
 		if apierrs.IsNotFound(err) {
 			return true, nil
 		}
 		return false, err
 	})
 	if err != nil {
-		t.Fatal("Timed out waiting on TektonChains to delete", err)
+		t.Fatal("Timed out waiting on TektonChain to delete", err)
 	}
 	_, b, _, _ := runtime.Caller(0)
 	m, err := mfc.NewManifest(filepath.Join((filepath.Dir(b)+"/.."), "manifests/"), clients.Config)
 	if err != nil {
 		t.Fatal("Failed to load manifest", err)
 	}
-	if err := verifyNoTektonChainsCR(clients); err != nil {
+	if err := verifyNoTektonChainCR(clients); err != nil {
 		t.Fatal(err)
 	}
 
@@ -126,13 +126,13 @@ func TektonChainsCRDelete(t *testing.T, clients *utils.Clients, crNames utils.Re
 	}
 }
 
-func verifyNoTektonChainsCR(clients *utils.Clients) error {
+func verifyNoTektonChainCR(clients *utils.Clients) error {
 	chains, err := clients.TektonChainsAll().List(context.TODO(), metav1.ListOptions{})
 	if err != nil {
 		return err
 	}
 	if len(chains.Items) > 0 {
-		return errors.New("Unable to verify cluster-scoped resources are deleted if any TektonChains exists")
+		return errors.New("Unable to verify cluster-scoped resources are deleted if any TektonChain exists")
 	}
 	return nil
 }
diff --git a/test/utils/cleanup.go b/test/utils/cleanup.go
index d18114df4..cf1f4b7dc 100644
--- a/test/utils/cleanup.go
+++ b/test/utils/cleanup.go
@@ -85,8 +85,8 @@ func TearDownResult(clients *Clients, name string) {
 	}
 }
 
-// TearDownChains will delete created TektonChains CRs using clients.
-func TearDownChains(clients *Clients, name string) {
+// TearDownChain will delete created TektonChain CRs using clients.
+func TearDownChain(clients *Clients, name string) {
 	if clients != nil && clients.Operator != nil {
 		_ = clients.TektonChains().Delete(context.TODO(), name, metav1.DeleteOptions{})
 	}
diff --git a/test/utils/clients.go b/test/utils/clients.go
index 55a513421..da343535b 100644
--- a/test/utils/clients.go
+++ b/test/utils/clients.go
@@ -140,12 +140,12 @@ func (c *Clients) TektonResultAll() operatorv1alpha1.TektonResultInterface {
 	return c.Operator.TektonResults()
 }
 
-func (c *Clients) TektonChains() operatorv1alpha1.TektonChainsInterface {
-	return c.Operator.TektonChainses()
+func (c *Clients) TektonChains() operatorv1alpha1.TektonChainInterface {
+	return c.Operator.TektonChains()
 }
 
-func (c *Clients) TektonChainsAll() operatorv1alpha1.TektonChainsInterface {
-	return c.Operator.TektonChainses()
+func (c *Clients) TektonChainsAll() operatorv1alpha1.TektonChainInterface {
+	return c.Operator.TektonChains()
 }
 
 func (c *Clients) TektonInstallerSet() operatorv1alpha1.TektonInstallerSetInterface {
diff --git a/test/utils/e2e_flags.go b/test/utils/e2e_flags.go
index c0ad74037..832ecb351 100644
--- a/test/utils/e2e_flags.go
+++ b/test/utils/e2e_flags.go
@@ -20,5 +20,5 @@ var (
 	TektonPipelineDeploymentLabel  = "app.kubernetes.io/part-of=tekton-pipelines"
 	TektonTriggerDeploymentLabel   = "app.kubernetes.io/part-of=tekton-triggers"
 	TektonDashboardDeploymentLabel = "app.kubernetes.io/part-of=tekton-dashboard"
-	TektonChainsDeploymentLabel    = "app.kubernetes.io/name=tekton-pipelines"
+	TektonChainDeploymentLabel     = "app.kubernetes.io/name=tekton-pipelines"
 )
diff --git a/test/utils/names.go b/test/utils/names.go
index 2728fe785..ebb8fe369 100644
--- a/test/utils/names.go
+++ b/test/utils/names.go
@@ -24,7 +24,7 @@ type ResourceNames struct {
 	TektonAddon     string
 	TektonConfig    string
 	TektonResult    string
-	TektonChains    string
+	TektonChain     string
 	Namespace       string
 	TargetNamespace string
 }