diff --git a/Classes/Command/NodeTemplateCommandController.php b/Classes/Application/Command/NodeTemplateCommandController.php
similarity index 91%
rename from Classes/Command/NodeTemplateCommandController.php
rename to Classes/Application/Command/NodeTemplateCommandController.php
index d30c82c..4cefd74 100644
--- a/Classes/Command/NodeTemplateCommandController.php
+++ b/Classes/Application/Command/NodeTemplateCommandController.php
@@ -2,9 +2,9 @@
 
 declare(strict_types=1);
 
-namespace Flowpack\NodeTemplates\Command;
+namespace Flowpack\NodeTemplates\Application\Command;
 
-use Flowpack\NodeTemplates\NodeTemplateDumper\NodeTemplateDumper;
+use Flowpack\NodeTemplates\Domain\NodeTemplateDumper\NodeTemplateDumper;
 use Neos\Flow\Annotations as Flow;
 use Neos\Flow\Cli\CommandController;
 use Neos\Neos\Domain\Service\ContentContextFactory;
diff --git a/Classes/Domain/DelegatingDocumentTitleNodeCreationHandler.php b/Classes/Domain/DelegatingDocumentTitleNodeCreationHandler.php
new file mode 100644
index 0000000..2dda3e8
--- /dev/null
+++ b/Classes/Domain/DelegatingDocumentTitleNodeCreationHandler.php
@@ -0,0 +1,43 @@
+<?php
+declare(strict_types=1);
+
+namespace Flowpack\NodeTemplates\Domain;
+
+use Neos\ContentRepository\Domain\Model\NodeInterface;
+use Neos\Flow\Annotations as Flow;
+use Neos\Neos\Ui\NodeCreationHandler\DocumentTitleNodeCreationHandler;
+use Neos\Neos\Ui\NodeCreationHandler\NodeCreationHandlerInterface;
+
+/**
+ * Augments the original neos ui document title node creation handler, which takes care of setting the "uriPathSegment" based of the title.
+ * This handler steps in when a node has a node template with the property `uriPathSegment`.
+ * In this case we will prevent the original handler from being called, as we handle setting the `uriPathSegment` ourselves and the original handler will just override our `uriPathSegment` again.
+ *
+ * @todo once we have sorting with https://github.com/neos/neos-ui/pull/3511 we can put our handler at the end instead.
+ */
+class DelegatingDocumentTitleNodeCreationHandler implements NodeCreationHandlerInterface
+{
+    /**
+     * @Flow\Inject
+     * @var DocumentTitleNodeCreationHandler
+     */
+    protected $originalDocumentTitleNodeCreationHandler;
+
+    /**
+     * @throws \Neos\Eel\Exception
+     * @throws \Neos\Neos\Exception
+     */
+    public function handle(NodeInterface $node, array $data): void
+    {
+        $template = $node->getNodeType()->getOptions()['template'] ?? null;
+        if (
+            !$template
+            || !isset($template['properties']['uriPathSegment'])
+        ) {
+            $this->originalDocumentTitleNodeCreationHandler->handle($node, $data);
+            return;
+        }
+
+        // do nothing, as we handle this already when applying the template
+    }
+}
diff --git a/Classes/Domain/ExceptionHandling/CaughtException.php b/Classes/Domain/ExceptionHandling/CaughtException.php
new file mode 100644
index 0000000..7a12c85
--- /dev/null
+++ b/Classes/Domain/ExceptionHandling/CaughtException.php
@@ -0,0 +1,71 @@
+<?php
+
+namespace Flowpack\NodeTemplates\Domain\ExceptionHandling;
+
+
+use Neos\Flow\Annotations as Flow;
+
+/**
+ * @Flow\Proxy(false)
+ */
+class CaughtException
+{
+    private \Throwable $exception;
+
+    private ?string $origin;
+
+    private function __construct(\Throwable $exception, ?string $origin)
+    {
+        $this->exception = $exception;
+        $this->origin = $origin;
+    }
+
+    public static function fromException(\Throwable $exception): self
+    {
+        return new self($exception, null);
+    }
+
+    public function withOrigin(string $origin): self
+    {
+        return new self($this->exception, $origin);
+    }
+
+    public function getException(): \Throwable
+    {
+        return $this->exception;
+    }
+
+    public function getOrigin(): ?string
+    {
+        return $this->origin;
+    }
+
+    public function toMessage(): string
+    {
+        $messageLines = [];
+
+        if ($this->origin) {
+            $messageLines[] = $this->origin;
+        }
+
+        $level = 0;
+        $exception = $this->exception;
+        do {
+            $level++;
+            if ($level >= 8) {
+                $messageLines[] = '...Recursion';
+                break;
+            }
+
+            $reflexception = new \ReflectionClass($exception);
+            $shortExceptionName = $reflexception->getShortName();
+            if ($shortExceptionName === 'Exception') {
+                $secondPartOfPackageName = explode('\\', $reflexception->getNamespaceName())[1] ?? '';
+                $shortExceptionName = $secondPartOfPackageName . $shortExceptionName;
+            }
+            $messageLines[] = sprintf('%s(%s, %s)', $shortExceptionName, $exception->getMessage(), $exception->getCode());
+        } while ($exception = $exception->getPrevious());
+
+        return join(' | ', $messageLines);
+    }
+}
diff --git a/Classes/Domain/ExceptionHandling/CaughtExceptions.php b/Classes/Domain/ExceptionHandling/CaughtExceptions.php
new file mode 100644
index 0000000..7710bec
--- /dev/null
+++ b/Classes/Domain/ExceptionHandling/CaughtExceptions.php
@@ -0,0 +1,45 @@
+<?php
+
+namespace Flowpack\NodeTemplates\Domain\ExceptionHandling;
+
+use Flowpack\NodeTemplates\Domain\ExceptionHandling\CaughtException;
+use Neos\Flow\Annotations as Flow;
+
+/** @Flow\Proxy(false) */
+class CaughtExceptions implements \IteratorAggregate
+{
+    /** @var array<int, CaughtException> */
+    private array $exceptions = [];
+
+    private function __construct()
+    {
+    }
+
+    public static function create(): self
+    {
+        return new self();
+    }
+
+    public function hasExceptions(): bool
+    {
+        return $this->exceptions !== [];
+    }
+
+    public function add(CaughtException $exception): void
+    {
+        $this->exceptions[] = $exception;
+    }
+
+    public function first(): ?CaughtException
+    {
+        return $this->exceptions[0] ?? null;
+    }
+
+    /**
+     * @return \Traversable<int, CaughtException>|CaughtException[]
+     */
+    public function getIterator()
+    {
+        yield from $this->exceptions;
+    }
+}
diff --git a/Classes/Domain/ExceptionHandling/ExceptionHandler.php b/Classes/Domain/ExceptionHandling/ExceptionHandler.php
new file mode 100644
index 0000000..5fff117
--- /dev/null
+++ b/Classes/Domain/ExceptionHandling/ExceptionHandler.php
@@ -0,0 +1,107 @@
+<?php
+
+namespace Flowpack\NodeTemplates\Domain\ExceptionHandling;
+
+use Neos\ContentRepository\Domain\Model\NodeInterface;
+use Neos\Flow\Annotations as Flow;
+use Neos\Flow\Log\ThrowableStorageInterface;
+use Neos\Flow\Log\Utility\LogEnvironment;
+use Neos\Neos\Ui\Domain\Model\Feedback\Messages\Error;
+use Neos\Neos\Ui\Domain\Model\FeedbackCollection;
+use Psr\Log\LoggerInterface;
+
+class ExceptionHandler
+{
+    /**
+     * @var FeedbackCollection
+     * @Flow\Inject(lazy=false)
+     */
+    protected $feedbackCollection;
+
+    /**
+     * @var LoggerInterface
+     * @Flow\Inject
+     */
+    protected $logger;
+
+    /**
+     * @var ThrowableStorageInterface
+     * @Flow\Inject
+     */
+    protected $throwableStorage;
+
+    /**
+     * @var ExceptionHandlingConfiguration
+     * @Flow\Inject
+     */
+    protected $configuration;
+
+    public function handleAfterTemplateConfigurationProcessing(CaughtExceptions $caughtExceptions, NodeInterface $node): void
+    {
+        if (!$caughtExceptions->hasExceptions()) {
+            return;
+        }
+
+        if (!$this->configuration->shouldStopOnExceptionAfterTemplateConfigurationProcessing()) {
+            return;
+        }
+
+        $templateNotCreatedException = new TemplateNotCreatedException(
+            sprintf('Template for "%s" was not applied. Only %s was created.', $node->getNodeType()->getLabel(), (string)$node),
+            1686135532992,
+            $caughtExceptions->first()->getException(),
+        );
+
+        $this->logCaughtExceptions($caughtExceptions, $templateNotCreatedException);
+
+        throw $templateNotCreatedException;
+    }
+
+    public function handleAfterNodeCreation(CaughtExceptions $caughtExceptions, NodeInterface $node): void
+    {
+        if (!$caughtExceptions->hasExceptions()) {
+            return;
+        }
+
+        $templatePartiallyCreatedException = new TemplatePartiallyCreatedException(
+            sprintf('Template for "%s" only partially applied. Please check the newly created nodes beneath %s.', $node->getNodeType()->getLabel(), (string)$node),
+            1686135564160,
+            $caughtExceptions->first()->getException(),
+        );
+
+        $this->logCaughtExceptions($caughtExceptions, $templatePartiallyCreatedException);
+
+        throw $templatePartiallyCreatedException;
+    }
+
+    /**
+     * @param TemplateNotCreatedException|TemplatePartiallyCreatedException $templateCreationException
+     */
+    private function logCaughtExceptions(CaughtExceptions $caughtExceptions, \DomainException $templateCreationException): void
+    {
+        $messages = [];
+        foreach ($caughtExceptions as $index => $caughtException) {
+            $messages[sprintf('CaughtException (%s)', $index)] = $caughtException->toMessage();
+        }
+
+        // log exception
+        $messageWithReference = $this->throwableStorage->logThrowable($templateCreationException, $messages);
+        $this->logger->warning($messageWithReference, LogEnvironment::fromMethodName(__METHOD__));
+
+        // neos ui logging
+        $nodeTemplateError = new Error();
+        $nodeTemplateError->setMessage($templateCreationException->getMessage());
+
+        $this->feedbackCollection->add(
+            $nodeTemplateError
+        );
+
+        foreach ($messages as $message) {
+            $error = new Error();
+            $error->setMessage($message);
+            $this->feedbackCollection->add(
+                $error
+            );
+        }
+    }
+}
diff --git a/Classes/Domain/ExceptionHandling/ExceptionHandlingConfiguration.php b/Classes/Domain/ExceptionHandling/ExceptionHandlingConfiguration.php
new file mode 100644
index 0000000..bbd29c5
--- /dev/null
+++ b/Classes/Domain/ExceptionHandling/ExceptionHandlingConfiguration.php
@@ -0,0 +1,18 @@
+<?php
+
+namespace Flowpack\NodeTemplates\Domain\ExceptionHandling;
+
+use Neos\Flow\Annotations as Flow;
+
+class ExceptionHandlingConfiguration
+{
+    /**
+     * @Flow\InjectConfiguration(package="Flowpack.NodeTemplates", path="exceptionHandling")
+     */
+    protected array $exceptionHandlingConfiguration;
+
+    public function shouldStopOnExceptionAfterTemplateConfigurationProcessing(): bool
+    {
+        return $this->exceptionHandlingConfiguration['templateConfigurationProcessing']['stopOnException'] ?? false;
+    }
+}
diff --git a/Classes/Domain/ExceptionHandling/TemplateNotCreatedException.php b/Classes/Domain/ExceptionHandling/TemplateNotCreatedException.php
new file mode 100644
index 0000000..5922a1f
--- /dev/null
+++ b/Classes/Domain/ExceptionHandling/TemplateNotCreatedException.php
@@ -0,0 +1,11 @@
+<?php
+
+namespace Flowpack\NodeTemplates\Domain\ExceptionHandling;
+
+/**
+ * Thrown if the templateConfigurationProcessing was unsuccessful (due to an invalid EEL expression f.x),
+ * and the {@see ExceptionHandlingConfiguration} is configured not to continue
+ */
+class TemplateNotCreatedException extends \DomainException
+{
+}
diff --git a/Classes/Domain/ExceptionHandling/TemplatePartiallyCreatedException.php b/Classes/Domain/ExceptionHandling/TemplatePartiallyCreatedException.php
new file mode 100644
index 0000000..a3c4ce4
--- /dev/null
+++ b/Classes/Domain/ExceptionHandling/TemplatePartiallyCreatedException.php
@@ -0,0 +1,12 @@
+<?php
+
+namespace Flowpack\NodeTemplates\Domain\ExceptionHandling;
+
+/**
+ * Thrown in the following cases:
+ * - the templateConfigurationProcessing was unsuccessful (due to an invalid EEL expression f.x)
+ * - the nodeCreation was unsuccessful (f.x. due to constrains from the cr)
+ */
+class TemplatePartiallyCreatedException extends \DomainException
+{
+}
diff --git a/Classes/Domain/NodeCreation/NodeCreationService.php b/Classes/Domain/NodeCreation/NodeCreationService.php
new file mode 100644
index 0000000..a0aafee
--- /dev/null
+++ b/Classes/Domain/NodeCreation/NodeCreationService.php
@@ -0,0 +1,135 @@
+<?php
+
+namespace Flowpack\NodeTemplates\Domain\NodeCreation;
+
+use Flowpack\NodeTemplates\Domain\ExceptionHandling\CaughtException;
+use Flowpack\NodeTemplates\Domain\ExceptionHandling\CaughtExceptions;
+use Flowpack\NodeTemplates\Domain\Template\RootTemplate;
+use Flowpack\NodeTemplates\Domain\Template\Template;
+use Flowpack\NodeTemplates\Domain\Template\Templates;
+use Neos\ContentRepository\Domain\Model\NodeInterface;
+use Neos\ContentRepository\Domain\Service\NodeTypeManager;
+use Neos\ContentRepository\Exception\NodeConstraintException;
+use Neos\Flow\Annotations as Flow;
+use Neos\Neos\Service\NodeOperations;
+use Neos\Neos\Utility\NodeUriPathSegmentGenerator;
+
+class NodeCreationService
+{
+    /**
+     * @var NodeOperations
+     * @Flow\Inject
+     */
+    protected $nodeOperations;
+
+    /**
+     * @var NodeTypeManager
+     * @Flow\Inject
+     */
+    protected $nodeTypeManager;
+
+    /**
+     * @Flow\Inject
+     * @var NodeUriPathSegmentGenerator
+     */
+    protected $nodeUriPathSegmentGenerator;
+
+    /**
+     * Applies the root template and its descending configured child node templates on the given node.
+     * @throws \InvalidArgumentException
+     */
+    public function apply(RootTemplate $template, NodeInterface $node, CaughtExceptions $caughtExceptions): void
+    {
+        $nodeType = $node->getNodeType();
+        $propertiesAndReferences = PropertiesAndReferences::createFromArrayAndTypeDeclarations($template->getProperties(), $nodeType);
+
+        // set properties
+        foreach ($propertiesAndReferences->requireValidProperties($nodeType, $caughtExceptions) as $key => $value) {
+            $node->setProperty($key, $value);
+        }
+
+        // set references
+        foreach ($propertiesAndReferences->requireValidReferences($nodeType, $node->getContext(), $caughtExceptions) as $key => $value) {
+            $node->setProperty($key, $value);
+        }
+
+        $this->ensureNodeHasUriPathSegment($node, $template);
+        $this->applyTemplateRecursively($template->getChildNodes(), $node, $caughtExceptions);
+    }
+
+    private function applyTemplateRecursively(Templates $templates, NodeInterface $parentNode, CaughtExceptions $caughtExceptions): void
+    {
+        foreach ($templates as $template) {
+            if ($template->getName() && $parentNode->getNodeType()->hasAutoCreatedChildNode($template->getName())) {
+                $node = $parentNode->getNode($template->getName()->__toString());
+                if ($template->getType() !== null) {
+                    $caughtExceptions->add(
+                        CaughtException::fromException(new \RuntimeException(sprintf('Template cant mutate type of auto created child nodes. Got: "%s"', $template->getType()->getValue()), 1685999829307))
+                    );
+                    // we continue processing the node
+                }
+            } else {
+                if ($template->getType() === null) {
+                    $caughtExceptions->add(
+                        CaughtException::fromException(new \RuntimeException(sprintf('Template requires type to be set for non auto created child nodes.'), 1685999829307))
+                    );
+                    continue;
+                }
+                if (!$this->nodeTypeManager->hasNodeType($template->getType()->getValue())) {
+                    $caughtExceptions->add(
+                        CaughtException::fromException(new \RuntimeException(sprintf('Template requires type to be a valid NodeType. Got: "%s".', $template->getType()->getValue()), 1685999795564))
+                    );
+                    continue;
+                }
+                try {
+                    $node = $this->nodeOperations->create(
+                        $parentNode,
+                        [
+                            'nodeType' => $template->getType()->getValue(),
+                            'nodeName' => $template->getName() ? $template->getName()->__toString() : null
+                        ],
+                        'into'
+                    );
+                } catch (NodeConstraintException $nodeConstraintException) {
+                    $caughtExceptions->add(
+                        CaughtException::fromException($nodeConstraintException)
+                    );
+                    continue; // try the next childNode
+                }
+            }
+            $nodeType = $node->getNodeType();
+            $propertiesAndReferences = PropertiesAndReferences::createFromArrayAndTypeDeclarations($template->getProperties(), $nodeType);
+
+            // set properties
+            foreach ($propertiesAndReferences->requireValidProperties($nodeType, $caughtExceptions) as $key => $value) {
+                $node->setProperty($key, $value);
+            }
+
+            // set references
+            foreach ($propertiesAndReferences->requireValidReferences($nodeType, $node->getContext(), $caughtExceptions) as $key => $value) {
+                $node->setProperty($key, $value);
+            }
+
+            $this->ensureNodeHasUriPathSegment($node, $template);
+            $this->applyTemplateRecursively($template->getChildNodes(), $node, $caughtExceptions);
+        }
+    }
+
+    /**
+     * All document node types get a uri path segment; if it is not explicitly set in the properties,
+     * it should be built based on the title property
+     *
+     * @param Template|RootTemplate $template
+     */
+    private function ensureNodeHasUriPathSegment(NodeInterface $node, $template)
+    {
+        if (!$node->getNodeType()->isOfType('Neos.Neos:Document')) {
+            return;
+        }
+        $properties = $template->getProperties();
+        if (isset($properties['uriPathSegment'])) {
+            return;
+        }
+        $node->setProperty('uriPathSegment', $this->nodeUriPathSegmentGenerator->generateUriPathSegment($node, $properties['title'] ?? null));
+    }
+}
diff --git a/Classes/Domain/NodeCreation/PropertiesAndReferences.php b/Classes/Domain/NodeCreation/PropertiesAndReferences.php
new file mode 100644
index 0000000..fd26a2b
--- /dev/null
+++ b/Classes/Domain/NodeCreation/PropertiesAndReferences.php
@@ -0,0 +1,129 @@
+<?php
+
+namespace Flowpack\NodeTemplates\Domain\NodeCreation;
+
+use Flowpack\NodeTemplates\Domain\ExceptionHandling\CaughtException;
+use Flowpack\NodeTemplates\Domain\ExceptionHandling\CaughtExceptions;
+use Neos\ContentRepository\Domain\Model\NodeType;
+use Neos\ContentRepository\Domain\Service\Context;
+use Neos\Flow\Annotations as Flow;
+
+/**
+ * @Flow\Proxy(false)
+ */
+class PropertiesAndReferences
+{
+    private array $properties;
+
+    private array $references;
+
+    private function __construct(array $properties, array $references)
+    {
+        $this->properties = $properties;
+        $this->references = $references;
+    }
+
+    public static function createFromArrayAndTypeDeclarations(array $propertiesAndReferences, NodeType $nodeType): self
+    {
+        $references = [];
+        $properties = [];
+        foreach ($propertiesAndReferences as $propertyName => $propertyValue) {
+            $declaration = $nodeType->getPropertyType($propertyName);
+            if ($declaration === 'reference' || $declaration === 'references') {
+                $references[$propertyName] = $propertyValue;
+                continue;
+            }
+            $properties[$propertyName] = $propertyValue;
+        }
+        return new self($properties, $references);
+    }
+
+    /**
+     * A few checks are run against the properties before they are applied on the node.
+     *
+     * 1. It is checked, that only properties will be set, that were declared in the NodeType
+     *
+     * 2. In case the property is a select-box, it is checked, that the current value is a valid option of the select-box
+     *
+     * 3. It is made sure is that a property value is not null when there is a default value:
+     *  In case that due to a condition in the nodeTemplate `null` is assigned to a node property, it will override the defaultValue.
+     *  This is a problem, as setting `null` might not be possible via the Neos UI and the Fusion rendering is most likely not going to handle this edge case.
+     *  Related discussion {@link https://github.com/Flowpack/Flowpack.NodeTemplates/issues/41}
+     */
+    public function requireValidProperties(NodeType $nodeType, CaughtExceptions $caughtExceptions): array
+    {
+        $validProperties = [];
+        foreach ($this->properties as $propertyName => $propertyValue) {
+            try {
+                $this->assertValidPropertyName($propertyName);
+                if (!isset($nodeType->getProperties()[$propertyName])) {
+                    throw new PropertyIgnoredException(
+                        sprintf(
+                            'Because property is not declared in NodeType. Got value `%s`.',
+                            json_encode($propertyValue)
+                        ),
+                        1685869035209
+                    );
+                }
+                $propertyType = PropertyType::fromPropertyOfNodeType($propertyName, $nodeType);
+                if (!$propertyType->isMatchedBy($propertyValue)) {
+                    throw new PropertyIgnoredException(
+                        sprintf(
+                            'Because value `%s` is not assignable to property type "%s".',
+                            json_encode($propertyValue),
+                            $propertyType->getValue()
+                        ),
+                        1685958105644
+                    );
+                }
+                $validProperties[$propertyName] = $propertyValue;
+            } catch (PropertyIgnoredException $propertyNotSetException) {
+                $caughtExceptions->add(
+                    CaughtException::fromException($propertyNotSetException)->withOrigin(sprintf('Property "%s" in NodeType "%s"', $propertyName, $nodeType->getName()))
+                );
+            }
+        }
+        return $validProperties;
+    }
+
+    public function requireValidReferences(NodeType $nodeType, Context $subgraph, CaughtExceptions $caughtExceptions): array
+    {
+        $validReferences = [];
+        foreach ($this->references as $referenceName => $referenceValue) {
+            $referenceType = ReferenceType::fromPropertyOfNodeType($referenceName, $nodeType);
+            if (!$referenceType->isMatchedBy($referenceValue, $subgraph)) {
+                $caughtExceptions->add(CaughtException::fromException(new \RuntimeException(
+                    sprintf(
+                        'Reference could not be set, because node reference(s) %s cannot be resolved.',
+                        json_encode($referenceValue)
+                    ),
+                    1685958176560
+                ))->withOrigin(sprintf('Reference "%s" in NodeType "%s"', $referenceName, $nodeType->getName())));
+                continue;
+            }
+            $validReferences[$referenceName] = $referenceValue;
+        }
+        return $validReferences;
+    }
+
+    /**
+     * In the old CR, it was common practice to set internal or meta properties via this syntax: `_hidden` but we don't allow this anymore.
+     * @throws PropertyIgnoredException
+     */
+    private function assertValidPropertyName($propertyName): void
+    {
+        $legacyInternalProperties = ['_accessRoles', '_contentObject', '_hidden', '_hiddenAfterDateTime', '_hiddenBeforeDateTime', '_hiddenInIndex',
+            '_index', '_name', '_nodeType', '_removed', '_workspace'];
+        if (!is_string($propertyName) || $propertyName === '') {
+            throw new PropertyIgnoredException(sprintf('Because property name must be a non empty string. Got "%s".', $propertyName), 1686149518395);
+        }
+        if ($propertyName[0] === '_') {
+            $lowerPropertyName = strtolower($propertyName);
+            foreach ($legacyInternalProperties as $legacyInternalProperty) {
+                if ($lowerPropertyName === strtolower($legacyInternalProperty)) {
+                    throw new PropertyIgnoredException(sprintf('Because internal legacy property "%s" not implement.', $propertyName), 1686149513158);
+                }
+            }
+        }
+    }
+}
diff --git a/Classes/Domain/NodeCreation/PropertyIgnoredException.php b/Classes/Domain/NodeCreation/PropertyIgnoredException.php
new file mode 100644
index 0000000..a6180ad
--- /dev/null
+++ b/Classes/Domain/NodeCreation/PropertyIgnoredException.php
@@ -0,0 +1,7 @@
+<?php
+
+namespace Flowpack\NodeTemplates\Domain\NodeCreation;
+
+class PropertyIgnoredException extends \RuntimeException
+{
+}
diff --git a/Classes/Domain/NodeCreation/PropertyType.php b/Classes/Domain/NodeCreation/PropertyType.php
new file mode 100644
index 0000000..fe0e4af
--- /dev/null
+++ b/Classes/Domain/NodeCreation/PropertyType.php
@@ -0,0 +1,237 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flowpack\NodeTemplates\Domain\NodeCreation;
+
+use GuzzleHttp\Psr7\Uri;
+use Neos\ContentRepository\Domain\Model\NodeType;
+use Neos\Flow\Annotations as Flow;
+use Psr\Http\Message\UriInterface;
+
+/**
+ * The property type value object as declared in a NodeType
+ *
+ * Implementation copied and adjusted (experimental nullable handling was removed) from {@see \Neos\ContentRepository\Core\Infrastructure\Property\PropertyType}
+ * {@link https://github.com/neos/neos-development-collection/blob/31cb00aa0bb513c9e8878807a0de23772f50d992/Neos.ContentRepository.Core/Classes/Infrastructure/Property/PropertyType.php#L30}
+ *
+ * @Flow\Proxy(false)
+ */
+final class PropertyType
+{
+    public const TYPE_BOOL = 'boolean';
+    public const TYPE_INT = 'integer';
+    public const TYPE_FLOAT = 'float';
+    public const TYPE_STRING = 'string';
+    public const TYPE_ARRAY = 'array';
+    public const TYPE_DATE = 'DateTimeImmutable';
+
+    public const PATTERN_ARRAY_OF = '/array<[^>]+>/';
+
+    private string $value;
+
+    private ?self $arrayOfType;
+
+    private function __construct(
+        string $value
+    ) {
+        $this->value = $value;
+        if ($this->isArrayOf()) {
+            $arrayOfType = self::tryFromString($this->getArrayOf());
+            if (!$arrayOfType && !$arrayOfType->isArray()) {
+                throw new \DomainException(sprintf(
+                    'Array declaration "%s" has invalid subType. Expected either class string or int',
+                    $this->value
+                ));
+            }
+            $this->arrayOfType = $arrayOfType;
+        }
+    }
+
+    public static function fromPropertyOfNodeType(
+        string $propertyName,
+        NodeType $nodeType
+    ): self {
+        $declaration = $nodeType->getPropertyType($propertyName);
+        if ($declaration === 'reference' || $declaration === 'references') {
+            throw new \DomainException(
+                sprintf(
+                    'Given property "%s" is declared as "reference" in node type "%s" and must be treated as such.',
+                    $propertyName,
+                    $nodeType->getName()
+                ),
+                1685964835205
+            );
+        }
+        $type = self::tryFromString($declaration);
+        if (!$type) {
+            throw new \DomainException(
+                sprintf(
+                    'Given property "%s" is declared as undefined type "%s" in node type "%s"',
+                    $propertyName,
+                    $declaration,
+                    $nodeType->getName()
+                ),
+                1685952798732
+            );
+        }
+        return $type;
+    }
+
+    public static function tryFromString(string $declaration): ?self
+    {
+        if ($declaration === 'reference' || $declaration === 'references') {
+            return null;
+        }
+        if ($declaration === 'bool' || $declaration === 'boolean') {
+            return self::bool();
+        }
+        if ($declaration === 'int' || $declaration === 'integer') {
+            return self::int();
+        }
+        if ($declaration === 'float' || $declaration === 'double') {
+            return self::float();
+        }
+        if (
+            in_array($declaration, [
+                'DateTime',
+                '\DateTime',
+                'DateTimeImmutable',
+                '\DateTimeImmutable',
+                'DateTimeInterface',
+                '\DateTimeInterface'
+            ])
+        ) {
+            return self::date();
+        }
+        if ($declaration === 'Uri' || $declaration === Uri::class || $declaration === UriInterface::class) {
+            $declaration = Uri::class;
+        }
+        $className = $declaration[0] != '\\'
+            ? '\\' . $declaration
+            : $declaration;
+        if (
+            $declaration !== self::TYPE_FLOAT
+            && $declaration !== self::TYPE_STRING
+            && $declaration !== self::TYPE_ARRAY
+            && !class_exists($className)
+            && !interface_exists($className)
+            && !preg_match(self::PATTERN_ARRAY_OF, $declaration)
+        ) {
+            return null;
+        }
+        return new self($declaration);
+    }
+
+    public static function bool(): self
+    {
+        return new self(self::TYPE_BOOL);
+    }
+
+    public static function int(): self
+    {
+        return new self(self::TYPE_INT);
+    }
+
+    public static function string(): self
+    {
+        return new self(self::TYPE_STRING);
+    }
+
+    public static function float(): self
+    {
+        return new self(self::TYPE_FLOAT);
+    }
+
+    public static function date(): self
+    {
+        return new self(self::TYPE_DATE);
+    }
+
+    public function isBool(): bool
+    {
+        return $this->value === self::TYPE_BOOL;
+    }
+
+    public function isInt(): bool
+    {
+        return $this->value === self::TYPE_INT;
+    }
+
+    public function isFloat(): bool
+    {
+        return $this->value === self::TYPE_FLOAT;
+    }
+
+    public function isString(): bool
+    {
+        return $this->value === self::TYPE_STRING;
+    }
+
+    public function isArray(): bool
+    {
+        return $this->value === self::TYPE_ARRAY;
+    }
+
+    public function isArrayOf(): bool
+    {
+        return (bool)preg_match(self::PATTERN_ARRAY_OF, $this->value);
+    }
+
+    public function isDate(): bool
+    {
+        return $this->value === self::TYPE_DATE;
+    }
+
+    public function getValue(): string
+    {
+        return $this->value;
+    }
+
+    private function getArrayOf(): string
+    {
+        return \mb_substr($this->value, 6, -1);
+    }
+
+    public function isMatchedBy($propertyValue): bool
+    {
+        if (is_null($propertyValue)) {
+            return true;
+        }
+        if ($this->isBool()) {
+            return is_bool($propertyValue);
+        }
+        if ($this->isInt()) {
+            return is_int($propertyValue);
+        }
+        if ($this->isFloat()) {
+            return is_float($propertyValue);
+        }
+        if ($this->isString()) {
+            return is_string($propertyValue);
+        }
+        if ($this->isArray()) {
+            return is_array($propertyValue);
+        }
+        if ($this->isDate()) {
+            return $propertyValue instanceof \DateTimeInterface;
+        }
+        if ($this->isArrayOf()) {
+            if (!is_array($propertyValue)) {
+                return false;
+            }
+            foreach ($propertyValue as $value) {
+                if (!$this->arrayOfType->isMatchedBy($value)) {
+                    return false;
+                }
+            }
+            return true;
+        }
+
+        $className = $this->value[0] != '\\'
+            ? '\\' . $this->value
+            : $this->value;
+
+        return (class_exists($className) || interface_exists($className)) && $propertyValue instanceof $className;
+    }
+}
diff --git a/Classes/Domain/NodeCreation/ReferenceType.php b/Classes/Domain/NodeCreation/ReferenceType.php
new file mode 100644
index 0000000..85d9d8a
--- /dev/null
+++ b/Classes/Domain/NodeCreation/ReferenceType.php
@@ -0,0 +1,96 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flowpack\NodeTemplates\Domain\NodeCreation;
+
+use Neos\ContentRepository\Domain\Model\NodeInterface;
+use Neos\ContentRepository\Domain\Model\NodeType;
+use Neos\ContentRepository\Domain\Service\Context;
+use Neos\Flow\Annotations as Flow;
+
+/**
+ * The reference type value object as declared in a NodeType
+ *
+ * @Flow\Proxy(false)
+ */
+final class ReferenceType
+{
+    public const TYPE_REFERENCE = 'reference';
+    public const TYPE_REFERENCES = 'references';
+
+    private string $value;
+
+    private function __construct(
+        string $value
+    ) {
+        $this->value = $value;
+    }
+
+    public static function fromPropertyOfNodeType(
+        string $propertyName,
+        NodeType $nodeType
+    ): self {
+        $declaration = $nodeType->getPropertyType($propertyName);
+        if ($declaration === 'reference') {
+            return self::reference();
+        }
+        if ($declaration === 'references') {
+            return self::references();
+        }
+        throw new \DomainException(
+            sprintf(
+                'Given property "%s" is not declared as "reference" in node type "%s" and must be treated as such.',
+                $propertyName,
+                $nodeType->getName()
+            ),
+            1685964955964
+        );
+    }
+
+    public static function reference(): self
+    {
+        return new self(self::TYPE_REFERENCE);
+    }
+
+    public static function references(): self
+    {
+        return new self(self::TYPE_REFERENCES);
+    }
+
+    public function isReference(): bool
+    {
+        return $this->value === self::TYPE_REFERENCE;
+    }
+
+    public function isReferences(): bool
+    {
+        return $this->value === self::TYPE_REFERENCES;
+    }
+
+    public function getValue(): string
+    {
+        return $this->value;
+    }
+
+    public function isMatchedBy($propertyValue, Context $subgraphForResolving): bool
+    {
+        if ($propertyValue === null) {
+            return true;
+        }
+        $nodeAggregatesOrIds = $this->isReference() ? [$propertyValue] : $propertyValue;
+        if (is_array($nodeAggregatesOrIds) === false) {
+            return false;
+        }
+        foreach ($nodeAggregatesOrIds as $singleNodeAggregateOrId) {
+            if ($singleNodeAggregateOrId instanceof NodeInterface) {
+                continue;
+            }
+            if (is_string($singleNodeAggregateOrId) && $subgraphForResolving->getNodeByIdentifier($singleNodeAggregateOrId) instanceof NodeInterface) {
+                continue;
+            }
+            return false;
+        }
+        return true;
+    }
+}
diff --git a/Classes/NodeTemplateDumper/Comment.php b/Classes/Domain/NodeTemplateDumper/Comment.php
similarity index 66%
rename from Classes/NodeTemplateDumper/Comment.php
rename to Classes/Domain/NodeTemplateDumper/Comment.php
index 6b9bc94..6eb1548 100644
--- a/Classes/NodeTemplateDumper/Comment.php
+++ b/Classes/Domain/NodeTemplateDumper/Comment.php
@@ -2,7 +2,7 @@
 
 declare(strict_types=1);
 
