In this talk, we will take a deep dive into reconciliation, which is the fundamental principle behind the working of Kubernetes, and see how we leverage Golang constructs to achieve these patterns. We will explore how to extend these patterns to create what are known as operators in Kubernetes, to enhance its functionalities taking Cluster API as our use-case. The reconciliation pattern is a design pattern that is commonly used in Kubernetes to ensure that the desired state of a system is consistently maintained. It involves continuously monitoring the state of the system and making adjustments as needed to ensure that it remains in compliance with the desired state. Reconciliation is one of the key patterns that emerge from control theory, which is a branch of engineering that deals with the design and analysis of systems that control the behavior of dynamic processes. Reconcilers are the heart of Kubernetes and Cluster API. The use of reconcilers in Kubernetes enables users to define the desired state of their clusters declaratively, and let Kubernetes handle the details of implementing and maintaining that state. The reconciliation pattern in Go is implemented by using the Kubernetes API to track the state of the cluster, and Go's concurrency features to ensure that the reconciler runs continuously and can make adjustments in real time. We will take a look into the implementation of these patterns in their nascent form and then their extension in Cluster API by the use of controllers.