diff --git a/chart/k8gb/templates/_helpers.tpl b/chart/k8gb/templates/_helpers.tpl
index 47a783e96d..9d671e4ce4 100644
--- a/chart/k8gb/templates/_helpers.tpl
+++ b/chart/k8gb/templates/_helpers.tpl
@@ -93,13 +93,9 @@ k8gb-{{ index (split ":" (index (split ";" (include "k8gb.dnsZonesString" .)) "_
 {{- $entries := list -}}
 {{- range .Values.k8gb.dnsZones }}
   {{- $dnsZoneNegTTL := toString (.dnsZoneNegTTL | default "300") }}
-  {{- $entry := printf "%s:%s:%s" .zone .domain $dnsZoneNegTTL }}
+  {{- $entry := printf "%s:%s:%s" .parentZone .loadBalancedZone $dnsZoneNegTTL }}
   {{- $entries = append $entries $entry }}
 {{- end }}
-{{- if and (or (not .Values.k8gb.dnsZones) (eq (len .Values.k8gb.dnsZones) 0)) .Values.k8gb.dnsZone .Values.k8gb.edgeDNSZone }}
-  {{- $extraEntry := printf "%s:%s:%s" .Values.k8gb.edgeDNSZone .Values.k8gb.dnsZone "300" }}
-  {{- $entries = append $entries $extraEntry }}
-{{- end }}
 {{- join ";" $entries }}
 {{- end }}
 
diff --git a/chart/k8gb/templates/_validators.tpl b/chart/k8gb/templates/_validators.tpl
index 227b5885ba..d9def0487e 100644
--- a/chart/k8gb/templates/_validators.tpl
+++ b/chart/k8gb/templates/_validators.tpl
@@ -12,31 +12,28 @@
 {{- end -}}
 {{- end -}}
 
-# Validates that the zones in k8gb.edgeDNSZone/k8gb.dnsZones match the zones in extdns.domainFilters
+# Validates that the zones in k8gb.dnsZones match the zones in extdns.domainFilters
 {{- define "validateDnsZones" -}}
-{{- $k8gbZones := list -}}
+{{- $parentZones := list -}}
 {{- range .Values.k8gb.dnsZones -}}
-  {{- $k8gbZones = append $k8gbZones .zone -}}
+  {{- $parentZones = append $parentZones .parentZone -}}
 {{- end -}}
-{{- if and (or (not .Values.k8gb.dnsZones) (eq (len .Values.k8gb.dnsZones) 0)) .Values.k8gb.dnsZone .Values.k8gb.edgeDNSZone }}
-  {{- $k8gbZones = append $k8gbZones .Values.k8gb.edgeDNSZone -}}
-{{- end }}
 
 {{- $extdnsZones := .Values.extdns.domainFilters -}}
 
-{{- if ne (len $k8gbZones) (len $extdnsZones) -}}
-  {{- fail (printf "Validation failed: Number of zones in k8gb.edgeDNSZone/k8gb.dnsZones (%d) does not match number of domains in extdns.domainFilters (%d)" (len $k8gbZones) (len $extdnsZones)) -}}
+{{- if ne (len $parentZones) (len $extdnsZones) -}}
+  {{- fail (printf "Validation failed: Number of zones in k8gb.dnsZones (%d) does not match number of domains in extdns.domainFilters (%d)" (len $parentZones) (len $extdnsZones)) -}}
 {{- end -}}
 
-{{- range $k8gbZone := $k8gbZones -}}
-  {{- if not (has $k8gbZone $extdnsZones) -}}
-    {{- fail (printf "Validation failed: Zone '%s' from k8gb.edgeDNSZone/k8gb.dnsZones is not present in extdns.domainFilters" $k8gbZone) -}}
+{{- range $parentZone := $parentZones -}}
+  {{- if not (has $parentZone $extdnsZones) -}}
+    {{- fail (printf "Validation failed: Zone '%s' from k8gb.dnsZones is not present in extdns.domainFilters" $parentZone) -}}
   {{- end -}}
 {{- end -}}
 
 {{- range $extdnsZone := $extdnsZones -}}
-  {{- if not (has $extdnsZone $k8gbZones) -}}
-    {{- fail (printf "Validation failed: Domain '%s' from extdns.domainFilters is not present in k8gb.edgeDNSZone/k8gb.dnsZones" $extdnsZone) -}}
+  {{- if not (has $extdnsZone $parentZones) -}}
+    {{- fail (printf "Validation failed: Domain '%s' from extdns.domainFilters is not present in k8gb.dnsZones" $extdnsZone) -}}
   {{- end -}}
 {{- end -}}
 
diff --git a/chart/k8gb/templates/coredns/cm.yaml b/chart/k8gb/templates/coredns/cm.yaml
index 001656149c..c8e19c2a8b 100644
--- a/chart/k8gb/templates/coredns/cm.yaml
+++ b/chart/k8gb/templates/coredns/cm.yaml
@@ -12,9 +12,9 @@ data:
 {{- $dnsZones := split ";" $dnsZonesRaw }}
 {{- range $dnsZones }}
     {{- $parts := split ":" . }}
-    {{- $domain := index $parts "_1" }}
+    {{- $loadBalancedZone := index $parts "_1" }}
     {{- $dnsZoneNegTTL := index $parts "_2" }}
-    {{ $domain }}:5353 {
+    {{ $loadBalancedZone }}:5353 {
         errors
         health
 {{- if $.Values.k8gb.coredns.extra_plugins }}
diff --git a/chart/k8gb/templates/external-dns/external-dns.yaml b/chart/k8gb/templates/external-dns/external-dns.yaml
index d1d4c00684..64f29dbf6a 100644
--- a/chart/k8gb/templates/external-dns/external-dns.yaml
+++ b/chart/k8gb/templates/external-dns/external-dns.yaml
@@ -26,8 +26,8 @@ spec:
 {{- $dnsZones := split ";" $dnsZonesRaw }}
 {{- range $dnsZones }}
         {{- $parts := split ":" . }}
-        {{- $zone := index $parts "_0" }}
-        - --domain-filter={{ $zone }} # will make ExternalDNS see only the hosted zones matching provided domain, omit to process all available hosted zones
+        {{- $parentZone := index $parts "_0" }}
+        - --domain-filter={{ $parentZone }} # will make ExternalDNS see only the hosted zones matching provided domain, omit to process all available hosted zones
 {{- end }}
         - --policy=sync # enable full synchronization including record removal
         - --log-level=debug # debug only
diff --git a/chart/k8gb/values-extdns.yaml b/chart/k8gb/values-extdns.yaml
index ca0bdacaf0..eb27f7a485 100644
--- a/chart/k8gb/values-extdns.yaml
+++ b/chart/k8gb/values-extdns.yaml
@@ -2,8 +2,8 @@ k8gb:
   clusterGeoTag: "us"
   extGslbClustersGeoTags: "eu"
   dnsZones:
-    - zone: "k8gb.io"
-      domain: "cloud.k8gb.io"
+    - parentZone: "k8gb.io"
+      loadBalancedZone: "cloud.k8gb.io"
       dnsZoneNegTTL: 30
 
 extdns:
diff --git a/chart/k8gb/values.schema.json b/chart/k8gb/values.schema.json
index 97d45f7a36..5292fbf4c5 100644
--- a/chart/k8gb/values.schema.json
+++ b/chart/k8gb/values.schema.json
@@ -277,18 +277,6 @@
                         "$ref": "#/definitions/k8gbDnsZone"
                     }
                 },
-                "dnsZone": {
-                    "format": "idn-hostname",
-                    "minLength": 1
-                },
-                "dnsZoneNegTTL": {
-                    "type": "integer",
-                    "minimum": 0
-                },
-                "edgeDNSZone": {
-                    "format": "idn-hostname",
-                    "minLength": 1
-                },
                 "edgeDNSServers": {
                     "type": "array",
                     "items": {
@@ -345,24 +333,11 @@
                     "type": "object"
                 }
             },
-            "oneOf": [
-                {
-                    "required": [
-                        "clusterGeoTag",
-                        "extGslbClustersGeoTags",
-                        "edgeDNSServers",
-                        "dnsZone",
-                        "edgeDNSZone"
-                    ]
-                },
-                {
-                    "required": [
-                        "clusterGeoTag",
-                        "extGslbClustersGeoTags",
-                        "edgeDNSServers",
-                        "dnsZones"
-                    ]
-                }
+            "required": [
+                "clusterGeoTag",
+                "extGslbClustersGeoTags",
+                "edgeDNSServers",
+                "dnsZones"
             ],
             "title": "k8gb"
         },
@@ -447,11 +422,11 @@
         "k8gbDnsZone": {
             "type": "object",
             "properties": {
-                "zone": {
+                "loadBalancedZone": {
                     "type": "string",
                     "format": "idn-hostname"
                 },
-                "domain": {
+                "parentZone": {
                     "type": "string",
                     "format": "idn-hostname"
                 },
@@ -462,8 +437,8 @@
                 }
             },
             "required": [
-                "zone",
-                "domain"
+                "loadBalancedZone",
+                "parentZone"
             ]
         },
         "Ns1": {
diff --git a/chart/k8gb/values.yaml b/chart/k8gb/values.yaml
index 32e7b73e60..a8cf85bff7 100644
--- a/chart/k8gb/values.yaml
+++ b/chart/k8gb/values.yaml
@@ -16,18 +16,11 @@ k8gb:
   # DNSZones - For backward compatibility, the dnsZone and edgeDNSZone fields are allowed; otherwise,
   # the dnsZones array is used. For valid values, use either dnsZone and edgeDNSZone or dnsZones.
   #
-  # -- dnsZone: deprecated
-  # dnsZone: "cloud.example.com"
-  # -- edgeDNSZone: deprecated
-  # edgeDNSZone: "example.com"
-  # -- array of dns zones controlled by gslb§
+  # -- array of dns zones controlled by gslb
   dnsZones:
-    - zone: "example.com" # -- main zone which would contain gslb zone to delegate (same meaning as to edgeDNSZone)
-      domain: "cloud.example.com" # -- domain controlled by gslb (same meaning as to dnsZone)
+    - parentZone: "example.com" # -- parent zone which would contain gslb zone to delegate (same meaning as the old edgeDNSZone)
+      loadBalancedZone: "cloud.example.com" # -- zone controlled by gslb (same meaning as the old dnsZone)
       dnsZoneNegTTL: 30  # -- Negative TTL for SOA record# -- host/ip[:port] format is supported here where port defaults to 53
-#    - zone: "example.org" # -- main zone which would contain gslb zone to delegate (same meaning as to edgeDNSZone)
-#      domain: "cloud.example.org" # -- domain controlled by gslb (same meaning as to dnsZone)
-#      dnsZoneNegTTL: 50  # -- Negative TTL for SOA record# -- host/ip[:port] format is supported here where port defaults to 53
   edgeDNSServers:
     # -- use this DNS server as a main resolver to enable cross k8gb DNS based communication
     - "1.1.1.1"
diff --git a/controllers/depresolver/depresolver.go b/controllers/depresolver/depresolver.go
index d0e4a830fe..a528bbe7f7 100644
--- a/controllers/depresolver/depresolver.go
+++ b/controllers/depresolver/depresolver.go
@@ -128,11 +128,11 @@ type Config struct {
 	extClustersGeoTags []string `env:"EXT_GSLB_CLUSTERS_GEO_TAGS, default=[]"`
 	// EdgeDNSType is READONLY and is set automatically by configuration
 	EdgeDNSType EdgeDNSType
-	// EdgeDNSServers
-	EdgeDNSServers utils.DNSList
-	// to avoid breaking changes is used as fallback server for EdgeDNSServers
+	// ParentZoneDNSServers
+	ParentZoneDNSServers utils.DNSList
+	// to avoid breaking changes is used as fallback server for ParentZoneDNSServers
 	fallbackEdgeDNSServerName string `env:"EDGE_DNS_SERVER"`
-	// to avoid breaking changes is used as fallback server port for EdgeDNSServers
+	// to avoid breaking changes is used as fallback server port for ParentZoneDNSServers
 	fallbackEdgeDNSServerPort int `env:"EDGE_DNS_SERVER_PORT, default=53"`
 	// DelegationZones
 	DelegationZones DelegationZones
diff --git a/controllers/depresolver/depresolver_config.go b/controllers/depresolver/depresolver_config.go
index aa2be9a447..3a8f9babf8 100644
--- a/controllers/depresolver/depresolver_config.go
+++ b/controllers/depresolver/depresolver_config.go
@@ -43,7 +43,7 @@ const (
 	CoreDNSServiceTypeKey      = "COREDNS_SERVICE_TYPE"
 	ExtClustersGeoTagsKey      = "EXT_GSLB_CLUSTERS_GEO_TAGS"
 	ExtDNSEnabledKey           = "EXTDNS_ENABLED"
-	EdgeDNSServersKey          = "EDGE_DNS_SERVERS"
+	ParentZoneDNSServersKey    = "EDGE_DNS_SERVERS"
 	DNSZonesKey                = "DNS_ZONES"
 	InfobloxGridHostKey        = "INFOBLOX_GRID_HOST"
 	InfobloxVersionKey         = "INFOBLOX_WAPI_VERSION"
@@ -95,8 +95,8 @@ func (dr *DependencyResolver) ResolveOperatorConfig() (*Config, error) {
 
 		// calculation
 		fallbackDNS := fmt.Sprintf("%s:%v", dr.config.fallbackEdgeDNSServerName, dr.config.fallbackEdgeDNSServerPort)
-		edgeDNSServerList := env.GetEnvAsArrayOfStringsOrFallback(EdgeDNSServersKey, []string{fallbackDNS})
-		dr.config.EdgeDNSServers = parseEdgeDNSServers(edgeDNSServerList)
+		edgeDNSServerList := env.GetEnvAsArrayOfStringsOrFallback(ParentZoneDNSServersKey, []string{fallbackDNS})
+		dr.config.ParentZoneDNSServers = parseParentZoneDNSServers(edgeDNSServerList)
 		dr.config.extClustersGeoTags = excludeGeoTag(dr.config.extClustersGeoTags, dr.config.ClusterGeoTag)
 		dr.config.Log.Level, _ = zerolog.ParseLevel(strings.ToLower(dr.config.Log.level))
 		dr.config.Log.Format = parseLogOutputFormat(strings.ToLower(dr.config.Log.format))
@@ -151,11 +151,11 @@ func (dr *DependencyResolver) validateConfig(config *Config, recognizedDNSTypes
 			return err
 		}
 	}
-	err = field(EdgeDNSServersKey, os.Getenv(EdgeDNSServersKey)).isNotEmpty().matchRegexp(hostNamesWithPortsRegex1).err
+	err = field(ParentZoneDNSServersKey, os.Getenv(ParentZoneDNSServersKey)).isNotEmpty().matchRegexp(hostNamesWithPortsRegex1).err
 	if err != nil {
 		return err
 	}
-	err = field(EdgeDNSServersKey, os.Getenv(EdgeDNSServersKey)).isNotEmpty().matchRegexp(hostNamesWithPortsRegex2).err
+	err = field(ParentZoneDNSServersKey, os.Getenv(ParentZoneDNSServersKey)).isNotEmpty().matchRegexp(hostNamesWithPortsRegex2).err
 	if err != nil {
 		return err
 	}
@@ -163,11 +163,11 @@ func (dr *DependencyResolver) validateConfig(config *Config, recognizedDNSTypes
 	if err != nil {
 		return err
 	}
-	err = field(EdgeDNSServersKey, config.EdgeDNSServers).isNotEmpty().matchRegexp(hostNamesWithPortsRegex1).err
+	err = field(ParentZoneDNSServersKey, config.ParentZoneDNSServers).isNotEmpty().matchRegexp(hostNamesWithPortsRegex1).err
 	if err != nil {
 		return err
 	}
-	for _, s := range config.EdgeDNSServers {
+	for _, s := range config.ParentZoneDNSServers {
 		if s.Port < 1 || s.Port > 65535 {
 			return fmt.Errorf("error for port of edge dns server(%v): it must be a positive integer between 1 and 65535", s)
 		}
@@ -205,8 +205,8 @@ func validateLocalhostNotAmongDNSServers(config *Config) error {
 		}
 		return false
 	}
-	if len(config.EdgeDNSServers) > 1 && containsLocalhost(config.EdgeDNSServers) {
-		return fmt.Errorf("invalid %s: the list can't contain 'localhost' or '127.0.0.1' on other than the first position", EdgeDNSServersKey)
+	if len(config.ParentZoneDNSServers) > 1 && containsLocalhost(config.ParentZoneDNSServers) {
+		return fmt.Errorf("invalid %s: the list can't contain 'localhost' or '127.0.0.1' on other than the first position", ParentZoneDNSServersKey)
 	}
 	return nil
 }
@@ -252,11 +252,11 @@ func (dr *DependencyResolver) GetDeprecations() (deprecations []string) {
 
 	var deprecated = map[oldVar]newVar{
 		EdgeDNSServerKey: newVar{
-			Name: EdgeDNSServersKey,
+			Name: ParentZoneDNSServersKey,
 			Msg:  "Pass the hostname or IP address as comma-separated list",
 		},
 		EdgeDNSServerPortKey: newVar{
-			Name: EdgeDNSServersKey,
+			Name: ParentZoneDNSServersKey,
 			Msg: "Port is an optional item in the comma-separated list of dns edge servers, in following form: dns1:53,dns2 (if not provided after the " +
 				"hostname and colon, it defaults to '53')",
 		},
@@ -281,7 +281,7 @@ func parseMetricsAddr(metricsAddr string) (host string, port int, err error) {
 	return
 }
 
-func parseEdgeDNSServers(serverList []string) (r []utils.DNSServer) {
+func parseParentZoneDNSServers(serverList []string) (r []utils.DNSServer) {
 	r = []utils.DNSServer{}
 	var host, portStr string
 	var err error
diff --git a/controllers/depresolver/depresolver_domaininfo.go b/controllers/depresolver/depresolver_domaininfo.go
index 53cd2da3f5..25798038aa 100644
--- a/controllers/depresolver/depresolver_domaininfo.go
+++ b/controllers/depresolver/depresolver_domaininfo.go
@@ -29,8 +29,8 @@ import (
 type DelegationZones []*DelegationZoneInfo
 
 type DelegationZoneInfo struct {
-	Domain            string // cloud.example.com
-	Zone              string // example.com
+	LoadBalancedZone  string // cloud.example.com
+	ParentZone        string // example.com
 	NegativeTTL       int
 	ClusterNSName     string
 	ExtClusterNSNames map[string]string
@@ -39,18 +39,18 @@ type DelegationZoneInfo struct {
 
 func parseDelegationZones(config *Config) ([]*DelegationZoneInfo, error) {
 	type info struct {
-		domain string
-		zone   string
-		negTTL string
+		loadBalancedZone string
+		parentZone       string
+		negTTL           string
 	}
 
 	zones := config.dnsZones
 
-	getNsName := func(tag, zone, edge string) string {
+	getNsName := func(tag, zone, parentZone string) string {
 		const prefix = "gslb-ns"
-		d := strings.TrimSuffix(zone, "."+edge)
+		d := strings.TrimSuffix(zone, "."+parentZone)
 		domainX := strings.ReplaceAll(d, ".", "-")
-		return fmt.Sprintf("%s-%s-%s.%s", prefix, tag, domainX, edge)
+		return fmt.Sprintf("%s-%s-%s.%s", prefix, tag, domainX, parentZone)
 	}
 
 	validateRFC1035 := func(zoneInfo *DelegationZoneInfo) error {
@@ -79,7 +79,12 @@ func parseDelegationZones(config *Config) ([]*DelegationZoneInfo, error) {
 			if len(touple) != 3 {
 				return tuples, fmt.Errorf("invalid format of delegation zones: %s", z)
 			}
-			tuples = append(tuples, info{zone: strings.Trim(touple[0], " "), domain: strings.Trim(touple[1], " "), negTTL: strings.Trim(touple[2], " ")})
+			tuples = append(tuples,
+				info{
+					parentZone:       strings.Trim(touple[0], " "),
+					loadBalancedZone: strings.Trim(touple[1], " "),
+					negTTL:           strings.Trim(touple[2], " "),
+				})
 		}
 		return tuples, nil
 	}
@@ -96,17 +101,17 @@ func parseDelegationZones(config *Config) ([]*DelegationZoneInfo, error) {
 			return dzi, fmt.Errorf("invalid value of delegation zones: %s", zones)
 		}
 		zoneInfo := &DelegationZoneInfo{
-			Domain:        inf.domain,
-			Zone:          inf.zone,
-			NegativeTTL:   negTTL,
-			ClusterNSName: getNsName(config.ClusterGeoTag, inf.domain, inf.zone),
+			LoadBalancedZone: inf.loadBalancedZone,
+			ParentZone:       inf.parentZone,
+			NegativeTTL:      negTTL,
+			ClusterNSName:    getNsName(config.ClusterGeoTag, inf.loadBalancedZone, inf.parentZone),
 			ExtClusterNSNames: func(zone, edge string) map[string]string {
 				m := map[string]string{}
 				for _, tag := range config.extClustersGeoTags {
 					m[tag] = getNsName(tag, zone, edge)
 				}
 				return m
-			}(inf.domain, inf.zone),
+			}(inf.loadBalancedZone, inf.parentZone),
 		}
 		dzi = append(dzi, zoneInfo)
 	}
@@ -132,7 +137,7 @@ func (z *DelegationZoneInfo) GetNSServerList() []string {
 
 // GetExternalDNSEndpointName returns name of endpoint sitting in k8gb namespace
 func (z *DelegationZoneInfo) GetExternalDNSEndpointName() string {
-	var suffix = strings.Trim(strings.ReplaceAll(z.Domain, ".", "-"), " ")
+	var suffix = strings.Trim(strings.ReplaceAll(z.LoadBalancedZone, ".", "-"), " ")
 	return fmt.Sprintf("k8gb-ns-extdns-%s", suffix)
 }
 
@@ -167,14 +172,14 @@ func (d *DelegationZones) ContainsZone(host string) bool {
 func (d *DelegationZones) ListZones() []string {
 	var zones []string
 	for _, z := range *d {
-		zones = append(zones, z.Zone)
+		zones = append(zones, z.LoadBalancedZone)
 	}
 	return zones
 }
 
 func (d *DelegationZones) getZone(host string) *DelegationZoneInfo {
 	for _, z := range *d {
-		if strings.Contains(host, z.Zone) {
+		if strings.Contains(host, z.LoadBalancedZone) {
 			return z
 		}
 	}
diff --git a/controllers/depresolver/depresolver_test.go b/controllers/depresolver/depresolver_test.go
index 18cc549b6c..e3d7dce870 100644
--- a/controllers/depresolver/depresolver_test.go
+++ b/controllers/depresolver/depresolver_test.go
@@ -60,7 +60,7 @@ var predefinedConfig = Config{
 	ClusterGeoTag:           "us",
 	extClustersGeoTags:      []string{"za", "eu"},
 	EdgeDNSType:             DNSTypeInfoblox,
-	EdgeDNSServers: []utils2.DNSServer{
+	ParentZoneDNSServers: []utils2.DNSServer{
 		{
 			Host: "dns.cloud.example.com",
 			Port: 53,
@@ -279,11 +279,11 @@ func TestResolveConfigWithDeprecatedEdgeDNSServerKey(t *testing.T) {
 	assert.Equal(t, expected, *config)
 }
 
-func TestResolveConfigWithMalformedEdgeDNSServersKey(t *testing.T) {
+func TestResolveConfigWithMalformedParentZoneDNSServersKey(t *testing.T) {
 	// arrange
 	defer cleanup()
 	configureEnvVar(predefinedConfig)
-	_ = os.Setenv(EdgeDNSServersKey, "dns1;dns2?")
+	_ = os.Setenv(ParentZoneDNSServersKey, "dns1;dns2?")
 	resolver := NewDependencyResolver()
 	// act
 	_, err := resolver.ResolveOperatorConfig()
@@ -342,7 +342,7 @@ func TestResolveConfigWithEmptyEdgeDnsServer(t *testing.T) {
 	// arrange
 	defer cleanup()
 	expected := predefinedConfig
-	expected.EdgeDNSServers = []utils2.DNSServer{}
+	expected.ParentZoneDNSServers = []utils2.DNSServer{}
 	// act,assert
 	arrangeVariablesAndAssert(t, expected, assert.Error)
 }
@@ -351,7 +351,7 @@ func TestResolveConfigWithTwoEdgeDnsServers(t *testing.T) {
 	// arrange
 	defer cleanup()
 	expected := predefinedConfig
-	expected.EdgeDNSServers = []utils2.DNSServer{
+	expected.ParentZoneDNSServers = []utils2.DNSServer{
 		{
 			Host: "8.8.8.8",
 			Port: 53,
@@ -369,16 +369,16 @@ func TestResolveConfigWithNoEdgeDnsServer(t *testing.T) {
 	// arrange
 	defer cleanup()
 	expected := predefinedConfig
-	expected.EdgeDNSServers = []utils2.DNSServer{}
+	expected.ParentZoneDNSServers = []utils2.DNSServer{}
 	// act,assert
-	arrangeVariablesAndAssert(t, expected, assert.Error, EdgeDNSServersKey)
+	arrangeVariablesAndAssert(t, expected, assert.Error, ParentZoneDNSServersKey)
 }
 
 func TestResolveConfigWithEmptyIpAddressInEdgeDnsServer(t *testing.T) {
 	// arrange
 	defer cleanup()
 	expected := predefinedConfig
-	expected.EdgeDNSServers = []utils2.DNSServer{
+	expected.ParentZoneDNSServers = []utils2.DNSServer{
 		{
 			Host: defaultEdgeDNSServerIP,
 			Port: 53,
@@ -392,7 +392,7 @@ func TestResolveConfigWithHostnameEdgeDnsServer(t *testing.T) {
 	// arrange
 	defer cleanup()
 	expected := predefinedConfig
-	expected.EdgeDNSServers = []utils2.DNSServer{
+	expected.ParentZoneDNSServers = []utils2.DNSServer{
 		{
 			Host: "server-nonprod.on.domain.l3.2l.com",
 			Port: 53,
@@ -407,7 +407,7 @@ func TestResolveConfigWithInvalidIpAddressEdgeDnsServer(t *testing.T) {
 	// arrange
 	defer cleanup()
 	expected := predefinedConfig
-	expected.EdgeDNSServers = []utils2.DNSServer{
+	expected.ParentZoneDNSServers = []utils2.DNSServer{
 		{
 			Host: fmt.Sprintf("%s.", defaultEdgeDNSServerIP),
 			Port: 53,
@@ -421,7 +421,7 @@ func TestResolveConfigWithMultipleEdgeDnsServers1(t *testing.T) {
 	// arrange
 	defer cleanup()
 	configureEnvVar(predefinedConfig)
-	_ = os.Setenv(EdgeDNSServersKey, "1.1.1.1:53,  2.2.2.2:42")
+	_ = os.Setenv(ParentZoneDNSServersKey, "1.1.1.1:53,  2.2.2.2:42")
 	resolver := NewDependencyResolver()
 	// act
 	config, err := resolver.ResolveOperatorConfig()
@@ -429,15 +429,15 @@ func TestResolveConfigWithMultipleEdgeDnsServers1(t *testing.T) {
 	// assert
 	assert.NoError(t, err)
 	assert.Empty(t, depr)
-	assert.Equal(t, 2, len(config.EdgeDNSServers))
-	assert.Equal(t, 42, config.EdgeDNSServers[1].Port)
+	assert.Equal(t, 2, len(config.ParentZoneDNSServers))
+	assert.Equal(t, 42, config.ParentZoneDNSServers[1].Port)
 }
 
 func TestResolveConfigWithMultipleEdgeDnsServers2(t *testing.T) {
 	// arrange
 	defer cleanup()
 	configureEnvVar(predefinedConfig)
-	_ = os.Setenv(EdgeDNSServersKey, "1.1.1.1:11, 2.2.2.2:22, 3.3.3.3, somedns:1337")
+	_ = os.Setenv(ParentZoneDNSServersKey, "1.1.1.1:11, 2.2.2.2:22, 3.3.3.3, somedns:1337")
 	resolver := NewDependencyResolver()
 	// act
 	config, err := resolver.ResolveOperatorConfig()
@@ -445,46 +445,46 @@ func TestResolveConfigWithMultipleEdgeDnsServers2(t *testing.T) {
 	// assert
 	assert.NoError(t, err)
 	assert.Empty(t, depr)
-	assert.Equal(t, 4, len(config.EdgeDNSServers))
-	assert.Equal(t, "1.1.1.1", config.EdgeDNSServers[0].Host)
-	assert.Equal(t, 11, config.EdgeDNSServers[0].Port)
-	assert.Equal(t, 22, config.EdgeDNSServers[1].Port)
-	assert.Equal(t, 53, config.EdgeDNSServers[2].Port)
-	assert.Equal(t, 1337, config.EdgeDNSServers[3].Port)
-	assert.Equal(t, "somedns", config.EdgeDNSServers[3].Host)
+	assert.Equal(t, 4, len(config.ParentZoneDNSServers))
+	assert.Equal(t, "1.1.1.1", config.ParentZoneDNSServers[0].Host)
+	assert.Equal(t, 11, config.ParentZoneDNSServers[0].Port)
+	assert.Equal(t, 22, config.ParentZoneDNSServers[1].Port)
+	assert.Equal(t, 53, config.ParentZoneDNSServers[2].Port)
+	assert.Equal(t, 1337, config.ParentZoneDNSServers[3].Port)
+	assert.Equal(t, "somedns", config.ParentZoneDNSServers[3].Host)
 }
 
 func TestResolveConfigWithNoEdgeDnsServerPort(t *testing.T) {
 	// arrange
 	defer cleanup()
 	configureEnvVar(predefinedConfig)
-	_ = os.Setenv(EdgeDNSServersKey, "1.1.1.1")
+	_ = os.Setenv(ParentZoneDNSServersKey, "1.1.1.1")
 	resolver := NewDependencyResolver()
 	// act
 	config, err := resolver.ResolveOperatorConfig()
 	// assert
 	assert.NoError(t, err)
-	assert.Equal(t, 53, config.EdgeDNSServers[0].Port)
+	assert.Equal(t, 53, config.ParentZoneDNSServers[0].Port)
 }
 
 func TestResolveConfigWithEdgeDnsServerPort(t *testing.T) {
 	// arrange
 	defer cleanup()
 	configureEnvVar(predefinedConfig)
-	_ = os.Setenv(EdgeDNSServersKey, "1.1.1.1:42")
+	_ = os.Setenv(ParentZoneDNSServersKey, "1.1.1.1:42")
 	resolver := NewDependencyResolver()
 	// act
 	config, err := resolver.ResolveOperatorConfig()
 	// assert
 	assert.NoError(t, err)
-	assert.Equal(t, 42, config.EdgeDNSServers[0].Port)
+	assert.Equal(t, 42, config.ParentZoneDNSServers[0].Port)
 }
 
 func TestResolveConfigWithInvalidEdgeDnsServerPort1(t *testing.T) {
 	// arrange
 	defer cleanup()
 	configureEnvVar(predefinedConfig)
-	_ = os.Setenv(EdgeDNSServersKey, "1.1.1.1:invalid")
+	_ = os.Setenv(ParentZoneDNSServersKey, "1.1.1.1:invalid")
 	resolver := NewDependencyResolver()
 	// act
 	_, err := resolver.ResolveOperatorConfig()
@@ -499,7 +499,7 @@ func TestResolveConfigWithInvalidEdgeDnsServersValue(t *testing.T) {
 		// arrange
 		defer cleanup()
 		configureEnvVar(predefinedConfig)
-		_ = os.Setenv(EdgeDNSServersKey, invalid)
+		_ = os.Setenv(ParentZoneDNSServersKey, invalid)
 		resolver := NewDependencyResolver()
 		// act
 		_, err := resolver.ResolveOperatorConfig()
@@ -514,7 +514,7 @@ func TestResolveConfigWithMultipleEdgeDnsServersLocalhostNotFirst(t *testing.T)
 		// arrange
 		defer cleanup()
 		configureEnvVar(predefinedConfig)
-		_ = os.Setenv(EdgeDNSServersKey, invalid)
+		_ = os.Setenv(ParentZoneDNSServersKey, invalid)
 		resolver := NewDependencyResolver()
 		// act
 		_, err := resolver.ResolveOperatorConfig()
@@ -528,7 +528,7 @@ func TestResolveConfigWithMultipleEdgeDnsServersMalformed1(t *testing.T) {
 	// arrange
 	defer cleanup()
 	configureEnvVar(predefinedConfig)
-	_ = os.Setenv(EdgeDNSServersKey, "somehost:,somehost3:123:aaa.com")
+	_ = os.Setenv(ParentZoneDNSServersKey, "somehost:,somehost3:123:aaa.com")
 	resolver := NewDependencyResolver()
 	// act
 	_, err := resolver.ResolveOperatorConfig()
@@ -541,7 +541,7 @@ func TestResolveConfigWithMultipleEdgeDnsServersMalformed2(t *testing.T) {
 	// arrange
 	defer cleanup()
 	configureEnvVar(predefinedConfig)
-	_ = os.Setenv(EdgeDNSServersKey, "1.1.1.1,")
+	_ = os.Setenv(ParentZoneDNSServersKey, "1.1.1.1,")
 	resolver := NewDependencyResolver()
 	// act
 	_, err := resolver.ResolveOperatorConfig()
@@ -554,7 +554,7 @@ func TestResolveConfigWithInvalidHostnameEdgeDnsServer(t *testing.T) {
 	// arrange
 	defer cleanup()
 	configureEnvVar(predefinedConfig)
-	_ = os.Setenv(EdgeDNSServersKey, "https://server-nonprod.on.domain.l3.2l.com")
+	_ = os.Setenv(ParentZoneDNSServersKey, "https://server-nonprod.on.domain.l3.2l.com")
 	resolver := NewDependencyResolver()
 	// act
 	_, err := resolver.ResolveOperatorConfig()
@@ -567,7 +567,7 @@ func TestResolveConfigWithZeroOrNegativeEdgeDnsServerPort(t *testing.T) {
 	// arrange
 	defer cleanup()
 	configureEnvVar(predefinedConfig)
-	_ = os.Setenv(EdgeDNSServersKey, "1.1.1.1:-53")
+	_ = os.Setenv(ParentZoneDNSServersKey, "1.1.1.1:-53")
 	resolver := NewDependencyResolver()
 	// act
 	_, err := resolver.ResolveOperatorConfig()
@@ -1207,7 +1207,7 @@ func arrangeVariablesAndAssert(t *testing.T, expected Config,
 
 func cleanup() {
 	for _, s := range []string{ReconcileRequeueSecondsKey, NSRecordTTLKey, ClusterGeoTagKey, ExtClustersGeoTagsKey,
-		EdgeDNSServersKey, ExtDNSEnabledKey, InfobloxGridHostKey, InfobloxVersionKey, InfobloxPortKey, InfobloxUsernameKey,
+		ParentZoneDNSServersKey, ExtDNSEnabledKey, InfobloxGridHostKey, InfobloxVersionKey, InfobloxPortKey, InfobloxUsernameKey,
 		InfobloxPasswordKey, K8gbNamespaceKey, CoreDNSExposedKey, InfobloxHTTPRequestTimeoutKey, CoreDNSServiceTypeKey,
 		InfobloxHTTPPoolConnectionsKey, LogLevelKey, LogFormatKey, LogNoColorKey, MetricsAddressKey, TracingEnabled,
 		TracingSamplingRatio, OtelExporterOtlpEndpoint, DNSZonesKey} {
@@ -1224,7 +1224,7 @@ func configureEnvVar(config Config) {
 	_ = os.Setenv(NSRecordTTLKey, strconv.Itoa(config.NSRecordTTL))
 	_ = os.Setenv(ClusterGeoTagKey, config.ClusterGeoTag)
 	_ = os.Setenv(ExtClustersGeoTagsKey, strings.Join(config.extClustersGeoTags, ","))
-	_ = os.Setenv(EdgeDNSServersKey, config.EdgeDNSServers.String())
+	_ = os.Setenv(ParentZoneDNSServersKey, config.ParentZoneDNSServers.String())
 	_ = os.Setenv(K8gbNamespaceKey, config.K8gbNamespace)
 	_ = os.Setenv(ExtDNSEnabledKey, strconv.FormatBool(config.extDNSEnabled))
 	_ = os.Setenv(CoreDNSExposedKey, strconv.FormatBool(config.CoreDNSExposed))
@@ -1292,10 +1292,10 @@ cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc3.eee`
 		{
 			name: "invalid negTTL",
 			config: &Config{
-				dnsZones:           "example.com:cloud.example.com:30x",
-				EdgeDNSServers:     []utils2.DNSServer{{Host: "edge.com", Port: 53}},
-				ClusterGeoTag:      "us",
-				extClustersGeoTags: []string{"za", "eu"},
+				dnsZones:             "example.com:cloud.example.com:30x",
+				ParentZoneDNSServers: []utils2.DNSServer{{Host: "edge.com", Port: 53}},
+				ClusterGeoTag:        "us",
+				extClustersGeoTags:   []string{"za", "eu"},
 			},
 			expectedLen: 0,
 			assert: func(_ []*DelegationZoneInfo, err error) {
@@ -1305,19 +1305,19 @@ cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc3.eee`
 		{
 			name: "multiple zones",
 			config: &Config{
-				dnsZones:           "example.com:cloud.example.com:30;example.io:cloud.example.io:50",
-				EdgeDNSServers:     []utils2.DNSServer{{Host: "edge.com", Port: 53}},
-				ClusterGeoTag:      "us",
-				extClustersGeoTags: []string{"za", "eu"},
+				dnsZones:             "example.com:cloud.example.com:30;example.io:cloud.example.io:50",
+				ParentZoneDNSServers: []utils2.DNSServer{{Host: "edge.com", Port: 53}},
+				ClusterGeoTag:        "us",
+				extClustersGeoTags:   []string{"za", "eu"},
 			},
 			expectedLen: 2,
 			assert: func(zoneInfo []*DelegationZoneInfo, err error) {
 				assert.NoError(t, err)
 				assert.True(t, contains(zoneInfo, func(info *DelegationZoneInfo) bool {
-					return info.Zone == "example.com" && info.Domain == "cloud.example.com"
+					return info.ParentZone == "example.com" && info.LoadBalancedZone == "cloud.example.com"
 				}))
 				assert.True(t, contains(zoneInfo, func(info *DelegationZoneInfo) bool {
-					return info.Zone == "example.io" && info.Domain == "cloud.example.io"
+					return info.ParentZone == "example.io" && info.LoadBalancedZone == "cloud.example.io"
 				}))
 				assert.True(t, contains(zoneInfo, func(info *DelegationZoneInfo) bool {
 					return info.ClusterNSName == "gslb-ns-us-cloud.example.com" &&
@@ -1338,19 +1338,19 @@ cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc3.eee`
 		{
 			name: "multiple domains",
 			config: &Config{
-				dnsZones:           "example.com:cloud.example.com:30;example.com:pair.example.com:50",
-				EdgeDNSServers:     []utils2.DNSServer{{Host: "edge.com", Port: 53}},
-				ClusterGeoTag:      "us",
-				extClustersGeoTags: []string{"za", "eu"},
+				dnsZones:             "example.com:cloud.example.com:30;example.com:pair.example.com:50",
+				ParentZoneDNSServers: []utils2.DNSServer{{Host: "edge.com", Port: 53}},
+				ClusterGeoTag:        "us",
+				extClustersGeoTags:   []string{"za", "eu"},
 			},
 			expectedLen: 2,
 			assert: func(zoneInfo []*DelegationZoneInfo, err error) {
 				assert.NoError(t, err)
 				assert.True(t, contains(zoneInfo, func(info *DelegationZoneInfo) bool {
-					return info.Zone == "example.com" && info.Domain == "cloud.example.com"
+					return info.ParentZone == "example.com" && info.LoadBalancedZone == "cloud.example.com"
 				}))
 				assert.True(t, contains(zoneInfo, func(info *DelegationZoneInfo) bool {
-					return info.Zone == "example.com" && info.Domain == "pair.example.com"
+					return info.ParentZone == "example.com" && info.LoadBalancedZone == "pair.example.com"
 				}))
 				assert.True(t, contains(zoneInfo, func(info *DelegationZoneInfo) bool {
 					return info.ClusterNSName == "gslb-ns-us-cloud.example.com" &&
@@ -1371,48 +1371,48 @@ cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc3.eee`
 		{
 			name: "ends with semicolon",
 			config: &Config{
-				dnsZones:           "example.com:cloud.example.com:30;example.io:cloud.example.io:300;",
-				EdgeDNSServers:     []utils2.DNSServer{{Host: "edge.com", Port: 53}},
-				ClusterGeoTag:      "us",
-				extClustersGeoTags: []string{"za", "eu"},
+				dnsZones:             "example.com:cloud.example.com:30;example.io:cloud.example.io:300;",
+				ParentZoneDNSServers: []utils2.DNSServer{{Host: "edge.com", Port: 53}},
+				ClusterGeoTag:        "us",
+				extClustersGeoTags:   []string{"za", "eu"},
 			},
 			expectedLen: 2,
 			assert: func(zoneInfo []*DelegationZoneInfo, err error) {
 				assert.NoError(t, err)
 				assert.True(t, contains(zoneInfo, func(info *DelegationZoneInfo) bool {
-					return info.Zone == "example.com" && info.Domain == "cloud.example.com"
+					return info.ParentZone == "example.com" && info.LoadBalancedZone == "cloud.example.com"
 				}))
 				assert.True(t, contains(zoneInfo, func(info *DelegationZoneInfo) bool {
-					return info.Zone == "example.io" && info.Domain == "cloud.example.io"
+					return info.ParentZone == "example.io" && info.LoadBalancedZone == "cloud.example.io"
 				}))
 			},
 		},
 		{
 			name: "trimmed spaces and semicolons",
 			config: &Config{
-				dnsZones:           "example.com: cloud.example.com: 50; example.io:cloud.example.io: 30 ;",
-				EdgeDNSServers:     []utils2.DNSServer{{Host: "edge.com", Port: 53}},
-				ClusterGeoTag:      "us",
-				extClustersGeoTags: []string{"za", "eu"},
+				dnsZones:             "example.com: cloud.example.com: 50; example.io:cloud.example.io: 30 ;",
+				ParentZoneDNSServers: []utils2.DNSServer{{Host: "edge.com", Port: 53}},
+				ClusterGeoTag:        "us",
+				extClustersGeoTags:   []string{"za", "eu"},
 			},
 			expectedLen: 2,
 			assert: func(zoneInfo []*DelegationZoneInfo, err error) {
 				assert.NoError(t, err)
 				assert.True(t, contains(zoneInfo, func(info *DelegationZoneInfo) bool {
-					return info.Zone == "example.com" && info.Domain == "cloud.example.com"
+					return info.ParentZone == "example.com" && info.LoadBalancedZone == "cloud.example.com"
 				}))
 				assert.True(t, contains(zoneInfo, func(info *DelegationZoneInfo) bool {
-					return info.Zone == "example.io" && info.Domain == "cloud.example.io"
+					return info.ParentZone == "example.io" && info.LoadBalancedZone == "cloud.example.io"
 				}))
 			},
 		},
 		{
 			name: "check nsNames",
 			config: &Config{
-				dnsZones:           "cloud.example.com: k8gb-test.gslb.cloud.example.com :60;",
-				EdgeDNSServers:     []utils2.DNSServer{{Host: "edge.com", Port: 53}},
-				ClusterGeoTag:      "us",
-				extClustersGeoTags: []string{"za", "eu"},
+				dnsZones:             "cloud.example.com: k8gb-test.gslb.cloud.example.com :60;",
+				ParentZoneDNSServers: []utils2.DNSServer{{Host: "edge.com", Port: 53}},
+				ClusterGeoTag:        "us",
+				extClustersGeoTags:   []string{"za", "eu"},
 			},
 			expectedLen: 1,
 			assert: func(zoneInfo []*DelegationZoneInfo, err error) {
@@ -1426,10 +1426,10 @@ cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc3.eee`
 		{
 			name: "nsName exceed exceed limit 253 characters",
 			config: &Config{
-				dnsZones:           fmt.Sprintf("cloud.example.com:k8gb-test.%s.gslb.cloud.example.com:60;", str220),
-				EdgeDNSServers:     []utils2.DNSServer{{Host: "edge.com", Port: 53}},
-				ClusterGeoTag:      "us",
-				extClustersGeoTags: []string{"za", "eu"},
+				dnsZones:             fmt.Sprintf("cloud.example.com:k8gb-test.%s.gslb.cloud.example.com:60;", str220),
+				ParentZoneDNSServers: []utils2.DNSServer{{Host: "edge.com", Port: 53}},
+				ClusterGeoTag:        "us",
+				extClustersGeoTags:   []string{"za", "eu"},
 			},
 			expectedLen: 1,
 			assert: func(_ []*DelegationZoneInfo, err error) {
@@ -1439,10 +1439,10 @@ cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc3.eee`
 		{
 			name: "nsName label exceed limit 63 characters",
 			config: &Config{
-				dnsZones:           fmt.Sprintf("cloud.example.com: %s.gslb.cloud.example.com:60;", str64),
-				EdgeDNSServers:     []utils2.DNSServer{{Host: "edge.com", Port: 53}},
-				ClusterGeoTag:      "us",
-				extClustersGeoTags: []string{"za", "eu"},
+				dnsZones:             fmt.Sprintf("cloud.example.com: %s.gslb.cloud.example.com:60;", str64),
+				ParentZoneDNSServers: []utils2.DNSServer{{Host: "edge.com", Port: 53}},
+				ClusterGeoTag:        "us",
+				extClustersGeoTags:   []string{"za", "eu"},
 			},
 			expectedLen: 1,
 			assert: func(_ []*DelegationZoneInfo, err error) {
diff --git a/controllers/gslb_controller_reconciliation.go b/controllers/gslb_controller_reconciliation.go
index 1be4927b08..075ca3b577 100644
--- a/controllers/gslb_controller_reconciliation.go
+++ b/controllers/gslb_controller_reconciliation.go
@@ -135,7 +135,7 @@ func (r *GslbReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.
 	}
 	gslb.Status.Servers = servers
 
-	loadBalancerExposedIPs, err := refResolver.GetGslbExposedIPs(gslb.Annotations, r.Config.EdgeDNSServers)
+	loadBalancerExposedIPs, err := refResolver.GetGslbExposedIPs(gslb.Annotations, r.Config.ParentZoneDNSServers)
 	if err != nil {
 		m.IncrementError(gslb)
 		return result.RequeueError(fmt.Errorf("getting load balancer exposed IPs (%s)", err))
diff --git a/controllers/providers/assistant/corednssvc.go b/controllers/providers/assistant/corednssvc.go
index f3e39ffd4b..50653c14ad 100644
--- a/controllers/providers/assistant/corednssvc.go
+++ b/controllers/providers/assistant/corednssvc.go
@@ -83,7 +83,7 @@ func (r *CoreDNSService) GetExposedIPs() ([]string, *corev1.Service, error) {
 	}
 	var ipList []string
 	for _, ingressStatusIP := range coreDNSService.Status.LoadBalancer.Ingress {
-		var confirmedIPs, err = extractIPFromLB(ingressStatusIP, r.config.EdgeDNSServers)
+		var confirmedIPs, err = extractIPFromLB(ingressStatusIP, r.config.ParentZoneDNSServers)
 		if err != nil {
 			return nil, nil, err
 		}
diff --git a/controllers/providers/dns/external.go b/controllers/providers/dns/external.go
index c9adc43a74..dc44b83a42 100644
--- a/controllers/providers/dns/external.go
+++ b/controllers/providers/dns/external.go
@@ -66,7 +66,7 @@ func (p *ExternalDNSProvider) CreateZoneDelegation(zoneInfo *depresolver.Delegat
 }
 
 func (p *ExternalDNSProvider) Finalize(zoneInfo *depresolver.DelegationZoneInfo) error {
-	log.Info().Msgf("Domain %s will be deleted by removing delegation DNSEndpoint %s", zoneInfo.Domain, zoneInfo.GetExternalDNSEndpointName())
+	log.Info().Msgf("Domain %s will be deleted by removing delegation DNSEndpoint %s", zoneInfo.LoadBalancedZone, zoneInfo.GetExternalDNSEndpointName())
 	return nil
 }
 
diff --git a/controllers/providers/dns/external_test.go b/controllers/providers/dns/external_test.go
index b13d206d7f..5a062cbcab 100644
--- a/controllers/providers/dns/external_test.go
+++ b/controllers/providers/dns/external_test.go
@@ -97,11 +97,11 @@ func TestCreateZoneDelegation(t *testing.T) {
 				NSRecordTTL:   60,
 				DelegationZones: []*depresolver.DelegationZoneInfo{
 					{
-						Domain:        "cloud.example.com",
-						Zone:          "example.com",
-						NegativeTTL:   60,
-						IPs:           []string{"10.0.0.1", "10.0.0.2"},
-						ClusterNSName: "gslb-ns-eu-k8gb-test-gslb.cloud.example.com",
+						LoadBalancedZone: "cloud.example.com",
+						ParentZone:       "example.com",
+						NegativeTTL:      60,
+						IPs:              []string{"10.0.0.1", "10.0.0.2"},
+						ClusterNSName:    "gslb-ns-eu-k8gb-test-gslb.cloud.example.com",
 						ExtClusterNSNames: map[string]string{
 							"us": "gslb-ns-us-k8gb-test-gslb.cloud.example.com",
 						},
@@ -118,11 +118,11 @@ func TestCreateZoneDelegation(t *testing.T) {
 				NSRecordTTL:   60,
 				DelegationZones: []*depresolver.DelegationZoneInfo{
 					{
-						Domain:        "cloud.example.com",
-						Zone:          "example.com",
-						NegativeTTL:   60,
-						IPs:           []string{"10.0.0.1", "10.0.0.2"},
-						ClusterNSName: "gslb-ns-eu-k8gb-test-gslb.cloud.example.com",
+						LoadBalancedZone: "cloud.example.com",
+						ParentZone:       "example.com",
+						NegativeTTL:      60,
+						IPs:              []string{"10.0.0.1", "10.0.0.2"},
+						ClusterNSName:    "gslb-ns-eu-k8gb-test-gslb.cloud.example.com",
 						ExtClusterNSNames: map[string]string{
 							"us": "gslb-ns-us-k8gb-test-gslb.cloud.example.com",
 						},
@@ -139,21 +139,21 @@ func TestCreateZoneDelegation(t *testing.T) {
 				NSRecordTTL:   60,
 				DelegationZones: []*depresolver.DelegationZoneInfo{
 					{
-						Domain:        "cloud.example.com",
-						Zone:          "example.com",
-						NegativeTTL:   60,
-						IPs:           []string{"10.0.0.1", "10.0.0.2"},
-						ClusterNSName: "gslb-ns-eu-k8gb-test-gslb.cloud.example.com",
+						LoadBalancedZone: "cloud.example.com",
+						ParentZone:       "example.com",
+						NegativeTTL:      60,
+						IPs:              []string{"10.0.0.1", "10.0.0.2"},
+						ClusterNSName:    "gslb-ns-eu-k8gb-test-gslb.cloud.example.com",
 						ExtClusterNSNames: map[string]string{
 							"us": "gslb-ns-us-k8gb-test-gslb.cloud.example.com",
 						},
 					},
 					{
-						Domain:        "cloud.example.org",
-						Zone:          "example.org",
-						NegativeTTL:   60,
-						IPs:           []string{"10.0.0.1", "10.0.0.2"},
-						ClusterNSName: "gslb-ns-eu-k8gb-test-gslb.cloud.example.org",
+						LoadBalancedZone: "cloud.example.org",
+						ParentZone:       "example.org",
+						NegativeTTL:      60,
+						IPs:              []string{"10.0.0.1", "10.0.0.2"},
+						ClusterNSName:    "gslb-ns-eu-k8gb-test-gslb.cloud.example.org",
 						ExtClusterNSNames: map[string]string{
 							"us": "gslb-ns-us-k8gb-test-gslb.cloud.example.org",
 						},
diff --git a/controllers/providers/dns/infoblox.go b/controllers/providers/dns/infoblox.go
index 66f6522373..7dc0957c1b 100644
--- a/controllers/providers/dns/infoblox.go
+++ b/controllers/providers/dns/infoblox.go
@@ -61,7 +61,7 @@ func (p *InfobloxProvider) CreateZoneDelegation(zoneInfo *depresolver.Delegation
 	if err != nil {
 		return err
 	}
-	findZone, err := p.getZoneDelegated(objMgr, zoneInfo.Domain)
+	findZone, err := p.getZoneDelegated(objMgr, zoneInfo.LoadBalancedZone)
 	if err != nil {
 		return err
 	}
@@ -74,12 +74,12 @@ func (p *InfobloxProvider) CreateZoneDelegation(zoneInfo *depresolver.Delegation
 
 	if findZone == nil {
 		log.Info().
-			Str("DNSZone", zoneInfo.Domain).
+			Str("DNSZone", zoneInfo.LoadBalancedZone).
 			Msg("Creating delegated zone")
 		log.Debug().
 			Interface("records", delegateTo).
 			Msg("Delegated records")
-		_, err = p.createZoneDelegated(objMgr, zoneInfo.Domain, delegateTo)
+		_, err = p.createZoneDelegated(objMgr, zoneInfo.LoadBalancedZone, delegateTo)
 		if err != nil {
 			return err
 		}
@@ -95,7 +95,7 @@ func (p *InfobloxProvider) CreateZoneDelegation(zoneInfo *depresolver.Delegation
 				Interface("records", findZone.DelegateTo).
 				Msg("Found delegated zone records")
 			log.Info().
-				Str("DNSZone", zoneInfo.Domain).
+				Str("DNSZone", zoneInfo.LoadBalancedZone).
 				Interface("serverList", currentList).
 				Msg("Updating delegated zone with the server list")
 			_, err = p.updateZoneDelegated(objMgr, findZone.Ref, currentList)
@@ -108,7 +108,7 @@ func (p *InfobloxProvider) CreateZoneDelegation(zoneInfo *depresolver.Delegation
 }
 
 func (p *InfobloxProvider) Finalize(zoneInfo *depresolver.DelegationZoneInfo) error {
-	log.Info().Msgf("Domain %s must deleted by manually in Infoblox", zoneInfo.Domain)
+	log.Info().Msgf("Zone %s must deleted by manually in Infoblox", zoneInfo.LoadBalancedZone)
 	return nil
 }
 
diff --git a/controllers/providers/dns/infoblox_test.go b/controllers/providers/dns/infoblox_test.go
index 1620e105d4..78d3ca4e1a 100644
--- a/controllers/providers/dns/infoblox_test.go
+++ b/controllers/providers/dns/infoblox_test.go
@@ -46,11 +46,11 @@ func TestCreateZoneDelegationInfoblox(t *testing.T) {
 				NSRecordTTL:   30,
 				DelegationZones: []*depresolver.DelegationZoneInfo{
 					{
-						Zone:          "example.com",
-						Domain:        "cloud.example.com",
-						ClusterNSName: "gslb-ns-eu-cloud.example.com",
-						IPs:           []string{"10.0.0.1", "10.0.0.2"},
-						NegativeTTL:   30,
+						ParentZone:       "example.com",
+						LoadBalancedZone: "cloud.example.com",
+						ClusterNSName:    "gslb-ns-eu-cloud.example.com",
+						IPs:              []string{"10.0.0.1", "10.0.0.2"},
+						NegativeTTL:      30,
 						ExtClusterNSNames: map[string]string{
 							"us": "gslb-ns-us-cloud.example.com",
 						},
@@ -102,11 +102,11 @@ func TestCreateZoneDelegationInfoblox(t *testing.T) {
 				NSRecordTTL:   30,
 				DelegationZones: []*depresolver.DelegationZoneInfo{
 					{
-						Zone:          "example.com",
-						Domain:        "cloud.example.com",
-						ClusterNSName: "gslb-ns-eu-cloud.example.com",
-						IPs:           []string{"10.0.0.1", "10.0.0.2"},
-						NegativeTTL:   30,
+						ParentZone:       "example.com",
+						LoadBalancedZone: "cloud.example.com",
+						ClusterNSName:    "gslb-ns-eu-cloud.example.com",
+						IPs:              []string{"10.0.0.1", "10.0.0.2"},
+						NegativeTTL:      30,
 						ExtClusterNSNames: map[string]string{
 							"us": "gslb-ns-us-cloud.example.com",
 							"za": "gslb-ns-za-cloud.example.com",
@@ -147,11 +147,11 @@ func TestCreateZoneDelegationInfoblox(t *testing.T) {
 				NSRecordTTL:   30,
 				DelegationZones: []*depresolver.DelegationZoneInfo{
 					{
-						Zone:          "example.com",
-						Domain:        "cloud.example.com",
-						ClusterNSName: "gslb-ns-eu-cloud.example.com",
-						IPs:           []string{"10.0.0.1", "10.0.0.2"},
-						NegativeTTL:   30,
+						ParentZone:       "example.com",
+						LoadBalancedZone: "cloud.example.com",
+						ClusterNSName:    "gslb-ns-eu-cloud.example.com",
+						IPs:              []string{"10.0.0.1", "10.0.0.2"},
+						NegativeTTL:      30,
 						ExtClusterNSNames: map[string]string{
 							"us": "gslb-ns-us-cloud.example.com",
 							"za": "gslb-ns-za-cloud.example.com",
@@ -221,11 +221,11 @@ func TestCreateZoneDelegationInfoblox(t *testing.T) {
 				NSRecordTTL:   30,
 				DelegationZones: []*depresolver.DelegationZoneInfo{
 					{
-						Zone:          "example.com",
-						Domain:        "cloud.example.com",
-						ClusterNSName: "gslb-ns-eu-cloud.example.com",
-						IPs:           []string{"10.0.0.1", "10.0.0.2"},
-						NegativeTTL:   30,
+						ParentZone:       "example.com",
+						LoadBalancedZone: "cloud.example.com",
+						ClusterNSName:    "gslb-ns-eu-cloud.example.com",
+						IPs:              []string{"10.0.0.1", "10.0.0.2"},
+						NegativeTTL:      30,
 						ExtClusterNSNames: map[string]string{
 							"us": "gslb-ns-us-cloud.example.com",
 							"za": "gslb-ns-za-cloud.example.com",
diff --git a/controllers/providers/k8gbendpoint/applicationDNSEndpoint.go b/controllers/providers/k8gbendpoint/applicationDNSEndpoint.go
index 015c70e54b..d0a8b93b1e 100644
--- a/controllers/providers/k8gbendpoint/applicationDNSEndpoint.go
+++ b/controllers/providers/k8gbendpoint/applicationDNSEndpoint.go
@@ -192,18 +192,18 @@ func (d *ApplicationDNSEndpoint) GetExternalTargets(host string) (targets Target
 		d.logger.Info().
 			Str("cluster", cluster).
 			Msg("Adding external Gslb targets from cluster")
-		glueA, err := d.queryService.Query(cluster, d.config.EdgeDNSServers)
+		glueA, err := d.queryService.Query(cluster, d.config.ParentZoneDNSServers)
 		if err != nil {
 			d.logger.Warn().
 				Str("fqdn", cluster+".").
-				Str("nameservers", d.config.EdgeDNSServers.String()).
+				Str("nameservers", d.config.ParentZoneDNSServers.String()).
 				Err(err).
 				Msg("can't lookup GlueA record")
 			continue
 		}
 		d.logger.Info().
 			Str("nameserver", cluster).
-			Str("edgeDNSServers", d.config.EdgeDNSServers.String()).
+			Str("edgeDNSServers", d.config.ParentZoneDNSServers.String()).
 			Interface("glueARecord", glueA.Answer).
 			Msg("Resolved glue A record for NS")
 		glueARecords := d.queryService.ExtractARecords(glueA)
@@ -213,7 +213,7 @@ func (d *ApplicationDNSEndpoint) GetExternalTargets(host string) (targets Target
 		} else {
 			hostToUse = cluster
 		}
-		nameServersToUse := getNSCombinations(d.config.EdgeDNSServers, hostToUse)
+		nameServersToUse := getNSCombinations(d.config.ParentZoneDNSServers, hostToUse)
 		lHost := fmt.Sprintf("localtargets-%s", host)
 		a, err := d.queryService.Query(lHost, nameServersToUse)
 		if err != nil {
diff --git a/controllers/providers/k8gbendpoint/applicationDNSEndpoint_weight_test.go b/controllers/providers/k8gbendpoint/applicationDNSEndpoint_weight_test.go
index 25b6839fd2..41049fa2b2 100644
--- a/controllers/providers/k8gbendpoint/applicationDNSEndpoint_weight_test.go
+++ b/controllers/providers/k8gbendpoint/applicationDNSEndpoint_weight_test.go
@@ -41,7 +41,7 @@ func TestWeight(t *testing.T) {
 	// void metrics
 	metrics := func(*k8gbv1beta1.Gslb, bool, k8gbv1beta1.HealthStatus, []string) {}
 
-	edgeDNSServers := []utils.DNSServer{
+	parentZoneDNSServers := []utils.DNSServer{
 		{Host: "10.0.0.1", Port: 53},
 	}
 	type wrr struct {
@@ -63,16 +63,16 @@ func TestWeight(t *testing.T) {
 				ClusterGeoTag: "eu",
 				DelegationZones: depresolver.DelegationZones{
 					{
-						Domain:        "cloud.example.com",
-						Zone:          "example.com",
-						ClusterNSName: "gslb-ns-eu-cloud.example.com",
+						LoadBalancedZone: "cloud.example.com",
+						ParentZone:       "example.com",
+						ClusterNSName:    "gslb-ns-eu-cloud.example.com",
 						ExtClusterNSNames: map[string]string{
 							"us": "gslb-ns-us-cloud.example.com",
 							"za": "gslb-ns-za-cloud.example.com",
 						},
 					},
 				},
-				EdgeDNSServers: edgeDNSServers,
+				ParentZoneDNSServers: parentZoneDNSServers,
 			},
 			gslb: &k8gbv1beta1.Gslb{
 				Spec: k8gbv1beta1.GslbSpec{
@@ -117,16 +117,16 @@ func TestWeight(t *testing.T) {
 				ClusterGeoTag: "eu",
 				DelegationZones: depresolver.DelegationZones{
 					{
-						Domain:        "cloud.example.com",
-						Zone:          "example.com",
-						ClusterNSName: "gslb-ns-eu-cloud.example.com",
+						LoadBalancedZone: "cloud.example.com",
+						ParentZone:       "example.com",
+						ClusterNSName:    "gslb-ns-eu-cloud.example.com",
 						ExtClusterNSNames: map[string]string{
 							"us": "gslb-ns-us-cloud.example.com",
 							"za": "gslb-ns-za-cloud.example.com",
 						},
 					},
 				},
-				EdgeDNSServers: edgeDNSServers,
+				ParentZoneDNSServers: parentZoneDNSServers,
 			},
 			gslb: &k8gbv1beta1.Gslb{
 				Spec: k8gbv1beta1.GslbSpec{
@@ -171,16 +171,16 @@ func TestWeight(t *testing.T) {
 				ClusterGeoTag: "eu",
 				DelegationZones: depresolver.DelegationZones{
 					{
-						Domain:        "cloud.example.com",
-						Zone:          "example.com",
-						ClusterNSName: "gslb-ns-eu-cloud.example.com",
+						LoadBalancedZone: "cloud.example.com",
+						ParentZone:       "example.com",
+						ClusterNSName:    "gslb-ns-eu-cloud.example.com",
 						ExtClusterNSNames: map[string]string{
 							"us": "gslb-ns-us-cloud.example.com",
 							"za": "gslb-ns-za-cloud.example.com",
 						},
 					},
 				},
-				EdgeDNSServers: edgeDNSServers,
+				ParentZoneDNSServers: parentZoneDNSServers,
 			},
 			gslb: &k8gbv1beta1.Gslb{
 				Spec: k8gbv1beta1.GslbSpec{
@@ -225,16 +225,16 @@ func TestWeight(t *testing.T) {
 				ClusterGeoTag: "eu",
 				DelegationZones: depresolver.DelegationZones{
 					{
-						Domain:        "cloud.example.com",
-						Zone:          "example.com",
-						ClusterNSName: "gslb-ns-eu-cloud.example.com",
+						LoadBalancedZone: "cloud.example.com",
+						ParentZone:       "example.com",
+						ClusterNSName:    "gslb-ns-eu-cloud.example.com",
 						ExtClusterNSNames: map[string]string{
 							"us": "gslb-ns-us-cloud.example.com",
 							"za": "gslb-ns-za-cloud.example.com",
 						},
 					},
 				},
-				EdgeDNSServers: edgeDNSServers,
+				ParentZoneDNSServers: parentZoneDNSServers,
 			},
 			gslb: &k8gbv1beta1.Gslb{
 				Spec: k8gbv1beta1.GslbSpec{
@@ -269,13 +269,13 @@ func TestWeight(t *testing.T) {
 				ClusterGeoTag: "eu",
 				DelegationZones: depresolver.DelegationZones{
 					{
-						Domain:            "cloud.example.com",
-						Zone:              "example.com",
+						LoadBalancedZone:  "cloud.example.com",
+						ParentZone:        "example.com",
 						ClusterNSName:     "gslb-ns-eu-cloud.example.com",
 						ExtClusterNSNames: map[string]string{},
 					},
 				},
-				EdgeDNSServers: edgeDNSServers,
+				ParentZoneDNSServers: parentZoneDNSServers,
 			},
 			gslb: &k8gbv1beta1.Gslb{
 				Spec: k8gbv1beta1.GslbSpec{
diff --git a/controllers/providers/k8gbendpoint/delegationDNSEndpoint.go b/controllers/providers/k8gbendpoint/delegationDNSEndpoint.go
index 2cb3123c5b..b1712350f9 100644
--- a/controllers/providers/k8gbendpoint/delegationDNSEndpoint.go
+++ b/controllers/providers/k8gbendpoint/delegationDNSEndpoint.go
@@ -78,7 +78,7 @@ func (d *DelegationDNSEndpoint) GetDNSEndpoint() (*externaldns.DNSEndpoint, erro
 		Spec: externaldns.DNSEndpointSpec{
 			Endpoints: []*externaldns.Endpoint{
 				{
-					DNSName:    d.info.Domain,
+					DNSName:    d.info.LoadBalancedZone,
 					RecordTTL:  ttl,
 					RecordType: "NS",
 					Targets:    d.info.GetNSServerList(),
diff --git a/controllers/providers/metrics/prometheus_test.go b/controllers/providers/metrics/prometheus_test.go
index a847ff5a0f..2ee5247a52 100644
--- a/controllers/providers/metrics/prometheus_test.go
+++ b/controllers/providers/metrics/prometheus_test.go
@@ -51,8 +51,8 @@ var (
 		K8gbNamespace: namespace,
 		DelegationZones: depresolver.DelegationZones{
 			{
-				Domain: "cloud.example.com",
-				Zone:   "example.com",
+				LoadBalancedZone: "cloud.example.com",
+				ParentZone:       "example.com",
 			},
 		},
 	}
diff --git a/controllers/refresolver/ingress/ingress.go b/controllers/refresolver/ingress/ingress.go
index c7edcc0f27..dd3bdc5080 100644
--- a/controllers/refresolver/ingress/ingress.go
+++ b/controllers/refresolver/ingress/ingress.go
@@ -176,7 +176,7 @@ func (rr *ReferenceResolver) GetServers() ([]*k8gbv1beta1.Server, error) {
 }
 
 // GetGslbExposedIPs retrieves the load balancer IP address of the GSLB
-func (rr *ReferenceResolver) GetGslbExposedIPs(gslbAnnotations map[string]string, edgeDNSServers utils.DNSList) ([]string, error) {
+func (rr *ReferenceResolver) GetGslbExposedIPs(gslbAnnotations map[string]string, parentZoneDNSServers utils.DNSList) ([]string, error) {
 	// fetch the IP addresses of the reverse proxy from an annotation if it exists
 	if ingressIPsFromAnnotation, ok := gslbAnnotations[ExternalIPsAnnotation]; ok {
 		return utils.ParseIPAddresses(ingressIPsFromAnnotation)
@@ -189,7 +189,7 @@ func (rr *ReferenceResolver) GetGslbExposedIPs(gslbAnnotations map[string]string
 			gslbIngressIPs = append(gslbIngressIPs, ip.IP)
 		}
 		if len(ip.Hostname) > 0 {
-			IPs, err := utils.Dig(ip.Hostname, 8, edgeDNSServers...)
+			IPs, err := utils.Dig(ip.Hostname, 8, parentZoneDNSServers...)
 			if err != nil {
 				log.Warn().Err(err).Msg("Dig error")
 				return nil, err
diff --git a/controllers/refresolver/istiovirtualservice/istiovirtualservice.go b/controllers/refresolver/istiovirtualservice/istiovirtualservice.go
index 49c3879f90..7dfc183a48 100644
--- a/controllers/refresolver/istiovirtualservice/istiovirtualservice.go
+++ b/controllers/refresolver/istiovirtualservice/istiovirtualservice.go
@@ -219,7 +219,7 @@ func (rr *ReferenceResolver) GetServers() ([]*k8gbv1beta1.Server, error) {
 }
 
 // GetGslbExposedIPs retrieves the load balancer IP address of the GSLB
-func (rr *ReferenceResolver) GetGslbExposedIPs(gslbAnnotations map[string]string, edgeDNSServers utils.DNSList) ([]string, error) {
+func (rr *ReferenceResolver) GetGslbExposedIPs(gslbAnnotations map[string]string, parentZoneDNSServers utils.DNSList) ([]string, error) {
 	// fetch the IP addresses of the reverse proxy from an annotation if it exists
 	if ingressIPsFromAnnotation, ok := gslbAnnotations[externalIPsAnnotation]; ok {
 		return utils.ParseIPAddresses(ingressIPsFromAnnotation)
@@ -232,7 +232,7 @@ func (rr *ReferenceResolver) GetGslbExposedIPs(gslbAnnotations map[string]string
 			gslbIngressIPs = append(gslbIngressIPs, ip.IP)
 		}
 		if len(ip.Hostname) > 0 {
-			IPs, err := utils.Dig(ip.Hostname, 8, edgeDNSServers...)
+			IPs, err := utils.Dig(ip.Hostname, 8, parentZoneDNSServers...)
 			if err != nil {
 				log.Warn().Err(err).Msg("Dig error")
 				return nil, err
diff --git a/controllers/refresolver/refresolver.go b/controllers/refresolver/refresolver.go
index 460de7f815..0b36a4788a 100644
--- a/controllers/refresolver/refresolver.go
+++ b/controllers/refresolver/refresolver.go
@@ -34,7 +34,7 @@ type GslbReferenceResolver interface {
 	// GetServers retrieves GSLB the server configuration
 	GetServers() ([]*k8gbv1beta1.Server, error)
 	// GetGslbExposedIPs retrieves the load balancer IP address of the GSLB
-	GetGslbExposedIPs(gslbAnnotations map[string]string, edgeDNSServers utils.DNSList) ([]string, error)
+	GetGslbExposedIPs(gslbAnnotations map[string]string, parentZoneDNSServers utils.DNSList) ([]string, error)
 }
 
 // New creates a new GSLBReferenceResolver
diff --git a/controllers/utils/dns.go b/controllers/utils/dns.go
index e318e25a75..716df3a2b1 100644
--- a/controllers/utils/dns.go
+++ b/controllers/utils/dns.go
@@ -45,16 +45,16 @@ func (l DNSList) String() string {
 	return strings.Join(aux, ",")
 }
 
-// Dig returns a list of IP addresses for a given FQDN by using the dns servers from edgeDNSServers
-// dns servers are tried one by one from the edgeDNSServers and if there is a non-error response it is returned and the rest is not tried
-func Dig(fqdn string, maxRecursion int, edgeDNSServers ...DNSServer) (ips []string, err error) {
+// Dig returns a list of IP addresses for a given FQDN by using the dns servers from parentZoneDNSServers
+// dns servers are tried one by one from the parentZoneDNSServers and if there is a non-error response it is returned and the rest is not tried
+func Dig(fqdn string, maxRecursion int, parentZoneDNSServers ...DNSServer) (ips []string, err error) {
 	if maxRecursion < 0 {
 		return nil, fmt.Errorf("maximum recursion limit reached")
 	}
 	maxRecursion--
 
-	if len(edgeDNSServers) == 0 {
-		return nil, fmt.Errorf("empty edgeDNSServers, provide at least one")
+	if len(parentZoneDNSServers) == 0 {
+		return nil, fmt.Errorf("empty parentZoneDNSServers, provide at least one")
 	}
 	if len(fqdn) == 0 {
 		return ips, nil
@@ -65,7 +65,7 @@ func Dig(fqdn string, maxRecursion int, edgeDNSServers ...DNSServer) (ips []stri
 	}
 	msg := new(dns.Msg)
 	msg.SetQuestion(fqdn, dns.TypeA)
-	ack, err := Exchange(msg, edgeDNSServers)
+	ack, err := Exchange(msg, parentZoneDNSServers)
 	if err != nil {
 		return nil, fmt.Errorf("dig error: %s", err)
 	}
@@ -99,7 +99,7 @@ func Dig(fqdn string, maxRecursion int, edgeDNSServers ...DNSServer) (ips []stri
 	// Check for non-resolved CNAMEs
 	for _, cname := range cnameRecords {
 		if !aResolved(cname) && !cResolved(cname) {
-			cnameIPs, err := Dig(cname.Target, maxRecursion, edgeDNSServers...)
+			cnameIPs, err := Dig(cname.Target, maxRecursion, parentZoneDNSServers...)
 			if err != nil {
 				return nil, err
 			}
@@ -110,11 +110,11 @@ func Dig(fqdn string, maxRecursion int, edgeDNSServers ...DNSServer) (ips []stri
 	return ips, nil
 }
 
-func Exchange(m *dns.Msg, edgeDNSServers []DNSServer) (msg *dns.Msg, err error) {
-	if len(edgeDNSServers) == 0 {
-		return nil, fmt.Errorf("empty edgeDNSServers, provide at least one")
+func Exchange(m *dns.Msg, parentZoneDNSServers []DNSServer) (msg *dns.Msg, err error) {
+	if len(parentZoneDNSServers) == 0 {
+		return nil, fmt.Errorf("empty parentZoneDNSServers, provide at least one")
 	}
-	for _, ns := range edgeDNSServers {
+	for _, ns := range parentZoneDNSServers {
 		if ns.Host == "" {
 			return nil, fmt.Errorf("empty edgeDNSServer.Host in the list")
 		}
diff --git a/controllers/utils/dns_test.go b/controllers/utils/dns_test.go
index af57e84594..d702e0490b 100644
--- a/controllers/utils/dns_test.go
+++ b/controllers/utils/dns_test.go
@@ -131,7 +131,7 @@ func TestOneValidEdgeDNSInTheList(t *testing.T) {
 		t.Skipf("no connectivity, skipping")
 	}
 	// arrange
-	edgeDNSServers := []DNSServer{
+	parentZoneDNSServers := []DNSServer{
 		{Host: "127.1.2.3", Port: 53}, // wrong
 		{Host: "8.8.8.8", Port: 153},  // wrong
 		{Host: "8.8.8.8", Port: 53},   // ok
@@ -139,7 +139,7 @@ func TestOneValidEdgeDNSInTheList(t *testing.T) {
 	}
 	fqdn := defaultFqdn
 	// act
-	result, err := Dig(fqdn, 8, edgeDNSServers...)
+	result, err := Dig(fqdn, 8, parentZoneDNSServers...)
 	// assert
 	if err != nil && strings.HasSuffix(err.Error(), "->8.8.8.8:253: i/o timeout") {
 		// udp 8.8.8.8:253 may be blocked on some local environments
@@ -152,14 +152,14 @@ func TestOneValidEdgeDNSInTheList(t *testing.T) {
 
 func TestNoValidEdgeDNSInTheList(t *testing.T) {
 	// arrange
-	edgeDNSServers := []DNSServer{
+	parentZoneDNSServers := []DNSServer{
 		{Host: "", Port: 53},         // wrong
 		{Host: "8.8.8.8", Port: 153}, // wrong
 		{Host: "8.8.4.4", Port: 253}, // wrong
 	}
 	fqdn := defaultFqdn
 	// act
-	result, err := Dig(fqdn, 8, edgeDNSServers...)
+	result, err := Dig(fqdn, 8, parentZoneDNSServers...)
 	// assert
 	assert.Error(t, err)
 	assert.Nil(t, result)
@@ -167,14 +167,14 @@ func TestNoValidEdgeDNSInTheList(t *testing.T) {
 
 func TestEmptyEdgeDNSInTheList(t *testing.T) {
 	// arrange
-	edgeDNSServers := []DNSServer{
+	parentZoneDNSServers := []DNSServer{
 		{Host: "", Port: 53},        // wrong
 		{Host: "8.8.8.8", Port: 53}, // ok
 		{Host: "8.8.4.4", Port: 53}, // ok
 	}
 	fqdn := defaultFqdn
 	// act
-	result, err := Dig(fqdn, 8, edgeDNSServers...)
+	result, err := Dig(fqdn, 8, parentZoneDNSServers...)
 	// assert
 	assert.Error(t, err)
 	assert.Nil(t, result)
@@ -185,14 +185,14 @@ func TestMultipleValidEdgeDNSInTheList(t *testing.T) {
 		t.Skipf("no connectivity, skipping")
 	}
 	// arrange
-	edgeDNSServers := []DNSServer{
+	parentZoneDNSServers := []DNSServer{
 		{Host: "1.1.1.1", Port: 53}, // ok
 		{Host: "8.8.8.8", Port: 53}, // ok
 		{Host: "8.8.4.4", Port: 53}, // ok
 	}
 	fqdn := defaultFqdn
 	// act
-	result, err := Dig(fqdn, 8, edgeDNSServers...)
+	result, err := Dig(fqdn, 8, parentZoneDNSServers...)
 	// assert
 	assert.NoError(t, err)
 	assert.NotEmpty(t, result)
diff --git a/deploy/helm/next.yaml b/deploy/helm/next.yaml
index 74566466ff..4dbe260082 100644
--- a/deploy/helm/next.yaml
+++ b/deploy/helm/next.yaml
@@ -1,6 +1,9 @@
 k8gb:
   reconcileRequeueSeconds: 10
-  dnsZoneNegTTL: 10
+  dnsZones:
+    - dnsZoneNegTTL: 10
+      loadBalancedZone: cloud.example.com
+      parentZone: example.com
   log:
     format: simple
     level: debug
diff --git a/docs/deploy_cloudflare.md b/docs/deploy_cloudflare.md
index f55d59e47f..f3d4dd9725 100644
--- a/docs/deploy_cloudflare.md
+++ b/docs/deploy_cloudflare.md
@@ -30,9 +30,9 @@ Remember to change the zone-related values to point configuration to your own DN
 
 ```yaml
 k8gb:
-  dnsZone: "cloudflare-test.k8gb.io"
-  # -- main zone which would contain gslb zone to delegate
-  edgeDNSZone: "k8gb.io" # main zone which would contain gslb zone to delegate
+  dnsZones:
+  - parentZone: "k8gb.io"
+    loadBalancedZone: "cloudflare-test.k8gb.io"
 ```
 
 ### Cloudflare-specific configuration
diff --git a/docs/deploy_infoblox.md b/docs/deploy_infoblox.md
index a8581cb922..ae20141ddd 100644
--- a/docs/deploy_infoblox.md
+++ b/docs/deploy_infoblox.md
@@ -17,7 +17,7 @@ cp chart/k8gb/values.yaml ~/k8gb/eu-cluster.yaml
 * Modify the example configuration. Important parameters described below:
   * `dnsZone` - this zone will be delegated to the `edgeDNS` in your environment. E.g. `yourzone.edgedns.com`
   * `edgeDNSZone` - this zone will be automatically configured by k8gb to delegate to `dnsZone` and will make k8gb controlled nodes act as authoritative server for this zone. E.g. `edgedns.com`
-  * `edgeDNSServers` stable DNS servers in your environment that is controlled by edgeDNS provider e.g. Infoblox so k8gb instances will be able to talk to each other through automatically created DNS names
+  * `parentZoneDNSServers` stable DNS servers in your environment that is controlled by edgeDNS provider e.g. Infoblox so k8gb instances will be able to talk to each other through automatically created DNS names
   * `clusterGeoTag` to geographically tag your cluster. We are operating `eu` cluster in this example
   * `extGslbClustersGeoTags` contains Geo tag of the cluster(s) to talk with when k8gb is deployed to multiple clusters. Imagine your second cluster is `us` so we tag it accordingly
   * `infoblox.enabled: true` to enable automated zone delegation configuration at edgeDNS provider. You don't need it for local testing and can optionally be skipped. Meanwhile, in this section we will cover a fully operational end-to-end scenario.
diff --git a/docs/deploy_windowsdns.md b/docs/deploy_windowsdns.md
index 102cbc437a..aba0e77c6d 100644
--- a/docs/deploy_windowsdns.md
+++ b/docs/deploy_windowsdns.md
@@ -82,7 +82,7 @@ Before deploying K8GB and the demo workload, ensure required configurations on W
         * Ensure that the following properties are updated with your values:
             * dnsZone
             * edgeDNSZone
-            * edgeDNSServers
+            * parentZoneDNSServers
             * host - always use FQDN with GSS-TSIG, not IP address
             * kerberos-username
             * kerberos-password
diff --git a/docs/examples/azure/k8gb/aks1-helm-values.yaml b/docs/examples/azure/k8gb/aks1-helm-values.yaml
index 852a2e1d0f..6f51f66454 100644
--- a/docs/examples/azure/k8gb/aks1-helm-values.yaml
+++ b/docs/examples/azure/k8gb/aks1-helm-values.yaml
@@ -1,15 +1,14 @@
 k8gb:
   # -- dnsZone controlled by gslb
-  dnsZone: "demo.k8gb-kubeconeu2023.com"
-  # -- Negative TTL for SOA record
-  dnsZoneNegTTL: 300
-  # -- main zone which would contain gslb zone to delegate
-  edgeDNSZone: "k8gb-kubeconeu2023.com" # main zone which would contain gslb zone to delegate
+  dnsZones:
+    - loadBalancedZone: "demo.k8gb-kubeconeu2023.com" # -- dnsZone controlled by gslb
+      parentZone: "k8gb-kubeconeu2023.com" # -- main zone which would contain gslb zone to delegate
+      dnsZoneNegTTL: 300 # -- Negative TTL for SOA record
   # -- host/ip[:port] format is supported here where port defaults to 53
-  edgeDNSServers:
-      # -- use these DNS server as a main resolver to enable cross k8gb DNS based communication
-      - "1.1.1.1"
-      - "8.8.8.8"
+  parentZoneDNSServers:
+    # -- use these DNS server as a main resolver to enable cross k8gb DNS based communication
+    - "1.1.1.1"
+    - "8.8.8.8"
   # -- used for places where we need to distinguish between different Gslb instances
   clusterGeoTag: "uksouth"
   # -- comma-separated list of external gslb geo tags to pair with
diff --git a/docs/examples/azure/k8gb/aks2-helm-values.yaml b/docs/examples/azure/k8gb/aks2-helm-values.yaml
index 8caba904f6..5c0394107c 100644
--- a/docs/examples/azure/k8gb/aks2-helm-values.yaml
+++ b/docs/examples/azure/k8gb/aks2-helm-values.yaml
@@ -1,15 +1,13 @@
 k8gb:
-  # -- dnsZone controlled by gslb
-  dnsZone: "demo.k8gb-kubeconeu2023.com"
-  # -- Negative TTL for SOA record
-  dnsZoneNegTTL: 300
-  # -- main zone which would contain gslb zone to delegate
-  edgeDNSZone: "k8gb-kubeconeu2023.com" # main zone which would contain gslb zone to delegate
+  dnsZones:
+    - loadBalancedZone: "demo.k8gb-kubeconeu2023.com" # -- dnsZone controlled by gslb
+      parentZone: "k8gb-kubeconeu2023.com" # -- main zone which would contain gslb zone to delegate
+      dnsZoneNegTTL: 300 # -- Negative TTL for SOA record
   # -- host/ip[:port] format is supported here where port defaults to 53
-  edgeDNSServers:
-      # -- use these DNS server as a main resolver to enable cross k8gb DNS based communication
-      - "1.1.1.1"
-      - "8.8.8.8"
+  parentZoneDNSServers:
+    # -- use these DNS server as a main resolver to enable cross k8gb DNS based communication
+    - "1.1.1.1"
+    - "8.8.8.8"
   # -- used for places where we need to distinguish between different Gslb instances
   clusterGeoTag: "francecentral"
   # -- comma-separated list of external gslb geo tags to pair with
diff --git a/docs/examples/cloudflare/k8gb-cluster-cloudflare-eu.yaml b/docs/examples/cloudflare/k8gb-cluster-cloudflare-eu.yaml
index e9792a7508..5d55e9c9f9 100644
--- a/docs/examples/cloudflare/k8gb-cluster-cloudflare-eu.yaml
+++ b/docs/examples/cloudflare/k8gb-cluster-cloudflare-eu.yaml
@@ -1,7 +1,7 @@
 k8gb:
-  dnsZone: "cloudflare-test.k8gb.io"
-  # -- main zone which would contain gslb zone to delegate
-  edgeDNSZone: "k8gb.io" # main zone which would contain gslb zone to delegate
+  dnsZones:
+    - loadBalancedZone: "cloudflare-test.k8gb.io" # -- dnsZone controlled by gslb
+      parentZone: "k8gb.io" # -- main zone which would contain gslb zone to delegate
   # -- used for places where we need to distinguish between different Gslb instances
   clusterGeoTag: "eu"
   # -- comma-separated list of external gslb geo tags to pair with
diff --git a/docs/examples/cloudflare/k8gb-cluster-cloudflare-us.yaml b/docs/examples/cloudflare/k8gb-cluster-cloudflare-us.yaml
index 8ec5722d5a..774734f797 100644
--- a/docs/examples/cloudflare/k8gb-cluster-cloudflare-us.yaml
+++ b/docs/examples/cloudflare/k8gb-cluster-cloudflare-us.yaml
@@ -1,7 +1,7 @@
 k8gb:
-  dnsZone: "cloudflare-test.k8gb.io"
-  # -- main zone which would contain gslb zone to delegate
-  edgeDNSZone: "k8gb.io" # main zone which would contain gslb zone to delegate
+  dnsZones:
+    - loadBalancedZone: "cloudflare-test.k8gb.io" # -- dnsZone controlled by gslb
+      parentZone: "k8gb.io" # -- main zone which would contain gslb zone to delegate
   # -- used for places where we need to distinguish between different Gslb instances
   clusterGeoTag: "us"
   # -- comma-separated list of external gslb geo tags to pair with
diff --git a/docs/examples/ns1/k8gb-cluster-ns1-eu-west-1.yaml b/docs/examples/ns1/k8gb-cluster-ns1-eu-west-1.yaml
index a0809404ae..b89b2b6de0 100644
--- a/docs/examples/ns1/k8gb-cluster-ns1-eu-west-1.yaml
+++ b/docs/examples/ns1/k8gb-cluster-ns1-eu-west-1.yaml
@@ -1,6 +1,7 @@
 k8gb:
-  dnsZone: "test.k8gb.io" # dnsZone controlled by gslb
-  edgeDNSZone: "k8gb.io" # main zone which would contain gslb zone to delegate
+  dnsZones:
+    - loadBalancedZone: "test.k8gb.io" # -- dnsZone controlled by gslb
+      parentZone: "k8gb.io" # -- main zone which would contain gslb zone to delegate
   edgeDNSServer: "169.254.169.253" # external DNS server to be used for resolution
   clusterGeoTag: "eu-west-1" # used for places where we need to distinguish between differnet Gslb instances
   extGslbClustersGeoTags: "us-east-1" # comma-separated list of external gslb geo tags to pair with
diff --git a/docs/examples/ns1/k8gb-cluster-ns1-us-east-1.yaml b/docs/examples/ns1/k8gb-cluster-ns1-us-east-1.yaml
index 90a23bcc7d..52fb171048 100644
--- a/docs/examples/ns1/k8gb-cluster-ns1-us-east-1.yaml
+++ b/docs/examples/ns1/k8gb-cluster-ns1-us-east-1.yaml
@@ -1,6 +1,7 @@
 k8gb:
-  dnsZone: "test.k8gb.io" # dnsZone controlled by gslb
-  edgeDNSZone: "k8gb.io" # main zone which would contain gslb zone to delegate
+  dnsZones:
+    - loadBalancedZone: "test.k8gb.io" # -- dnsZone controlled by gslb
+      parentZone: "k8gb.io" # -- main zone which would contain gslb zone to delegate
   edgeDNSServer: "169.254.169.253" # external DNS server to be used for resolution
   clusterGeoTag: "us-east-1" # used for places where we need to distinguish between differnet Gslb instances
   extGslbClustersGeoTags: "eu-west-1" # comma-separated list of external gslb geo tags to pair with
diff --git a/docs/examples/route53/k8gb/k8gb-cluster-eu-west-1.yaml b/docs/examples/route53/k8gb/k8gb-cluster-eu-west-1.yaml
index d8f171c8a4..633d2028fd 100644
--- a/docs/examples/route53/k8gb/k8gb-cluster-eu-west-1.yaml
+++ b/docs/examples/route53/k8gb/k8gb-cluster-eu-west-1.yaml
@@ -1,6 +1,7 @@
 k8gb:
-  dnsZone: "test.k8gb.io" # dnsZone controlled by gslb
-  edgeDNSZone: "k8gb.io" # main zone which would contain gslb zone to delegate
+  dnsZones:
+    - loadBalancedZone: "test.k8gb.io" # -- dnsZone controlled by gslb
+      parentZone: "k8gb.io" # -- main zone which would contain gslb zone to delegate
   edgeDNSServer: "169.254.169.253" # use this DNS server as a main resolver to enable cross k8gb DNS based communication
   clusterGeoTag: "eu-west-1" # used for places where we need to distinguish between differnet Gslb instances
   extGslbClustersGeoTags: "us-east-1" # comma-separated list of external gslb geo tags to pair with
diff --git a/docs/examples/route53/k8gb/k8gb-cluster-us-east-1.yaml b/docs/examples/route53/k8gb/k8gb-cluster-us-east-1.yaml
index cda33d8468..07f2e372ed 100644
--- a/docs/examples/route53/k8gb/k8gb-cluster-us-east-1.yaml
+++ b/docs/examples/route53/k8gb/k8gb-cluster-us-east-1.yaml
@@ -1,6 +1,7 @@
 k8gb:
-  dnsZone: "test.k8gb.io" # dnsZone controlled by gslb
-  edgeDNSZone: "k8gb.io" # main zone which would contain gslb zone to delegate
+  dnsZones:
+    - loadBalancedZone: "test.k8gb.io" # -- dnsZone controlled by gslb
+      parentZone: "k8gb.io" # -- main zone which would contain gslb zone to delegate
   edgeDNSServer: "169.254.169.253" # use this DNS server as a main resolver to enable cross k8gb DNS based communication
   clusterGeoTag: "us-east-1" # used for places where we need to distinguish between differnet Gslb instances
   extGslbClustersGeoTags: "eu-west-1" # comma-separated list of external gslb geo tags to pair with
diff --git a/docs/examples/windowsdns/k8gb/aks1-helm-values.yaml b/docs/examples/windowsdns/k8gb/aks1-helm-values.yaml
index e95603545f..0d0e47e634 100644
--- a/docs/examples/windowsdns/k8gb/aks1-helm-values.yaml
+++ b/docs/examples/windowsdns/k8gb/aks1-helm-values.yaml
@@ -3,13 +3,12 @@ k8gb:
   deployCrds: true
   deployRbac: true
   # -- dns zone that will be managed by CoreDNS
-  dnsZone: "global.k8gb.local"
-  # -- Negative TTL for SOA record
-  dnsZoneNegTTL: 300
-  # -- main zone which would contain gslb zone to delegate
-  edgeDNSZone: "k8gb.local"
+  dnsZones:
+    - loadBalancedZone: "global.k8gb.local" # -- dnsZone controlled by gslb
+      parentZone: "k8gb.local" # -- main zone which would contain gslb zone to delegate
+      dnsZoneNegTTL: 300 # -- Negative TTL for SOA record
   # -- host/ip[:port] format is supported here where port defaults to 53
-  edgeDNSServers:
+  parentZoneDNSServers:
       # -- use this DNS server as a main resolver to enable cross k8gb DNS based communication
       - "10.10.0.6"
   # -- used for places where we need to distinguish between different Gslb instances
@@ -78,4 +77,4 @@ rfc2136:
       gssTsigCreds:
         - kerberos-username: k8gb
         - kerberos-password: asdfkuj#f8guh1
-        - kerberos-realm: k8gb.local
\ No newline at end of file
+        - kerberos-realm: k8gb.local
diff --git a/docs/examples/windowsdns/k8gb/aks2-helm-values.yaml b/docs/examples/windowsdns/k8gb/aks2-helm-values.yaml
index b2c373141c..5d204599f3 100644
--- a/docs/examples/windowsdns/k8gb/aks2-helm-values.yaml
+++ b/docs/examples/windowsdns/k8gb/aks2-helm-values.yaml
@@ -3,13 +3,12 @@ k8gb:
   deployCrds: true
   deployRbac: true
   # -- dns zone that will be managed by CoreDNS
-  dnsZone: "global.k8gb.local"
-  # -- Negative TTL for SOA record
-  dnsZoneNegTTL: 300
-  # -- main zone which would contain gslb zone to delegate
-  edgeDNSZone: "k8gb.local"
+  dnsZones:
+    - loadBalancedZone: "global.k8gb.local" # -- dnsZone controlled by gslb
+      parentZone: "k8gb.local" # -- main zone which would contain gslb zone to delegate
+      dnsZoneNegTTL: 300 # -- Negative TTL for SOA record
   # -- host/ip[:port] format is supported here where port defaults to 53
-  edgeDNSServers:
+  parentZoneDNSServers:
       # -- use this DNS server as a main resolver to enable cross k8gb DNS based communication
       - "10.10.0.6"
   # -- used for places where we need to distinguish between different Gslb instances
@@ -78,4 +77,4 @@ rfc2136:
       gssTsigCreds:
         - kerberos-username: k8gb
         - kerberos-password: asdfkuj#f8guh1
-        - kerberos-realm: K8GB.LOCAL
\ No newline at end of file
+        - kerberos-realm: K8GB.LOCAL
diff --git a/docs/rancher.md b/docs/rancher.md
index dcd32113bf..85b50b8ac7 100644
--- a/docs/rancher.md
+++ b/docs/rancher.md
@@ -21,9 +21,10 @@ helm:
   releaseName: k8gb
   values:
     k8gb:
-      dnsZone: global.fleet.clusterLabels.k8gb-dnsZone
-      edgeDNSZone: "cloud.example.com"
-      edgeDNSServers:
+      dnsZones:
+        - parentZone: cloud.example.com
+          loadBalancedZone: global.fleet.clusterLabels.k8gb-dnsZone
+      parentZoneDNSServers:
         - "1.2.3.4"
         - "5.6.7.8"
       clusterGeoTag: global.fleet.clusterLabels.k8gb-clusterGeoTag