diff --git a/src/main/java/org/springframework/data/neo4j/core/Neo4jTemplate.java b/src/main/java/org/springframework/data/neo4j/core/Neo4jTemplate.java
index a462a762b..3781d45b0 100644
--- a/src/main/java/org/springframework/data/neo4j/core/Neo4jTemplate.java
+++ b/src/main/java/org/springframework/data/neo4j/core/Neo4jTemplate.java
@@ -123,7 +123,7 @@ public final class Neo4jTemplate implements
 
 	private EventSupport eventSupport;
 
-	private ProjectionFactory projectionFactory;
+	private ProjectionFactory projectionFactoryf;
 
 	private Renderer renderer;
 
@@ -169,6 +169,11 @@ public final class Neo4jTemplate implements
 		this.neo4jMappingContext = neo4jMappingContext;
 		this.cypherGenerator = CypherGenerator.INSTANCE;
 		this.eventSupport = EventSupport.useExistingCallbacks(neo4jMappingContext, entityCallbacks);
+		this.renderer = Renderer.getDefaultRenderer();
+	}
+
+	ProjectionFactory getProjectionFactory() {
+		return Objects.requireNonNull(this.projectionFactoryf, "Projection support for the Neo4j template is only available when the template is a proper and fully initialized Spring bean.");
 	}
 
 	@Override
@@ -283,7 +288,7 @@ public final class Neo4jTemplate implements
 
 		if (resultType.isInterface()) {
 			return intermediaResults.stream()
-					.map(instance -> projectionFactory.createProjection(resultType, instance))
+					.map(instance -> getProjectionFactory().createProjection(resultType, instance))
 					.collect(Collectors.toList());
 		}
 
@@ -370,9 +375,10 @@ public final class Neo4jTemplate implements
 			return resultType.cast(save(instance));
 		}
 
-		ProjectionInformation projectionInformation = projectionFactory.getProjectionInformation(resultType);
+		ProjectionFactory localProjectionFactory = getProjectionFactory();
+		ProjectionInformation projectionInformation = localProjectionFactory.getProjectionInformation(resultType);
 		Collection<PropertyFilter.ProjectedPath> pps = PropertyFilterSupport.addPropertiesFrom(instance.getClass(), resultType,
-				projectionFactory, neo4jMappingContext);
+				localProjectionFactory, neo4jMappingContext);
 
 		T savedInstance = saveImpl(instance, pps, null);
 		if (!resultType.isInterface()) {
@@ -380,13 +386,13 @@ public final class Neo4jTemplate implements
 			return result;
 		}
 		if (projectionInformation.isClosed()) {
-			return projectionFactory.createProjection(resultType, savedInstance);
+			return localProjectionFactory.createProjection(resultType, savedInstance);
 		}
 
 		Neo4jPersistentEntity<?> entityMetaData = neo4jMappingContext.getRequiredPersistentEntity(savedInstance.getClass());
 		Neo4jPersistentProperty idProperty = entityMetaData.getIdProperty();
 		PersistentPropertyAccessor<T> propertyAccessor = entityMetaData.getPropertyAccessor(savedInstance);
-		return projectionFactory.createProjection(resultType,
+		return localProjectionFactory.createProjection(resultType,
 				this.findById(propertyAccessor.getProperty(idProperty), savedInstance.getClass()).get());
 	}
 
@@ -570,15 +576,16 @@ public final class Neo4jTemplate implements
 			return saveElements;
 		}
 
-		ProjectionInformation projectionInformation = projectionFactory.getProjectionInformation(resultType);
+		ProjectionFactory localProjectionFactory = getProjectionFactory();
+		ProjectionInformation projectionInformation = localProjectionFactory.getProjectionInformation(resultType);
 
 		Collection<PropertyFilter.ProjectedPath> pps = PropertyFilterSupport.addPropertiesFrom(commonElementType, resultType,
-				projectionFactory, neo4jMappingContext);
+				localProjectionFactory, neo4jMappingContext);
 
 		List<T> savedInstances = saveAllImpl(instances, pps, null);
 
 		if (projectionInformation.isClosed()) {
-			return savedInstances.stream().map(instance -> projectionFactory.createProjection(resultType, instance))
+			return savedInstances.stream().map(instance -> localProjectionFactory.createProjection(resultType, instance))
 					.collect(Collectors.toList());
 		}
 