-namespace Flowpack\NodeTemplates\NodeTemplateDumper;
+namespace Flowpack\NodeTemplates\Domain\NodeTemplateDumper;
 
 use Neos\Flow\Annotations as Flow;
 
@@ -14,15 +14,21 @@
  */
 class Comment
 {
+    /**
+     * @psalm-var \Closure(string $indentation, string $propertyName): string $renderFunction
+     */
     private \Closure $renderFunction;
 
+    /**
+     * @psalm-param \Closure(string $indentation, string $propertyName): string $renderFunction
+     */
     private function __construct(\Closure $renderFunction)
     {
         $this->renderFunction = $renderFunction;
     }
 
     /**
-     * @psalm-param callable(string $indentation, string $propertyName): string $renderFunction
+     * @psalm-param \Closure(string $indentation, string $propertyName): string $renderFunction
      */
     public static function fromRenderer($renderFunction): self
     {
diff --git a/Classes/NodeTemplateDumper/Comments.php b/Classes/Domain/NodeTemplateDumper/Comments.php
similarity index 96%
rename from Classes/NodeTemplateDumper/Comments.php
rename to Classes/Domain/NodeTemplateDumper/Comments.php
index bc39ff5..bf18141 100644
--- a/Classes/NodeTemplateDumper/Comments.php
+++ b/Classes/Domain/NodeTemplateDumper/Comments.php
@@ -2,7 +2,7 @@
 
 declare(strict_types=1);
 
-namespace Flowpack\NodeTemplates\NodeTemplateDumper;
+namespace Flowpack\NodeTemplates\Domain\NodeTemplateDumper;
 
 use Neos\Flow\Annotations as Flow;
 use Neos\Flow\Utility\Algorithms;
diff --git a/Classes/NodeTemplateDumper/NodeTemplateDumper.php b/Classes/Domain/NodeTemplateDumper/NodeTemplateDumper.php
similarity index 97%
rename from Classes/NodeTemplateDumper/NodeTemplateDumper.php
rename to Classes/Domain/NodeTemplateDumper/NodeTemplateDumper.php
index d8751c9..437e20b 100644
--- a/Classes/NodeTemplateDumper/NodeTemplateDumper.php
+++ b/Classes/Domain/NodeTemplateDumper/NodeTemplateDumper.php
@@ -2,7 +2,7 @@
 
 declare(strict_types=1);
 
-namespace Flowpack\NodeTemplates\NodeTemplateDumper;
+namespace Flowpack\NodeTemplates\Domain\NodeTemplateDumper;
 
 use Neos\ContentRepository\Domain\Model\ArrayPropertyCollection;
 use Neos\ContentRepository\Domain\Model\NodeInterface;
@@ -80,9 +80,7 @@ private function nodeTemplateFromNodes(array $nodes, Comments $comments): array
             $templatePart = array_filter([
                 'properties' => $this->nonDefaultConfiguredNodeProperties($node, $comments),
                 'childNodes' => $this->nodeTemplateFromNodes(
-                    $isDocumentNode
-                        ? $node->getChildNodes('Neos.Neos:Content,Neos.Neos:ContentCollection,Neos.Neos:Document')
-                        : $node->getChildNodes('Neos.Neos:Content,Neos.Neos:ContentCollection'),
+                    $node->getChildNodes('Neos.Neos:Node'),
                     $comments
                 )
             ]);
diff --git a/Classes/Domain/Template/RootTemplate.php b/Classes/Domain/Template/RootTemplate.php
new file mode 100644
index 0000000..f030e05
--- /dev/null
+++ b/Classes/Domain/Template/RootTemplate.php
@@ -0,0 +1,57 @@
+<?php
+declare(strict_types=1);
+
+namespace Flowpack\NodeTemplates\Domain\Template;
+
+use Neos\Flow\Annotations as Flow;
+
+/**
+ * The root of a template (which is not allowed to have a "name" and a "type" unlike {@see Template}
+ *
+ * @Flow\Proxy(false)
+ */
+class RootTemplate implements \JsonSerializable
+{
+    /**
+     * @var array<string, mixed>
+     */
+    private array $properties;
+
+    private Templates $childNodes;
+
+    /**
+     * @internal
+     * @param array<string, mixed> $properties
+     */
+    public function __construct(array $properties, Templates $childNodes)
+    {
+        $this->properties = $properties;
+        $this->childNodes = $childNodes;
+    }
+
+    public static function empty(): self
+    {
+        return new RootTemplate([], Templates::empty());
+    }
+
+    /**
+     * @return array<string, string>
+     */
+    public function getProperties(): array
+    {
+        return $this->properties;
+    }
+
+    public function getChildNodes(): Templates
+    {
+        return $this->childNodes;
+    }
+
+    public function jsonSerialize()
+    {
+        return [
+            'properties' => $this->properties,
+            'childNodes' => $this->childNodes
+        ];
+    }
+}
diff --git a/Classes/Domain/Template/Template.php b/Classes/Domain/Template/Template.php
new file mode 100644
index 0000000..b9715ab
--- /dev/null
+++ b/Classes/Domain/Template/Template.php
@@ -0,0 +1,68 @@
+<?php
+declare(strict_types=1);
+
+namespace Flowpack\NodeTemplates\Domain\Template;
+
+use Neos\ContentRepository\Domain\NodeAggregate\NodeName;
+use Neos\ContentRepository\Domain\NodeType\NodeTypeName;
+use Neos\Flow\Annotations as Flow;
+
+/** @Flow\Proxy(false) */
+class Template implements \JsonSerializable
+{
+    private ?NodeTypeName $type;
+
+    private ?NodeName $name;
+
+    /**
+     * @var array<string, mixed>
+     */
+    private array $properties;
+
+    private Templates $childNodes;
+
+    /**
+     * @internal
+     * @param array<string, mixed> $properties
+     */
+    public function __construct(?NodeTypeName $type, ?NodeName $name, array $properties, Templates $childNodes)
+    {
+        $this->type = $type;
+        $this->name = $name;
+        $this->properties = $properties;
+        $this->childNodes = $childNodes;
+    }
+
+    public function getType(): ?NodeTypeName
+    {
+        return $this->type;
+    }
+
+    public function getName(): ?NodeName
+    {
+        return $this->name;
+    }
+
+    /**
+     * @return array<string, string>
+     */
+    public function getProperties(): array
+    {
+        return $this->properties;
+    }
+
+    public function getChildNodes(): Templates
+    {
+        return $this->childNodes;
+    }
+
+    public function jsonSerialize()
+    {
+        return [
+            'type' => $this->type,
+            'name' => $this->name,
+            'properties' => $this->properties,
+            'childNodes' => $this->childNodes
+        ];
+    }
+}
diff --git a/Classes/Domain/Template/Templates.php b/Classes/Domain/Template/Templates.php
new file mode 100644
index 0000000..b03b676
--- /dev/null
+++ b/Classes/Domain/Template/Templates.php
@@ -0,0 +1,60 @@
+<?php
+
+namespace Flowpack\NodeTemplates\Domain\Template;
+
+use Neos\Flow\Annotations as Flow;
+
+/** @Flow\Proxy(false) */
+class Templates implements \IteratorAggregate, \JsonSerializable
+{
+    /** @var array<int|string, Template> */
+    private array $items;
+
+    public function __construct(
+        Template ...$items
+    ) {
+        $this->items = $items;
+    }
+
+    public static function empty(): self
+    {
+        return new self();
+    }
+
+    /**
+     * @return \Traversable<int|string, Template>|Template[]
+     */
+    public function getIterator(): \Traversable
+    {
+        yield from $this->items;
+    }
+
+    public function withAdded(Template $template): self
+    {
+        return new  self(...$this->items, ...[$template]);
+    }
+
+    public function merge(Templates $other): self
+    {
+        return new self(...$this->items, ...$other->items);
+    }
+
+    public function toRootTemplate(): RootTemplate
+    {
+        if (count($this->items) > 1) {
+            throw new \BadMethodCallException('Templates cannot be transformed to RootTemplate because it holds multiple Templates.', 1685866910655);
+        }
+        foreach ($this->items as $first) {
+            return new RootTemplate(
+                $first->getProperties(),
+                $first->getChildNodes()
+            );
+        }
+        return RootTemplate::empty();
+    }
+
+    public function jsonSerialize()
+    {
+        return $this->items;
+    }
+}
diff --git a/Classes/Service/EelEvaluationService.php b/Classes/Domain/TemplateConfiguration/EelEvaluationService.php
similarity index 52%
rename from Classes/Service/EelEvaluationService.php
rename to Classes/Domain/TemplateConfiguration/EelEvaluationService.php
index d99404f..542c6f4 100644
--- a/Classes/Service/EelEvaluationService.php
+++ b/Classes/Domain/TemplateConfiguration/EelEvaluationService.php
@@ -1,11 +1,11 @@
 <?php
 
-namespace Flowpack\NodeTemplates\Service;
+namespace Flowpack\NodeTemplates\Domain\TemplateConfiguration;
 
+use Neos\Eel\CompilingEvaluator;
 use Neos\Eel\ParserException;
-use Neos\Flow\Annotations as Flow;
 use Neos\Eel\Utility as EelUtility;
-use Neos\Eel\CompilingEvaluator;
+use Neos\Flow\Annotations as Flow;
 
 /**
  * @Flow\Scope("singleton")
@@ -20,33 +20,24 @@ class EelEvaluationService
 
     /**
      * @Flow\InjectConfiguration(path="defaultEelContext")
-     * @var array
      */
-    protected $defaultContext;
+    protected array $defaultContextConfiguration;
 
-    /**
-     * @var array
-     */
-    protected $defaultContextVariables;
+    protected ?array $defaultContextVariables = null;
 
     /**
      * Evaluate an Eel expression.
      *
+     * @param $contextVariables array<string, mixed> additional context for eel expressions
      * @return mixed The result of the evaluated Eel expression
-     * @throws \Neos\Eel\Exception
+     * @throws ParserException|\Exception
      */
     public function evaluateEelExpression(string $expression, array $contextVariables)
     {
         if ($this->defaultContextVariables === null) {
-            $this->defaultContextVariables = EelUtility::getDefaultContextVariables($this->defaultContext);
+            $this->defaultContextVariables = EelUtility::getDefaultContextVariables($this->defaultContextConfiguration);
         }
         $contextVariables = array_merge($this->defaultContextVariables, $contextVariables);
-        try {
-            return EelUtility::evaluateEelExpression($expression, $this->eelEvaluator, $contextVariables);
-        } catch (ParserException $parserException) {
-            throw new EelException('EEL Expression in NodeType template could not be parsed.', 1684788574212, $parserException);
-        } catch (\Exception $exception) {
-            throw new EelException(sprintf('EEL Expression "%s" in NodeType template caused an error.', $expression), 1684761760723, $exception);
-        }
+        return EelUtility::evaluateEelExpression($expression, $this->eelEvaluator, $contextVariables);
     }
 }
diff --git a/Classes/Domain/TemplateConfiguration/StopBuildingTemplatePartException.php b/Classes/Domain/TemplateConfiguration/StopBuildingTemplatePartException.php
new file mode 100644
index 0000000..13ef8d8
--- /dev/null
+++ b/Classes/Domain/TemplateConfiguration/StopBuildingTemplatePartException.php
@@ -0,0 +1,8 @@
+<?php
+
+namespace Flowpack\NodeTemplates\Domain\TemplateConfiguration;
+
+/** @internal implementation detail of {@see TemplateConfigurationProcessor} */
+class StopBuildingTemplatePartException extends \RuntimeException
+{
+}
diff --git a/Classes/Domain/TemplateConfiguration/TemplateConfigurationProcessor.php b/Classes/Domain/TemplateConfiguration/TemplateConfigurationProcessor.php
new file mode 100644
index 0000000..d2a6b5f
--- /dev/null
+++ b/Classes/Domain/TemplateConfiguration/TemplateConfigurationProcessor.php
@@ -0,0 +1,145 @@
+<?php
+
+namespace Flowpack\NodeTemplates\Domain\TemplateConfiguration;
+
+use Flowpack\NodeTemplates\Domain\ExceptionHandling\CaughtException;
+use Flowpack\NodeTemplates\Domain\ExceptionHandling\CaughtExceptions;
+use Flowpack\NodeTemplates\Domain\Template\RootTemplate;
+use Flowpack\NodeTemplates\Domain\Template\Template;
+use Flowpack\NodeTemplates\Domain\Template\Templates;
+use Neos\ContentRepository\Domain\NodeAggregate\NodeName;
+use Neos\ContentRepository\Domain\NodeType\NodeTypeName;
+use Neos\Flow\Annotations as Flow;
+
+/**
+ * @Flow\Scope("singleton")
+ */
+class TemplateConfigurationProcessor
+{
+    /**
+     * @Flow\Inject
+     * @var EelEvaluationService
+     */
+    protected $eelEvaluationService;
+
+    /**
+     * @psalm-param array<string, mixed> $configuration
+     * @psalm-param array<string, mixed> $evaluationContext
+     * @param CaughtExceptions $caughtEvaluationExceptions
+     * @return RootTemplate
+     */
+    public function processTemplateConfiguration(array $configuration, array $evaluationContext, CaughtExceptions $caughtEvaluationExceptions): RootTemplate
+    {
+        try {
+            $templatePart = TemplatePart::createRoot(
+                $configuration,
+                $evaluationContext,
+                fn ($value, $evaluationContext) => $this->preprocessConfigurationValue($value, $evaluationContext),
+                $caughtEvaluationExceptions
+            );
+        } catch (StopBuildingTemplatePartException $e) {
+            return RootTemplate::empty();
+        }
+        return $this->createTemplatesFromTemplatePart($templatePart)->toRootTemplate();
+    }
+
+    private function createTemplatesFromTemplatePart(TemplatePart $templatePart): Templates
+    {
+        try {
+            $withContext = [];
+            foreach ($templatePart->getRawConfiguration('withContext') ?? [] as $key => $_) {
+                $withContext[$key] = $templatePart->processConfiguration(['withContext', $key]);
+            }
+            $templatePart = $templatePart->withMergedEvaluationContext($withContext);
+
+            if ($templatePart->hasConfiguration('when') && !$templatePart->processConfiguration('when')) {
+                return Templates::empty();
+            }
+
+            if (!$templatePart->hasConfiguration('withItems')) {
+                return new Templates($this->createTemplateFromTemplatePart($templatePart));
+            }
+            $items = $templatePart->processConfiguration('withItems');
+
+            if (!is_iterable($items)) {
+                $templatePart->getCaughtExceptions()->add(
+                    CaughtException::fromException(
+                        new \RuntimeException(sprintf('Type %s is not iterable.', gettype($items)), 1685802354186)
+                    )->withOrigin(sprintf('Configuration "%s" in "%s"', json_encode($templatePart->getRawConfiguration('withItems')), join('.', array_merge($templatePart->getFullPathToConfiguration(), ['withItems']))))
+                );
+                return Templates::empty();
+            }
+
+            $templates = Templates::empty();
+            foreach ($items as $itemKey => $itemValue) {
+                $itemTemplatePart = $templatePart->withMergedEvaluationContext([
+                    'item' => $itemValue,
+                    'key' => $itemKey
+                ]);
+
+                try {
+                    $templates = $templates->withAdded($this->createTemplateFromTemplatePart($itemTemplatePart));
+                } catch (StopBuildingTemplatePartException $e) {
+                }
+            }
+            return $templates;
+        } catch (StopBuildingTemplatePartException $e) {
+            return Templates::empty();
+        }
+    }
+
+    private function createTemplateFromTemplatePart(TemplatePart $templatePart): Template
+    {
+        // process the properties
+        $processedProperties = [];
+        foreach ($templatePart->getRawConfiguration('properties') ?? [] as $propertyName => $value) {
+            if (!is_scalar($value) && !is_null($value)) {
+                $templatePart->getCaughtExceptions()->add(CaughtException::fromException(
+                    new \RuntimeException(sprintf('Template configuration properties can only hold int|float|string|bool|null. Property "%s" has type "%s"', $propertyName, gettype($value)), 1685725310730)
+                ));
+                continue;
+            }
+            try {
+                $processedProperties[$propertyName] = $templatePart->processConfiguration(['properties', $propertyName]);
+            } catch (StopBuildingTemplatePartException $e) {
+            }
+        }
+
+        // process the childNodes
+        $childNodeTemplates = Templates::empty();
+        foreach ($templatePart->getRawConfiguration('childNodes') ?? [] as $childNodeConfigurationPath => $_) {
+            try {
+                $childNodeTemplatePart = $templatePart->withConfigurationByConfigurationPath(['childNodes', $childNodeConfigurationPath]);
+            } catch (StopBuildingTemplatePartException $e) {
+                continue;
+            }
+            $childNodeTemplates = $childNodeTemplates->merge($this->createTemplatesFromTemplatePart($childNodeTemplatePart));
+        }
+
+        $type = $templatePart->processConfiguration('type');
+        $name = $templatePart->processConfiguration('name');
+        return new Template(
+            $type ? NodeTypeName::fromString($type) : null,
+            $name ? NodeName::fromString($name) : null,
+            $processedProperties,
+            $childNodeTemplates
+        );
+    }
+
+    /**
+     * @psalm-param mixed $rawConfigurationValue
+     * @psalm-param array<string, mixed> $evaluationContext
+     * @psalm-return mixed
+     * @throws \Neos\Eel\ParserException|\Exception
+     */
+    private function preprocessConfigurationValue($rawConfigurationValue, array $evaluationContext)
+    {
+        if (!is_string($rawConfigurationValue)) {
+            return $rawConfigurationValue;
+        }
+        if (strpos($rawConfigurationValue, '${') !== 0) {
+            return $rawConfigurationValue;
+        }
+        return $this->eelEvaluationService->evaluateEelExpression($rawConfigurationValue, $evaluationContext);
+    }
+}
diff --git a/Classes/Domain/TemplateConfiguration/TemplatePart.php b/Classes/Domain/TemplateConfiguration/TemplatePart.php
new file mode 100644
index 0000000..e66bce0
--- /dev/null
+++ b/Classes/Domain/TemplateConfiguration/TemplatePart.php
@@ -0,0 +1,217 @@
+<?php
+
+namespace Flowpack\NodeTemplates\Domain\TemplateConfiguration;
+
+use Flowpack\NodeTemplates\Domain\ExceptionHandling\CaughtException;
+use Flowpack\NodeTemplates\Domain\ExceptionHandling\CaughtExceptions;
+use Neos\Flow\Annotations as Flow;
+
+/**
+ * @internal implementation detail of {@see TemplateConfigurationProcessor}
+ * @psalm-immutable
+ * @Flow\Proxy(false)
+ */
+class TemplatePart
+{
+    /**
+     * @psalm-readonly
+     */
+    private array $configuration;
+
+    /**
+     * @psalm-readonly
+     */
+    private array $fullPathToConfiguration;
+
+    /**
+     * @psalm-readonly
+     */
+    private array $evaluationContext;
+
+    /**
+     * @psalm-readonly
+     * @psalm-var \Closure(mixed $value, array<string, mixed> $evaluationContext): mixed
+     */
+    private \Closure $configurationValueProcessor;
+
+    /**
+     * @psalm-readonly
+     */
+    private CaughtExceptions $caughtExceptions;
+
+    /**
+     * @psalm-param array<string, mixed> $configuration
+     * @psalm-param array<string, mixed> $evaluationContext
+     * @psalm-param \Closure(mixed $value, array<string, mixed> $evaluationContext): mixed $configurationValueProcessor
+     * @throws StopBuildingTemplatePartException
+     */
+    private function __construct(
+        array $configuration,
+        array $fullPathToConfiguration,
+        array $evaluationContext,
+        \Closure $configurationValueProcessor,
+        CaughtExceptions $caughtExceptions
+    ) {
+        $this->configuration = $configuration;
+        $this->fullPathToConfiguration = $fullPathToConfiguration;
+        $this->evaluationContext = $evaluationContext;
+        $this->configurationValueProcessor = $configurationValueProcessor;
+        $this->caughtExceptions = $caughtExceptions;
+        $this->validateTemplateConfigurationKeys();
+    }
+
+    /**
+     * @psalm-param array<string, mixed> $configuration
+     * @psalm-param array<string, mixed> $evaluationContext
+     * @psalm-param \Closure(mixed $value, array<string, mixed> $evaluationContext): mixed $configurationValueProcessor
+     * @throws StopBuildingTemplatePartException
+     */
+    public static function createRoot(
+        array $configuration,
+        array $evaluationContext,
+        \Closure $configurationValueProcessor,
+        CaughtExceptions $caughtExceptions
+    ): self {
+        return new self(
+            $configuration,
+            [],
+            $evaluationContext,
+            $configurationValueProcessor,
+            $caughtExceptions
+        );
+    }
+
+    public function getCaughtExceptions(): CaughtExceptions
+    {
+        return $this->caughtExceptions;
+    }
+
+    public function getFullPathToConfiguration(): array
+    {
+        return $this->fullPathToConfiguration;
+    }
+
+    /**
+     * @psalm-param string|list<string> $configurationPath
+     * @throws StopBuildingTemplatePartException
+     */
+    public function withConfigurationByConfigurationPath($configurationPath): self
+    {
+        return new self(
+            $this->getRawConfiguration($configurationPath),
+            array_merge($this->fullPathToConfiguration, $configurationPath),
+            $this->evaluationContext,
+            $this->configurationValueProcessor,
+            $this->caughtExceptions
+        );
+    }
+
+    /**
+     * @psalm-param array<string, mixed> $evaluationContext
+     */
+    public function withMergedEvaluationContext(array $evaluationContext): self
+    {
+        if ($evaluationContext === []) {
+            return $this;
+        }
+        return new self(
+            $this->configuration,
+            $this->fullPathToConfiguration,
+            array_merge($this->evaluationContext, $evaluationContext),
+            $this->configurationValueProcessor,
+            $this->caughtExceptions
+        );
+    }
+
+    /**
+     * @psalm-param string|list<string> $configurationPath
+     * @return mixed
+     * @throws StopBuildingTemplatePartException
+     */
+    public function processConfiguration($configurationPath)
+    {
+        if (($value = $this->getRawConfiguration($configurationPath)) === null) {
+            return null;
+        }
+        try {
+            return ($this->configurationValueProcessor)($value, $this->evaluationContext);
+        } catch (\Throwable $exception) {
+            $fullConfigurationPath = array_merge(
+                $this->fullPathToConfiguration,
+                is_array($configurationPath) ? $configurationPath : [$configurationPath]
+            );
+            $this->caughtExceptions->add(
+                CaughtException::fromException($exception)->withOrigin(
+                    sprintf(
+                        'Expression "%s" in "%s"',
+                        $value,
+                        join('.', $fullConfigurationPath)
+                    )
+                )
+            );
+            throw new StopBuildingTemplatePartException();
+        }
+    }
+
+    /**
+     * Minimal implementation of {@see \Neos\Utility\Arrays::getValueByPath()} (but we dont allow $configurationPath to contain dots.)
+     *
+     * @psalm-param string|list<string> $configurationPath
+     */
+    public function getRawConfiguration($configurationPath)
+    {
+        assert(is_array($configurationPath) || is_string($configurationPath));
+        $path = is_array($configurationPath) ? $configurationPath : [$configurationPath];
+        $array = $this->configuration;
+        foreach ($path as $key) {
+            if (is_array($array) && array_key_exists($key, $array)) {
+                $array = $array[$key];
+            } else {
+                return null;
+            }
+        }
+        return $array;
+    }
+
+    /**
+     * @psalm-param string|list<string> $configurationPath
+     */
+    public function hasConfiguration($configurationPath): bool
+    {
+        assert(is_array($configurationPath) || is_string($configurationPath));
+        $path = is_array($configurationPath) ? $configurationPath : [$configurationPath];
+        $array = $this->configuration;
+        foreach ($path as $key) {
+            if (is_array($array) && array_key_exists($key, $array)) {
+                $array = $array[$key];
+            } else {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    /**
+     * @throws StopBuildingTemplatePartException
+     */
+    private function validateTemplateConfigurationKeys(): void
+    {
+        $isRootTemplate = $this->fullPathToConfiguration === [];
+        foreach (array_keys($this->configuration) as $key) {
+            if (!in_array($key, ['type', 'name', 'properties', 'childNodes', 'when', 'withItems', 'withContext'], true)) {
+                $this->caughtExceptions->add(
+                    CaughtException::fromException(new \InvalidArgumentException(sprintf('Template configuration has illegal key "%s"', $key), 1686150349274))
+                );
+                throw new StopBuildingTemplatePartException();
+            }
+            if ($isRootTemplate) {
+                if (!in_array($key, ['properties', 'childNodes', 'when', 'withContext'], true)) {
+                    $this->caughtExceptions->add(
+                        CaughtException::fromException(new \InvalidArgumentException(sprintf('Root template configuration doesnt allow option "%s', $key), 1686150340657))
+                    );
+                    throw new StopBuildingTemplatePartException();
+                }
+            }
+        }
+    }
+}
diff --git a/Classes/Domain/TemplateNodeCreationHandler.php b/Classes/Domain/TemplateNodeCreationHandler.php
new file mode 100644
index 0000000..55f1573
--- /dev/null
+++ b/Classes/Domain/TemplateNodeCreationHandler.php
@@ -0,0 +1,64 @@
+<?php
+
+namespace Flowpack\NodeTemplates\Domain;
+
+use Flowpack\NodeTemplates\Domain\ExceptionHandling\CaughtExceptions;
+use Flowpack\NodeTemplates\Domain\ExceptionHandling\ExceptionHandler;
+use Flowpack\NodeTemplates\Domain\ExceptionHandling\TemplateNotCreatedException;
+use Flowpack\NodeTemplates\Domain\ExceptionHandling\TemplatePartiallyCreatedException;
+use Flowpack\NodeTemplates\Domain\NodeCreation\NodeCreationService;
+use Flowpack\NodeTemplates\Domain\TemplateConfiguration\TemplateConfigurationProcessor;
+use Neos\ContentRepository\Domain\Model\NodeInterface;
+use Neos\Flow\Annotations as Flow;
+use Neos\Neos\Ui\NodeCreationHandler\NodeCreationHandlerInterface;
+
+class TemplateNodeCreationHandler implements NodeCreationHandlerInterface
+{
+    /**
+     * @var TemplateConfigurationProcessor
+     * @Flow\Inject
+     */
+    protected $templateConfigurationProcessor;
+
+    /**
+     * @var NodeCreationService
+     * @Flow\Inject
+     */
+    protected $nodeCreationService;
+
+    /**
+     * @var ExceptionHandler
+     * @Flow\Inject
+     */
+    protected $exceptionHandler;
+
+    /**
+     * Create child nodes and change properties upon node creation
+     *
+     * @param NodeInterface $node The newly created node
+     * @param array $data incoming data from the creationDialog
+     */
+    public function handle(NodeInterface $node, array $data): void
+    {
+        if (!$node->getNodeType()->hasConfiguration('options.template')) {
+            return;
+        }
+
+        $evaluationContext = [
+            'data' => $data,
+            'triggeringNode' => $node,
+        ];
+
+        $templateConfiguration = $node->getNodeType()->getConfiguration('options.template');
+
+        $caughtExceptions = CaughtExceptions::create();
+        try {
+            $template = $this->templateConfigurationProcessor->processTemplateConfiguration($templateConfiguration, $evaluationContext, $caughtExceptions);
+            $this->exceptionHandler->handleAfterTemplateConfigurationProcessing($caughtExceptions, $node);
+
+            $this->nodeCreationService->apply($template, $node, $caughtExceptions);
+            $this->exceptionHandler->handleAfterNodeCreation($caughtExceptions, $node);
+        } catch (TemplateNotCreatedException|TemplatePartiallyCreatedException $templateCreationException) {
+        }
+    }
+}
diff --git a/Classes/NodeCreationHandler/TemplateNodeCreationHandler.php b/Classes/NodeCreationHandler/TemplateNodeCreationHandler.php
deleted file mode 100644
index 584ccfb..0000000
--- a/Classes/NodeCreationHandler/TemplateNodeCreationHandler.php
+++ /dev/null
@@ -1,129 +0,0 @@
-<?php
-
-namespace Flowpack\NodeTemplates\NodeCreationHandler;
-
-use Flowpack\NodeTemplates\Service\EelException;
-use Flowpack\NodeTemplates\Template;
-use Neos\ContentRepository\Domain\Model\NodeInterface;
-use Neos\ContentRepository\Exception\NodeConstraintException;
-use Neos\Flow\Annotations as Flow;
-use Neos\Flow\Property\PropertyMapper;
-use Neos\Neos\Ui\Domain\Model\Feedback\Messages\Error;
-use Neos\Neos\Ui\Domain\Model\FeedbackCollection;
-use Neos\Neos\Ui\NodeCreationHandler\NodeCreationHandlerInterface;
-
-class TemplateNodeCreationHandler implements NodeCreationHandlerInterface
-{
-    /**
-     * @var PropertyMapper
-     * @Flow\Inject
-     */
-    protected $propertyMapper;
-
-    /**
-     * @var integer
-     * @Flow\InjectConfiguration(path="nodeCreationDepth")
-     */
-    protected $nodeCreationDepth;
-
-    /**
-     * @var FeedbackCollection
-     * @Flow\Inject
-     */
-    protected $feedbackCollection;
-
-    /**
-     * Create child nodes and change properties upon node creation
-     *
-     * @param NodeInterface $node The newly created node
-     * @param array $data incoming data from the creationDialog
-     */
-    public function handle(NodeInterface $node, array $data): void
-    {
-        if ($node->getNodeType()->hasConfiguration('options.template')) {
-            $templateConfiguration = $node->getNodeType()->getConfiguration('options.template');
-        } else {
-            return;
-        }
-
-        $propertyMappingConfiguration = $this->propertyMapper->buildPropertyMappingConfiguration();
-
-        $subPropertyMappingConfiguration = $propertyMappingConfiguration;
-        for ($i = 0; $i < $this->nodeCreationDepth; $i++) {
-            $subPropertyMappingConfiguration = $subPropertyMappingConfiguration
-                ->forProperty('childNodes.*')
-                ->allowAllProperties();
-        }
-
-        /** @var Template $template */
-        $template = $this->propertyMapper->convert(
-            $templateConfiguration,
-            Template::class,
-            $propertyMappingConfiguration
-        );
-
-        $context = [
-            'data' => $data,
-            'triggeringNode' => $node,
-        ];
-
-        try {
-            $template->apply($node, $context);
-        } catch (\Exception $exception) {
-            $this->handleExceptions($node, $exception);
-        }
-    }
-
-    /**
-     * Known exceptions are logged to the Neos.Ui and caught
-     *
-     * @param NodeInterface $node the newly created node
-     * @param \Exception $exception the exception to handle
-     * @throws \Exception in case the exception is unknown and cant be handled
-     */
-    private function handleExceptions(NodeInterface $node, \Exception $exception): void
-    {
-        $nodeTemplateError = new Error();
-        $nodeTemplateError->setMessage(sprintf('Template for "%s" only partially applied. Please check the newly created nodes.', $node->getNodeType()->getLabel()));
-
-        if ($exception instanceof NodeConstraintException) {
-            $this->feedbackCollection->add(
-                $nodeTemplateError
-            );
-
-            $error = new Error();
-            $error->setMessage($exception->getMessage());
-            $this->feedbackCollection->add(
-                $error
-            );
-            return;
-        }
-        if ($exception instanceof EelException) {
-            $this->feedbackCollection->add(
-                $nodeTemplateError
-            );
-
-            $error = new Error();
-            $error->setMessage(
-                $exception->getMessage()
-            );
-            $this->feedbackCollection->add(
-                $error
-            );
-
-            $level = 0;
-            while (($exception = $exception->getPrevious()) && $level <= 8) {
-                $level++;
-                $error = new Error();
-                $error->setMessage(
-                    sprintf('%s [%s(%s)]', $exception->getMessage(), get_class($exception), $exception->getCode())
-                );
-                $this->feedbackCollection->add(
-                    $error
-                );
-            }
-            return;
-        }
-        throw $exception;
-    }
-}
diff --git a/Classes/NodeCreationHandler/TemplatingDocumentTitleNodeCreationHandler.php b/Classes/NodeCreationHandler/TemplatingDocumentTitleNodeCreationHandler.php
deleted file mode 100644
index ef4e5c2..0000000
--- a/Classes/NodeCreationHandler/TemplatingDocumentTitleNodeCreationHandler.php
+++ /dev/null
@@ -1,76 +0,0 @@
-<?php
-declare(strict_types=1);
-
-namespace Flowpack\NodeTemplates\NodeCreationHandler;
-
-use Neos\Eel\Package;
-use Neos\Flow\Annotations as Flow;
-use Flowpack\NodeTemplates\Service\EelEvaluationService;
-use Neos\ContentRepository\Domain\Model\NodeInterface;
-use Neos\Neos\Ui\NodeCreationHandler\NodeCreationHandlerInterface;
-use Neos\Neos\Utility\NodeUriPathSegmentGenerator;
-
-class TemplatingDocumentTitleNodeCreationHandler implements NodeCreationHandlerInterface
-{
-    /**
-     * @var EelEvaluationService
-     * @Flow\Inject
-     */
-    protected $eelEvaluationService;
-
-    /**
-     * @Flow\Inject
-     * @var NodeUriPathSegmentGenerator
-     */
-    protected $nodeUriPathSegmentGenerator;
-
-    /**
-     * @throws \Neos\Eel\Exception
-     * @throws \Neos\Neos\Exception
-     */
-    public function handle(NodeInterface $node, array $data): void
-    {
-        $title = null;
-        $uriPathSegment = null;
-
-        if (!$node->getNodeType()->isOfType('Neos.Neos:Document')) {
-            return;
-        }
-
-        $titleTemplate = $node->getNodeType()->getOptions()['template']['properties']['title'] ?? '';
-
-        if ($titleTemplate === '') {
-            $title = $data['title'] ?? null;
-        } else {
-            if (preg_match(Package::EelExpressionRecognizer, $titleTemplate)) {
-                $context = [
-                    'data' => $data,
-                    'triggeringNode' => $node,
-                ];
-
-                $title = $this->eelEvaluationService->evaluateEelExpression($titleTemplate, $context);
-            }
-        }
-
-        $uriPathSegmentTemplate = $node->getNodeType()->getOptions()['template']['properties']['uriPathSegment'] ?? '';
-        if ($uriPathSegmentTemplate === '') {
-            $uriPathSegment = $data['uriPathSegment'] ?? null;
-        } else {
-            if (preg_match(Package::EelExpressionRecognizer, $uriPathSegmentTemplate)) {
-                $context = [
-                    'data' => $data,
-                    'triggeringNode' => $node,
-                ];
-
-                $uriPathSegment = $this->eelEvaluationService->evaluateEelExpression($uriPathSegmentTemplate, $context);
-            }
-        }
-
-        if (!isset($uriPathSegment) || $uriPathSegment === '') {
-            $uriPathSegment = $title;
-        }
-
-        $node->setProperty('title', (string) $title);
-        $node->setProperty('uriPathSegment', $this->nodeUriPathSegmentGenerator->generateUriPathSegment($node, $uriPathSegment));
-    }
-}
diff --git a/Classes/Service/EelException.php b/Classes/Service/EelException.php
deleted file mode 100644
index 5c36816..0000000
--- a/Classes/Service/EelException.php
+++ /dev/null
@@ -1,7 +0,0 @@
-<?php
-
-namespace Flowpack\NodeTemplates\Service;
-
-class EelException extends \Exception
-{
-}
diff --git a/Classes/Template.php b/Classes/Template.php
deleted file mode 100644
index 44c951c..0000000
--- a/Classes/Template.php
+++ /dev/null
@@ -1,277 +0,0 @@
-<?php
-namespace Flowpack\NodeTemplates;
-
-use Neos\Flow\Annotations as Flow;
-use Flowpack\NodeTemplates\Service\EelEvaluationService;
-use Neos\Eel\FlowQuery\FlowQuery;
-use Neos\ContentRepository\Domain\Model\NodeInterface;
-use Neos\ContentRepository\Utility as NodeUtility;
-use Neos\Flow\Persistence\Doctrine\PersistenceManager;
-use Neos\Neos\Service\NodeOperations;
-use Neos\Utility\ObjectAccess;
-
-class Template
-{
-    /**
-     * @var string
-     */
-    protected $type;
-
-    /**
-     * @var string
-     */
-    protected $name;
-
-    /**
-     * @var array
-     */
-    protected $properties;
-
-    /**
-     * @var array<Template>
-     */
-    protected $childNodes;
-
-    /**
-     * Options can be used to configure third party processing
-     *
-     * @var array
-     */
-    protected $options;
-
-    /**
-     * @var string
-     */
-    protected $when;
-
-    /**
-     * @var string
-     */
-    protected $withItems;
-
-    /**
-     * @var array
-     */
-    protected $withContext;
-
-    /**
-     * @var EelEvaluationService
-     * @Flow\Inject
-     */
-    protected $eelEvaluationService;
-
-    /**
-     * @var NodeOperations
-     * @Flow\Inject
-     */
-    protected $nodeOperations;
-
-    /**
-     * @var PersistenceManager
-     * @Flow\Inject
-     */
-    protected $persistenceManager;
-
-    /**
-     * Template constructor
-     *
-     * @param string $type
-     * @param string $name
-     * @param array $properties
-     * @param array<Template> $childNodes
-     * @param array $options
-     * @param string $when
-     * @param string $withItems
-     * @param array $withContext
-     */
-    public function __construct(
-        $type = null,
-        $name = null,
-        array $properties = [],
-        array $childNodes = [],
-        array $options = [],
-        $when = null,
-        $withItems = null,
-        $withContext = []
-    ) {
-        $this->type = $type;
-        $this->name = $name;
-        $this->properties = $properties;
-        $this->childNodes = $childNodes;
-        $this->options = $options;
-        $this->when = $when;
-        $this->withItems = $withItems;
-        $this->withContext = $withContext;
-    }
-
-    /**
-     * Apply this template to the given node while providing context for EEL processing
-     *
-     * The entry point
-     */
-    public function apply(NodeInterface $node, array $context): void
-    {
-        $context = $this->mergeContextAndWithContext($context);
-        $this->applyTemplateOnNode($node, $context);
-    }
-
-    private function applyTemplateOnNode(NodeInterface $node, array $context): void
-    {
-        $context['node'] = $node;
-
-        // Check if this template should be applied at all
-        if (!$this->isApplicable($context)) {
-            return;
-        }
-        $this->setProperties($node, $context);
-
-        // Create child nodes if applicable
-        /** @var Template $childNodeTemplate */
-        foreach ($this->childNodes as $childNodeTemplate) {
-            $childNodeTemplate->createOrFetchAndApply($node, $context);
-        }
-
-        $this->emitNodeTemplateApplied($node, $context, $this->options);
-    }
-
-    /**
-     * @deprecated will be made internal and private
-     * @internal
-     */
-    public function createOrFetchAndApply(NodeInterface $parentNode, array $context): void
-    {
-        $context['parentNode'] = $parentNode;
-
-        $context = $this->mergeContextAndWithContext($context);
-
-        if (!$this->isApplicable($context)) {
-            return;
-        }
-
-        $items = $this->withItems;
-
-        if (!$items) { // Not set
-            $items = [false];
-        } else if (preg_match(\Neos\Eel\Package::EelExpressionRecognizer, $items)) { // Eel expression
-            $items = $this->eelEvaluationService->evaluateEelExpression($items, $context);
-        } else { // Yaml array converted to comma-delimited string
-            $items = explode(',', $items);
-        }
-
-        foreach ($items as $key => $item) {
-            // only set item context if withItems is set in template to prevent losing item context from parent template
-            if ($this->withItems) {
-                $context['item'] = $item;
-                $context['key'] = $key;
-            }
-            $node = null;
-            $name = $this->name;
-            if (preg_match(\Neos\Eel\Package::EelExpressionRecognizer, $name)) {
-                $name = $this->eelEvaluationService->evaluateEelExpression($name, $context);
-            }
-            if ($name !== null) {
-                $flowQuery = new FlowQuery(array($parentNode));
-                $node = $flowQuery->find($name)->get(0);
-            }
-            if (!$node instanceof NodeInterface) {
-                $type = $this->type;
-                if (preg_match(\Neos\Eel\Package::EelExpressionRecognizer, $type)) {
-                    $type = $this->eelEvaluationService->evaluateEelExpression($type, $context);
-                }
-                $node = $this->nodeOperations->create($parentNode, ['nodeType' => $type, 'nodeName' => $name], 'into');
-
-                // All document node types get a uri path segment; if it is not explicitly set in the properties,
-                // it should be built based on the title property
-                if ($node->getNodeType()->isOfType('Neos.Neos:Document')
-                    && isset($this->properties['title'])
-                    && !isset($this->properties['uriPathSegment'])) {
-                    $node->setProperty('uriPathSegment', NodeUtility::renderValidNodeName($this->properties['title']));
-                }
-            }
-            if ($node instanceof NodeInterface) {
-                $this->applyTemplateOnNode($node, $context);
-            }
-        }
-    }
-
-    public function isApplicable(array $context): bool
-    {
-        $isApplicable = true;
-        if ($this->when !== null) {
-            $isApplicable = $this->when;
-            if (preg_match(\Neos\Eel\Package::EelExpressionRecognizer, $isApplicable)) {
-                $isApplicable = $this->eelEvaluationService->evaluateEelExpression($isApplicable, $context);
-            }
-        }
-        return (bool)$isApplicable;
-    }
-
-    /**
-     * TODO: Handle EEL parsing for nested properties
-     */
-    protected function setProperties(NodeInterface $node, array $context): void
-    {
-        foreach ($this->properties as $propertyName => $propertyValue) {
-            //evaluate Eel only on string properties
-            if (is_string($propertyValue) && preg_match(\Neos\Eel\Package::EelExpressionRecognizer, $propertyValue)) {
-                $this->persistenceManager->persistAll();
-                $propertyValue = $this->eelEvaluationService->evaluateEelExpression($propertyValue, $context);
-            }
-            if ($propertyName[0] === '_') {
-                ObjectAccess::setProperty($node, substr($propertyName, 1), $propertyValue);
-            } else {
-                $node->setProperty($propertyName, $propertyValue);
-            }
-        }
-    }
-
-    /**
-     * Merge `withContext` onto the current $context, evaluating EEL if necessary
-     *
-     * The option `withContext` takes an array of items whose value can be any yaml/php type
-     * and might also contain eel expressions
-     *
-     * ```yaml
-     * withContext:
-     *   someText: '<p>foo</p>'
-     *   processedData: "${String.trim(data.bla)}"
-     *   booleanType: true
-     *   arrayType: ["value"]
-     * ```
-     *
-     * scopes and order of evaluation:
-     *
-     * - inside `withContext` the "upper" context may be accessed in eel expressions,
-     * but sibling context values are not available
-     *
-     * - `withContext` is evaluated before `when` and `withItems` so you can access computed values,
-     * that means the context `item` from `withItems` will not be available yet
-     *
-     * @param array<string, mixed> $context
-     * @return array<string, mixed>
-     */
-    private function mergeContextAndWithContext(array $context): array
-    {
-        if ($this->withContext === []) {
-            return $context;
-        }
-        $withContext = [];
-        foreach ($this->withContext as $key => $value) {
-            if (is_string($value) && preg_match(\Neos\Eel\Package::EelExpressionRecognizer, $value)) {
-                $value = $this->eelEvaluationService->evaluateEelExpression($value, $context);
-            }
-            $withContext[$key] = $value;
-        }
-        return array_merge($context, $withContext);
-    }
-
-    /**
-     * Signals that a node template has been applied to the given node.
-     *
-     * @Flow\Signal
-     * @api
-     */
-    public function emitNodeTemplateApplied(NodeInterface $node, array $context, array $options): void
-    {
-    }
-}
diff --git a/Configuration/NodeTypes.yaml b/Configuration/NodeTypes.yaml
index 0e7dc07..fb38e74 100644
--- a/Configuration/NodeTypes.yaml
+++ b/Configuration/NodeTypes.yaml
@@ -2,10 +2,10 @@
   options:
     nodeCreationHandlers:
       templateNodeCreationHandler:
-        nodeCreationHandler: 'Flowpack\NodeTemplates\NodeCreationHandler\TemplateNodeCreationHandler'
+        nodeCreationHandler: 'Flowpack\NodeTemplates\Domain\TemplateNodeCreationHandler'
 
 'Neos.Neos:Document':
   options:
     nodeCreationHandlers:
       documentTitle:
-        nodeCreationHandler: 'Flowpack\NodeTemplates\NodeCreationHandler\TemplatingDocumentTitleNodeCreationHandler'
+        nodeCreationHandler: 'Flowpack\NodeTemplates\Domain\DelegatingDocumentTitleNodeCreationHandler'
diff --git a/Configuration/Settings.yaml b/Configuration/Settings.yaml
index ae2336c..52477d1 100644
--- a/Configuration/Settings.yaml
+++ b/Configuration/Settings.yaml
@@ -1,5 +1,9 @@
 Flowpack:
   NodeTemplates:
+    exceptionHandling:
+      templateConfigurationProcessing:
+        stopOnException: false
+
     defaultEelContext:
       String: 'Neos\Eel\Helper\StringHelper'
       Array: 'Neos\Eel\Helper\ArrayHelper'
@@ -12,4 +16,3 @@ Flowpack:
       Type: 'Neos\Eel\Helper\TypeHelper'
       I18n: 'Neos\Flow\I18n\EelHelper\TranslationHelper'
       q: 'Neos\Eel\FlowQuery\FlowQuery::q'
-    nodeCreationDepth: 10
diff --git a/Configuration/Testing/NodeTypes.Malformed.yaml b/Configuration/Testing/NodeTypes.Malformed.yaml
new file mode 100644
index 0000000..1d5cd1e
--- /dev/null
+++ b/Configuration/Testing/NodeTypes.Malformed.yaml
@@ -0,0 +1,95 @@
+'Flowpack.NodeTemplates:Content.WithOneEvaluationException':
+  superTypes:
+    'Neos.Neos:ContentCollection': true
+  ui:
+    label: "WithOneEvaluationException"
+  options:
+    template:
+      childNodes:
+        abort:
+          type: 'Flowpack.NodeTemplates:Content.Text'
+          when: "${'left open"
+
+'Flowpack.NodeTemplates:Content.WithEvaluationExceptions':
+  superTypes:
+    'Neos.Neos:ContentCollection': true
+  ui:
+    label: "WithEvaluationExceptions"
+  properties:
+    boolValue:
+      type: boolean
+    stringValue:
+      type: string
+    reference:
+      type: reference
+    references:
+      type: references
+    working:
+      type: string
+  childNodes:
+    type-cant-mutate:
+      type: 'Flowpack.NodeTemplates:Content.Text'
+  options:
+    template:
+      properties:
+        foo: "${cannotCallThis()}"
+        # legacy properties fail
+        _hidden: true
+        _hiddenAfterDateTime: 123
+        boolValue: 123
+        stringValue: false
+        reference: "non-existing-node-id"
+        references: "${['non-existing-node-id']}"
+        working: "working"
+        nonDeclaredProperty: "hi"
+        bar: "${'left open"
+        # only simple scalar types
+        nonEelArrayNotAllowed:
+          not: allowed
+      childNodes:
+        whenAbort:
+          type: 'Flowpack.NodeTemplates:Content.Text'
+          when: "${parse äüäö error}"
+        working:
+          type: 'Flowpack.NodeTemplates:Content.Text'
+          properties:
+            text: bar
+        illegalNodeAbort:
+          type: 'Neos.Neos:Document'
+          name: 'illegal'
+          properties:
+            text: huhu
+        withContextAbort:
+          type: 'Flowpack.NodeTemplates:Content.Text'
+          withContext:
+            foo: "${}"
+        withItemsAbort:
+          type: 'Flowpack.NodeTemplates:Content.Text'
+          withItems: "${Array.map()}"
+        propertiesPartiallyWorking:
+          type: 'Flowpack.NodeTemplates:Content.Text'
+          properties:
+            propertyIsExcludedFromTemplate: "${"
+            text: "123"
+        typeAbort:
+          type: "${"
+        nameAbort:
+          name: "${"
+        withItemsPartiallyWorking:
+          type: 'Flowpack.NodeTemplates:Content.Text'
+          withItems: [1, 2]
+          name: "${item == 1 ? cannotCallThis() : null}"
+          properties:
+            text: "foo"
+        withItemsAbortBecauseNotIterable:
+          type: 'Flowpack.NodeTemplates:Content.Text'
+          withItems: null
+        typeIsNull:
+          type: null
+        typeIsInvalidNodeType:
+          type: "Flowpack.NodeTemplates:InvalidNodeType"
+        typeCantMutate:
+          name: "type-cant-mutate"
+          type: "Flowpack.NodeTemplates:Content.WithEvaluationExceptions"
+        invalidOption:
+          crazy: me
diff --git a/Configuration/Testing/NodeTypes.PageTemplates.yaml b/Configuration/Testing/NodeTypes.PageTemplates.yaml
new file mode 100644
index 0000000..35a1b1b
--- /dev/null
+++ b/Configuration/Testing/NodeTypes.PageTemplates.yaml
@@ -0,0 +1,109 @@
+
+'Flowpack.NodeTemplates:Document.Page.Static':
+  superTypes:
+    'Neos.Neos:Document': true
+  childNodes:
+    main:
+      type: 'Neos.Neos:ContentCollection'
+  options:
+    template:
+      properties:
+        title: Page1
+        uriPathSegment: page1
+      childNodes:
+        'Content Collection (main)':
+          name: main
+          childNodes:
+            content0:
+              type: 'Flowpack.NodeTemplates:Content.Text'
+              properties:
+                text: textOnPage1
+        page1:
+          type: 'Flowpack.NodeTemplates:Document.Page'
+          properties:
+            title: Page2
+            uriPathSegment: page2
+          childNodes:
+            'Content Collection (main)':
+              name: main
+              childNodes:
+                content0:
+                  type: 'Flowpack.NodeTemplates:Content.Text'
+                  properties:
+                    text: textOnPage2
+            page1:
+              type: 'Flowpack.NodeTemplates:Document.Page'
+              properties:
+                title: Page3
+                uriPathSegment: page3
+              childNodes:
+                'Content Collection (main)':
+                  name: main
+                  childNodes:
+                    content0:
+                      type: 'Flowpack.NodeTemplates:Content.Text'
+                      properties:
+                        text: textOnPage3
+        page2:
+          type: 'Flowpack.NodeTemplates:Document.Page'
+          properties:
+            title: Page4
+            uriPathSegment: page4
+          childNodes:
+            'Content Collection (main)':
+              name: main
+              childNodes:
+                content0:
+                  type: 'Flowpack.NodeTemplates:Content.Text'
+                  properties:
+                    text: textOnPage4
+
+
+'Flowpack.NodeTemplates:Document.Page.Dynamic':
+  superTypes:
+    'Neos.Neos:Document': true
+  childNodes:
+    main:
+      type: 'Neos.Neos:ContentCollection'
+  options:
+    template:
+      # title and uri path segment should be set via creation dialog data
+      childNodes:
+        'Content Collection (main)':
+          name: main
+          childNodes:
+            content0:
+              type: 'Flowpack.NodeTemplates:Content.Text'
+              properties:
+                # Text
+                text: textOnPage1
+        subPages:
+          withItems:
+            - Page2
+            - Page4
+          type: 'Flowpack.NodeTemplates:Document.Page'
+          properties:
+            title: "${item}"
+            # URL path segment will be set based on title
+          childNodes:
+            'Content Collection (main)':
+              name: main
+              childNodes:
+                content0:
+                  type: 'Flowpack.NodeTemplates:Content.Text'
+                  properties:
+                    text: "${item == 'Page2' ? 'textOnPage2' : 'textOnPage4'}"
+            page1:
+              when: "${item == 'Page2'}"
+              type: 'Flowpack.NodeTemplates:Document.Page'
+              properties:
+                title: Page3
+                uriPathSegment: page3
+              childNodes:
+                'Content Collection (main)':
+                  name: main
+                  childNodes:
+                    content0:
+                      type: 'Flowpack.NodeTemplates:Content.Text'
+                      properties:
+                        text: textOnPage3
diff --git a/Configuration/Testing/NodeTypes.yaml b/Configuration/Testing/NodeTypes.yaml
index 68af831..cca63f4 100644
--- a/Configuration/Testing/NodeTypes.yaml
+++ b/Configuration/Testing/NodeTypes.yaml
@@ -14,6 +14,56 @@
       ui:
         label: "Text"
 
+'Flowpack.NodeTemplates:Content.DifferentPropertyTypes':
+  superTypes:
+    'Neos.Neos:Content': true
+  properties:
+    text:
+      type: string
+      ui:
+        label: "Text"
+    isEnchanted:
+      type: boolean
+      ui:
+        label: "Boolean"
+    selectBox:
+      type: string
+      ui:
+        label: "Select Box"
+        inspector:
+          editor: Neos.Neos/Inspector/Editors/SelectBoxEditor
+          editorOptions:
+            values:
+              karma:
+                label: "A"
+              longLive:
+                label: "B"
+    reference:
+      type: reference
+      ui:
+        label: "Reference"
+        inspector:
+          editorOptions:
+            nodeTypes: ['Flowpack.NodeTemplates:Content.DifferentPropertyTypes']
+    nullValue: # Will be ignored from dumper but we nevertheless test, that we can set the value to "null"
+      type: string
+      ui:
+        label: "Null value"
+    unsetValueWithDefault:
+      defaultValue: true
+      type: boolean
+    someValueWithDefault:
+      defaultValue: true
+      type: boolean
+  options:
+    template:
+      properties:
+        text: "abc"
+        isEnchanted: false
+        selectBox: karma
+        reference: "${data.someNode}"
+        nullValue: null
+        unsetValueWithDefault: null
 'Flowpack.NodeTemplates:Content.Columns.Two':
   superTypes:
     'Neos.Neos:Content': true
diff --git a/README.md b/README.md
index ce2e6ba..6ce00da 100644
--- a/README.md
+++ b/README.md
@@ -12,8 +12,6 @@ template is applied can be changed or removed by the editor.
 The desired node structure is defined in a declarative way in the NodeTypes.yaml
 under the path "options.template".
 
-**Please note that the node templates package only works when using the new React UI.**
-
 ## TL;DR
 
 1. `composer require flowpack/nodetemplates`
@@ -80,16 +78,23 @@ You could let the editor choose between different dummy texts like this:
 If you want to apply a template only under some conditions, you can use the ``when`` configuration
 key. It can be used in the main node template or in any child node template.
 
-The following example hides a newly created node if the title entered in the node creation dialog
-contains the string "dummy":
+The following example only creates a text node if the option was selected in the creation dialog:
 
 ```yaml
-'Neos.NodeTypes:Page':
+'Your.NodeType:ContentCollection':
+  ui:
+    creationDialog:
+      elements:
+        createText:
+          type: boolean
   options:
     template:
-      properties:
-        _hidden: true
-      when: '${String.indexOf(String.toLowerCase(data.title), "dummy") >= 0}'
+      childNodes:
+        text:
+          type: 'Your.NodeType:Text'
+          properties:
+            text: "bar"
+          when: '${data.createText}'
 ```
 
 As a ``when`` condition that evaluates to ``false`` prevents the whole template (and all child
@@ -126,16 +131,14 @@ because it inspires a more declarative mood. The naming is inspired by Ansible.
 
 ## EEL context variables
 
-There are several variables available in the EEL context that allow for accessing node data, for example.
+There are several variables available in the EEL context for example.
 
-| Variable name  | Description                                                                               | Availability            |
-|----------------|-------------------------------------------------------------------------------------------|-------------------------|
-| data           | Data from the node creation dialog                                                        | Global (if data exists) |
-| triggeringNode | The main node whose creation triggered template processing                                | Global                  |
-| node           | The current node that has been created (equals triggeringNode for the outermost template) | Global                  |
-| parentNode     | The parentNode of the current node                                                        | Child nodes             |
-| item           | The current item inside a withItems loop                                                  | Inside withItems loop   |
-| key            | The current key inside a withItems loop                                                   | Inside withItems loop   |
+| Variable name  | Type                 | Description                                                | Availability          |
+|----------------|----------------------|------------------------------------------------------------|-----------------------|
+| data           | array<string, mixed> | Data from the node creation dialog                         | Global                |
+| triggeringNode | NodeInterface        | The main node whose creation triggered template processing | Global                |
+| item           | mixed                | The current item inside a withItems loop                   | Inside withItems loop |
+| key            | string               | The current key inside a withItems loop                    | Inside withItems loop |
 
 ### Additional context
 
@@ -166,16 +169,24 @@ values are not available. As ``withContext`` is evaluated before ``when`` and ``
 access context variables from ``withContext`` in ``withItems`` at the same level – but not the other
 way around.
 
-## Node creation depth
+## Exception handling, resuming with the next possible operation.
 
-The node creation depth can be configured via Settings.yaml with `nodeCreationDepth`, defaults to `10`. 
+In the first step the configuration is processed, exceptions like those caused by an EEL Expression are caught, and any malformed parts of the template are ignored (with their errors being logged).
+This might lead to a partially processed template with some properties or childNodes missing.
+
+You can decide via the exception handling configuration `Flowpack.NodeTemplates.exceptionHandling`, if you want to start the node creation of this partially processed template (`stopOnException: false`) or abort the process (`stopOnException: true`), which will only lead to creating the root node, ignoring the whole template.
 
 ```yaml
 Flowpack:
   NodeTemplates:
-    nodeCreationDepth: 10
+    exceptionHandling:
+     templateConfigurationProcessing:
+        stopOnException: false
 ```
 
+In case exceptions are thrown in the node creation of the template, because a node constraint was not met or the `type` field was not set, the creation of the childNode is aborted, but we continue with the node creation of the other left over parts of the template.
+It behaves similar with properties: In case a property value doesn't match its declared type the exception is logged, but we will try to continue with the next property.
+
 ## Create template from node subtree
 
 When creating a more complex node template (to create multiple pages and content elements) it can be helpful to take the current node subtree from your workspace as reference.
diff --git a/Testing/Functional/NodeTemplateTest.php b/Testing/Functional/NodeTemplateTest.php
deleted file mode 100644
index 8ac025b..0000000
--- a/Testing/Functional/NodeTemplateTest.php
+++ /dev/null
@@ -1,161 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Flowpack\NodeTemplates\Tests\Functional;
-
-use Flowpack\NodeTemplates\NodeTemplateDumper\NodeTemplateDumper;
-use Neos\ContentRepository\Domain\Model\Node;
-use Neos\ContentRepository\Domain\Model\NodeInterface;
-use Neos\ContentRepository\Domain\Model\Workspace;
-use Neos\ContentRepository\Domain\NodeType\NodeTypeName;
-use Neos\ContentRepository\Domain\Repository\WorkspaceRepository;
-use Neos\ContentRepository\Domain\Service\ContextFactoryInterface;
-use Neos\ContentRepository\Domain\Service\NodeTypeManager;
-use Neos\Flow\Tests\FunctionalTestCase;
-use Neos\Neos\Domain\Model\Site;
-use Neos\Neos\Domain\Repository\SiteRepository;
-use Neos\Neos\Ui\Domain\Model\ChangeCollection;
-use Neos\Neos\Ui\TypeConverter\ChangeCollectionConverter;
-
-class NodeTemplateTest extends FunctionalTestCase
-{
-    protected static $testablePersistenceEnabled = true;
-
-    private ContextFactoryInterface $contextFactory;
-
-    private Node $homePageNode;
-
-    private NodeTemplateDumper $nodeTemplateDumper;
-
-    public function setUp(): void
-    {
-        parent::setUp();
-        $this->setupContentRepository();
-        $this->nodeTemplateDumper = $this->objectManager->get(NodeTemplateDumper::class);
-    }
-
-    private function setupContentRepository(): void
-    {
-        // Create an environment to create nodes.
-        $liveWorkspace = new Workspace('live');
-        $workspaceRepository = $this->objectManager->get(WorkspaceRepository::class);
-        $workspaceRepository->add($liveWorkspace);
-
-        $testSite = new Site('test-site');
-        $testSite->setSiteResourcesPackageKey('Test.Site');
-        $siteRepository = $this->objectManager->get(SiteRepository::class);
-        $siteRepository->add($testSite);
-
-        $this->persistenceManager->persistAll();
-        $this->contextFactory = $this->objectManager->get(ContextFactoryInterface::class);
-        $this->subgraph = $this->contextFactory->create(['workspaceName' => 'live']);
-
-        $rootNode = $this->subgraph->getRootNode();
-
-        $nodeTypeManager = $this->objectManager->get(NodeTypeManager::class);
-
-        $sitesRootNode = $rootNode->createNode('sites');
-        $testSiteNode = $sitesRootNode->createNode('test-site');
-        $this->homePageNode = $testSiteNode->createNode(
-            'homepage',
-            $nodeTypeManager->getNodeType('Flowpack.NodeTemplates:Document.Page')
-        );
-    }
-
-    /**
-     * @param Node|NodeInterface $targetNode
-     * @param array<string, mixed> $nodeCreationDialogValues
-     */
-    private function createNodeInto(Node $targetNode, NodeTypeName $nodeTypeName, array $nodeCreationDialogValues): void
-    {
-        $targetNodeContextPath = $targetNode->getContextPath();
-
-        $changeCollectionSerialized = [[
-            'type' => 'Neos.Neos.Ui:CreateInto',
-            'subject' => $targetNodeContextPath,
-            'payload' => [
-                'parentContextPath' => $targetNodeContextPath,
-                'parentDomAddress' => [
-                    'contextPath' => $targetNodeContextPath,
-                ],
-                'nodeType' => $nodeTypeName->getValue(),
-                'data' => $nodeCreationDialogValues,
-                'baseNodeType' => '',
-            ],
-        ]];
-
-        $changeCollection = (new ChangeCollectionConverter())->convertFrom($changeCollectionSerialized, null);
-        assert($changeCollection instanceof ChangeCollection);
-        $changeCollection->apply();
-    }
-
-
-    /** @test */
-    public function testNodeCreationMatchesSnapshot1(): void
-    {
-        $this->createNodeInto(
-            $targetNode = $this->homePageNode->getNode('main'),
-            $toBeCreatedNodeTypeName = NodeTypeName::fromString('Flowpack.NodeTemplates:Content.Columns.Two'),
-            []
-        );
-
-        $createdNode = $targetNode->getChildNodes($toBeCreatedNodeTypeName->getValue())[0];
-
-        $dumpedYamlTemplate = $this->nodeTemplateDumper->createNodeTemplateYamlDumpFromSubtree($createdNode);
-
-        $snapshot = file_get_contents(__DIR__ . '/Fixtures/TwoColumnPreset.yaml');
-        self::assertSame(
-            str_replace('{nodeTypeName}', $toBeCreatedNodeTypeName->getValue(), $snapshot),
-            $dumpedYamlTemplate
-        );
-    }
-
-    /** @test */
-    public function testNodeCreationMatchesSnapshot2(): void
-    {
-        $this->createNodeInto(
-            $targetNode = $this->homePageNode->getNode('main'),
-            $toBeCreatedNodeTypeName = NodeTypeName::fromString('Flowpack.NodeTemplates:Content.Columns.Two.CreationDialogAndWithItems'),
-            [
-                'text' => '<p>bar</p>'
-            ]
-        );
-
-        $createdNode = $targetNode->getChildNodes($toBeCreatedNodeTypeName->getValue())[0];
-
-        $dumpedYamlTemplate = $this->nodeTemplateDumper->createNodeTemplateYamlDumpFromSubtree($createdNode);
-
-        $snapshot = file_get_contents(__DIR__ . '/Fixtures/TwoColumnPreset.yaml');
-        self::assertSame(
-            str_replace('{nodeTypeName}', $toBeCreatedNodeTypeName->getValue(), $snapshot),
-            $dumpedYamlTemplate
-        );
-    }
-
-    /** @test */
-    public function testNodeCreationMatchesSnapshot3(): void
-    {
-        $this->createNodeInto(
-            $targetNode = $this->homePageNode->getNode('main'),
-            $toBeCreatedNodeTypeName = NodeTypeName::fromString('Flowpack.NodeTemplates:Content.Columns.Two.WithContext'),
-            []
-        );
-
-        $createdNode = $targetNode->getChildNodes($toBeCreatedNodeTypeName->getValue())[0];
-
-        $dumpedYamlTemplate = $this->nodeTemplateDumper->createNodeTemplateYamlDumpFromSubtree($createdNode);
-
-        $snapshot = file_get_contents(__DIR__ . '/Fixtures/TwoColumnPreset.yaml');
-        self::assertSame(
-            str_replace('{nodeTypeName}', $toBeCreatedNodeTypeName->getValue(), $snapshot),
-            $dumpedYamlTemplate
-        );
-    }
-
-    public function tearDown(): void
-    {
-        parent::tearDown();
-        $this->inject($this->contextFactory, 'contextInstances', []);
-    }
-}
diff --git a/Tests/Functional/FeedbackCollectionMessagesTrait.php b/Tests/Functional/FeedbackCollectionMessagesTrait.php
new file mode 100644
index 0000000..ff79289
--- /dev/null
+++ b/Tests/Functional/FeedbackCollectionMessagesTrait.php
@@ -0,0 +1,27 @@
+<?php
+
+namespace Flowpack\NodeTemplates\Tests\Functional;
+
+use Neos\Flow\Mvc\Controller\ControllerContext;
+use Neos\Neos\Ui\Domain\Model\Feedback\AbstractMessageFeedback;
+use Neos\Neos\Ui\Domain\Model\FeedbackCollection;
+use Neos\Neos\Ui\Domain\Model\FeedbackInterface;
+use Neos\Utility\ObjectAccess;
+
+trait FeedbackCollectionMessagesTrait
+{
+    private function getMessagesOfFeedbackCollection(): array
+    {
+        /** @var FeedbackInterface[] $allFeedbacks */
+        $allFeedbacks = ObjectAccess::getProperty($this->objectManager->get(FeedbackCollection::class), 'feedbacks', true);
+
+        /** @var AbstractMessageFeedback[] $allFeedbacks */
+        $messages = [];
+        foreach ($allFeedbacks as $feedback) {
+            if ($feedback instanceof AbstractMessageFeedback) {
+                $messages[] = $feedback->serializePayload($this->createStub(ControllerContext::class));
+            }
+        }
+        return $messages;
+    }
+}
diff --git a/Tests/Functional/Fixtures/DifferentPropertyTypes.nodes.json b/Tests/Functional/Fixtures/DifferentPropertyTypes.nodes.json
new file mode 100644
index 0000000..544d30d
--- /dev/null
+++ b/Tests/Functional/Fixtures/DifferentPropertyTypes.nodes.json
@@ -0,0 +1,16 @@
+{
+    "properties": {
+        "unsetValueWithDefault": null,
+        "someValueWithDefault": true,
+        "text": "abc",
+        "isEnchanted": false,
+        "selectBox": "karma"
+    },
+    "references": {
+        "reference": [
+            {
+                "node": "Node(7f7bac1c-9400-4db5-bbaa-2b8251d127c5, unstructured)"
+            }
+        ]
+    }
+}
diff --git a/Tests/Functional/Fixtures/DifferentPropertyTypes.template.json b/Tests/Functional/Fixtures/DifferentPropertyTypes.template.json
new file mode 100644
index 0000000..81c8297
--- /dev/null
+++ b/Tests/Functional/Fixtures/DifferentPropertyTypes.template.json
@@ -0,0 +1,11 @@
+{
+    "properties": {
+        "text": "abc",
+        "isEnchanted": false,
+        "selectBox": "karma",
+        "reference": "Node(7f7bac1c-9400-4db5-bbaa-2b8251d127c5, unstructured)",
+        "nullValue": null,
+        "unsetValueWithDefault": null
+    },
+    "childNodes": []
+}
diff --git a/Tests/Functional/Fixtures/DifferentPropertyTypes.yaml b/Tests/Functional/Fixtures/DifferentPropertyTypes.yaml
new file mode 100644
index 0000000..141c5ba
--- /dev/null
+++ b/Tests/Functional/Fixtures/DifferentPropertyTypes.yaml
@@ -0,0 +1,12 @@
+'{nodeTypeName}':
+  options:
+    template:
+      properties:
+        # Text
+        text: abc
+        # Boolean
+        isEnchanted: false
+        # Select Box
+        # selectBox -> SelectBox of ["karma","longLive"] with value "karma"
+        # Reference
+        # reference -> Reference of NodeTypes (Flowpack.NodeTemplates:Content.DifferentPropertyTypes) with value Node(7f7bac1c-9400-4db5-bbaa-2b8251d127c5)
diff --git a/Tests/Functional/Fixtures/PagePreset.nodes.json b/Tests/Functional/Fixtures/PagePreset.nodes.json
new file mode 100644
index 0000000..7bf8181
--- /dev/null
+++ b/Tests/Functional/Fixtures/PagePreset.nodes.json
@@ -0,0 +1,83 @@
+{
+    "properties": {
+        "uriPathSegment": "page1",
+        "title": "Page1"
+    },
+    "childNodes": [
+        {
+            "nodeTypeName": "Neos.Neos:ContentCollection",
+            "nodeName": "main",
+            "childNodes": [
+                {
+                    "nodeTypeName": "Flowpack.NodeTemplates:Content.Text",
+                    "properties": {
+                        "text": "textOnPage1"
+                    }
+                }
+            ]
+        },
+        {
+            "nodeTypeName": "Flowpack.NodeTemplates:Document.Page",
+            "properties": {
+                "uriPathSegment": "page2",
+                "title": "Page2"
+            },
+            "childNodes": [
+                {
+                    "nodeTypeName": "Neos.Neos:ContentCollection",
+                    "nodeName": "main",
+                    "childNodes": [
+                        {
+                            "nodeTypeName": "Flowpack.NodeTemplates:Content.Text",
+                            "properties": {
+                                "text": "textOnPage2"
+                            }
+                        }
+                    ]
+                },
+                {
+                    "nodeTypeName": "Flowpack.NodeTemplates:Document.Page",
+                    "properties": {
+                        "uriPathSegment": "page3",
+                        "title": "Page3"
+                    },
+                    "childNodes": [
+                        {
+                            "nodeTypeName": "Neos.Neos:ContentCollection",
+                            "nodeName": "main",
+                            "childNodes": [
+                                {
+                                    "nodeTypeName": "Flowpack.NodeTemplates:Content.Text",
+                                    "properties": {
+                                        "text": "textOnPage3"
+                                    }
+                                }
+                            ]
+                        }
+                    ]
+                }
+            ]
+        },
+        {
+            "nodeTypeName": "Flowpack.NodeTemplates:Document.Page",
+            "properties": {
+                "uriPathSegment": "page4",
+                "title": "Page4"
+            },
+            "childNodes": [
+                {
+                    "nodeTypeName": "Neos.Neos:ContentCollection",
+                    "nodeName": "main",
+                    "childNodes": [
+                        {
+                            "nodeTypeName": "Flowpack.NodeTemplates:Content.Text",
+                            "properties": {
+                                "text": "textOnPage4"
+                            }
+                        }
+                    ]
+                }
+            ]
+        }
+    ]
+}
diff --git a/Tests/Functional/Fixtures/PagePreset.template.json b/Tests/Functional/Fixtures/PagePreset.template.json
new file mode 100644
index 0000000..37cee55
--- /dev/null
+++ b/Tests/Functional/Fixtures/PagePreset.template.json
@@ -0,0 +1,98 @@
+{
+    "properties": {
+        "title": "Page1",
+        "uriPathSegment": "page1"
+    },
+    "childNodes": [
+        {
+            "type": null,
+            "name": "main",
+            "properties": [],
+            "childNodes": [
+                {
+                    "type": "Flowpack.NodeTemplates:Content.Text",
+                    "name": null,
+                    "properties": {
+                        "text": "textOnPage1"
+                    },
+                    "childNodes": []
+                }
+            ]
+        },
+        {
+            "type": "Flowpack.NodeTemplates:Document.Page",
+            "name": null,
+            "properties": {
+                "title": "Page2",
+                "uriPathSegment": "page2"
+            },
+            "childNodes": [
+                {
+                    "type": null,
+                    "name": "main",
+                    "properties": [],
+                    "childNodes": [
+                        {
+                            "type": "Flowpack.NodeTemplates:Content.Text",
+                            "name": null,
+                            "properties": {
+                                "text": "textOnPage2"
+                            },
+                            "childNodes": []
+                        }
+                    ]
+                },
+                {
+                    "type": "Flowpack.NodeTemplates:Document.Page",
+                    "name": null,
+                    "properties": {
+                        "title": "Page3",
+                        "uriPathSegment": "page3"
+                    },
+                    "childNodes": [
+                        {
+                            "type": null,
+                            "name": "main",
+                            "properties": [],
+                            "childNodes": [
+                                {
+                                    "type": "Flowpack.NodeTemplates:Content.Text",
+                                    "name": null,
+                                    "properties": {
+                                        "text": "textOnPage3"
+                                    },
+                                    "childNodes": []
+                                }
+                            ]
+                        }
+                    ]
+                }
+            ]
+        },
+        {
+            "type": "Flowpack.NodeTemplates:Document.Page",
+            "name": null,
+            "properties": {
+                "title": "Page4",
+                "uriPathSegment": "page4"
+            },
+            "childNodes": [
+                {
+                    "type": null,
+                    "name": "main",
+                    "properties": [],
+                    "childNodes": [
+                        {
+                            "type": "Flowpack.NodeTemplates:Content.Text",
+                            "name": null,
+                            "properties": {
+                                "text": "textOnPage4"
+                            },
+                            "childNodes": []
+                        }
+                    ]
+                }
+            ]
+        }
+    ]
+}
diff --git a/Tests/Functional/Fixtures/PagePreset.yaml b/Tests/Functional/Fixtures/PagePreset.yaml
new file mode 100644
index 0000000..5138a4f
--- /dev/null
+++ b/Tests/Functional/Fixtures/PagePreset.yaml
@@ -0,0 +1,65 @@
+'{nodeTypeName}':
+  options:
+    template:
+      properties:
+        # Title
+        title: Page1
+        # URL path segment
+        uriPathSegment: page1
+      childNodes:
+        'Content Collection (main)':
+          name: main
+          childNodes:
+            content0:
+              type: 'Flowpack.NodeTemplates:Content.Text'
+              properties:
+                # Text
+                text: textOnPage1
+        page1:
+          type: 'Flowpack.NodeTemplates:Document.Page'
+          properties:
+            # Title
+            title: Page2
+            # URL path segment
+            uriPathSegment: page2
+          childNodes:
+            'Content Collection (main)':
+              name: main
+              childNodes:
+                content0:
+                  type: 'Flowpack.NodeTemplates:Content.Text'
+                  properties:
+                    # Text
+                    text: textOnPage2
+            page1:
+              type: 'Flowpack.NodeTemplates:Document.Page'
+              properties:
+                # Title
+                title: Page3
+                # URL path segment
+                uriPathSegment: page3
+              childNodes:
+                'Content Collection (main)':
+                  name: main
+                  childNodes:
+                    content0:
+                      type: 'Flowpack.NodeTemplates:Content.Text'
+                      properties:
+                        # Text
+                        text: textOnPage3
+        page2:
+          type: 'Flowpack.NodeTemplates:Document.Page'
+          properties:
+            # Title
+            title: Page4
+            # URL path segment
+            uriPathSegment: page4
+          childNodes:
+            'Content Collection (main)':
+              name: main
+              childNodes:
+                content0:
+                  type: 'Flowpack.NodeTemplates:Content.Text'
+                  properties:
+                    # Text
+                    text: textOnPage4
diff --git a/Tests/Functional/Fixtures/TwoColumnPreset.nodes.json b/Tests/Functional/Fixtures/TwoColumnPreset.nodes.json
new file mode 100644
index 0000000..886a6cb
--- /dev/null
+++ b/Tests/Functional/Fixtures/TwoColumnPreset.nodes.json
@@ -0,0 +1,28 @@
+{
+    "childNodes": [
+        {
+            "nodeTypeName": "Neos.Neos:ContentCollection",
+            "nodeName": "column0",
+            "childNodes": [
+                {
+                    "nodeTypeName": "Flowpack.NodeTemplates:Content.Text",
+                    "properties": {
+                        "text": "<p>foo<\/p>"
+                    }
+                }
+            ]
+        },
+        {
+            "nodeTypeName": "Neos.Neos:ContentCollection",
+            "nodeName": "column1",
+            "childNodes": [
+                {
+                    "nodeTypeName": "Flowpack.NodeTemplates:Content.Text",
+                    "properties": {
+                        "text": "<p>bar<\/p>"
+                    }
+                }
+            ]
+        }
+    ]
+}
diff --git a/Tests/Functional/Fixtures/TwoColumnPreset.template.json b/Tests/Functional/Fixtures/TwoColumnPreset.template.json
new file mode 100644
index 0000000..973a42e
--- /dev/null
+++ b/Tests/Functional/Fixtures/TwoColumnPreset.template.json
@@ -0,0 +1,35 @@
+{
+    "properties": [],
+    "childNodes": [
+        {
+            "type": null,
+            "name": "column0",
+            "properties": [],
+            "childNodes": [
+                {
+                    "type": "Flowpack.NodeTemplates:Content.Text",
+                    "name": null,
+                    "properties": {
+                        "text": "<p>foo<\/p>"
+                    },
+                    "childNodes": []
+                }
+            ]
+        },
+        {
+            "type": null,
+            "name": "column1",
+            "properties": [],
+            "childNodes": [
+                {
+                    "type": "Flowpack.NodeTemplates:Content.Text",
+                    "name": null,
+                    "properties": {
+                        "text": "<p>bar<\/p>"
+                    },
+                    "childNodes": []
+                }
+            ]
+        }
+    ]
+}
diff --git a/Testing/Functional/Fixtures/TwoColumnPreset.yaml b/Tests/Functional/Fixtures/TwoColumnPreset.yaml
similarity index 100%
rename from Testing/Functional/Fixtures/TwoColumnPreset.yaml
rename to Tests/Functional/Fixtures/TwoColumnPreset.yaml
diff --git a/Tests/Functional/Fixtures/WithEvaluationExceptions.messages.json b/Tests/Functional/Fixtures/WithEvaluationExceptions.messages.json
new file mode 100644
index 0000000..0e0b812
--- /dev/null
+++ b/Tests/Functional/Fixtures/WithEvaluationExceptions.messages.json
@@ -0,0 +1,98 @@
+[
+    {
+        "message": "Template for \"WithEvaluationExceptions\" only partially applied. Please check the newly created nodes beneath Node \/sites\/test-site\/homepage\/main\/new-node@live[Flowpack.NodeTemplates:Content.WithEvaluationExceptions].",
+        "severity": "ERROR"
+    },
+    {
+        "message": "Expression \"${cannotCallThis()}\" in \"properties.foo\" | NotAllowedException(Method \"cannotCallThis\" is not callable in untrusted context, 1369043080)",
+        "severity": "ERROR"
+    },
+    {
+        "message": "Expression \"${'left open\" in \"properties.bar\" | EelException(The EEL expression \"${'left open\" was not a valid EEL expression. Perhaps you forgot to wrap it in ${...}?, 1410441849)",
+        "severity": "ERROR"
+    },
+    {
+        "message": "RuntimeException(Template configuration properties can only hold int|float|string|bool|null. Property \"nonEelArrayNotAllowed\" has type \"array\", 1685725310730)",
+        "severity": "ERROR"
+    },
+    {
+        "message": "Expression \"${parse \u00e4\u00fc\u00e4\u00f6 error}\" in \"childNodes.whenAbort.when\" | ParserException(Expression \"parse \u00e4\u00fc\u00e4\u00f6 error\" could not be parsed. Error starting at character 5: \" \u00e4\u00fc\u00e4\u00f6 error\"., 1327682383)",
+        "severity": "ERROR"
+    },
+    {
+        "message": "Expression \"${}\" in \"childNodes.withContextAbort.withContext.foo\" | ParserException(Expression \"\" could not be parsed., 1344513194)",
+        "severity": "ERROR"
+    },
+    {
+        "message": "Expression \"${Array.map()}\" in \"childNodes.withItemsAbort.withItems\" | ArgumentCountError(Too few arguments to function Neos\\Eel\\Helper\\ArrayHelper::map(), 0 passed and exactly 2 expected, 0)",
+        "severity": "ERROR"
+    },
+    {
+        "message": "Expression \"${\" in \"childNodes.propertiesPartiallyWorking.properties.propertyIsExcludedFromTemplate\" | EelException(The EEL expression \"${\" was not a valid EEL expression. Perhaps you forgot to wrap it in ${...}?, 1410441849)",
+        "severity": "ERROR"
+    },
+    {
+        "message": "Expression \"${\" in \"childNodes.typeAbort.type\" | EelException(The EEL expression \"${\" was not a valid EEL expression. Perhaps you forgot to wrap it in ${...}?, 1410441849)",
+        "severity": "ERROR"
+    },
+    {
+        "message": "Expression \"${\" in \"childNodes.nameAbort.name\" | EelException(The EEL expression \"${\" was not a valid EEL expression. Perhaps you forgot to wrap it in ${...}?, 1410441849)",
+        "severity": "ERROR"
+    },
+    {
+        "message": "Expression \"${item == 1 ? cannotCallThis() : null}\" in \"childNodes.withItemsPartiallyWorking.name\" | NotAllowedException(Method \"cannotCallThis\" is not callable in untrusted context, 1369043080)",
+        "severity": "ERROR"
+    },
+    {
+        "message": "Configuration \"null\" in \"childNodes.withItemsAbortBecauseNotIterable.withItems\" | RuntimeException(Type NULL is not iterable., 1685802354186)",
+        "severity": "ERROR"
+    },
+    {
+        "message": "InvalidArgumentException(Template configuration has illegal key \"crazy\", 1686150349274)",
+        "severity": "ERROR"
+    },
+    {
+        "message": "Property \"_hidden\" in NodeType \"Flowpack.NodeTemplates:Content.WithEvaluationExceptions\" | PropertyIgnoredException(Because internal legacy property \"_hidden\" not implement., 1686149513158)",
+        "severity": "ERROR"
+    },
+    {
+        "message": "Property \"_hiddenAfterDateTime\" in NodeType \"Flowpack.NodeTemplates:Content.WithEvaluationExceptions\" | PropertyIgnoredException(Because internal legacy property \"_hiddenAfterDateTime\" not implement., 1686149513158)",
+        "severity": "ERROR"
+    },
+    {
+        "message": "Property \"boolValue\" in NodeType \"Flowpack.NodeTemplates:Content.WithEvaluationExceptions\" | PropertyIgnoredException(Because value `123` is not assignable to property type \"boolean\"., 1685958105644)",
+        "severity": "ERROR"
+    },
+    {
+        "message": "Property \"stringValue\" in NodeType \"Flowpack.NodeTemplates:Content.WithEvaluationExceptions\" | PropertyIgnoredException(Because value `false` is not assignable to property type \"string\"., 1685958105644)",
+        "severity": "ERROR"
+    },
+    {
+        "message": "Property \"nonDeclaredProperty\" in NodeType \"Flowpack.NodeTemplates:Content.WithEvaluationExceptions\" | PropertyIgnoredException(Because property is not declared in NodeType. Got value `\"hi\"`., 1685869035209)",
+        "severity": "ERROR"
+    },
+    {
+        "message": "Reference \"reference\" in NodeType \"Flowpack.NodeTemplates:Content.WithEvaluationExceptions\" | RuntimeException(Reference could not be set, because node reference(s) \"non-existing-node-id\" cannot be resolved., 1685958176560)",
+        "severity": "ERROR"
+    },
+    {
+        "message": "Reference \"references\" in NodeType \"Flowpack.NodeTemplates:Content.WithEvaluationExceptions\" | RuntimeException(Reference could not be set, because node reference(s) [\"non-existing-node-id\"] cannot be resolved., 1685958176560)",
+        "severity": "ERROR"
+    },
+    {
+        "message": "NodeConstraintException(Cannot create new node \"illegal\" of Type \"Neos.Neos:Document\" in Node \/sites\/test-site\/homepage\/main\/new-node@live[Flowpack.NodeTemplates:Content.WithEvaluationExceptions], 1400782413)",
+        "severity": "ERROR"
+    },
+    {
+        "message": "RuntimeException(Template requires type to be set for non auto created child nodes., 1685999829307)",
+        "severity": "ERROR"
+    },
+    {
+        "message": "RuntimeException(Template requires type to be a valid NodeType. Got: \"Flowpack.NodeTemplates:InvalidNodeType\"., 1685999795564)",
+        "severity": "ERROR"
+    },
+    {
+        "message": "RuntimeException(Template cant mutate type of auto created child nodes. Got: \"Flowpack.NodeTemplates:Content.WithEvaluationExceptions\", 1685999829307)",
+        "severity": "ERROR"
+    }
+]
diff --git a/Tests/Functional/Fixtures/WithEvaluationExceptions.nodes.json b/Tests/Functional/Fixtures/WithEvaluationExceptions.nodes.json
new file mode 100644
index 0000000..fda3e10
--- /dev/null
+++ b/Tests/Functional/Fixtures/WithEvaluationExceptions.nodes.json
@@ -0,0 +1,29 @@
+{
+    "properties": {
+        "working": "working"
+    },
+    "childNodes": [
+        {
+            "nodeTypeName": "Flowpack.NodeTemplates:Content.Text",
+            "nodeName": "type-cant-mutate"
+        },
+        {
+            "nodeTypeName": "Flowpack.NodeTemplates:Content.Text",
+            "properties": {
+                "text": "bar"
+            }
+        },
+        {
+            "nodeTypeName": "Flowpack.NodeTemplates:Content.Text",
+            "properties": {
+                "text": "123"
+            }
+        },
+        {
+            "nodeTypeName": "Flowpack.NodeTemplates:Content.Text",
+            "properties": {
+                "text": "foo"
+            }
+        }
+    ]
+}
diff --git a/Tests/Functional/Fixtures/WithEvaluationExceptions.template.json b/Tests/Functional/Fixtures/WithEvaluationExceptions.template.json
new file mode 100644
index 0000000..dc99bca
--- /dev/null
+++ b/Tests/Functional/Fixtures/WithEvaluationExceptions.template.json
@@ -0,0 +1,66 @@
+{
+    "properties": {
+        "_hidden": true,
+        "_hiddenAfterDateTime": 123,
+        "boolValue": 123,
+        "stringValue": false,
+        "reference": "non-existing-node-id",
+        "references": [
+            "non-existing-node-id"
+        ],
+        "working": "working",
+        "nonDeclaredProperty": "hi"
+    },
+    "childNodes": [
+        {
+            "type": "Flowpack.NodeTemplates:Content.Text",
+            "name": null,
+            "properties": {
+                "text": "bar"
+            },
+            "childNodes": []
+        },
+        {
+            "type": "Neos.Neos:Document",
+            "name": "illegal",
+            "properties": {
+                "text": "huhu"
+            },
+            "childNodes": []
+        },
+        {
+            "type": "Flowpack.NodeTemplates:Content.Text",
+            "name": null,
+            "properties": {
+                "text": "123"
+            },
+            "childNodes": []
+        },
+        {
+            "type": "Flowpack.NodeTemplates:Content.Text",
+            "name": null,
+            "properties": {
+                "text": "foo"
+            },
+            "childNodes": []
+        },
+        {
+            "type": null,
+            "name": null,
+            "properties": [],
+            "childNodes": []
+        },
+        {
+            "type": "Flowpack.NodeTemplates:InvalidNodeType",
+            "name": null,
+            "properties": [],
+            "childNodes": []
+        },
+        {
+            "type": "Flowpack.NodeTemplates:Content.WithEvaluationExceptions",
+            "name": "type-cant-mutate",
+            "properties": [],
+            "childNodes": []
+        }
+    ]
+}
diff --git a/Tests/Functional/Fixtures/WithEvaluationExceptions.yaml b/Tests/Functional/Fixtures/WithEvaluationExceptions.yaml
new file mode 100644
index 0000000..c5c7aca
--- /dev/null
+++ b/Tests/Functional/Fixtures/WithEvaluationExceptions.yaml
@@ -0,0 +1,21 @@
+'{nodeTypeName}':
+  options:
+    template:
+      properties:
+        working: working
+      childNodes:
+        content1:
+          type: 'Flowpack.NodeTemplates:Content.Text'
+          properties:
+            # Text
+            text: bar
+        content2:
+          type: 'Flowpack.NodeTemplates:Content.Text'
+          properties:
+            # Text
+            text: '123'
+        content3:
+          type: 'Flowpack.NodeTemplates:Content.Text'
+          properties:
+            # Text
+            text: foo
diff --git a/Tests/Functional/Fixtures/WithOneEvaluationException.template.json b/Tests/Functional/Fixtures/WithOneEvaluationException.template.json
new file mode 100644
index 0000000..a61e568
--- /dev/null
+++ b/Tests/Functional/Fixtures/WithOneEvaluationException.template.json
@@ -0,0 +1,4 @@
+{
+    "properties": [],
+    "childNodes": []
+}
diff --git a/Tests/Functional/JsonSerializeNodeTreeTrait.php b/Tests/Functional/JsonSerializeNodeTreeTrait.php
new file mode 100644
index 0000000..9b8f023
--- /dev/null
+++ b/Tests/Functional/JsonSerializeNodeTreeTrait.php
@@ -0,0 +1,62 @@
+<?php
+
+namespace Flowpack\NodeTemplates\Tests\Functional;
+
+use Neos\ContentRepository\Domain\Model\NodeInterface;
+
+trait JsonSerializeNodeTreeTrait
+{
+    private function jsonSerializeNodeAndDescendents(NodeInterface $node): array
+    {
+        $nodeType = $node->getNodeType();
+        $references = [];
+        $properties = [];
+        foreach ($node->getProperties() as $propertyName => $propertyValue) {
+            $declaration = $nodeType->getPropertyType($propertyName);
+            if ($declaration === 'reference' || $declaration === 'references') {
+                $references[$propertyName] = [];
+                foreach ($declaration === 'reference' ? [$propertyValue] : $propertyValue as $reference) {
+                    $references[$propertyName][] = array_filter([
+                        'node' => $reference,
+                        'properties' => []
+                    ]);
+                }
+                continue;
+            }
+            $properties[$propertyName] = $propertyValue;
+        }
+        return array_filter([
+            'nodeTypeName' => $node->getNodeType()->getName(),
+            'nodeName' => $node->isAutoCreated() ? $node->getName() : null,
+            'isDisabled' => $node->isHidden(),
+            'properties' => $this->serializeValuesInArray($properties),
+            'references' => $this->serializeValuesInArray($references),
+            'childNodes' => array_map(
+                fn ($node) => $this->jsonSerializeNodeAndDescendents($node),
+                $node->getChildNodes('Neos.Neos:Node')
+            )
+        ]);
+    }
+
+    private function serializeValuesInArray(array $array): array
+    {
+        foreach ($array as $key => $value) {
+            if (is_array($value)) {
+                $value = $this->serializeValuesInArray($value);
+            } elseif ($value instanceof NodeInterface) {
+                $value = sprintf('Node(%s, %s)', $value->getIdentifier(), $value->getNodeType()->getName());
+            } elseif ($value instanceof \JsonSerializable) {
+                $value = $value->jsonSerialize();
+                if (is_array($value)) {
+                    $value = $this->serializeValuesInArray($value);
+                }
+            } elseif (is_object($value)) {
+                $value = sprintf('object(%s)', get_class($value));
+            } else {
+                continue;
+            }
+            $array[$key] = $value;
+        }
+        return $array;
+    }
+}
diff --git a/Tests/Functional/NodeTemplateTest.php b/Tests/Functional/NodeTemplateTest.php
new file mode 100644
index 0000000..3ad81c6
--- /dev/null
+++ b/Tests/Functional/NodeTemplateTest.php
@@ -0,0 +1,311 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flowpack\NodeTemplates\Tests\Functional;
+
+use Flowpack\NodeTemplates\Domain\Template\RootTemplate;
+use Flowpack\NodeTemplates\Domain\TemplateConfiguration\TemplateConfigurationProcessor;
+use Flowpack\NodeTemplates\Domain\NodeTemplateDumper\NodeTemplateDumper;
+use Neos\ContentRepository\Domain\Model\Node;
+use Neos\ContentRepository\Domain\Model\NodeInterface;
+use Neos\ContentRepository\Domain\Model\Workspace;
+use Neos\ContentRepository\Domain\NodeType\NodeTypeName;
+use Neos\ContentRepository\Domain\Repository\ContentDimensionRepository;
+use Neos\ContentRepository\Domain\Repository\WorkspaceRepository;
+use Neos\ContentRepository\Domain\Service\ContextFactoryInterface;
+use Neos\ContentRepository\Domain\Service\NodeTypeManager;
+use Neos\Flow\Tests\FunctionalTestCase;
+use Neos\Neos\Domain\Model\Site;
+use Neos\Neos\Domain\Repository\SiteRepository;
+use Neos\Neos\Ui\Domain\Model\ChangeCollection;
+use Neos\Neos\Ui\Domain\Model\FeedbackCollection;
+use Neos\Neos\Ui\TypeConverter\ChangeCollectionConverter;
+
+class NodeTemplateTest extends FunctionalTestCase
+{
+    use SnapshotTrait;
+    use FeedbackCollectionMessagesTrait;
+    use WithConfigurationTrait;
+    use JsonSerializeNodeTreeTrait;
+
+    protected static $testablePersistenceEnabled = true;
+
+    private ContextFactoryInterface $contextFactory;
+
+    private Node $homePageNode;
+
+    private NodeTemplateDumper $nodeTemplateDumper;
+
+    private RootTemplate $lastCreatedRootTemplate;
+
+    public function setUp(): void
+    {
+        parent::setUp();
+        $this->setupContentRepository();
+        $this->nodeTemplateDumper = $this->objectManager->get(NodeTemplateDumper::class);
+
+        $templateFactory = $this->objectManager->get(TemplateConfigurationProcessor::class);
+
+        $templateFactoryMock = $this->getMockBuilder(TemplateConfigurationProcessor::class)->disableOriginalConstructor()->getMock();
+        $templateFactoryMock->expects(self::once())->method('processTemplateConfiguration')->willReturnCallback(function (...$args) use($templateFactory) {
+            $rootTemplate = $templateFactory->processTemplateConfiguration(...$args);
+            $this->lastCreatedRootTemplate = $rootTemplate;
+            return $rootTemplate;
+        });
+        $this->objectManager->setInstance(TemplateConfigurationProcessor::class, $templateFactoryMock);
+    }
+
+    public function tearDown(): void
+    {
+        parent::tearDown();
+        $this->inject($this->contextFactory, 'contextInstances', []);
+        $this->objectManager->get(FeedbackCollection::class)->reset();
+        $this->objectManager->forgetInstance(ContentDimensionRepository::class);
+        $this->objectManager->forgetInstance(TemplateConfigurationProcessor::class);
+    }
+
+    private function setupContentRepository(): void
+    {
+        // Create an environment to create nodes.
+        $this->objectManager->get(ContentDimensionRepository::class)->setDimensionsConfiguration([]);
+
+        $liveWorkspace = new Workspace('live');
+        $workspaceRepository = $this->objectManager->get(WorkspaceRepository::class);
+        $workspaceRepository->add($liveWorkspace);
+
+        $testSite = new Site('test-site');
+        $testSite->setSiteResourcesPackageKey('Test.Site');
+        $siteRepository = $this->objectManager->get(SiteRepository::class);
+        $siteRepository->add($testSite);
+
+        $this->persistenceManager->persistAll();
+        $this->contextFactory = $this->objectManager->get(ContextFactoryInterface::class);
+        $this->subgraph = $this->contextFactory->create(['workspaceName' => 'live']);
+
+        $rootNode = $this->subgraph->getRootNode();
+
+        $nodeTypeManager = $this->objectManager->get(NodeTypeManager::class);
+
+        $sitesRootNode = $rootNode->createNode('sites');
+        $testSiteNode = $sitesRootNode->createNode('test-site');
+        $this->homePageNode = $testSiteNode->createNode(
+            'homepage',
+            $nodeTypeManager->getNodeType('Flowpack.NodeTemplates:Document.Page')
+        );
+    }
+
+    /**
+     * @param Node|NodeInterface $targetNode
+     * @param array<string, mixed> $nodeCreationDialogValues
+     */
+    private function createNodeInto(Node $targetNode, NodeTypeName $nodeTypeName, array $nodeCreationDialogValues): void
+    {
+        $targetNodeContextPath = $targetNode->getContextPath();
+
+        $changeCollectionSerialized = [[
+            'type' => 'Neos.Neos.Ui:CreateInto',
+            'subject' => $targetNodeContextPath,
+            'payload' => [
+                'parentContextPath' => $targetNodeContextPath,
+                'parentDomAddress' => [
+                    'contextPath' => $targetNodeContextPath,
+                ],
+                'nodeType' => $nodeTypeName->getValue(),
+                'name' => 'new-node',
+                'data' => $nodeCreationDialogValues,
+                'baseNodeType' => '',
+            ],
+        ]];
+
+        $changeCollection = (new ChangeCollectionConverter())->convertFrom($changeCollectionSerialized, null);
+        assert($changeCollection instanceof ChangeCollection);
+        $changeCollection->apply();
+    }
+
+
+    /** @test */
+    public function testNodeCreationMatchesSnapshot1(): void
+    {
+        $this->createNodeInto(
+            $targetNode = $this->homePageNode->getNode('main'),
+            $toBeCreatedNodeTypeName = NodeTypeName::fromString('Flowpack.NodeTemplates:Content.Columns.Two'),
+            []
+        );
+
+        $this->assertLastCreatedTemplateMatchesSnapshot('TwoColumnPreset');
+
+        $createdNode = $targetNode->getChildNodes($toBeCreatedNodeTypeName->getValue())[0];
+
+        self::assertSame([], $this->getMessagesOfFeedbackCollection());
+
+        $this->assertNodeDumpAndTemplateDumpMatchSnapshot('TwoColumnPreset', $createdNode);
+    }
+
+    /** @test */
+    public function testNodeCreationMatchesSnapshot2(): void
+    {
+        $this->createNodeInto(
+            $targetNode = $this->homePageNode->getNode('main'),
+            $toBeCreatedNodeTypeName = NodeTypeName::fromString('Flowpack.NodeTemplates:Content.Columns.Two.CreationDialogAndWithItems'),
+            [
+                'text' => '<p>bar</p>'
+            ]
+        );
+
+        $this->assertLastCreatedTemplateMatchesSnapshot('TwoColumnPreset');
+
+        $createdNode = $targetNode->getChildNodes($toBeCreatedNodeTypeName->getValue())[0];
+
+        self::assertSame([], $this->getMessagesOfFeedbackCollection());
+        $this->assertNodeDumpAndTemplateDumpMatchSnapshot('TwoColumnPreset', $createdNode);
+    }
+
+    /** @test */
+    public function testNodeCreationMatchesSnapshot3(): void
+    {
+        $this->createNodeInto(
+            $targetNode = $this->homePageNode->getNode('main'),
+            $toBeCreatedNodeTypeName = NodeTypeName::fromString('Flowpack.NodeTemplates:Content.Columns.Two.WithContext'),
+            []
+        );
+
+        $this->assertLastCreatedTemplateMatchesSnapshot('TwoColumnPreset');
+
+        $createdNode = $targetNode->getChildNodes($toBeCreatedNodeTypeName->getValue())[0];
+
+        self::assertSame([], $this->getMessagesOfFeedbackCollection());
+        $this->assertNodeDumpAndTemplateDumpMatchSnapshot('TwoColumnPreset', $createdNode);
+    }
+
+    /** @test */
+    public function testNodeCreationWithDifferentPropertyTypes(): void
+    {
+        $this->createNodeInto(
+            $targetNode = $this->homePageNode->getNode('main'),
+            $toBeCreatedNodeTypeName = NodeTypeName::fromString('Flowpack.NodeTemplates:Content.DifferentPropertyTypes'),
+            [
+                'someNode' => $this->homePageNode->createNode('some-node', null, '7f7bac1c-9400-4db5-bbaa-2b8251d127c5')
+            ]
+        );
+
+        $this->assertLastCreatedTemplateMatchesSnapshot('DifferentPropertyTypes');
+
+        $createdNode = $targetNode->getChildNodes($toBeCreatedNodeTypeName->getValue())[0];
+
+        self::assertSame([], $this->getMessagesOfFeedbackCollection());
+        $this->assertNodeDumpAndTemplateDumpMatchSnapshot('DifferentPropertyTypes', $createdNode);
+    }
+
+    /** @test */
+    public function exceptionsAreCaughtAndPartialTemplateIsBuild(): void
+    {
+        $this->createNodeInto(
+            $targetNode = $this->homePageNode->getNode('main'),
+            $toBeCreatedNodeTypeName = NodeTypeName::fromString('Flowpack.NodeTemplates:Content.WithEvaluationExceptions'),
+            []
+        );
+
+        $this->assertLastCreatedTemplateMatchesSnapshot('WithEvaluationExceptions');
+
+        $createdNode = $targetNode->getChildNodes($toBeCreatedNodeTypeName->getValue())[0];
+
+        $this->assertStringEqualsFileOrCreateSnapshot(__DIR__ . '/Fixtures/WithEvaluationExceptions.messages.json', json_encode($this->getMessagesOfFeedbackCollection(), JSON_PRETTY_PRINT));
+
+        $this->assertNodeDumpAndTemplateDumpMatchSnapshot('WithEvaluationExceptions', $createdNode);
+    }
+
+    /** @test */
+    public function exceptionsAreCaughtAndPartialTemplateNotBuild(): void
+    {
+        $this->withMockedConfigurationSettings([
+            'Flowpack' => [
+                'NodeTemplates' => [
+                    'exceptionHandling' => [
+                        'templateConfigurationProcessing' => [
+                            'stopOnException' => true
+                        ]
+                    ]
+                ]
+            ]
+        ], function () {
+            $this->createNodeInto(
+                $targetNode = $this->homePageNode->getNode('main'),
+                $toBeCreatedNodeTypeName = NodeTypeName::fromString('Flowpack.NodeTemplates:Content.WithOneEvaluationException'),
+                []
+            );
+
+            $this->assertLastCreatedTemplateMatchesSnapshot('WithOneEvaluationException');
+
+            self::assertSame([
+                [
+                    'message' => 'Template for "WithOneEvaluationException" was not applied. Only Node /sites/test-site/homepage/main/new-node@live[Flowpack.NodeTemplates:Content.WithOneEvaluationException] was created.',
+                    'severity' => 'ERROR'
+                ],
+                [
+                    'message' => 'Expression "${\'left open" in "childNodes.abort.when" | EelException(The EEL expression "${\'left open" was not a valid EEL expression. Perhaps you forgot to wrap it in ${...}?, 1410441849)',
+                    'severity' => 'ERROR'
+                ]
+            ], $this->getMessagesOfFeedbackCollection());
+
+            $createdNode = $targetNode->getChildNodes($toBeCreatedNodeTypeName->getValue())[0];
+
+            self::assertEmpty($createdNode->getChildNodes());
+        });
+    }
+
+    /** @test */
+    public function testPageNodeCreationMatchesSnapshot1(): void
+    {
+        $this->createNodeInto(
+            $targetNode = $this->homePageNode,
+            $toBeCreatedNodeTypeName = NodeTypeName::fromString('Flowpack.NodeTemplates:Document.Page.Static'),
+            []
+        );
+
+        $this->assertLastCreatedTemplateMatchesSnapshot('PagePreset');
+
+        $createdNode = $targetNode->getChildNodes($toBeCreatedNodeTypeName->getValue())[0];
+
+        self::assertSame([], $this->getMessagesOfFeedbackCollection());
+        $this->assertNodeDumpAndTemplateDumpMatchSnapshot('PagePreset', $createdNode);
+    }
+
+    /** @test */
+    public function testPageNodeCreationMatchesSnapshot2(): void
+    {
+        $this->createNodeInto(
+            $targetNode = $this->homePageNode,
+            $toBeCreatedNodeTypeName = NodeTypeName::fromString('Flowpack.NodeTemplates:Document.Page.Dynamic'),
+            [
+                'title' => 'Page1'
+            ]
+        );
+
+        $createdNode = $targetNode->getChildNodes($toBeCreatedNodeTypeName->getValue())[0];
+
+        self::assertSame([], $this->getMessagesOfFeedbackCollection());
+        $this->assertNodeDumpAndTemplateDumpMatchSnapshot('PagePreset', $createdNode);
+    }
+
+    private function assertLastCreatedTemplateMatchesSnapshot(string $snapShotName): void
+    {
+        $lastCreatedTemplate = $this->serializeValuesInArray(
+            $this->lastCreatedRootTemplate->jsonSerialize()
+        );
+        $this->assertStringEqualsFileOrCreateSnapshot(__DIR__ . '/Fixtures/' . $snapShotName . '.template.json', json_encode($lastCreatedTemplate, JSON_PRETTY_PRINT));
+    }
+
+    private function assertNodeDumpAndTemplateDumpMatchSnapshot(string $snapShotName, NodeInterface $node): void
+    {
+        $serializedNodes = $this->jsonSerializeNodeAndDescendents($node);
+        unset($serializedNodes['nodeTypeName']);
+        $this->assertStringEqualsFileOrCreateSnapshot(__DIR__ . '/Fixtures/' . $snapShotName . '.nodes.json', json_encode($serializedNodes, JSON_PRETTY_PRINT));
+
+        $dumpedYamlTemplate = $this->nodeTemplateDumper->createNodeTemplateYamlDumpFromSubtree($node);
+
+        $yamlTemplateWithoutOriginNodeTypeName = '\'{nodeTypeName}\'' . substr($dumpedYamlTemplate, strlen($node->getNodeType()->getName()) + 2);
+
+        $this->assertStringEqualsFileOrCreateSnapshot(__DIR__ . '/Fixtures/' . $snapShotName . '.yaml', $yamlTemplateWithoutOriginNodeTypeName);
+    }
+}
diff --git a/Tests/Functional/SnapshotTrait.php b/Tests/Functional/SnapshotTrait.php
new file mode 100644
index 0000000..a1a994f
--- /dev/null
+++ b/Tests/Functional/SnapshotTrait.php
@@ -0,0 +1,18 @@
+<?php
+
+namespace Flowpack\NodeTemplates\Tests\Functional;
+
+use PHPUnit\Framework\Assert;
+
+trait SnapshotTrait
+{
+    private function assertStringEqualsFileOrCreateSnapshot(string $snapshotFileName, string $expectedString): void
+    {
+        $expectedString = rtrim($expectedString, "\n") . "\n";
+        if (getenv('CREATE_SNAPSHOT') === '1') {
+            file_put_contents($snapshotFileName, $expectedString);
+            $this->addWarning('Created snapshot.');
+        }
+        Assert::assertStringEqualsFile($snapshotFileName, $expectedString);
+    }
+}
diff --git a/Tests/Functional/WithConfigurationTrait.php b/Tests/Functional/WithConfigurationTrait.php
new file mode 100644
index 0000000..233c50d
--- /dev/null
+++ b/Tests/Functional/WithConfigurationTrait.php
@@ -0,0 +1,34 @@
+<?php
+
+namespace Flowpack\NodeTemplates\Tests\Functional;
+
+use Neos\Flow\Configuration\ConfigurationManager;
+use Neos\Utility\Arrays;
+
+trait WithConfigurationTrait
+{
+    /**
+     * Mock the settings of the configuration manager and cleanup afterwards
+     *
+     * WARNING: If you activate Singletons during this transaction they will later still have a reference to the mocked object manger, so you might need to call
+     * {@see ObjectManagerInterface::forgetInstance()}. An alternative would be also to hack the protected $this->settings of the manager.
+     *
+     * @param array $additionalSettings settings that are merged onto the the current testing configuration
+     * @param callable $fn test code that is executed in the modified context
+     */
+    private function withMockedConfigurationSettings(array $additionalSettings, callable $fn): void
+    {
+        $configurationManager = $this->objectManager->get(ConfigurationManager::class);
+        $configurationManagerMock = $this->getMockBuilder(ConfigurationManager::class)->disableOriginalConstructor()->getMock();
+        $mockedSettings = Arrays::arrayMergeRecursiveOverrule($configurationManager->getConfiguration('Settings'), $additionalSettings);
+        $configurationManagerMock->expects(self::any())->method('getConfiguration')->willReturnCallback(function (string $configurationType, string $configurationPath = null) use($configurationManager, $mockedSettings) {
+            if ($configurationType !== 'Settings') {
+                return $configurationManager->getConfiguration($configurationType, $configurationPath);
+            }
+            return $configurationPath ? Arrays::getValueByPath($mockedSettings, $configurationPath) : $mockedSettings;
+        });
+        $this->objectManager->setInstance(ConfigurationManager::class, $configurationManagerMock);
+        $fn();
+        $this->objectManager->setInstance(ConfigurationManager::class, $configurationManager);
+    }
+}
diff --git a/Tests/README.md b/Tests/README.md
new file mode 100644
index 0000000..1413574
--- /dev/null
+++ b/Tests/README.md
@@ -0,0 +1,12 @@
+
+
+Run the test with the environment variable `CREATE_SNAPSHOT=1` to created new snapshots (where implemented)
+
+```
+# Functional
+CREATE_SNAPSHOT=1 ./bin/phpUnit -c Build/BuildEssentials/PhpUnit/FunctionalTests.xml Packages/Application/Flowpack.NodeTemplates/Tests/Functional
+./bin/phpUnit -c Build/BuildEssentials/PhpUnit/FunctionalTests.xml Packages/Application/Flowpack.NodeTemplates/Tests/Functional
+
+# Unit
+./bin/phpUnit -c Build/BuildEssentials/PhpUnit/UnitTests.xml Packages/Application/Flowpack.NodeTemplates/Tests/Unit
+```
diff --git a/Tests/Unit/Domain/NodeCreation/Fixture/PostalAddress.php b/Tests/Unit/Domain/NodeCreation/Fixture/PostalAddress.php
new file mode 100644
index 0000000..994adeb
--- /dev/null
+++ b/Tests/Unit/Domain/NodeCreation/Fixture/PostalAddress.php
@@ -0,0 +1,72 @@
+<?php
+declare(strict_types=1);
+
+namespace Flowpack\NodeTemplates\Tests\Unit\Domain\NodeCreation\Fixture;
+
+/*
+ * This file is part of the Neos.ContentRepository package.
+ *
+ * (c) Contributors of the Neos Project - www.neos.io
+ *
+ * This package is Open Source Software. For the full copyright and license
+ * information, please view the LICENSE file which was distributed with this
+ * source code.
+ */
+
+/**
+ * A postal address value object
+ *
+ * @see https://schema.org/PostalAddress
+ */
+final class PostalAddress
+{
+    private string $streetAddress;
+
+    private string $postalCode;
+
+    private string $addressLocality;
+
+    private string $addressCountry;
+
+    public function __construct(
+        string $streetAddress,
+        string $postalCode,
+        string $addressLocality,
+        string $addressCountry
+    ) {
+        $this->streetAddress = $streetAddress;
+        $this->postalCode = $postalCode;
+        $this->addressLocality = $addressLocality;
+        $this->addressCountry = $addressCountry;
+    }
+
+    public static function dummy(): self
+    {
+        return new self(
+            '28 31st of February Street',
+            '12345',
+            'City',
+            'Country'
+        );
+    }
+
+    public function getStreetAddress(): string
+    {
+        return $this->streetAddress;
+    }
+
+    public function getPostalCode(): string
+    {
+        return $this->postalCode;
+    }
+
+    public function getAddressLocality(): string
+    {
+        return $this->addressLocality;
+    }
+
+    public function getAddressCountry(): string
+    {
+        return $this->addressCountry;
+    }
+}
diff --git a/Tests/Unit/Domain/NodeCreation/PropertyTypeTest.php b/Tests/Unit/Domain/NodeCreation/PropertyTypeTest.php
new file mode 100644
index 0000000..2546db3
--- /dev/null
+++ b/Tests/Unit/Domain/NodeCreation/PropertyTypeTest.php
@@ -0,0 +1,178 @@
+<?php
+namespace Flowpack\NodeTemplates\Tests\Unit\Domain\NodeCreation;
+
+/*
+ * This file is part of the Neos.ContentRepository package.
+ *
+ * (c) Contributors of the Neos Project - www.neos.io
+ *
+ * This package is Open Source Software. For the full copyright and license
+ * information, please view the LICENSE file which was distributed with this
+ * source code.
+ */
+
+use Flowpack\NodeTemplates\Domain\NodeCreation\PropertyType;
+use Flowpack\NodeTemplates\Tests\Unit\Domain\NodeCreation\Fixture\PostalAddress;
+use GuzzleHttp\Psr7\Uri;
+use Neos\ContentRepository\Domain\Model\NodeType;
+use Neos\Flow\ResourceManagement\PersistentResource;
+use Neos\Media\Domain\Model\Asset;
+use Neos\Media\Domain\Model\Image;
+use Neos\Media\Domain\Model\ImageInterface;
+use PHPUnit\Framework\Assert;
+use PHPUnit\Framework\TestCase;
+use Psr\Http\Message\UriInterface;
+
+require_once(__DIR__ . '/Fixture/PostalAddress.php');
+
+/**
+ * Test cases for the PropertyType value object
+ *
+ * copied and adjusted from
+ * https://github.com/neos/neos-development-collection/blob/cc02be6c06a55110e9d7a820820513c51c68882c/Neos.ContentRepository.Core/Tests/Unit/Infrastructure/Property/PropertyTypeTest.php#L32
+ */
+class PropertyTypeTest extends TestCase
+{
+    /**
+     * @dataProvider declarationAndValueProvider
+     */
+    public function testIsMatchedBy(array $declarationsByType, array $validValues, array $invalidValues): void
+    {
+        foreach ($declarationsByType as $declaration) {
+            $nodeTypeMock = $this->getMockBuilder(NodeType::class)->disableOriginalConstructor()->getMock();
+            $nodeTypeMock->expects(self::once())->method('getPropertyType')->with('test')->willReturn($declaration);
+            $subject = PropertyType::fromPropertyOfNodeType(
+                'test',
+                $nodeTypeMock,
+            );
+            foreach ($validValues as $validValue) {
+                Assert::assertTrue($subject->isMatchedBy($validValue));
+            }
+            foreach ($invalidValues as $invalidValue) {
+                Assert::assertFalse($subject->isMatchedBy($invalidValue));
+            }
+        }
+    }
+
+    public function declarationAndValueProvider(): array
+    {
+        $bool = true;
+        $int = 42;
+        $float = 4.2;
+        $string = 'It\'s a graph!';
+        $array = [$string];
+        $image = new Image(new PersistentResource());
+        $asset = new Asset(new PersistentResource());
+        $date = \DateTimeImmutable::createFromFormat(\DateTimeInterface::W3C, '2020-08-20T18:56:15+00:00');
+        $uri = new Uri('https://www.neos.io');
+        $postalAddress = PostalAddress::dummy();
+
+        return [
+            [
+                ['bool', 'boolean'],
+                [$bool, null],
+                [0, $int, 0.0, $float, '', $string, [], $array, $date, $uri, $postalAddress, $image, $asset, [$asset]]
+            ],
+            [
+                ['int', 'integer'],
+                [42, null],
+                [$bool, $float, $string, $array, $date, $uri, $postalAddress, $image, $asset, [$asset]]
+            ],
+            [
+                ['float', 'double'],
+                [4.2, null],
+                [$bool, $int, $string, $array, $date, $uri, $postalAddress, $image, $asset, [$asset]]
+            ],
+            [
+                ['string'],
+                ['', null],
+                [$bool, $int, $float, $array, $date, $uri, $postalAddress, $image, $asset, [$asset]]
+            ],
+            [
+                ['array'],
+                [[], $array, [$asset], null],
+                [$bool, $int, $float, $string, $date, $uri, $postalAddress, $image, $asset]
+            ],
+            [
+                [\DateTime::class, \DateTimeImmutable::class, \DateTimeInterface::class],
+                [$date, null],
+                [$bool, $int, $float, $string, $array, $uri, $postalAddress, $image, $asset, [$asset]]
+            ],
+            [
+                ['Uri', Uri::class, UriInterface::class],
+                [$uri, null],
+                [$bool, $int, $float, $string, $array, $date, $postalAddress, $image, $asset, [$asset]]
+            ],
+            [
+                [PostalAddress::class],
+                [$postalAddress, null],
+                [$bool, $int, $float, $string, $array, $date, $uri, $image, $asset, [$asset]]
+            ],
+            [
+                [ImageInterface::class],
+                [$image, null],
+                [$bool, $int, $float, $string, $array, $date, $uri, $postalAddress, $asset, [$image]]
+            ],
+            [
+                [Asset::class],
+                [$asset, $image, null],
+                [$bool, $int, $float, $string, $array, $date, $uri, $postalAddress, [$asset]]
+            ],
+            [
+                ['array<' . Asset::class . '>'],
+                [[$asset], [$image], null],
+                [$bool, $int, $float, $string, $array, $date, $uri, $postalAddress, $image, $asset]
+            ],
+            [
+                ['array<string>'],
+                [[], [$string], [$string, ''], null],
+                [$bool, $int, $float, $string, [$string, $int], $date, $uri, $postalAddress, $image, $asset, [$bool], [$float]]
+            ],
+            [
+                ['array<integer>'],
+                [[], [$int], [$int, 23432], null],
+                [$bool, $int, $float, $string, $date, $uri, $postalAddress, $image, $asset, [$bool], [$float]]
+            ],
+        ];
+    }
+
+    /**
+     * @dataProvider declarationTypeProvider
+     * @param array $declaredTypes
+     * @param string $expectedSerializationType
+     */
+    public function testGetValue(array $declaredTypes, string $expectedSerializationType): void
+    {
+        foreach ($declaredTypes as $declaredType) {
+            $nodeTypeMock = $this->getMockBuilder(NodeType::class)->disableOriginalConstructor()->getMock();
+            $nodeTypeMock->expects(self::once())->method('getPropertyType')->with('test')->willReturn($declaredType);
+            $subject = PropertyType::fromPropertyOfNodeType(
+                'test',
+                $nodeTypeMock,
+            );
+            $actualSerializationType = $subject->getValue();
+            Assert::assertSame(
+                $expectedSerializationType,
+                $actualSerializationType,
+                'Serialization type does not match for declared type "' . $declaredType . '". Expected "' . $expectedSerializationType . '", got "' . $actualSerializationType . '"'
+            );
+        }
+    }
+
+    public function declarationTypeProvider(): array
+    {
+        return [
+            [['bool', 'boolean'], 'boolean'],
+            [['int', 'integer'], 'integer'],
+            [['float', 'double'], 'float'],
+            [['string', ], 'string'],
+            [['array', ], 'array'],
+            [['DateTime', 'DateTimeImmutable', 'DateTimeInterface'], 'DateTimeImmutable'],
+            [['Uri', Uri::class, UriInterface::class], Uri::class],
+            [[PostalAddress::class], PostalAddress::class],
+            [[ImageInterface::class], ImageInterface::class],
+            [[Asset::class], Asset::class],
+            [['array<' . Asset::class . '>'], 'array<' . Asset::class . '>'],
+        ];
+    }
+}
diff --git a/Tests/Unit/Domain/NodeCreation/ReferenceTypeTest.php b/Tests/Unit/Domain/NodeCreation/ReferenceTypeTest.php
new file mode 100644
index 0000000..29680b0
--- /dev/null
+++ b/Tests/Unit/Domain/NodeCreation/ReferenceTypeTest.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Flowpack\NodeTemplates\Tests\Unit\Domain\NodeCreation;
+
+use Flowpack\NodeTemplates\Domain\NodeCreation\ReferenceType;
+use GuzzleHttp\Psr7\Uri;
+use Neos\ContentRepository\Domain\Model\NodeInterface;
+use Neos\ContentRepository\Domain\Model\NodeType;
+use Neos\ContentRepository\Domain\Service\Context;
+use Neos\Flow\ResourceManagement\PersistentResource;
+use Neos\Media\Domain\Model\Asset;
+use Neos\Media\Domain\Model\Image;
+use PHPUnit\Framework\Assert;
+use PHPUnit\Framework\TestCase;
+
+class ReferenceTypeTest extends TestCase
+{
+
+    private const VALID_NODE_ID_1 = '123';
+    private const VALID_NODE_ID_2 = '456';
+
+    /**
+     * @dataProvider declarationAndValueProvider
+     */
+    public function testIsMatchedBy(string $declarationType, array $validValues, array $invalidValues): void
+    {
+        // subgraph that knows the nodes 123 and 456
+        $subgraphMock = $this->getMockBuilder(Context::class)->disableOriginalConstructor()->getMock();
+        $subgraphMock->expects(self::any())->method('getNodeByIdentifier')->willReturnCallback(function ($nodeId) {
+            if ($nodeId === self::VALID_NODE_ID_1 || $nodeId === self::VALID_NODE_ID_2) {
+                return $this->createStub(NodeInterface::class);
+            }
+            return null;
+        });
+        $nodeTypeMock = $this->getMockBuilder(NodeType::class)->disableOriginalConstructor()->getMock();
+        $nodeTypeMock->expects(self::once())->method('getPropertyType')->with('test')->willReturn($declarationType);
+        $subject = ReferenceType::fromPropertyOfNodeType(
+            'test',
+            $nodeTypeMock,
+        );
+        foreach ($validValues as $validValue) {
+            Assert::assertTrue($subject->isMatchedBy($validValue, $subgraphMock), sprintf('Value %s should match.', get_debug_type($validValue)));
+        }
+        foreach ($invalidValues as $invalidValue) {
+            Assert::assertFalse($subject->isMatchedBy($invalidValue, $subgraphMock), sprintf('Value %s should not match.', get_debug_type($validValue)));
+        }
+    }
+
+    public function declarationAndValueProvider(): array
+    {
+        $int = 13;
+        $float = 4.2;
+        $string = 'It\'s a graph!';
+        $stringArray = [$string];
+        $image = new Image(new PersistentResource());
+        $asset = new Asset(new PersistentResource());
+        $date = \DateTimeImmutable::createFromFormat(\DateTimeInterface::W3C, '2020-08-20T18:56:15+00:00');
+        $uri = new Uri('https://www.neos.io');
+
+        $nodeMock1 = $this->createStub(NodeInterface::class);
+        $nodeMock2 = $this->createStub(NodeInterface::class);
+
+        return [
+            [
+                'reference',
+                [null, $nodeMock1, $nodeMock2, self::VALID_NODE_ID_1, self::VALID_NODE_ID_2],
+                [0, $int, 0.0, $float, '', $string, [], $stringArray, $date, $uri, $image, $asset, [$asset]]
+            ],
+            [
+                'references',
+                [[], null, [self::VALID_NODE_ID_1], [$nodeMock1], [self::VALID_NODE_ID_2, $nodeMock2]],
+                [true, $float, $string, $stringArray, $date, $uri, $image, $asset, [$asset]]
+            ],
+        ];
+    }
+}