diff --git a/controllers/account_controller.go b/controllers/account_controller.go
index 68d5e5ec..abd7374e 100644
--- a/controllers/account_controller.go
+++ b/controllers/account_controller.go
@@ -56,8 +56,7 @@ func (r *AccountReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ct
 	log := ctrllog.FromContext(ctx)
 
 	instance := &cfv1.Account{}
-	err := r.Get(ctx, req.NamespacedName, instance)
-	if err != nil {
+	if err := r.Get(ctx, req.NamespacedName, instance); err != nil {
 		if errors.IsNotFound(err) {
 			log.Info("Account resource not found. Ignoring since object must be deleted.")
 			return ctrl.Result{}, nil
@@ -68,8 +67,7 @@ func (r *AccountReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ct
 
 	if !controllerutil.ContainsFinalizer(instance, cloudflareOperatorFinalizer) {
 		controllerutil.AddFinalizer(instance, cloudflareOperatorFinalizer)
-		err := r.Update(ctx, instance)
-		if err != nil {
+		if err := r.Update(ctx, instance); err != nil {
 			log.Error(err, "Failed to update Account finalizer")
 			return ctrl.Result{}, err
 		}
@@ -81,8 +79,7 @@ func (r *AccountReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ct
 		}
 
 		controllerutil.RemoveFinalizer(instance, cloudflareOperatorFinalizer)
-		err := r.Update(ctx, instance)
-		if err != nil {
+		if err := r.Update(ctx, instance); err != nil {
 			return ctrl.Result{}, err
 		}
 		return ctrl.Result{}, nil
@@ -91,10 +88,8 @@ func (r *AccountReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ct
 	accountFailureCounter.WithLabelValues(instance.Name).Set(0)
 
 	secret := &corev1.Secret{}
-	err = r.Get(ctx, client.ObjectKey{Namespace: instance.Spec.ApiToken.SecretRef.Namespace, Name: instance.Spec.ApiToken.SecretRef.Name}, secret)
-	if err != nil {
-		err := r.markFailed(instance, ctx, "Failed to get secret")
-		if err != nil {
+	if err := r.Get(ctx, client.ObjectKey{Namespace: instance.Spec.ApiToken.SecretRef.Namespace, Name: instance.Spec.ApiToken.SecretRef.Name}, secret); err != nil {
+		if err := r.markFailed(instance, ctx, "Failed to get secret"); err != nil {
 			log.Error(err, "Failed to update Account status")
 			return ctrl.Result{}, err
 		}
@@ -103,18 +98,16 @@ func (r *AccountReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ct
 
 	cfApiToken := string(secret.Data["apiToken"])
 	if cfApiToken == "" {
-		err := r.markFailed(instance, ctx, "Secret has no 'apiToken' key")
-		if err != nil {
+		if err := r.markFailed(instance, ctx, "Secret has no 'apiToken' key"); err != nil {
 			log.Error(err, "Failed to update Account status")
 			return ctrl.Result{}, err
 		}
-		return ctrl.Result{RequeueAfter: time.Second * 30}, err
+		return ctrl.Result{RequeueAfter: time.Second * 30}, nil
 	}
 
 	cf, err := cloudflare.NewWithAPIToken(cfApiToken)
 	if err != nil {
-		err := r.markFailed(instance, ctx, err.Error())
-		if err != nil {
+		if err := r.markFailed(instance, ctx, err.Error()); err != nil {
 			log.Error(err, "Failed to update Account status")
 			return ctrl.Result{}, err
 		}
@@ -124,8 +117,7 @@ func (r *AccountReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ct
 
 	cfZones, err := r.Cf.ListZones(ctx)
 	if err != nil {
-		err := r.markFailed(instance, ctx, err.Error())
-		if err != nil {
+		if err := r.markFailed(instance, ctx, err.Error()); err != nil {
 			log.Error(err, "Failed to update Account status")
 			return ctrl.Result{}, err
 		}
@@ -148,10 +140,8 @@ func (r *AccountReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ct
 	}
 
 	zones := &cfv1.ZoneList{}
-	err = r.List(ctx, zones)
-	if err != nil {
-		err := r.markFailed(instance, ctx, "Failed to list zones")
-		if err != nil {
+	if err := r.List(ctx, zones); err != nil {
+		if err := r.markFailed(instance, ctx, "Failed to list zones"); err != nil {
 			log.Error(err, "Failed to update Account status")
 			return ctrl.Result{}, err
 		}
@@ -191,8 +181,7 @@ func (r *AccountReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ct
 					Interval: instance.Spec.Interval,
 				},
 			}
-			err = r.Create(ctx, z)
-			if err != nil {
+			if err := r.Create(ctx, z); err != nil {
 				log.Error(err, "Failed to create Zone resource", "Zone.Name", operatorManagedZone.Name, "Zone.ID", operatorManagedZone.ID)
 				continue
 			}
@@ -202,8 +191,7 @@ func (r *AccountReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ct
 
 	if !reflect.DeepEqual(instance.Status.Zones, operatorManagedZones) {
 		instance.Status.Zones = operatorManagedZones
-		err := r.Status().Update(ctx, instance)
-		if err != nil {
+		if err := r.Status().Update(ctx, instance); err != nil {
 			log.Error(err, "Failed to update Account status")
 			return ctrl.Result{}, err
 		}
@@ -211,8 +199,7 @@ func (r *AccountReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ct
 
 	for _, z := range zones.Items {
 		if _, found := operatorManagedZoneMap[z.Spec.ID]; !found {
-			err = r.Delete(ctx, &z)
-			if err != nil {
+			if err := r.Delete(ctx, &z); err != nil {
 				log.Error(err, "Failed to delete Zone resource", "Zone.Name", z.Name)
 				return ctrl.Result{}, err
 			}
@@ -227,8 +214,7 @@ func (r *AccountReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ct
 		Message:            "Account is ready",
 		ObservedGeneration: instance.Generation,
 	})
-	err = r.Status().Update(ctx, instance)
-	if err != nil {
+	if err := r.Status().Update(ctx, instance); err != nil {
 		log.Error(err, "Failed to update Account status")
 		return ctrl.Result{}, err
 	}
diff --git a/controllers/dnsrecord_controller.go b/controllers/dnsrecord_controller.go
index d2c3d3dd..873fb931 100644
--- a/controllers/dnsrecord_controller.go
+++ b/controllers/dnsrecord_controller.go
@@ -56,8 +56,7 @@ func (r *DNSRecordReconciler) Reconcile(ctx context.Context, req ctrl.Request) (
 	log := ctrllog.FromContext(ctx)
 
 	instance := &cfv1.DNSRecord{}
-	err := r.Get(ctx, req.NamespacedName, instance)
-	if err != nil {
+	if err := r.Get(ctx, req.NamespacedName, instance); err != nil {
 		if errors.IsNotFound(err) {
 			log.Info("DNSRecord resource not found. Ignoring since object must be deleted.")
 			return ctrl.Result{}, nil
@@ -74,23 +73,20 @@ func (r *DNSRecordReconciler) Reconcile(ctx context.Context, req ctrl.Request) (
 			Message:            "Cloudflare account is not yet ready",
 			ObservedGeneration: instance.Generation,
 		})
-		err := r.Status().Update(ctx, instance)
-		if err != nil {
+		if err := r.Status().Update(ctx, instance); err != nil {
 			log.Error(err, "Failed to update DNSRecord status")
 			return ctrl.Result{}, err
 		}
-		return ctrl.Result{RequeueAfter: time.Second * 5}, err
+		return ctrl.Result{RequeueAfter: time.Second * 5}, nil
 	}
 
 	zoneName, _ := publicsuffix.EffectiveTLDPlusOne(instance.Spec.Name)
 	zoneName = strings.ReplaceAll(zoneName, ".", "-")
 
 	zone := &cfv1.Zone{}
-	err = r.Get(ctx, client.ObjectKey{Name: zoneName}, zone)
-	if err != nil {
+	if err := r.Get(ctx, client.ObjectKey{Name: zoneName}, zone); err != nil {
 		if errors.IsNotFound(err) {
-			err := r.markFailed(instance, ctx, "Zone not found")
-			if err != nil {
+			if err := r.markFailed(instance, ctx, "Zone not found"); err != nil {
 				log.Error(err, "Failed to update DNSRecord status")
 				return ctrl.Result{}, err
 			}
@@ -108,8 +104,7 @@ func (r *DNSRecordReconciler) Reconcile(ctx context.Context, req ctrl.Request) (
 			Message:            "Zone is not yet ready",
 			ObservedGeneration: instance.Generation,
 		})
-		err := r.Status().Update(ctx, instance)
-		if err != nil {
+		if err := r.Status().Update(ctx, instance); err != nil {
 			log.Error(err, "Failed to update DNSRecord status")
 			return ctrl.Result{}, err
 		}
@@ -118,8 +113,7 @@ func (r *DNSRecordReconciler) Reconcile(ctx context.Context, req ctrl.Request) (
 
 	if !controllerutil.ContainsFinalizer(instance, cloudflareOperatorFinalizer) {
 		controllerutil.AddFinalizer(instance, cloudflareOperatorFinalizer)
-		err := r.Update(ctx, instance)
-		if err != nil {
+		if err := r.Update(ctx, instance); err != nil {
 			log.Error(err, "Failed to update DNSRecord finalizer")
 			return ctrl.Result{}, err
 		}
@@ -132,8 +126,7 @@ func (r *DNSRecordReconciler) Reconcile(ctx context.Context, req ctrl.Request) (
 		}
 
 		controllerutil.RemoveFinalizer(instance, cloudflareOperatorFinalizer)
-		err := r.Update(ctx, instance)
-		if err != nil {
+		if err := r.Update(ctx, instance); err != nil {
 			return ctrl.Result{}, err
 		}
 		return ctrl.Result{}, nil
@@ -144,6 +137,7 @@ func (r *DNSRecordReconciler) Reconcile(ctx context.Context, req ctrl.Request) (
 	var existingRecord cloudflare.DNSRecord
 
 	if instance.Status.RecordID != "" {
+		var err error
 		existingRecord, err = r.Cf.GetDNSRecord(ctx, cloudflare.ZoneIdentifier(zone.Spec.ID), instance.Status.RecordID)
 		if err != nil && err.Error() != "Record does not exist. (81044)" {
 			log.Error(err, "Failed to get DNS record from Cloudflare")
@@ -153,10 +147,8 @@ func (r *DNSRecordReconciler) Reconcile(ctx context.Context, req ctrl.Request) (
 
 	if (instance.Spec.Type == "A" || instance.Spec.Type == "AAAA") && instance.Spec.IPRef.Name != "" {
 		ip := &cfv1.IP{}
-		err := r.Get(ctx, client.ObjectKey{Name: instance.Spec.IPRef.Name}, ip)
-		if err != nil {
-			err := r.markFailed(instance, ctx, "IP object not found")
-			if err != nil {
+		if err := r.Get(ctx, client.ObjectKey{Name: instance.Spec.IPRef.Name}, ip); err != nil {
+			if err := r.markFailed(instance, ctx, "IP object not found"); err != nil {
 				log.Error(err, "Failed to update DNSRecord status")
 				return ctrl.Result{}, err
 			}
@@ -164,8 +156,7 @@ func (r *DNSRecordReconciler) Reconcile(ctx context.Context, req ctrl.Request) (
 		}
 		if ip.Spec.Address != instance.Spec.Content {
 			instance.Spec.Content = ip.Spec.Address
-			err = r.Update(ctx, instance)
-			if err != nil {
+			if err := r.Update(ctx, instance); err != nil {
 				log.Error(err, "Failed to update DNSRecord resource")
 				return ctrl.Result{}, err
 			}
@@ -173,8 +164,7 @@ func (r *DNSRecordReconciler) Reconcile(ctx context.Context, req ctrl.Request) (
 	}
 
 	if *instance.Spec.Proxied && instance.Spec.TTL != 1 {
-		err := r.markFailed(instance, ctx, "TTL must be 1 when proxied")
-		if err != nil {
+		if err := r.markFailed(instance, ctx, "TTL must be 1 when proxied"); err != nil {
 			log.Error(err, "Failed to update DNSRecord status")
 			return ctrl.Result{}, err
 		}
@@ -192,8 +182,7 @@ func (r *DNSRecordReconciler) Reconcile(ctx context.Context, req ctrl.Request) (
 			Data:     instance.Spec.Data,
 		})
 		if err != nil {
-			err := r.markFailed(instance, ctx, err.Error())
-			if err != nil {
+			if err := r.markFailed(instance, ctx, err.Error()); err != nil {
 				log.Error(err, "Failed to update DNSRecord status")
 				return ctrl.Result{}, err
 			}
@@ -207,8 +196,7 @@ func (r *DNSRecordReconciler) Reconcile(ctx context.Context, req ctrl.Request) (
 			ObservedGeneration: instance.Generation,
 		})
 		instance.Status.RecordID = newDNSRecord.ID
-		err = r.Status().Update(ctx, instance)
-		if err != nil {
+		if err := r.Status().Update(ctx, instance); err != nil {
 			log.Error(err, "Failed to update DNSRecord status")
 			return ctrl.Result{}, err
 		}
@@ -216,7 +204,7 @@ func (r *DNSRecordReconciler) Reconcile(ctx context.Context, req ctrl.Request) (
 	}
 
 	if !compareDNSRecord(instance.Spec, existingRecord) {
-		_, err := r.Cf.UpdateDNSRecord(ctx, cloudflare.ZoneIdentifier(zone.Spec.ID), cloudflare.UpdateDNSRecordParams{
+		if _, err := r.Cf.UpdateDNSRecord(ctx, cloudflare.ZoneIdentifier(zone.Spec.ID), cloudflare.UpdateDNSRecordParams{
 			ID:       existingRecord.ID,
 			Name:     instance.Spec.Name,
 			Type:     instance.Spec.Type,
@@ -225,10 +213,8 @@ func (r *DNSRecordReconciler) Reconcile(ctx context.Context, req ctrl.Request) (
 			Proxied:  instance.Spec.Proxied,
 			Priority: instance.Spec.Priority,
 			Data:     instance.Spec.Data,
-		})
-		if err != nil {
-			err := r.markFailed(instance, ctx, err.Error())
-			if err != nil {
+		}); err != nil {
+			if err := r.markFailed(instance, ctx, err.Error()); err != nil {
 				log.Error(err, "Failed to update DNSRecord status")
 				return ctrl.Result{}, err
 			}
@@ -242,8 +228,7 @@ func (r *DNSRecordReconciler) Reconcile(ctx context.Context, req ctrl.Request) (
 			ObservedGeneration: instance.Generation,
 		})
 		instance.Status.RecordID = existingRecord.ID
-		err = r.Status().Update(ctx, instance)
-		if err != nil {
+		if err := r.Status().Update(ctx, instance); err != nil {
 			log.Error(err, "Failed to update DNSRecord status")
 			return ctrl.Result{}, err
 		}
@@ -259,8 +244,7 @@ func (r *DNSRecordReconciler) Reconcile(ctx context.Context, req ctrl.Request) (
 		ObservedGeneration: instance.Generation,
 	})
 	instance.Status.RecordID = existingRecord.ID
-	err = r.Status().Update(ctx, instance)
-	if err != nil {
+	if err := r.Status().Update(ctx, instance); err != nil {
 		log.Error(err, "Failed to update DNSRecord status")
 		return ctrl.Result{}, err
 	}
@@ -277,8 +261,7 @@ func (r *DNSRecordReconciler) SetupWithManager(mgr ctrl.Manager) error {
 
 // finalizeDNSRecord deletes the DNS record from cloudflare
 func (r *DNSRecordReconciler) finalizeDNSRecord(ctx context.Context, dnsRecordZoneId string, log logr.Logger, d *cfv1.DNSRecord) {
-	err := r.Cf.DeleteDNSRecord(ctx, cloudflare.ZoneIdentifier(dnsRecordZoneId), d.Status.RecordID)
-	if err != nil {
+	if err := r.Cf.DeleteDNSRecord(ctx, cloudflare.ZoneIdentifier(dnsRecordZoneId), d.Status.RecordID); err != nil {
 		log.Error(err, "Failed to delete DNS record in Cloudflare. Record may still exist in Cloudflare")
 	}
 }
@@ -319,8 +302,7 @@ func compareData(a interface{}, b *apiextensionsv1.JSON) bool {
 		return false
 	}
 	var bb interface{}
-	err := json.Unmarshal(b.Raw, &bb)
-	if err != nil {
+	if err := json.Unmarshal(b.Raw, &bb); err != nil {
 		return false
 	}
 	return reflect.DeepEqual(a, bb)
diff --git a/controllers/ingress_controller.go b/controllers/ingress_controller.go
index d914dc1c..24d042c4 100644
--- a/controllers/ingress_controller.go
+++ b/controllers/ingress_controller.go
@@ -47,8 +47,7 @@ func (r *IngressReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ct
 	log := ctrllog.FromContext(ctx)
 
 	instance := &networkingv1.Ingress{}
-	err := r.Get(ctx, req.NamespacedName, instance)
-	if err != nil {
+	if err := r.Get(ctx, req.NamespacedName, instance); err != nil {
 		if errors.IsNotFound(err) {
 			log.Info("Ingress resource not found. Ignoring since object must be deleted.")
 			return ctrl.Result{}, nil
@@ -58,12 +57,7 @@ func (r *IngressReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ct
 	}
 
 	dnsRecords := &cfv1.DNSRecordList{}
-	err = r.List(
-		ctx,
-		dnsRecords,
-		client.InNamespace(instance.Namespace),
-		client.MatchingFields{"metadata.ownerReferences.uid": string(instance.UID)})
-	if err != nil {
+	if err := r.List(ctx, dnsRecords, client.InNamespace(instance.Namespace), client.MatchingFields{"metadata.ownerReferences.uid": string(instance.UID)}); err != nil {
 		log.Error(err, "Failed to fetch DNSRecord")
 		return ctrl.Result{RequeueAfter: time.Second * 30}, err
 	}
@@ -71,14 +65,13 @@ func (r *IngressReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ct
 	if instance.Annotations["cloudflare-operator.io/ignore"] == "true" {
 		if len(dnsRecords.Items) > 0 {
 			for _, dnsRecord := range dnsRecords.Items {
-				err := r.Delete(ctx, &dnsRecord)
-				if err != nil {
+				if err := r.Delete(ctx, &dnsRecord); err != nil {
 					log.Error(err, "Failed to delete DNSRecord")
 					return ctrl.Result{RequeueAfter: time.Second * 30}, err
 				}
 				log.Info("Deleted DNSRecord, because it was owned by an Ingress that is being ignored", "DNSRecord", dnsRecord.Name)
 			}
-			return ctrl.Result{}, err
+			return ctrl.Result{}, nil
 		}
 		log.Info("Ingress has ignore annotation, skipping reconciliation", "ingress", instance.Name)
 		return ctrl.Result{}, nil
@@ -107,7 +100,7 @@ func (r *IngressReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ct
 			dnsRecordSpec.Proxied = newFalse()
 		default:
 			dnsRecordSpec.Proxied = newTrue()
-			log.Error(err, "Failed to parse proxied annotation, defaulting to true", "proxied", proxied, "ingress", instance.Name)
+			log.Error(nil, "Failed to parse proxied annotation, defaulting to true", "proxied", proxied, "ingress", instance.Name)
 		}
 	}
 	if dnsRecordSpec.Proxied == nil {
@@ -185,8 +178,7 @@ func (r *IngressReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ct
 		}
 
 		log.Info("Creating DNSRecord", "name", dnsRecord.Name)
-		err = r.Create(ctx, dnsRecord)
-		if err != nil {
+		if err := r.Create(ctx, dnsRecord); err != nil {
 			log.Error(err, "Failed to create DNSRecord")
 			return ctrl.Result{}, err
 		}
@@ -205,8 +197,7 @@ func (r *IngressReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ct
 
 		log.Info("Updating DNSRecord", "name", dnsRecord.Name)
 		dnsRecord.Spec = dnsRecordSpec
-		err := r.Update(ctx, &dnsRecord)
-		if err != nil {
+		if err := r.Update(ctx, &dnsRecord); err != nil {
 			log.Error(err, "Failed to update DNSRecord")
 			return ctrl.Result{}, err
 		}
@@ -217,8 +208,7 @@ func (r *IngressReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ct
 			continue
 		}
 		log.Info("Deleting DNSRecord", "name", dnsRecord.Name)
-		err := r.Delete(ctx, &dnsRecord)
-		if err != nil {
+		if err := r.Delete(ctx, &dnsRecord); err != nil {
 			log.Error(err, "Failed to delete DNSRecord")
 		}
 	}
diff --git a/controllers/ip_controller.go b/controllers/ip_controller.go
index d645c97c..2d35f4ed 100644
--- a/controllers/ip_controller.go
+++ b/controllers/ip_controller.go
@@ -62,8 +62,7 @@ func (r *IPReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Re
 	log := ctrllog.FromContext(ctx)
 
 	instance := &cfv1.IP{}
-	err := r.Get(ctx, req.NamespacedName, instance)
-	if err != nil {
+	if err := r.Get(ctx, req.NamespacedName, instance); err != nil {
 		if errors.IsNotFound(err) {
 			log.Info("IP resource not found. Ignoring since object must be deleted.")
 			return ctrl.Result{}, nil
@@ -74,8 +73,7 @@ func (r *IPReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Re
 
 	if !controllerutil.ContainsFinalizer(instance, cloudflareOperatorFinalizer) {
 		controllerutil.AddFinalizer(instance, cloudflareOperatorFinalizer)
-		err := r.Update(ctx, instance)
-		if err != nil {
+		if err := r.Update(ctx, instance); err != nil {
 			log.Error(err, "Failed to update IP finalizer")
 			return ctrl.Result{}, err
 		}
@@ -87,8 +85,7 @@ func (r *IPReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Re
 		}
 
 		controllerutil.RemoveFinalizer(instance, cloudflareOperatorFinalizer)
-		err := r.Update(ctx, instance)
-		if err != nil {
+		if err := r.Update(ctx, instance); err != nil {
 			return ctrl.Result{}, err
 		}
 		return ctrl.Result{}, nil
@@ -98,16 +95,14 @@ func (r *IPReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Re
 
 	if instance.Spec.Type == "static" {
 		if instance.Spec.Address == "" {
-			err := r.markFailed(instance, ctx, "Address is required for static IPs")
-			if err != nil {
+			if err := r.markFailed(instance, ctx, "Address is required for static IPs"); err != nil {
 				log.Error(err, "Failed to update IP resource")
 				return ctrl.Result{}, err
 			}
 			return ctrl.Result{}, nil
 		}
 		if net.ParseIP(instance.Spec.Address) == nil {
-			err := r.markFailed(instance, ctx, "Address is not a valid IP address")
-			if err != nil {
+			if err := r.markFailed(instance, ctx, "Address is not a valid IP address"); err != nil {
 				log.Error(err, "Failed to update IP resource")
 				return ctrl.Result{}, err
 			}
@@ -118,20 +113,18 @@ func (r *IPReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Re
 	if instance.Spec.Type == "dynamic" {
 		if instance.Spec.Interval == nil {
 			instance.Spec.Interval = &metav1.Duration{Duration: time.Minute * 5}
-			err := r.Update(ctx, instance)
-			if err != nil {
+			if err := r.Update(ctx, instance); err != nil {
 				log.Error(err, "Failed to update IP resource")
 				return ctrl.Result{}, err
 			}
 		}
 
 		if len(instance.Spec.IPSources) == 0 {
-			err := r.markFailed(instance, ctx, "IPSources is required for dynamic IPs")
-			if err != nil {
+			if err := r.markFailed(instance, ctx, "IPSources is required for dynamic IPs"); err != nil {
 				log.Error(err, "Failed to update IP resource")
 				return ctrl.Result{}, err
 			}
-			return ctrl.Result{}, err
+			return ctrl.Result{}, nil
 		}
 
 		if len(instance.Spec.IPSources) > 1 {
@@ -153,32 +146,28 @@ func (r *IPReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Re
 		}
 
 		if ipSourceError != "" {
-			err := r.markFailed(instance, ctx, ipSourceError)
-			if err != nil {
+			if err := r.markFailed(instance, ctx, ipSourceError); err != nil {
 				log.Error(err, "Failed to update IP resource")
 				return ctrl.Result{}, err
 			}
-			return ctrl.Result{RequeueAfter: time.Second * 30}, err
+			return ctrl.Result{RequeueAfter: time.Second * 30}, nil
 		}
 	}
 
 	if instance.Spec.Address != instance.Status.LastObservedIP {
-		err := r.Update(ctx, instance)
-		if err != nil {
+		if err := r.Update(ctx, instance); err != nil {
 			log.Error(err, "Failed to update IP resource")
 			return ctrl.Result{}, err
 		}
 		instance.Status.LastObservedIP = instance.Spec.Address
-		err = r.Status().Update(ctx, instance)
-		if err != nil {
+		if err := r.Status().Update(ctx, instance); err != nil {
 			log.Error(err, "Failed to update IP resource")
 			return ctrl.Result{}, err
 		}
 	}
 
 	dnsRecords := &cfv1.DNSRecordList{}
-	err = r.List(ctx, dnsRecords)
-	if err != nil {
+	if err := r.List(ctx, dnsRecords); err != nil {
 		log.Error(err, "Failed to list DNSRecords")
 		return ctrl.Result{RequeueAfter: time.Second * 30}, err
 	}
@@ -191,8 +180,7 @@ func (r *IPReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Re
 			continue
 		}
 		dnsRecord.Spec.Content = instance.Spec.Address
-		err := r.Update(ctx, &dnsRecord)
-		if err != nil {
+		if err := r.Update(ctx, &dnsRecord); err != nil {
 			log.Error(err, "Failed to update DNSRecord")
 		}
 	}
@@ -204,8 +192,7 @@ func (r *IPReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Re
 		Message:            "IP is ready",
 		ObservedGeneration: instance.Generation,
 	})
-	err = r.Status().Update(ctx, instance)
-	if err != nil {
+	if err := r.Status().Update(ctx, instance); err != nil {
 		log.Error(err, "Failed to update IP resource")
 		return ctrl.Result{}, err
 	}
@@ -225,8 +212,7 @@ func (r *IPReconciler) SetupWithManager(mgr ctrl.Manager) error {
 
 // getIPSource returns the IP gathered from the IPSource
 func (r *IPReconciler) getIPSource(ctx context.Context, source cfv1.IPSpecIPSources, log logr.Logger) (string, error) {
-	_, err := url.Parse(source.URL)
-	if err != nil {
+	if _, err := url.Parse(source.URL); err != nil {
 		return "", fmt.Errorf("failed to parse URL %s: %s", source.URL, err)
 	}
 
@@ -241,8 +227,7 @@ func (r *IPReconciler) getIPSource(ctx context.Context, source cfv1.IPSpecIPSour
 
 	if source.RequestHeaders != nil {
 		var requestHeaders map[string]string
-		err = json.Unmarshal(source.RequestHeaders.Raw, &requestHeaders)
-		if err != nil {
+		if err := json.Unmarshal(source.RequestHeaders.Raw, &requestHeaders); err != nil {
 			return "", fmt.Errorf("failed to unmarshal request headers: %s", err)
 		}
 
@@ -253,11 +238,10 @@ func (r *IPReconciler) getIPSource(ctx context.Context, source cfv1.IPSpecIPSour
 
 	if source.RequestHeadersSecretRef.Name != "" {
 		secret := &corev1.Secret{}
-		err := r.Get(ctx, client.ObjectKey{
+		if err := r.Get(ctx, client.ObjectKey{
 			Name:      source.RequestHeadersSecretRef.Name,
 			Namespace: source.RequestHeadersSecretRef.Namespace,
-		}, secret)
-		if err != nil {
+		}, secret); err != nil {
 			return "", fmt.Errorf("failed to get secret %s: %s", source.RequestHeadersSecretRef.Name, err)
 		}
 		for key, value := range secret.Data {
@@ -273,8 +257,7 @@ func (r *IPReconciler) getIPSource(ctx context.Context, source cfv1.IPSpecIPSour
 		return "", fmt.Errorf("failed to get IP from %s: %s", source.URL, err)
 	}
 	defer func(Body io.ReadCloser) {
-		err := Body.Close()
-		if err != nil {
+		if err := Body.Close(); err != nil {
 			log.Error(err, "Failed to close response body")
 		}
 	}(resp.Body)
@@ -290,8 +273,7 @@ func (r *IPReconciler) getIPSource(ctx context.Context, source cfv1.IPSpecIPSour
 	extractedIP := string(response)
 	if source.ResponseJQFilter != "" {
 		var jsonResponse interface{}
-		err := json.Unmarshal(response, &jsonResponse)
-		if err != nil {
+		if err := json.Unmarshal(response, &jsonResponse); err != nil {
 			return "", fmt.Errorf("failed to get IP from %s: %s", source.URL, err)
 		}
 		jq, err := gojq.Parse(source.ResponseJQFilter)
diff --git a/controllers/zone_controller.go b/controllers/zone_controller.go
index 6afd334e..914b805d 100644
--- a/controllers/zone_controller.go
+++ b/controllers/zone_controller.go
@@ -52,8 +52,7 @@ func (r *ZoneReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.
 	log := ctrllog.FromContext(ctx)
 
 	instance := &cfv1.Zone{}
-	err := r.Get(ctx, req.NamespacedName, instance)
-	if err != nil {
+	if err := r.Get(ctx, req.NamespacedName, instance); err != nil {
 		if errors.IsNotFound(err) {
 			log.Info("Zone resource not found. Ignoring since object must be deleted.")
 			return ctrl.Result{}, nil
@@ -64,8 +63,7 @@ func (r *ZoneReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.
 
 	if !controllerutil.ContainsFinalizer(instance, cloudflareOperatorFinalizer) {
 		controllerutil.AddFinalizer(instance, cloudflareOperatorFinalizer)
-		err := r.Update(ctx, instance)
-		if err != nil {
+		if err := r.Update(ctx, instance); err != nil {
 			log.Error(err, "Failed to update Zone finalizer")
 			return ctrl.Result{}, err
 		}
@@ -77,8 +75,7 @@ func (r *ZoneReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.
 		}
 
 		controllerutil.RemoveFinalizer(instance, cloudflareOperatorFinalizer)
-		err := r.Update(ctx, instance)
-		if err != nil {
+		if err := r.Update(ctx, instance); err != nil {
 			return ctrl.Result{}, err
 		}
 		return ctrl.Result{}, nil
@@ -94,18 +91,15 @@ func (r *ZoneReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.
 			Message:            "Cloudflare account is not yet ready",
 			ObservedGeneration: instance.Generation,
 		})
-		err := r.Status().Update(ctx, instance)
-		if err != nil {
+		if err := r.Status().Update(ctx, instance); err != nil {
 			log.Error(err, "Failed to update Zone status")
 			return ctrl.Result{}, err
 		}
-		return ctrl.Result{RequeueAfter: time.Second * 5}, err
+		return ctrl.Result{RequeueAfter: time.Second * 5}, nil
 	}
 
-	_, err = r.Cf.ZoneDetails(ctx, instance.Spec.ID)
-	if err != nil {
-		err := r.markFailed(instance, ctx, err.Error())
-		if err != nil {
+	if _, err := r.Cf.ZoneDetails(ctx, instance.Spec.ID); err != nil {
+		if err := r.markFailed(instance, ctx, err.Error()); err != nil {
 			log.Error(err, "Failed to update Zone status")
 			return ctrl.Result{}, err
 		}
@@ -113,16 +107,14 @@ func (r *ZoneReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.
 	}
 
 	dnsRecords := &cfv1.DNSRecordList{}
-	err = r.List(ctx, dnsRecords)
-	if err != nil {
+	if err := r.List(ctx, dnsRecords); err != nil {
 		log.Error(err, "Failed to list DNSRecord resources")
 		return ctrl.Result{RequeueAfter: time.Second * 30}, err
 	}
 
 	cfDnsRecords, _, err := r.Cf.ListDNSRecords(ctx, cloudflare.ZoneIdentifier(instance.Spec.ID), cloudflare.ListDNSRecordsParams{})
 	if err != nil {
-		err := r.markFailed(instance, ctx, err.Error())
-		if err != nil {
+		if err := r.markFailed(instance, ctx, err.Error()); err != nil {
 			log.Error(err, "Failed to update Zone status")
 			return ctrl.Result{}, err
 		}
@@ -140,10 +132,8 @@ func (r *ZoneReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.
 		}
 
 		if _, found := dnsRecordMap[cfDnsRecord.ID]; !found {
-			err = r.Cf.DeleteDNSRecord(ctx, cloudflare.ZoneIdentifier(instance.Spec.ID), cfDnsRecord.ID)
-			if err != nil {
-				err := r.markFailed(instance, ctx, err.Error())
-				if err != nil {
+			if err := r.Cf.DeleteDNSRecord(ctx, cloudflare.ZoneIdentifier(instance.Spec.ID), cfDnsRecord.ID); err != nil {
+				if err := r.markFailed(instance, ctx, err.Error()); err != nil {
 					log.Error(err, "Failed to update Zone status")
 				}
 			}
@@ -158,8 +148,7 @@ func (r *ZoneReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.
 		Message:            "Zone is ready",
 		ObservedGeneration: instance.Generation,
 	})
-	err = r.Status().Update(ctx, instance)
-	if err != nil {
+	if err := r.Status().Update(ctx, instance); err != nil {
 		log.Error(err, "Failed to update Zone status")
 		return ctrl.Result{}, err
 	}