@@ -591,7 +598,7 @@ public final class Neo4jTemplate implements
 		}).collect(Collectors.toList());
 
 		return findAllById(ids, commonElementType)
-				.stream().map(instance -> projectionFactory.createProjection(resultType, instance))
+				.stream().map(instance -> localProjectionFactory.createProjection(resultType, instance))
 				.collect(Collectors.toList());
 	}
 
@@ -1024,7 +1031,7 @@ public final class Neo4jTemplate implements
 		SpelAwareProxyProjectionFactory spelAwareProxyProjectionFactory = new SpelAwareProxyProjectionFactory();
 		spelAwareProxyProjectionFactory.setBeanClassLoader(beanClassLoader);
 		spelAwareProxyProjectionFactory.setBeanFactory(beanFactory);
-		this.projectionFactory = spelAwareProxyProjectionFactory;
+		this.projectionFactoryf = spelAwareProxyProjectionFactory;
 
 		Configuration cypherDslConfiguration = beanFactory
 				.getBeanProvider(Configuration.class)
@@ -1078,7 +1085,7 @@ public final class Neo4jTemplate implements
 		Class<?> resultType = TemplateSupport.findCommonElementType(instances);
 
 		Collection<PropertyFilter.ProjectedPath> pps = PropertyFilterSupport.addPropertiesFrom(domainType, resultType,
-				projectionFactory, neo4jMappingContext);
+				getProjectionFactory(), neo4jMappingContext);
 
 		NestedRelationshipProcessingStateMachine stateMachine = new NestedRelationshipProcessingStateMachine(neo4jMappingContext);
 		List<R> results = new ArrayList<>();
diff --git a/src/main/java/org/springframework/data/neo4j/core/ReactiveNeo4jTemplate.java b/src/main/java/org/springframework/data/neo4j/core/ReactiveNeo4jTemplate.java
index e26d23259..de4b932cd 100644
--- a/src/main/java/org/springframework/data/neo4j/core/ReactiveNeo4jTemplate.java
+++ b/src/main/java/org/springframework/data/neo4j/core/ReactiveNeo4jTemplate.java
@@ -150,6 +150,11 @@ public final class ReactiveNeo4jTemplate implements
 		this.neo4jMappingContext = neo4jMappingContext;
 		this.cypherGenerator = CypherGenerator.INSTANCE;
 		this.eventSupport = ReactiveEventSupport.useExistingCallbacks(neo4jMappingContext, ReactiveEntityCallbacks.create());
+		this.renderer = Renderer.getDefaultRenderer();
+	}
+
+	ProjectionFactory getProjectionFactory() {
+		return Objects.requireNonNull(this.projectionFactory, "Projection support for the Neo4j template is only available when the template is a proper and fully initialized Spring bean.");
 	}
 
 	@Override
@@ -264,7 +269,7 @@ public final class ReactiveNeo4jTemplate implements
 		}
 
 		if (resultType.isInterface()) {
-			return intermediaResults.map(instance -> projectionFactory.createProjection(resultType, instance));
+			return intermediaResults.map(instance -> getProjectionFactory().createProjection(resultType, instance));
 		}
 
 		DtoInstantiatingConverter converter = new DtoInstantiatingConverter(resultType, neo4jMappingContext);
@@ -355,9 +360,10 @@ public final class ReactiveNeo4jTemplate implements
 			return save(instance).map(resultType::cast);
 		}
 
