diff --git a/pkg/controllers/follower/controller.go b/pkg/controllers/follower/controller.go
index 6bc3969b..4c96e422 100644
--- a/pkg/controllers/follower/controller.go
+++ b/pkg/controllers/follower/controller.go
@@ -64,16 +64,16 @@ const (
 )
 
 var (
-	// Map from supported leader type to pod template path.
+	// Map from supported leader type to pod spec path.
 	// TODO: think about whether PodTemplatePath/PodSpecPath should be specified in the FTC instead.
 	// Specifying in the FTC allows changing the path according to the api version.
 	// Other controllers should consider using the specified paths instead of hardcoded paths.
-	leaderPodTemplatePaths = map[schema.GroupKind]string{
-		{Group: appsv1.GroupName, Kind: common.DeploymentKind}:  "spec.template",
-		{Group: appsv1.GroupName, Kind: common.StatefulSetKind}: "spec.template",
-		{Group: appsv1.GroupName, Kind: common.DaemonSetKind}:   "spec.template",
-		{Group: batchv1.GroupName, Kind: common.JobKind}:        "spec.template",
-		{Group: batchv1.GroupName, Kind: common.CronJobKind}:    "spec.jobTemplate.spec.template",
+	leaderPodSpecPaths = map[schema.GroupKind]string{
+		{Group: appsv1.GroupName, Kind: common.DeploymentKind}:  "spec.template.spec",
+		{Group: appsv1.GroupName, Kind: common.StatefulSetKind}: "spec.template.spec",
+		{Group: appsv1.GroupName, Kind: common.DaemonSetKind}:   "spec.template.spec",
+		{Group: batchv1.GroupName, Kind: common.JobKind}:        "spec.template.spec",
+		{Group: batchv1.GroupName, Kind: common.CronJobKind}:    "spec.jobTemplate.spec.template.spec",
 		{Group: "", Kind: common.PodKind}:                       "spec",
 	}
 
@@ -202,7 +202,7 @@ func NewFollowerController(
 		targetGK := schema.GroupKind{Group: targetType.Group, Kind: targetType.Kind}
 		federatedGK := schema.GroupKind{Group: federatedType.Group, Kind: federatedType.Kind}
 
-		if _, exists := leaderPodTemplatePaths[targetGK]; exists {
+		if _, exists := leaderPodSpecPaths[targetGK]; exists {
 			handles := getHandles(ftc, "leader", c.reconcileLeader)
 			c.sourceToFederatedGKMap[targetGK] = federatedGK
 			c.leaderTypeHandles[federatedGK] = handles
@@ -365,16 +365,16 @@ func (c *Controller) inferFollowers(
 		return nil, err
 	}
 
-	followersFromPodTemplate, err := getFollowersFromPodTemplate(
+	followersFromPodSpec, err := getFollowersFromPodSpec(
 		fedObj,
-		leaderPodTemplatePaths[handles.sourceGK],
+		leaderPodSpecPaths[handles.sourceGK],
 		c.sourceToFederatedGKMap,
 	)
 	if err != nil {
 		return nil, err
 	}
 
-	return followersFromAnnotation.Union(followersFromPodTemplate), err
+	return followersFromAnnotation.Union(followersFromPodSpec), err
 }
 
 func (c *Controller) updateFollower(
diff --git a/pkg/controllers/follower/util.go b/pkg/controllers/follower/util.go
index db356ac7..d6a0a671 100644
--- a/pkg/controllers/follower/util.go
+++ b/pkg/controllers/follower/util.go
@@ -77,12 +77,12 @@ func getFollowersFromAnnotation(
 	return followers, nil
 }
 
-func getFollowersFromPodTemplate(
+func getFollowersFromPodSpec(
 	fedObject *unstructured.Unstructured,
-	podTemplatePath string,
+	podSpecPath string,
 	sourceToFederatedGKMap map[schema.GroupKind]schema.GroupKind,
 ) (sets.Set[FollowerReference], error) {
-	podSpec, err := getPodSpec(fedObject, podTemplatePath)
+	podSpec, err := getPodSpec(fedObject, podSpecPath)
 	if err != nil {
 		return nil, err
 	}
@@ -148,23 +148,23 @@ func getFollowersFromPod(
 	return followers
 }
 
-func getPodSpec(fedObject *unstructured.Unstructured, podTemplatePath string) (*corev1.PodSpec, error) {
+func getPodSpec(fedObject *unstructured.Unstructured, podSpecPath string) (*corev1.PodSpec, error) {
 	if fedObject == nil {
 		return nil, fmt.Errorf("fedObject is nil")
 	}
-	fedObjectPodTemplatePath := append(
+	fedObjectPodSpecPath := append(
 		[]string{common.SpecField, common.TemplateField},
-		strings.Split(podTemplatePath, ".")...)
-	podTemplateMap, found, err := unstructured.NestedMap(fedObject.Object, fedObjectPodTemplatePath...)
+		strings.Split(podSpecPath, ".")...)
+	podSpecMap, found, err := unstructured.NestedMap(fedObject.Object, fedObjectPodSpecPath...)
 	if err != nil {
 		return nil, err
 	}
 	if !found {
-		return nil, fmt.Errorf("pod template does not exist at path %q", podTemplatePath)
+		return nil, fmt.Errorf("pod spec does not exist at path %q", podSpecPath)
 	}
-	podTemplate := &corev1.PodTemplateSpec{}
-	if err := runtime.DefaultUnstructuredConverter.FromUnstructured(podTemplateMap, podTemplate); err != nil {
+	podSpec := &corev1.PodSpec{}
+	if err := runtime.DefaultUnstructuredConverter.FromUnstructured(podSpecMap, podSpec); err != nil {
 		return nil, err
 	}
-	return &podTemplate.Spec, nil
+	return podSpec, nil
 }