-		ProjectionInformation projectionInformation = projectionFactory.getProjectionInformation(resultType);
+		ProjectionFactory localProjectionFactory = getProjectionFactory();
+		ProjectionInformation projectionInformation = localProjectionFactory.getProjectionInformation(resultType);
 		Collection<PropertyFilter.ProjectedPath> pps = PropertyFilterSupport.addPropertiesFrom(instance.getClass(), resultType,
-				projectionFactory, neo4jMappingContext);
+				localProjectionFactory, neo4jMappingContext);
 
 		Mono<T> savingPublisher = saveImpl(instance, pps, null);
 
@@ -369,7 +375,7 @@ public final class ReactiveNeo4jTemplate implements
 			});
 		}
 		if (projectionInformation.isClosed()) {
-			return savingPublisher.map(savedInstance -> projectionFactory.createProjection(resultType, savedInstance));
+			return savingPublisher.map(savedInstance -> localProjectionFactory.createProjection(resultType, savedInstance));
 		}
 
 		return savingPublisher.flatMap(savedInstance -> {
@@ -378,7 +384,7 @@ public final class ReactiveNeo4jTemplate implements
 			Neo4jPersistentProperty idProperty = entityMetaData.getIdProperty();
 			PersistentPropertyAccessor<T> propertyAccessor = entityMetaData.getPropertyAccessor(savedInstance);
 			return this.findById(propertyAccessor.getProperty(idProperty), savedInstance.getClass())
-					.map(loadedValue -> projectionFactory.createProjection(resultType, loadedValue));
+					.map(loadedValue -> localProjectionFactory.createProjection(resultType, loadedValue));
 		});
 	}
 
@@ -391,7 +397,7 @@ public final class ReactiveNeo4jTemplate implements
 		Class<?> resultType = TemplateSupport.findCommonElementType(instances);
 
 		Collection<PropertyFilter.ProjectedPath> pps = PropertyFilterSupport.addPropertiesFrom(domainType, resultType,
-				projectionFactory, neo4jMappingContext);
+				getProjectionFactory(), neo4jMappingContext);
 
 		NestedRelationshipProcessingStateMachine stateMachine = new NestedRelationshipProcessingStateMachine(neo4jMappingContext);
 		EntityFromDtoInstantiatingConverter<T> converter = new EntityFromDtoInstantiatingConverter<>(domainType, neo4jMappingContext);
@@ -515,13 +521,14 @@ public final class ReactiveNeo4jTemplate implements
 			return saveAll(instances).map(resultType::cast);
 		}
 
-		ProjectionInformation projectionInformation = projectionFactory.getProjectionInformation(resultType);
+		ProjectionFactory localProjectionFactory = getProjectionFactory();
+		ProjectionInformation projectionInformation = localProjectionFactory.getProjectionInformation(resultType);
 		Collection<PropertyFilter.ProjectedPath> pps = PropertyFilterSupport.addPropertiesFrom(commonElementType, resultType,
-				projectionFactory, neo4jMappingContext);
+				localProjectionFactory, neo4jMappingContext);
 
 		Flux<T> savedInstances = saveAllImpl(instances, pps, null);
 		if (projectionInformation.isClosed()) {
-			return savedInstances.map(instance -> projectionFactory.createProjection(resultType, instance));
+			return savedInstances.map(instance -> localProjectionFactory.createProjection(resultType, instance));
 		}
 
 		Neo4jPersistentEntity<?> entityMetaData = neo4jMappingContext.getRequiredPersistentEntity(commonElementType);
@@ -530,7 +537,7 @@ public final class ReactiveNeo4jTemplate implements
 		return savedInstances.flatMap(savedInstance -> {
 			PersistentPropertyAccessor<T> propertyAccessor = entityMetaData.getPropertyAccessor(savedInstance);
 			return findById(propertyAccessor.getProperty(idProperty), commonElementType);
-		}).map(instance -> projectionFactory.createProjection(resultType, instance));
+		}).map(instance -> localProjectionFactory.createProjection(resultType, instance));
 	}
 
 	private <T> Flux<T> saveAllImpl(Iterable<T> instances, @Nullable Collection<PropertyFilter.ProjectedPath> includedProperties, @Nullable BiPredicate<PropertyPath, Neo4jPersistentProperty> includeProperty) {