Merge remote-tracking branch 'origin/5.14' into 5.15

Change-Id: Ifebc3b8bbb4e0f8b045b8919ce2f8377fdf92eea

122 files changed, 1131 insertions, 1929 deletions

diff --git a/src/animation/backend/additiveclipblend.cpp b/src/animation/backend/additiveclipblend.cpp
index ac8b849e2..b89a1bbb2 100644
--- a/src/animation/backend/additiveclipblend.cpp
+++ b/src/animation/backend/additiveclipblend.cpp
@@ -35,10 +35,8 @@
 ****************************************************************************/
 
 #include "additiveclipblend_p.h"
-#include <Qt3DAnimation/qclipblendnodecreatedchange.h>
 #include <Qt3DAnimation/qadditiveclipblend.h>
 #include <Qt3DAnimation/private/qadditiveclipblend_p.h>
-#include <Qt3DCore/qpropertyupdatedchange.h>
 
 QT_BEGIN_NAMESPACE
 
@@ -58,17 +56,16 @@ AdditiveClipBlend::~AdditiveClipBlend()
 {
 }
 
-void AdditiveClipBlend::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
+void AdditiveClipBlend::syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime)
 {
-    if (e->type() == Qt3DCore::PropertyUpdated) {
-        Qt3DCore::QPropertyUpdatedChangePtr change = qSharedPointerCast<Qt3DCore::QPropertyUpdatedChange>(e);
-        if (change->propertyName() == QByteArrayLiteral("additiveFactor"))
-            m_additiveFactor = change->value().toFloat();
-        else if (change->propertyName() == QByteArrayLiteral("baseClip"))
-            m_baseClipId = change->value().value<Qt3DCore::QNodeId>();
-        else if (change->propertyName() == QByteArrayLiteral("additiveClip"))
-            m_additiveClipId = change->value().value<Qt3DCore::QNodeId>();
-    }
+    BackendNode::syncFromFrontEnd(frontEnd, firstTime);
+    const QAdditiveClipBlend *node = qobject_cast<const QAdditiveClipBlend *>(frontEnd);
+    if (!node)
+        return;
+
+    m_additiveFactor = node->additiveFactor();
+    m_baseClipId = Qt3DCore::qIdForNode(node->baseClip());
+    m_additiveClipId = Qt3DCore::qIdForNode(node->additiveClip());
 }
 
 ClipResults AdditiveClipBlend::doBlend(const QVector<ClipResults> &blendData) const
@@ -84,16 +81,6 @@ ClipResults AdditiveClipBlend::doBlend(const QVector<ClipResults> &blendData) co
     return blendResults;
 }
 
-void AdditiveClipBlend::initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change)
-{
-    ClipBlendNode::initializeFromPeer(change);
-    const auto creationChangeData = qSharedPointerCast<Qt3DAnimation::QClipBlendNodeCreatedChange<Qt3DAnimation::QAdditiveClipBlendData>>(change);
-    const Qt3DAnimation::QAdditiveClipBlendData cloneData = creationChangeData->data;
-    m_baseClipId = cloneData.baseClipId;
-    m_additiveClipId = cloneData.additiveClipId;
-    m_additiveFactor = cloneData.additiveFactor;
-}
-
 } // Animation
 
 } // Qt3DAnimation
diff --git a/src/animation/backend/additiveclipblend_p.h b/src/animation/backend/additiveclipblend_p.h
index 0cf74ad56..48e882303 100644
--- a/src/animation/backend/additiveclipblend_p.h
+++ b/src/animation/backend/additiveclipblend_p.h
@@ -71,7 +71,7 @@ public:
     inline float additiveFactor() const { return m_additiveFactor; }
     void setAdditiveFactor(float additiveFactor) { m_additiveFactor = additiveFactor; } // For unit tests
 
-    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e) final;
+    void syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime) final;
 
     inline QVector<Qt3DCore::QNodeId> allDependencyIds() const override
     {
@@ -94,8 +94,6 @@ protected:
     ClipResults doBlend(const QVector<ClipResults> &blendData) const final;
 
 private:
-    void initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change) final;
-
     Qt3DCore::QNodeId m_baseClipId;
     Qt3DCore::QNodeId m_additiveClipId;
     float m_additiveFactor;
diff --git a/src/animation/backend/animationclip.cpp b/src/animation/backend/animationclip.cpp
index 3e0b8ce2b..690972075 100644
--- a/src/animation/backend/animationclip.cpp
+++ b/src/animation/backend/animationclip.cpp
@@ -72,29 +72,6 @@ AnimationClip::AnimationClip()
 {
 }
 
-void AnimationClip::initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change)
-{
-    const auto loaderTypedChange = qSharedPointerDynamicCast<Qt3DCore::QNodeCreatedChange<QAnimationClipLoaderData>>(change);
-    if (loaderTypedChange) {
-        const auto &data = loaderTypedChange->data;
-        m_dataType = File;
-        m_source = data.source;
-        if (!m_source.isEmpty())
-            setDirty(Handler::AnimationClipDirty);
-        return;
-    }
-
-    const auto clipTypedChange = qSharedPointerDynamicCast<Qt3DCore::QNodeCreatedChange<QAnimationClipChangeData>>(change);
-    if (clipTypedChange) {
-        const auto &data = clipTypedChange->data;
-        m_dataType = Data;
-        m_clipData = data.clipData;
-        if (m_clipData.isValid())
-            setDirty(Handler::AnimationClipDirty);
-        return;
-    }
-}
-
 void AnimationClip::cleanup()
 {
     setEnabled(false);
@@ -121,28 +98,36 @@ void AnimationClip::setStatus(QAnimationClipLoader::Status status)
     }
 }
 
-void AnimationClip::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
+void AnimationClip::syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime)
 {
-    switch (e->type()) {
-    case Qt3DCore::PropertyUpdated: {
-        const auto change = qSharedPointerCast<Qt3DCore::QPropertyUpdatedChange>(e);
-        if (change->propertyName() == QByteArrayLiteral("source")) {
-            Q_ASSERT(m_dataType == File);
-            m_source = change->value().toUrl();
-            setDirty(Handler::AnimationClipDirty);
-        } else if (change->propertyName() == QByteArrayLiteral("clipData")) {
-            Q_ASSERT(m_dataType == Data);
-            m_clipData = change->value().value<Qt3DAnimation::QAnimationClipData>();
+    BackendNode::syncFromFrontEnd(frontEnd, firstTime);
+    const QAbstractAnimationClip *node = qobject_cast<const QAbstractAnimationClip *>(frontEnd);
+    if (!node)
+        return;
+
+    const QAnimationClip *clipNode = qobject_cast<const QAnimationClip *>(frontEnd);
+    if (clipNode) {
+        if (firstTime)
+            m_dataType = Data;
+        Q_ASSERT(m_dataType == Data);
+        if (m_clipData != clipNode->clipData()) {
+            m_clipData = clipNode->clipData();
             if (m_clipData.isValid())
                 setDirty(Handler::AnimationClipDirty);
         }
-        break;
     }
 
-    default:
-        break;
+    const QAnimationClipLoader *loaderNode = qobject_cast<const QAnimationClipLoader *>(frontEnd);
+    if (loaderNode) {
+        if (firstTime)
+            m_dataType = File;
+        Q_ASSERT(m_dataType == File);
+        if (m_source != loaderNode->source()) {
+            m_source = loaderNode->source();
+            if (m_clipData.isValid())
+                setDirty(Handler::AnimationClipDirty);
+        }
     }
-    QBackendNode::sceneChangeEvent(e);
 }
 
 /*!
diff --git a/src/animation/backend/animationclip_p.h b/src/animation/backend/animationclip_p.h
index 0b8298723..22f589f72 100644
--- a/src/animation/backend/animationclip_p.h
+++ b/src/animation/backend/animationclip_p.h
@@ -72,7 +72,7 @@ public:
     QUrl source() const { return m_source; }
     void setStatus(QAnimationClipLoader::Status status);
     QAnimationClipLoader::Status status() const { return m_status; }
-    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e) override;
+    void syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime) override;
 
     void addDependingClipAnimator(const Qt3DCore::QNodeId &id);
     void addDependingBlendedClipAnimator(const Qt3DCore::QNodeId &id);
@@ -103,7 +103,6 @@ public:
 #endif
 
 private:
-    void initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change) final;
     void loadAnimationFromUrl();
     void loadAnimationFromData();
     void clearData();
diff --git a/src/animation/backend/backendnode.cpp b/src/animation/backend/backendnode.cpp
index 6ea7f89c7..f44836a67 100644
--- a/src/animation/backend/backendnode.cpp
+++ b/src/animation/backend/backendnode.cpp
@@ -38,6 +38,8 @@
 ****************************************************************************/
 
 #include "backendnode_p.h"
+#include <Qt3DCore/qnode.h>
+#include <Qt3DCore/private/qbackendnode_p.h>
 
 QT_BEGIN_NAMESPACE
 
@@ -65,6 +67,13 @@ void BackendNode::setDirty(Handler::DirtyFlag flag)
     m_handler->setDirty(flag, peerId());
 }
 
+void BackendNode::syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime)
+{
+    Q_UNUSED(firstTime)
+
+    d_ptr->setEnabled(frontEnd->isEnabled());
+}
+
 } // namespace Animation
 } // namespace Qt3DAnimation
 
diff --git a/src/animation/backend/backendnode_p.h b/src/animation/backend/backendnode_p.h
index d7842517a..4e450b6ec 100644
--- a/src/animation/backend/backendnode_p.h
+++ b/src/animation/backend/backendnode_p.h
@@ -68,6 +68,8 @@ public:
 
     void setHandler(Handler *handler);
 
+    virtual void syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime);
+
 protected:
     void setDirty(Handler::DirtyFlag flag);
     Handler *m_handler;
diff --git a/src/animation/backend/blendedclipanimator.cpp b/src/animation/backend/blendedclipanimator.cpp
index fe8a5d815..254883478 100644
--- a/src/animation/backend/blendedclipanimator.cpp
+++ b/src/animation/backend/blendedclipanimator.cpp
@@ -36,6 +36,9 @@
 
 #include "blendedclipanimator_p.h"
 #include <Qt3DAnimation/qblendedclipanimator.h>
+#include <Qt3DAnimation/qchannelmapper.h>
+#include <Qt3DAnimation/qclock.h>
+#include <Qt3DAnimation/qabstractclipblendnode.h>
 #include <Qt3DAnimation/private/qblendedclipanimator_p.h>
 #include <Qt3DAnimation/private/qanimationcallbacktrigger_p.h>
 #include <Qt3DCore/qpropertyupdatedchange.h>
@@ -57,19 +60,6 @@ BlendedClipAnimator::BlendedClipAnimator()
 {
 }
 
-void BlendedClipAnimator::initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change)
-{
-    const auto typedChange = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<QBlendedClipAnimatorData>>(change);
-    const QBlendedClipAnimatorData &data = typedChange->data;
-    m_blendTreeRootId = data.blendTreeRootId;
-    m_mapperId = data.mapperId;
-    m_clockId = data.clockId;
-    m_running = data.running;
-    m_loops = data.loops;
-    m_normalizedLocalTime = data.normalizedTime;
-    setDirty(Handler::BlendedClipAnimatorDirty);
-}
-
 double BlendedClipAnimator::lastLocalTime() const
 {
     return m_lastLocalTime;
@@ -167,30 +157,32 @@ void BlendedClipAnimator::setNormalizedLocalTime(float normalizedTime)
         setDirty(Handler::BlendedClipAnimatorDirty);
 }
 
-void BlendedClipAnimator::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
-{
-    switch (e->type()) {
-    case Qt3DCore::PropertyUpdated: {
-        const auto change = qSharedPointerCast<Qt3DCore::QPropertyUpdatedChange>(e);
-        if (change->propertyName() == QByteArrayLiteral("blendTree"))
-            setBlendTreeRootId(change->value().value<Qt3DCore::QNodeId>());
-        else if (change->propertyName() == QByteArrayLiteral("channelMapper"))
-            setMapperId(change->value().value<Qt3DCore::QNodeId>());
-        else if (change->propertyName() == QByteArrayLiteral("clock"))
-            setClockId(change->value().value<Qt3DCore::QNodeId>());
-        else if (change->propertyName() == QByteArrayLiteral("running"))
-            setRunning(change->value().toBool());
-        else if (change->propertyName() == QByteArrayLiteral("loops"))
-            m_loops = change->value().toInt();
-        else if (change->propertyName() == QByteArrayLiteral("normalizedTime"))
-            setNormalizedLocalTime(change->value().toFloat());
-        break;
-    }
+void BlendedClipAnimator::syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime)
+{
+    BackendNode::syncFromFrontEnd(frontEnd, firstTime);
+    const QBlendedClipAnimator *node = qobject_cast<const QBlendedClipAnimator *>(frontEnd);
+    if (!node)
+        return;
 
-    default:
-        break;
-    }
-    BackendNode::sceneChangeEvent(e);
+    auto id = Qt3DCore::qIdForNode(node->blendTree());
+    if (id != m_blendTreeRootId)
+        setBlendTreeRootId(id);
+    id = Qt3DCore::qIdForNode(node->channelMapper());
+    if (m_mapperId != id)
+        setMapperId(id);
+    id = Qt3DCore::qIdForNode(node->clock());
+    if (m_clockId != id)
+        setClockId(id);
+
+    if (m_running != node->isRunning())
+        setRunning(node->isRunning());
+    if (m_loops != node->loopCount())
+        m_loops = node->loopCount();
+    if (!qFuzzyCompare(m_normalizedLocalTime, node->normalizedTime()))
+        setNormalizedLocalTime(node->normalizedTime());
+
+    if (firstTime)
+        setDirty(Handler::BlendedClipAnimatorDirty);
 }
 
 } // namespace Animation
diff --git a/src/animation/backend/blendedclipanimator_p.h b/src/animation/backend/blendedclipanimator_p.h
index 09a071c06..f47b55796 100644
--- a/src/animation/backend/blendedclipanimator_p.h
+++ b/src/animation/backend/blendedclipanimator_p.h
@@ -64,7 +64,7 @@ public:
     BlendedClipAnimator();
 
     void cleanup();
-    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e) override;
+    void syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime) override;
 
     Qt3DCore::QNodeId blendTreeRootId() const;
     Qt3DCore::QNodeId mapperId() const { return m_mapperId; }
@@ -112,7 +112,6 @@ public:
     }
 
 private:
-    void initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change) final;
     Qt3DCore::QNodeId m_blendTreeRootId;
     Qt3DCore::QNodeId m_mapperId;
     Qt3DCore::QNodeId m_clockId;
diff --git a/src/animation/backend/channelmapper.cpp b/src/animation/backend/channelmapper.cpp
index 48a1335fa..7ea07557b 100644
--- a/src/animation/backend/channelmapper.cpp
+++ b/src/animation/backend/channelmapper.cpp
@@ -36,6 +36,7 @@
 
 #include "channelmapper_p.h"
 #include <Qt3DAnimation/qchannelmapper.h>
+#include <Qt3DAnimation/qchannelmapping.h>
 #include <Qt3DAnimation/private/qchannelmapper_p.h>
 #include <Qt3DAnimation/private/animationlogging_p.h>
 #include <Qt3DAnimation/private/managers_p.h>
@@ -43,6 +44,8 @@
 #include <Qt3DCore/qpropertynodeaddedchange.h>
 #include <Qt3DCore/qpropertynoderemovedchange.h>
 
+#include <algorithm>
+
 QT_BEGIN_NAMESPACE
 
 namespace Qt3DAnimation {
@@ -55,14 +58,6 @@ ChannelMapper::ChannelMapper()
 {
 }
 
-void ChannelMapper::initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change)
-{
-    const auto typedChange = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<QChannelMapperData>>(change);
-    const auto &data = typedChange->data;
-    m_mappingIds = data.mappingIds;
-    m_isDirty = true;
-}
-
 void ChannelMapper::cleanup()
 {
     setEnabled(false);
@@ -71,33 +66,21 @@ void ChannelMapper::cleanup()
     m_isDirty = true;
 }
 
-void ChannelMapper::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
+void ChannelMapper::syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime)
 {
-    switch (e->type()) {
-    case Qt3DCore::PropertyValueAdded: {
-        const auto change = qSharedPointerCast<Qt3DCore::QPropertyNodeAddedChange>(e);
-        if (change->propertyName() == QByteArrayLiteral("mappings")) {
-            m_mappingIds.push_back(change->addedNodeId());
-            setDirty(Handler::ChannelMappingsDirty);
-            m_isDirty = true;
-        }
-        break;
-    }
-
-    case Qt3DCore::PropertyValueRemoved: {
-        const auto change = qSharedPointerCast<Qt3DCore::QPropertyNodeRemovedChange>(e);
-        if (change->propertyName() == QByteArrayLiteral("mappings")) {
-            m_mappingIds.removeOne(change->removedNodeId());
-            setDirty(Handler::ChannelMappingsDirty);
-            m_isDirty = true;
-        }
-        break;
-    }
+    BackendNode::syncFromFrontEnd(frontEnd, firstTime);
+    const QChannelMapper *node = qobject_cast<const QChannelMapper *>(frontEnd);
+    if (!node)
+        return;
 
-    default:
-        break;
+    auto ids = Qt3DCore::qIdsForNodes(node->mappings());
+    std::sort(std::begin(ids), std::end(ids));
+    m_isDirty = firstTime;
+    if (m_mappingIds != ids) {
+        m_mappingIds = ids;
+        setDirty(Handler::ChannelMappingsDirty);
+        m_isDirty = true;
     }
-    QBackendNode::sceneChangeEvent(e);
 }
 
 void ChannelMapper::updateMappings() const
diff --git a/src/animation/backend/channelmapper_p.h b/src/animation/backend/channelmapper_p.h
index fd99c8dbd..45a3e789e 100644
--- a/src/animation/backend/channelmapper_p.h
+++ b/src/animation/backend/channelmapper_p.h
@@ -69,7 +69,7 @@ public:
 
     void cleanup();
 
-    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e) override;
+    void syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime) override;
 
     void setMappingIds(const QVector<Qt3DCore::QNodeId> &mappingIds) { m_mappingIds = mappingIds; }
     QVector<Qt3DCore::QNodeId> mappingIds() const { return m_mappingIds; }
@@ -82,7 +82,6 @@ public:
     }
 
 private:
-    void initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change) final;
     void updateMappings() const;
 
     QVector<Qt3DCore::QNodeId> m_mappingIds;
diff --git a/src/animation/backend/channelmapping.cpp b/src/animation/backend/channelmapping.cpp
index 2323182c6..83e7322da 100644
--- a/src/animation/backend/channelmapping.cpp
+++ b/src/animation/backend/channelmapping.cpp
@@ -36,13 +36,15 @@
 
 #include "channelmapping_p.h"
 #include <Qt3DAnimation/qchannelmapping.h>
+#include <Qt3DAnimation/qskeletonmapping.h>
+#include <Qt3DAnimation/qcallbackmapping.h>
 #include <Qt3DAnimation/private/qcallbackmapping_p.h>
 #include <Qt3DAnimation/private/qchannelmapping_p.h>
 #include <Qt3DAnimation/private/qskeletonmapping_p.h>
 #include <Qt3DAnimation/private/animationlogging_p.h>
 #include <Qt3DAnimation/private/qchannelmappingcreatedchange_p.h>
 #include <Qt3DAnimation/private/managers_p.h>
-#include <Qt3DCore/qpropertyupdatedchange.h>
+#include <Qt3DCore/qabstractskeleton.h>
 
 QT_BEGIN_NAMESPACE
 
@@ -63,43 +65,6 @@ ChannelMapping::ChannelMapping()
 {
 }
 
-void ChannelMapping::initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change)
-{
-    const auto createdChange = qSharedPointerCast<QChannelMappingCreatedChangeBase>(change);
-    switch (createdChange->type()) {
-    case QChannelMappingCreatedChangeBase::ChannelMapping: {
-        const auto typedChange = qSharedPointerCast<QChannelMappingCreatedChange<QChannelMappingData>>(change);
-        const auto &data = typedChange->data;
-        m_channelName = data.channelName;
-        m_targetId = data.targetId;
-        m_type = data.type;
-        m_componentCount = data.componentCount;
-        m_propertyName = data.propertyName;
-        m_mappingType = ChannelMappingType;
-        break;
-    }
-
-    case QChannelMappingCreatedChangeBase::SkeletonMapping: {
-        const auto typedChange = qSharedPointerCast<QChannelMappingCreatedChange<QSkeletonMappingData>>(change);
-        const auto &data = typedChange->data;
-        m_skeletonId = data.skeletonId;
-        m_mappingType = SkeletonMappingType;
-        break;
-    }
-
-    case QChannelMappingCreatedChangeBase::CallbackMapping: {
-        const auto typedChange = qSharedPointerCast<QChannelMappingCreatedChange<QCallbackMappingData>>(change);
-        const auto &data = typedChange->data;
-        m_channelName = data.channelName;
-        m_type = data.type;
-        m_callback = data.callback;
-        m_callbackFlags = data.callbackFlags;
-        m_mappingType = ChannelMappingType;
-        break;
-    }
-    }
-}
-
 void ChannelMapping::cleanup()
 {
     setEnabled(false);
@@ -113,34 +78,41 @@ void ChannelMapping::cleanup()
     m_skeletonId = Qt3DCore::QNodeId();
 }
 
-void ChannelMapping::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
+void ChannelMapping::syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime)
 {
-    switch (e->type()) {
-    case Qt3DCore::PropertyUpdated: {
-        const auto change = qSharedPointerCast<Qt3DCore::QPropertyUpdatedChange>(e);
-        if (change->propertyName() == QByteArrayLiteral("channelName"))
-            m_channelName = change->value().toString();
-        else if (change->propertyName() == QByteArrayLiteral("target"))
-            m_targetId = change->value().value<Qt3DCore::QNodeId>();
-        else if (change->propertyName() == QByteArrayLiteral("type"))
-            m_type = change->value().toInt();
-        else if (change->propertyName() == QByteArrayLiteral("propertyName"))
-            m_propertyName = static_cast<const char *>(const_cast<const void *>(change->value().value<void *>()));
-        else if (change->propertyName() == QByteArrayLiteral("componentCount"))
-            m_componentCount = change->value().toInt();
-        else if (change->propertyName() == QByteArrayLiteral("callback"))
-            m_callback = static_cast<QAnimationCallback *>(change->value().value<void *>());
-        else if (change->propertyName() == QByteArrayLiteral("callbackFlags"))
-            m_callbackFlags = QAnimationCallback::Flags(change->value().toInt());
-        else if (change->propertyName() == QByteArrayLiteral("skeleton"))
-            m_skeletonId = change->value().value<Qt3DCore::QNodeId>();
-        break;
+    BackendNode::syncFromFrontEnd(frontEnd, firstTime);
+    const QAbstractChannelMapping *node = qobject_cast<const QAbstractChannelMapping *>(frontEnd);
+    if (!node)
+        return;
+
+    const QChannelMapping *channelMapping = qobject_cast<const QChannelMapping *>(frontEnd);
+    if (channelMapping) {
+        m_mappingType = ChannelMappingType;
+        m_channelName = channelMapping->channelName();
+        m_targetId = Qt3DCore::qIdForNode(channelMapping->target());
+
+        QChannelMappingPrivate *d = static_cast<QChannelMappingPrivate *>(Qt3DCore::QNodePrivate::get(const_cast<QChannelMapping *>(channelMapping)));
+        m_type = d->m_type;
+        m_propertyName = d->m_propertyName;
+        m_componentCount = d->m_componentCount;
     }
 
-    default:
-        break;
+    const QSkeletonMapping *skeletonMapping = qobject_cast<const QSkeletonMapping *>(frontEnd);
+    if (skeletonMapping) {
+        m_mappingType = SkeletonMappingType;
+        m_skeletonId = Qt3DCore::qIdForNode(skeletonMapping->skeleton());
+    }
+
+    const QCallbackMapping *callbackMapping = qobject_cast<const QCallbackMapping *>(frontEnd);
+    if (callbackMapping) {
+        m_mappingType = ChannelMappingType;
+        m_channelName = channelMapping->channelName();
+
+        const QCallbackMappingPrivate *d = static_cast<const QCallbackMappingPrivate *>(Qt3DCore::QNodePrivate::get(channelMapping));
+        m_type = d->m_type;
+        m_callback = d->m_callback;
+        m_callbackFlags = d->m_callbackFlags;
     }
-    QBackendNode::sceneChangeEvent(e);
 }
 
 Skeleton *ChannelMapping::skeleton() const
diff --git a/src/animation/backend/channelmapping_p.h b/src/animation/backend/channelmapping_p.h
index aa30e84ee..a0ff5f1ca 100644
--- a/src/animation/backend/channelmapping_p.h
+++ b/src/animation/backend/channelmapping_p.h
@@ -76,7 +76,7 @@ public:
 
     void cleanup();
 
-    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e) override;
+    void syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime) override;
 
     void setChannelName(const QString &channelName) { m_channelName = channelName; }
     QString channelName() const { return m_channelName; }
@@ -107,8 +107,6 @@ public:
     MappingType mappingType() const { return m_mappingType; }
 
 private:
-    void initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change) final;
-
     // Properties from QChannelMapping
     QString m_channelName;
     Qt3DCore::QNodeId m_targetId;
diff --git a/src/animation/backend/clipanimator.cpp b/src/animation/backend/clipanimator.cpp
index acb3c8170..b6bcc9239 100644
--- a/src/animation/backend/clipanimator.cpp
+++ b/src/animation/backend/clipanimator.cpp
@@ -36,6 +36,8 @@
 
 #include "clipanimator_p.h"
 #include <Qt3DAnimation/qclipanimator.h>
+#include <Qt3DAnimation/qchannelmapper.h>
+#include <Qt3DAnimation/qclock.h>
 #include <Qt3DAnimation/private/qclipanimator_p.h>
 #include <Qt3DAnimation/private/animationclip_p.h>
 #include <Qt3DAnimation/private/managers_p.h>
@@ -65,19 +67,6 @@ ClipAnimator::ClipAnimator()
 {
 }
 
-void ClipAnimator::initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change)
-{
-    const auto typedChange = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<QClipAnimatorData>>(change);
-    const auto &data = typedChange->data;
-    m_clipId = data.clipId;
-    m_mapperId = data.mapperId;
-    m_clockId = data.clockId;
-    m_running = data.running;
-    m_loops = data.loops;
-    m_normalizedLocalTime = data.normalizedTime;
-    setDirty(Handler::ClipAnimatorDirty);
-}
-
 void ClipAnimator::setClipId(Qt3DCore::QNodeId clipId)
 {
     m_clipId = clipId;
@@ -129,30 +118,32 @@ void ClipAnimator::cleanup()
     m_normalizedLocalTime = m_lastNormalizedLocalTime = -1.0f;
 }
 
-void ClipAnimator::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
+void ClipAnimator::syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime)
 {
-    switch (e->type()) {
-    case Qt3DCore::PropertyUpdated: {
-        const auto change = qSharedPointerCast<Qt3DCore::QPropertyUpdatedChange>(e);
-        if (change->propertyName() == QByteArrayLiteral("clip"))
-            setClipId(change->value().value<Qt3DCore::QNodeId>());
-        else if (change->propertyName() == QByteArrayLiteral("channelMapper"))
-            setMapperId(change->value().value<Qt3DCore::QNodeId>());
-        else if (change->propertyName() == QByteArrayLiteral("clock"))
-            setClockId(change->value().value<Qt3DCore::QNodeId>());
-        else if (change->propertyName() == QByteArrayLiteral("running"))
-            setRunning(change->value().toBool());
-        else if (change->propertyName() == QByteArrayLiteral("loops"))
-            m_loops = change->value().toInt();
-        else if (change->propertyName() == QByteArrayLiteral("normalizedTime"))
-            setNormalizedLocalTime(change->value().toFloat());
-        break;
-    }
+    BackendNode::syncFromFrontEnd(frontEnd, firstTime);
+    const QClipAnimator *node = qobject_cast<const QClipAnimator *>(frontEnd);
+    if (!node)
+        return;
 
-    default:
-        break;
-    }
-    QBackendNode::sceneChangeEvent(e);
+    auto id = Qt3DCore::qIdForNode(node->clip());
+    if (m_clipId != id)
+        setClipId(id);
+    id = Qt3DCore::qIdForNode(node->channelMapper());
+    if (m_mapperId != id)
+        setMapperId(id);
+    id = Qt3DCore::qIdForNode(node->clock());
+    if (m_clockId != id)
+        setClockId(id);
+
+    if (m_running != node->isRunning())
+        setRunning(node->isRunning());
+    if (m_loops != node->loopCount())
+        m_loops = node->loopCount();
+    if (!qFuzzyCompare(m_normalizedLocalTime, node->normalizedTime()))
+        setNormalizedLocalTime(node->normalizedTime());
+
+    if (firstTime)
+        setDirty(Handler::ClipAnimatorDirty);
 }
 
 void ClipAnimator::sendPropertyChanges(const QVector<Qt3DCore::QSceneChangePtr> &changes)
diff --git a/src/animation/backend/clipanimator_p.h b/src/animation/backend/clipanimator_p.h
index f4c04a4bf..54d1527a4 100644
--- a/src/animation/backend/clipanimator_p.h
+++ b/src/animation/backend/clipanimator_p.h
@@ -80,7 +80,7 @@ public:
     void setNormalizedLocalTime(float normalizedLocalTime);
     float normalizedLocalTime() const { return m_normalizedLocalTime; }
 
-    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e) override;
+    void syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime) override;
     void setHandler(Handler *handler) { m_handler = handler; }
 
     // Called by jobs
@@ -116,8 +116,6 @@ public:
     }
 
 private:
-    void initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change) final;
-
     Qt3DCore::QNodeId m_clipId;
     Qt3DCore::QNodeId m_mapperId;
     Qt3DCore::QNodeId m_clockId;
diff --git a/src/animation/backend/clipblendvalue.cpp b/src/animation/backend/clipblendvalue.cpp
index 5685d5191..e1586953b 100644
--- a/src/animation/backend/clipblendvalue.cpp
+++ b/src/animation/backend/clipblendvalue.cpp
@@ -54,22 +54,14 @@ ClipBlendValue::~ClipBlendValue()
 {
 }
 
-void ClipBlendValue::initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change)
+void ClipBlendValue::syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime)
 {
-    ClipBlendNode::initializeFromPeer(change);
-    const auto creationChange
-            = qSharedPointerCast<QClipBlendNodeCreatedChange<QClipBlendValueData>>(change);
-    const Qt3DAnimation::QClipBlendValueData data = creationChange->data;
-    m_clipId = data.clipId;
-}
+    BackendNode::syncFromFrontEnd(frontEnd, firstTime);
+    const QClipBlendValue *node = qobject_cast<const QClipBlendValue *>(frontEnd);
+    if (!node)
+        return;
 
-void ClipBlendValue::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
-{
-    if (e->type() == Qt3DCore::PropertyUpdated) {
-        Qt3DCore::QPropertyUpdatedChangePtr change = qSharedPointerCast<Qt3DCore::QPropertyUpdatedChange>(e);
-        if (change->propertyName() == QByteArrayLiteral("clip"))
-            m_clipId = change->value().value<Qt3DCore::QNodeId>();
-    }
+    m_clipId = Qt3DCore::qIdForNode(node->clip());
 }
 
 ClipResults ClipBlendValue::doBlend(const QVector<ClipResults> &blendData) const
diff --git a/src/animation/backend/clipblendvalue_p.h b/src/animation/backend/clipblendvalue_p.h
index 168989a89..8a0f93d3d 100644
--- a/src/animation/backend/clipblendvalue_p.h
+++ b/src/animation/backend/clipblendvalue_p.h
@@ -64,7 +64,7 @@ public:
     inline Qt3DCore::QNodeId clipId() const { return m_clipId; }
     void setClipId(Qt3DCore::QNodeId clipId) { m_clipId = clipId; } // For unit tests
 
-    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e) override;
+    void syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime) override;
 
     inline QVector<Qt3DCore::QNodeId> allDependencyIds() const override
     {
@@ -86,8 +86,6 @@ protected:
     ClipResults doBlend(const QVector<ClipResults> &blendData) const override;
 
 private:
-    void initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change) final;
-
     Qt3DCore::QNodeId m_clipId;
 
     QVector<Qt3DCore::QNodeId> m_animatorIds;
diff --git a/src/animation/backend/clock.cpp b/src/animation/backend/clock.cpp
index f5b2bd1d3..ab30f735c 100644
--- a/src/animation/backend/clock.cpp
+++ b/src/animation/backend/clock.cpp
@@ -52,28 +52,16 @@ Clock::Clock()
 {
 }
 
-void Clock::initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change)
+void Clock::syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime)
 {
-    const auto typedChange = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<QClockData>>(change);
-    const auto &data = typedChange->data;
-    m_playbackRate = data.playbackRate;
-}
-
-void Clock::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
-{
-    switch (e->type()) {
-    case Qt3DCore::PropertyUpdated: {
-        const auto change = qSharedPointerCast<Qt3DCore::QPropertyUpdatedChange>(e);
-        if (change->propertyName() == QByteArrayLiteral("playbackRate")) {
-            m_playbackRate = change.data()->value().toDouble();
-        }
-        break;
-    }
+    BackendNode::syncFromFrontEnd(frontEnd, firstTime);
+    const QClock *node = qobject_cast<const QClock *>(frontEnd);
+    if (!node)
+        return;
 
-    default:
-        break;
+    if (!qFuzzyCompare(m_playbackRate, node->playbackRate())) {
+        m_playbackRate = node->playbackRate();
     }
-    QBackendNode::sceneChangeEvent(e);
 }
 
 void Clock::cleanup()
diff --git a/src/animation/backend/clock_p.h b/src/animation/backend/clock_p.h
index 10987655a..b4a60b3a7 100644
--- a/src/animation/backend/clock_p.h
+++ b/src/animation/backend/clock_p.h
@@ -61,15 +61,13 @@ class Q_AUTOTEST_EXPORT Clock : public BackendNode
 public:
     Clock();
 
-    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e);
+    void syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime) override;
     void cleanup();
 
     void setPlaybackRate(double playbackRate) { m_playbackRate = playbackRate; }
     double playbackRate() const { return m_playbackRate; }
 
 private:
-    void initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change) final;
-
     double m_playbackRate;
 };
 
diff --git a/src/animation/backend/lerpclipblend.cpp b/src/animation/backend/lerpclipblend.cpp
index eef0072f9..b2ba2ff7e 100644
--- a/src/animation/backend/lerpclipblend.cpp
+++ b/src/animation/backend/lerpclipblend.cpp
@@ -35,9 +35,8 @@
 ****************************************************************************/
 
 #include "lerpclipblend_p.h"
-#include <Qt3DAnimation/qclipblendnodecreatedchange.h>
+#include <Qt3DAnimation/qlerpclipblend.h>
 #include <Qt3DAnimation/private/qlerpclipblend_p.h>
-#include <Qt3DCore/qpropertyupdatedchange.h>
 
 QT_BEGIN_NAMESPACE
 
@@ -57,17 +56,16 @@ LerpClipBlend::~LerpClipBlend()
 {
 }
 
-void LerpClipBlend::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
+void LerpClipBlend::syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime)
 {
-    if (e->type() == Qt3DCore::PropertyUpdated) {
-        Qt3DCore::QPropertyUpdatedChangePtr change = qSharedPointerCast<Qt3DCore::QPropertyUpdatedChange>(e);
-        if (change->propertyName() == QByteArrayLiteral("blendFactor"))
-            m_blendFactor = change->value().toFloat();
-        else if (change->propertyName() == QByteArrayLiteral("startClip"))
-            m_startClipId = change->value().value<Qt3DCore::QNodeId>();
-        else if (change->propertyName() == QByteArrayLiteral("endClip"))
-            m_endClipId = change->value().value<Qt3DCore::QNodeId>();
-    }
+    BackendNode::syncFromFrontEnd(frontEnd, firstTime);
+    const QLerpClipBlend *node = qobject_cast<const QLerpClipBlend *>(frontEnd);
+    if (!node)
+        return;
+
+    m_blendFactor = node->blendFactor();
+    m_startClipId = Qt3DCore::qIdForNode(node->startClip());
+    m_endClipId = Qt3DCore::qIdForNode(node->endClip());
 }
 
 ClipResults LerpClipBlend::doBlend(const QVector<ClipResults> &blendData) const
@@ -83,16 +81,6 @@ ClipResults LerpClipBlend::doBlend(const QVector<ClipResults> &blendData) const
     return blendResults;
 }
 
-void LerpClipBlend::initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change)
-{
-    ClipBlendNode::initializeFromPeer(change);
-    const auto creationChangeData = qSharedPointerCast<Qt3DAnimation::QClipBlendNodeCreatedChange<Qt3DAnimation::QLerpClipBlendData>>(change);
-    const Qt3DAnimation::QLerpClipBlendData cloneData = creationChangeData->data;
-    m_startClipId = cloneData.startClipId;
-    m_endClipId = cloneData.endClipId;
-    m_blendFactor = cloneData.blendFactor;
-}
-
 double LerpClipBlend::duration() const
 {
     ClipBlendNode *startNode = clipBlendNodeManager()->lookupNode(m_startClipId);
@@ -101,7 +89,7 @@ double LerpClipBlend::duration() const
     ClipBlendNode *endNode = clipBlendNodeManager()->lookupNode(m_endClipId);
     const double endNodeDuration = endNode ? endNode->duration() : 0.0;
 
-    return (1.0f - m_blendFactor) * startNodeDuration + m_blendFactor * endNodeDuration;
+    return (1.0 - static_cast<double>(m_blendFactor)) * startNodeDuration + static_cast<double>(m_blendFactor) * endNodeDuration;
 }
 
 } // Animation
diff --git a/src/animation/backend/lerpclipblend_p.h b/src/animation/backend/lerpclipblend_p.h
index 6120f8afa..61434af2c 100644
--- a/src/animation/backend/lerpclipblend_p.h
+++ b/src/animation/backend/lerpclipblend_p.h
@@ -71,7 +71,7 @@ public:
     inline Qt3DCore::QNodeId endClipId() const { return m_endClipId; }
     void setEndClipId(Qt3DCore::QNodeId endClipId) { m_endClipId = endClipId; }  // For unit tests
 
-    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e) final;
+    void syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime) final;
 
     inline QVector<Qt3DCore::QNodeId> allDependencyIds() const override
     {
@@ -89,8 +89,6 @@ protected:
     ClipResults doBlend(const QVector<ClipResults> &blendData) const final;
 
 private:
-    void initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change) final;
-
     Qt3DCore::QNodeId m_startClipId;
     Qt3DCore::QNodeId m_endClipId;
     float m_blendFactor;
diff --git a/src/animation/backend/skeleton.cpp b/src/animation/backend/skeleton.cpp
index dcfaf55e7..720b43e33 100644
--- a/src/animation/backend/skeleton.cpp
+++ b/src/animation/backend/skeleton.cpp
@@ -62,14 +62,7 @@ void Skeleton::cleanup()
     m_jointLocalPoses.clear();
 }
 
-void Skeleton::initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change)
-{
-    // Nothing to initialize from the frontend. We get all of our internal state
-    // from whatever aspect loads the skeleton data - the render aspect in the
-    // default case.
-    Q_UNUSED(change);
-}
-
+// TODOSYNC remove once backend > backend communication no longer requires messages
 void Skeleton::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
 {
     // Get the joint names and initial local poses from a change sent
diff --git a/src/animation/backend/skeleton_p.h b/src/animation/backend/skeleton_p.h
index f1ddb1e81..668ff8712 100644
--- a/src/animation/backend/skeleton_p.h
+++ b/src/animation/backend/skeleton_p.h
@@ -112,8 +112,6 @@ public:
 #endif
 
 private:
-    void initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change) Q_DECL_FINAL;
-
     QVector<QString> m_jointNames;
     QVector<Qt3DCore::Sqt> m_jointLocalPoses;
 };
diff --git a/src/animation/frontend/qanimationaspect.cpp b/src/animation/frontend/qanimationaspect.cpp
index a25eb533e..744346e1f 100644
--- a/src/animation/frontend/qanimationaspect.cpp
+++ b/src/animation/frontend/qanimationaspect.cpp
@@ -69,6 +69,12 @@ QAnimationAspectPrivate::QAnimationAspectPrivate()
 {
 }
 
+void QAnimationAspectPrivate::syncDirtyFrontEndNode(QNode *node, QBackendNode *backend, bool firstTime) const
+{
+    Animation::BackendNode *renderBackend = static_cast<Animation::BackendNode *>(backend);
+    renderBackend->syncFromFrontEnd(node, firstTime);
+}
+
 /*!
     \class Qt3DAnimation::QAnimationAspect
     \inherits Qt3DCore::QAbstractAspect
@@ -98,34 +104,34 @@ QAnimationAspect::QAnimationAspect(QAnimationAspectPrivate &dd, QObject *parent)
     qRegisterMetaType<QVector<Qt3DCore::Sqt>>();
     qRegisterMetaType<Qt3DAnimation::QAbstractAnimationClip*>();
 
-    registerBackendType<QAbstractAnimationClip>(
+    registerBackendType<QAbstractAnimationClip, true>(
         QSharedPointer<Animation::NodeFunctor<Animation::AnimationClip, Animation::AnimationClipLoaderManager>>::create(d->m_handler.data(),
                                                                                                                         d->m_handler->animationClipLoaderManager()));
-    registerBackendType<QClock>(
+    registerBackendType<QClock, true>(
         QSharedPointer<Animation::NodeFunctor<Animation::Clock, Animation::ClockManager>>::create(d->m_handler.data(),
                                                                                                   d->m_handler->clockManager()));
-    registerBackendType<QClipAnimator>(
+    registerBackendType<QClipAnimator, true>(
         QSharedPointer<Animation::NodeFunctor<Animation::ClipAnimator, Animation::ClipAnimatorManager>>::create(d->m_handler.data(),
                                                                                                                 d->m_handler->clipAnimatorManager()));
-    registerBackendType<QBlendedClipAnimator>(
+    registerBackendType<QBlendedClipAnimator, true>(
         QSharedPointer<Animation::NodeFunctor<Animation::BlendedClipAnimator, Animation::BlendedClipAnimatorManager>>::create(d->m_handler.data(),
                                                                                                                               d->m_handler->blendedClipAnimatorManager()));
-    registerBackendType<QAbstractChannelMapping>(
+    registerBackendType<QAbstractChannelMapping, true>(
         QSharedPointer<Animation::NodeFunctor<Animation::ChannelMapping, Animation::ChannelMappingManager>>::create(d->m_handler.data(),
                                                                                                                     d->m_handler->channelMappingManager()));
-    registerBackendType<QChannelMapper>(
+    registerBackendType<QChannelMapper, true>(
         QSharedPointer<Animation::NodeFunctor<Animation::ChannelMapper, Animation::ChannelMapperManager>>::create(d->m_handler.data(),
                                                                                                                   d->m_handler->channelMapperManager()));
-    registerBackendType<QLerpClipBlend>(
+    registerBackendType<QLerpClipBlend, true>(
                 QSharedPointer<Animation::ClipBlendNodeFunctor<Animation::LerpClipBlend, Animation::ClipAnimatorManager>>::create(d->m_handler.data(),
                                                                                                                                   d->m_handler->clipBlendNodeManager()));
-    registerBackendType<QAdditiveClipBlend>(
+    registerBackendType<QAdditiveClipBlend, true>(
                 QSharedPointer<Animation::ClipBlendNodeFunctor<Animation::AdditiveClipBlend, Animation::ClipAnimatorManager>>::create(d->m_handler.data(),
                                                                                                                                       d->m_handler->clipBlendNodeManager()));
-    registerBackendType<QClipBlendValue>(
+    registerBackendType<QClipBlendValue, true>(
                 QSharedPointer<Animation::ClipBlendNodeFunctor<Animation::ClipBlendValue, Animation::ClipAnimatorManager>>::create(d->m_handler.data(),
                                                                                                                                    d->m_handler->clipBlendNodeManager()));
-    registerBackendType<Qt3DCore::QAbstractSkeleton>(
+    registerBackendType<Qt3DCore::QAbstractSkeleton, true>(
         QSharedPointer<Animation::NodeFunctor<Animation::Skeleton, Animation::SkeletonManager>>::create(d->m_handler.data(),
                                                                                                         d->m_handler->skeletonManager()));
 }
diff --git a/src/animation/frontend/qanimationaspect_p.h b/src/animation/frontend/qanimationaspect_p.h
index 2ecc8fdb8..203acd386 100644
--- a/src/animation/frontend/qanimationaspect_p.h
+++ b/src/animation/frontend/qanimationaspect_p.h
@@ -70,6 +70,8 @@ public:
 
     Q_DECLARE_PUBLIC(QAnimationAspect)
 
+    void syncDirtyFrontEndNode(Qt3DCore::QNode *node, Qt3DCore::QBackendNode *backend, bool firstTime) const override;
+
     QScopedPointer<Animation::Handler> m_handler;
 };
 
diff --git a/src/animation/frontend/qcallbackmapping.cpp b/src/animation/frontend/qcallbackmapping.cpp
index c0163da80..f312ddaa5 100644
--- a/src/animation/frontend/qcallbackmapping.cpp
+++ b/src/animation/frontend/qcallbackmapping.cpp
@@ -130,24 +130,15 @@ void QCallbackMapping::setCallback(int type, QAnimationCallback *callback, QAnim
     Q_D(QCallbackMapping);
     if (d->m_type != type) {
         d->m_type = type;
-        auto e = Qt3DCore::QPropertyUpdatedChangePtr::create(id());
-        e->setPropertyName("type");
-        e->setValue(QVariant(d->m_type));
-        notifyObservers(e);
+        d->update();
     }
     if (d->m_callback != callback) {
         d->m_callback = callback;
-        auto e = Qt3DCore::QPropertyUpdatedChangePtr::create(id());
-        e->setPropertyName("callback");
-        e->setValue(QVariant::fromValue(static_cast<void *>(d->m_callback)));
-        notifyObservers(e);
+        d->update();
     }
     if (d->m_callbackFlags != flags) {
         d->m_callbackFlags = flags;
-        auto e = Qt3DCore::QPropertyUpdatedChangePtr::create(id());
-        e->setPropertyName("callbackFlags");
-        e->setValue(QVariant::fromValue(int(d->m_callbackFlags)));
-        notifyObservers(e);
+        d->update();
     }
 }
 
diff --git a/src/animation/frontend/qchannelmapper.cpp b/src/animation/frontend/qchannelmapper.cpp
index 82ce5ebbe..34b5ffbe6 100644
--- a/src/animation/frontend/qchannelmapper.cpp
+++ b/src/animation/frontend/qchannelmapper.cpp
@@ -87,11 +87,7 @@ void QChannelMapper::addMapping(QAbstractChannelMapping *mapping)
         if (!mapping->parent())
             mapping->setParent(this);
 
-        if (d->m_changeArbiter != nullptr) {
-            const auto change = Qt3DCore::QPropertyNodeAddedChangePtr::create(id(), mapping);
-            change->setPropertyName("mappings");
-            d->notifyObservers(change);
-        }
+        d->update();
     }
 }
 
@@ -99,12 +95,8 @@ void QChannelMapper::removeMapping(QAbstractChannelMapping *mapping)
 {
     Q_ASSERT(mapping);
     Q_D(QChannelMapper);
-    if (d->m_changeArbiter != nullptr) {
-        const auto change = Qt3DCore::QPropertyNodeRemovedChangePtr::create(id(), mapping);
-        change->setPropertyName("mappings");
-        d->notifyObservers(change);
-    }
     d->m_mappings.removeOne(mapping);
+    d->update();
     // Remove bookkeeping connection
     d->unregisterDestructionHelper(mapping);
 }
diff --git a/src/animation/frontend/qchannelmapping.cpp b/src/animation/frontend/qchannelmapping.cpp
index 8f6ebe9ab..fa89d5042 100644
--- a/src/animation/frontend/qchannelmapping.cpp
+++ b/src/animation/frontend/qchannelmapping.cpp
@@ -147,37 +147,20 @@ void QChannelMappingPrivate::updatePropertyNameTypeAndComponentCount()
 
     if (m_type != type) {
         m_type = type;
-
-        // Send update to the backend
-        Q_Q(QChannelMapping);
-        auto e = Qt3DCore::QPropertyUpdatedChangePtr::create(q->id());
-        e->setPropertyName("type");
-        e->setValue(QVariant(m_type));
-        notifyObservers(e);
+        update();
     }
 
     if (m_componentCount != componentCount) {
         m_componentCount = componentCount;
-
-        // Send update to the backend
-        Q_Q(QChannelMapping);
-        auto e = Qt3DCore::QPropertyUpdatedChangePtr::create(q->id());
-        e->setPropertyName("componentCount");
-        e->setValue(QVariant(m_componentCount));
-        notifyObservers(e);
+        update();
     }
 
     if (qstrcmp(m_propertyName, propertyName) != 0) {
         m_propertyName = propertyName;
-
-        // Send update to the backend
-        Q_Q(QChannelMapping);
-        auto e = Qt3DCore::QPropertyUpdatedChangePtr::create(q->id());
-        e->setPropertyName("propertyName");
-        e->setValue(QVariant::fromValue(const_cast<void *>(static_cast<const void *>(m_propertyName))));
-        notifyObservers(e);
+        update();
     }
 }
+
 /*!
     \class QChannelMapping
     \inherits Qt3DCore::QNode
diff --git a/src/core/nodes/qnode.cpp b/src/core/nodes/qnode.cpp
index b41f5b3e2..5c37e337e 100644
--- a/src/core/nodes/qnode.cpp
+++ b/src/core/nodes/qnode.cpp
@@ -687,6 +687,11 @@ QNodePrivate *QNodePrivate::get(QNode *q)
     return q->d_func();
 }
 
+const QNodePrivate *QNodePrivate::get(const QNode *q)
+{
+    return q->d_func();
+}
+
 /*!
     \internal
  */
diff --git a/src/core/nodes/qnode_p.h b/src/core/nodes/qnode_p.h
index d8310731c..839751a5e 100644
--- a/src/core/nodes/qnode_p.h
+++ b/src/core/nodes/qnode_p.h
@@ -108,6 +108,7 @@ public:
     QHash<QString, QNode::PropertyTrackingMode> m_trackedPropertiesOverrides;
 
     static QNodePrivate *get(QNode *q);
+    static const QNodePrivate *get(const QNode *q);
     static void nodePtrDeleter(QNode *q);
 
     template<typename Caller, typename NodeType>
diff --git a/src/render/backend/abstractrenderer_p.h b/src/render/backend/abstractrenderer_p.h
index 24371a9f0..006919512 100644
--- a/src/render/backend/abstractrenderer_p.h
+++ b/src/render/backend/abstractrenderer_p.h
@@ -113,7 +113,6 @@ public:
         JointDirty          = 1 << 11,
         LayersDirty         = 1 << 12,
         TechniquesDirty     = 1 << 13,
-        EntityHierarchyDirty= 1 << 14,
         LightsDirty         = 1 << 15,
         AllDirty            = 0xffffff
     };
diff --git a/src/render/backend/entity.cpp b/src/render/backend/entity.cpp
index d8520a97e..8be58dd46 100644
--- a/src/render/backend/entity.cpp
+++ b/src/render/backend/entity.cpp
@@ -95,11 +95,19 @@ void Entity::cleanup()
     if (m_nodeManagers != nullptr) {
         m_nodeManagers->worldMatrixManager()->releaseResource(peerId());
         qCDebug(Render::RenderNodes) << Q_FUNC_INFO;
+
+        removeFromParentChildHandles();
+
+        for (auto &childHandle : qAsConst(m_childrenHandles)) {
+            auto child = m_nodeManagers->renderNodesManager()->data(childHandle);
+            // children should always exist and have this as parent
+            // if they were destroyed, they would have removed themselves from our m_childrenHandles
+            Q_ASSERT(child);
+            Q_ASSERT(child->m_parentHandle == m_handle);
+            child->m_parentHandle = {};
+        }
     }
-    if (!m_parentEntityId.isNull())
-        markDirty(AbstractRenderer::EntityHierarchyDirty);
 
-    m_parentEntityId = Qt3DCore::QNodeId();
     m_worldTransform = HMatrix();
     // Release all component will have to perform their own release when they receive the
     // NodeDeleted notification
@@ -122,6 +130,7 @@ void Entity::cleanup()
     m_localBoundingVolume.reset();
     m_worldBoundingVolume.reset();
     m_worldBoundingVolumeWithChildren.reset();
+    m_parentHandle = {};
     m_boundingDirty = false;
     QBackendNode::setEnabled(false);
 }
@@ -129,6 +138,12 @@ void Entity::cleanup()
 void Entity::setParentHandle(HEntity parentHandle)
 {
     Q_ASSERT(m_nodeManagers);
+
+    if (parentHandle == m_parentHandle)
+        return;
+
+    removeFromParentChildHandles();
+
     m_parentHandle = parentHandle;
     auto parent = m_nodeManagers->renderNodesManager()->data(parentHandle);
     if (parent != nullptr && !parent->m_childrenHandles.contains(m_handle))
@@ -182,13 +197,19 @@ void Entity::syncFromFrontEnd(const QNode *frontEnd, bool firstTime)
     }
 
     const auto parentID = node->parentEntity() ? node->parentEntity()->id() : Qt3DCore::QNodeId();
-    if (m_parentEntityId != parentID) {
-        m_parentEntityId = parentID;
-        // TODO: change to EventHierarchyDirty and update renderer to
-        //       ensure all jobs are run that depend on Entity hierarchy.
+    auto parentHandle = m_nodeManagers->renderNodesManager()->lookupHandle(parentID);
+
+    // All entity creation is done from top-down and always during the same frame, so
+    // we if we have a valid parent node, we should always be able to resolve the
+    // backend parent at this time
+    Q_ASSERT(!node->parentEntity() || (!parentHandle.isNull() && m_nodeManagers->renderNodesManager()->data(parentHandle)));
+
+    if (parentHandle != m_parentHandle) {
         markDirty(AbstractRenderer::AllDirty);
     }
 
+    setParentHandle(parentHandle);
+
     if (firstTime) {
         m_worldTransform = m_nodeManagers->worldMatrixManager()->getOrAcquireHandle(peerId());
 
@@ -215,8 +236,6 @@ void Entity::syncFromFrontEnd(const QNode *frontEnd, bool firstTime)
             const auto idAndType = QNodeIdTypePair(c->id(), QNodePrivate::findStaticMetaObject(c->metaObject()));
             addComponent(idAndType);
         }
-
-        markDirty(AbstractRenderer::EntityHierarchyDirty);
     }
 
     BackendNode::syncFromFrontEnd(frontEnd, firstTime);
@@ -238,25 +257,12 @@ Entity *Entity::parent() const
     return m_nodeManagers->renderNodesManager()->data(m_parentHandle);
 }
 
-
-// clearEntityHierarchy and rebuildEntityHierarchy should only be called
-// from UpdateEntityHierarchyJob to update the entity hierarchy for the
-// entire scene at once
-void Entity::clearEntityHierarchy()
-{
-    m_childrenHandles.clear();
-    m_parentHandle = HEntity();
-}
-
-// clearEntityHierarchy and rebuildEntityHierarchy should only be called
-// from UpdateEntityHierarchyJob to update the entity hierarchy for the
-// entire scene at once
-void Entity::rebuildEntityHierarchy()
+void Entity::removeFromParentChildHandles()
 {
-    if (!m_parentEntityId.isNull())
-        setParentHandle(m_nodeManagers->renderNodesManager()->lookupHandle(m_parentEntityId));
-    else
-        qCDebug(Render::RenderNodes) << Q_FUNC_INFO << "No parent entity found for Entity" << peerId();
+    // remove ourself from our parent's list of children.
+    auto p = parent();
+    if (p)
+        p->removeChildHandle(m_handle);
 }
 
 void Entity::appendChildHandle(HEntity childHandle)
diff --git a/src/render/backend/entity_p.h b/src/render/backend/entity_p.h
index 493774feb..403f5568c 100644
--- a/src/render/backend/entity_p.h
+++ b/src/render/backend/entity_p.h
@@ -98,11 +98,8 @@ public:
     HEntity handle() const { return m_handle; }
     Entity *parent() const;
     HEntity parentHandle() const { return m_parentHandle; }
-    Qt3DCore::QNodeId parentEntityId() const { return m_parentEntityId; }
-
-    void clearEntityHierarchy();
-    void rebuildEntityHierarchy();
 
+    void removeFromParentChildHandles();
     void appendChildHandle(HEntity childHandle);
     void removeChildHandle(HEntity childHandle) { m_childrenHandles.removeOne(childHandle); }
     QVector<HEntity> childrenHandles() const { return m_childrenHandles; }
@@ -185,8 +182,6 @@ private:
     HEntity m_parentHandle;
     QVector<HEntity > m_childrenHandles;
 
-    Qt3DCore::QNodeId m_parentEntityId;
-
     HMatrix m_worldTransform;
     QSharedPointer<Sphere> m_localBoundingVolume;
     QSharedPointer<Sphere> m_worldBoundingVolume;
@@ -304,7 +299,7 @@ ENTITY_COMPONENT_LIST_TEMPLATE_SPECIALIZATION(ShaderData, HShaderData)
 ENTITY_COMPONENT_LIST_TEMPLATE_SPECIALIZATION(Light, HLight)
 ENTITY_COMPONENT_LIST_TEMPLATE_SPECIALIZATION(EnvironmentLight, HEnvironmentLight)
 
-class RenderEntityFunctor : public Qt3DCore::QBackendNodeMapper
+class Q_AUTOTEST_EXPORT RenderEntityFunctor : public Qt3DCore::QBackendNodeMapper
 {
 public:
     explicit RenderEntityFunctor(AbstractRenderer *renderer, NodeManagers *manager);
diff --git a/src/render/framegraph/blitframebuffer.cpp b/src/render/framegraph/blitframebuffer.cpp
index 342594baf..c45d3fdbc 100644
--- a/src/render/framegraph/blitframebuffer.cpp
+++ b/src/render/framegraph/blitframebuffer.cpp
@@ -60,48 +60,44 @@ BlitFramebuffer::BlitFramebuffer()
 {
 }
 
-void BlitFramebuffer::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
+void BlitFramebuffer::syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime)
 {
-    if (e->type() == PropertyUpdated) {
-        QPropertyUpdatedChangePtr propertyChange = qSharedPointerCast<QPropertyUpdatedChange>(e);
-        if (propertyChange->propertyName() == QByteArrayLiteral("sourceRenderTarget")) {
-            m_sourceRenderTargetId = propertyChange->value().value<QNodeId>();
-            markDirty(AbstractRenderer::FrameGraphDirty);
-        } else if (propertyChange->propertyName() == QByteArrayLiteral("destinationRenderTarget")) {
-            m_destinationRenderTargetId = propertyChange->value().value<QNodeId>();
-            markDirty(AbstractRenderer::FrameGraphDirty);
-        } else if (propertyChange->propertyName() == QByteArrayLiteral("sourceRect")) {
-            m_sourceRect = propertyChange->value().toRect();
-            markDirty(AbstractRenderer::FrameGraphDirty);
-        } else if (propertyChange->propertyName() == QByteArrayLiteral("destinationRect")) {
-            m_destinationRect = propertyChange->value().toRect();
-            markDirty(AbstractRenderer::FrameGraphDirty);
-        } else if (propertyChange->propertyName() == QByteArrayLiteral("sourceAttachmentPoint")) {
-            m_sourceAttachmentPoint = propertyChange->value().value<Qt3DRender::QRenderTargetOutput::AttachmentPoint>();
-            markDirty(AbstractRenderer::FrameGraphDirty);
-        } else if (propertyChange->propertyName() == QByteArrayLiteral("destinationAttachmentPoint")) {
-            m_destinationAttachmentPoint = propertyChange->value().value<Qt3DRender::QRenderTargetOutput::AttachmentPoint>();
-            markDirty(AbstractRenderer::FrameGraphDirty);
-        } else if (propertyChange->propertyName() == QByteArrayLiteral("interpolationMethod")) {
-            m_interpolationMethod = propertyChange->value().value<QBlitFramebuffer::InterpolationMethod>();
-            markDirty(AbstractRenderer::FrameGraphDirty);
-        }
-    }
-    FrameGraphNode::sceneChangeEvent(e);
-}
+    const QBlitFramebuffer *node = qobject_cast<const QBlitFramebuffer *>(frontEnd);
+    if (!node)
+        return;
 
-void BlitFramebuffer::initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change)
-{
-    FrameGraphNode::initializeFromPeer(change);
-    const auto typedChange = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<QBlitFramebufferData> >(change);
-    const auto &data = typedChange->data;
-    m_sourceRect = data.m_sourceRect;
-    m_destinationRect = data.m_destinationRect;
-    m_sourceRenderTargetId = data.m_sourceRenderTargetId;
-    m_destinationRenderTargetId = data.m_destinationRenderTargetId;
-    m_sourceAttachmentPoint = data.m_sourceAttachmentPoint;
-    m_destinationAttachmentPoint = data.m_destinationAttachmentPoint;
-    m_interpolationMethod = data.m_interpolationMethod;
+    FrameGraphNode::syncFromFrontEnd(frontEnd, firstTime);
+
+    if (node->sourceRect().toRect() != m_sourceRect) {
+        m_sourceRect = node->sourceRect().toRect();
+        markDirty(AbstractRenderer::FrameGraphDirty);
+    }
+    if (node->destinationRect().toRect() != m_destinationRect) {
+        m_destinationRect = node->destinationRect().toRect();
+        markDirty(AbstractRenderer::FrameGraphDirty);
+    }
+    if (node->sourceAttachmentPoint() != m_sourceAttachmentPoint) {
+        m_sourceAttachmentPoint = node->sourceAttachmentPoint();
+        markDirty(AbstractRenderer::FrameGraphDirty);
+    }
+    if (node->destinationAttachmentPoint() != m_destinationAttachmentPoint) {
+        m_destinationAttachmentPoint = node->destinationAttachmentPoint();
+        markDirty(AbstractRenderer::FrameGraphDirty);
+    }
+    if (node->interpolationMethod() != m_interpolationMethod) {
+        m_interpolationMethod = node->interpolationMethod();
+        markDirty(AbstractRenderer::FrameGraphDirty);
+    }
+    const QNodeId destinationNodeId = qIdForNode(node->destination());
+    if (destinationNodeId != m_destinationRenderTargetId) {
+        m_destinationRenderTargetId = destinationNodeId;
+        markDirty(AbstractRenderer::FrameGraphDirty);
+    }
+    const QNodeId sourceNodeId = qIdForNode(node->source());
+    if (sourceNodeId != m_sourceRenderTargetId) {
+        m_sourceRenderTargetId = sourceNodeId;
+        markDirty(AbstractRenderer::FrameGraphDirty);
+    }
 }
 
 Qt3DRender::QRenderTargetOutput::AttachmentPoint BlitFramebuffer::destinationAttachmentPoint() const
diff --git a/src/render/framegraph/blitframebuffer_p.h b/src/render/framegraph/blitframebuffer_p.h
index 796c223ca..fa9ddacd9 100644
--- a/src/render/framegraph/blitframebuffer_p.h
+++ b/src/render/framegraph/blitframebuffer_p.h
@@ -65,7 +65,7 @@ class Q_AUTOTEST_EXPORT BlitFramebuffer : public FrameGraphNode
 public:
     BlitFramebuffer();
 
-    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e) override;
+    void syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime) override;
 
     Qt3DCore::QNodeId sourceRenderTargetId() const;
 
@@ -82,8 +82,6 @@ public:
     QBlitFramebuffer::InterpolationMethod interpolationMethod() const;
 
 private:
-    void initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change) final;
-
     Qt3DCore::QNodeId m_sourceRenderTargetId;
     Qt3DCore::QNodeId m_destinationRenderTargetId;
     QRect m_sourceRect;
diff --git a/src/render/framegraph/cameraselectornode.cpp b/src/render/framegraph/cameraselectornode.cpp
index 357611c7c..482429b00 100644
--- a/src/render/framegraph/cameraselectornode.cpp
+++ b/src/render/framegraph/cameraselectornode.cpp
@@ -57,25 +57,19 @@ CameraSelector::CameraSelector()
 {
 }
 
-void CameraSelector::initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change)
+void CameraSelector::syncFromFrontEnd(const QNode *frontEnd, bool firstTime)
 {
-    FrameGraphNode::initializeFromPeer(change);
-    const auto typedChange = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<QCameraSelectorData>>(change);
-    const auto &data = typedChange->data;
-    m_cameraUuid = data.cameraId;
-}
+    const QCameraSelector *node = qobject_cast<const QCameraSelector *>(frontEnd);
+    if (!node)
+        return;
 
-void CameraSelector::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
-{
-    qCDebug(Render::Framegraph) << Q_FUNC_INFO;
-    if (e->type() == PropertyUpdated) {
-        QPropertyUpdatedChangePtr propertyChange = qSharedPointerCast<QPropertyUpdatedChange>(e);
-        if (propertyChange->propertyName() == QByteArrayLiteral("camera")) {
-            m_cameraUuid = propertyChange->value().value<QNodeId>();
-            markDirty(AbstractRenderer::FrameGraphDirty);
-        }
+    FrameGraphNode::syncFromFrontEnd(frontEnd, firstTime);
+
+    const QNodeId cameraId = qIdForNode(node->camera());
+    if (m_cameraUuid != cameraId) {
+        m_cameraUuid = cameraId;
+        markDirty(AbstractRenderer::FrameGraphDirty);
     }
-    FrameGraphNode::sceneChangeEvent(e);
 }
 
 QNodeId CameraSelector::cameraUuid() const
diff --git a/src/render/framegraph/cameraselectornode_p.h b/src/render/framegraph/cameraselectornode_p.h
index 0e532d68f..dd7e050d0 100644
--- a/src/render/framegraph/cameraselectornode_p.h
+++ b/src/render/framegraph/cameraselectornode_p.h
@@ -69,12 +69,11 @@ class CameraSelector : public FrameGraphNode
 public:
     CameraSelector();
 
-    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e) override;
     Qt3DCore::QNodeId cameraUuid() const;
 
-private:
-    void initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change) final;
+    void syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime) override;
 
+private:
     Qt3DCore::QNodeId m_cameraUuid;
 };
 
diff --git a/src/render/framegraph/clearbuffers.cpp b/src/render/framegraph/clearbuffers.cpp
index ab6225a4b..98de30906 100644
--- a/src/render/framegraph/clearbuffers.cpp
+++ b/src/render/framegraph/clearbuffers.cpp
@@ -61,42 +61,40 @@ ClearBuffers::ClearBuffers()
 {
 }
 
-void ClearBuffers::initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change)
+void ClearBuffers::syncFromFrontEnd(const QNode *frontEnd, bool firstTime)
 {
-    FrameGraphNode::initializeFromPeer(change);
-    const auto typedChange = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<QClearBuffersData>>(change);
-    const auto &data = typedChange->data;
-    m_type = data.buffersType;
-    m_clearColorAsColor = data.clearColor;
-    m_clearColor = vec4dFromColor(m_clearColorAsColor);
-    m_clearDepthValue = data.clearDepthValue;
-    m_clearStencilValue = data.clearStencilValue;
-    m_colorBufferId = data.bufferId;
-}
+    const QClearBuffers *node = qobject_cast<const QClearBuffers *>(frontEnd);
+    if (!node)
+        return;
 
-void ClearBuffers::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
-{
-    if (e->type() == PropertyUpdated) {
-        QPropertyUpdatedChangePtr propertyChange = qSharedPointerCast<QPropertyUpdatedChange>(e);
-        if (propertyChange->propertyName() == QByteArrayLiteral("buffers")) {
-            m_type = static_cast<QClearBuffers::BufferType>(propertyChange->value().toInt());
-            markDirty(AbstractRenderer::FrameGraphDirty);
-        } else if (propertyChange->propertyName() == QByteArrayLiteral("clearColor")) {
-            m_clearColorAsColor = propertyChange->value().value<QColor>();
-            m_clearColor = vec4dFromColor(m_clearColorAsColor);
-            markDirty(AbstractRenderer::FrameGraphDirty);
-        } else if (propertyChange->propertyName() == QByteArrayLiteral("clearDepthValue")) {
-            m_clearDepthValue = propertyChange->value().toFloat();
-            markDirty(AbstractRenderer::FrameGraphDirty);
-        } else if (propertyChange->propertyName() == QByteArrayLiteral("clearStencilValue")) {
-            m_clearStencilValue = propertyChange->value().toInt();
-            markDirty(AbstractRenderer::FrameGraphDirty);
-        } else if (propertyChange->propertyName() == QByteArrayLiteral("colorBuffer")) {
-            m_colorBufferId = propertyChange->value().value<QNodeId>();
-            markDirty(AbstractRenderer::FrameGraphDirty);
-        }
+    FrameGraphNode::syncFromFrontEnd(frontEnd, firstTime);
+
+    if (m_clearColorAsColor != node->clearColor()) {
+        m_clearColorAsColor = node->clearColor();
+        m_clearColor = vec4dFromColor(node->clearColor());
+        markDirty(AbstractRenderer::FrameGraphDirty);
+    }
+
+    if (m_clearDepthValue != node->clearDepthValue()) {
+        m_clearDepthValue = node->clearDepthValue();
+        markDirty(AbstractRenderer::FrameGraphDirty);
+    }
+
+    if (m_clearStencilValue != node->clearStencilValue()) {
+        m_clearStencilValue = node->clearStencilValue();
+        markDirty(AbstractRenderer::FrameGraphDirty);
+    }
+
+    const QNodeId colorBufferId = qIdForNode(node->colorBuffer());
+    if (m_colorBufferId != colorBufferId) {
+        m_colorBufferId = colorBufferId;
+        markDirty(AbstractRenderer::FrameGraphDirty);
+    }
+
+    if (m_type != node->buffers()) {
+        m_type = node->buffers();
+        markDirty(AbstractRenderer::FrameGraphDirty);
     }
-    FrameGraphNode::sceneChangeEvent(e);
 }
 
 QClearBuffers::BufferType ClearBuffers::type() const
diff --git a/src/render/framegraph/clearbuffers_p.h b/src/render/framegraph/clearbuffers_p.h
index e3c56c165..ca55d2a98 100644
--- a/src/render/framegraph/clearbuffers_p.h
+++ b/src/render/framegraph/clearbuffers_p.h
@@ -67,8 +67,6 @@ class ClearBuffers : public FrameGraphNode
 public:
     ClearBuffers();
 
-    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e) override;
-
     QClearBuffers::BufferType type() const;
     float clearDepthValue() const;
     int clearStencilValue() const;
@@ -85,10 +83,9 @@ public:
     QColor clearColorAsColor() const;
 
     bool clearsAllColorBuffers() const;
+    void syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime) override;
 
 private:
-    void initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change) final;
-
     QClearBuffers::BufferType m_type;
     QVector4D m_clearColor;
     QColor m_clearColorAsColor;
diff --git a/src/render/framegraph/dispatchcompute.cpp b/src/render/framegraph/dispatchcompute.cpp
index f7e9dcff4..5eae75bc6 100644
--- a/src/render/framegraph/dispatchcompute.cpp
+++ b/src/render/framegraph/dispatchcompute.cpp
@@ -66,32 +66,26 @@ void DispatchCompute::cleanup()
     m_workGroups[2] = 1;
 }
 
-void DispatchCompute::initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change)
+void DispatchCompute::syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime)
 {
-    FrameGraphNode::initializeFromPeer(change);
-    const auto typedChange = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<QDispatchComputeData>>(change);
-    const auto &data = typedChange->data;
-    m_workGroups[0] = data.workGroupX;
-    m_workGroups[1] = data.workGroupY;
-    m_workGroups[2] = data.workGroupZ;
-}
+    const QDispatchCompute *node = qobject_cast<const QDispatchCompute *>(frontEnd);
+    if (!node)
+        return;
 
-void DispatchCompute::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
-{
-    if (e->type() == Qt3DCore::PropertyUpdated) {
-        Qt3DCore::QPropertyUpdatedChangePtr propertyChange = qSharedPointerCast<Qt3DCore::QPropertyUpdatedChange>(e);
-        if (propertyChange->propertyName() == QByteArrayLiteral("workGroupX")) {
-            m_workGroups[0] = propertyChange->value().toInt();
-            markDirty(AbstractRenderer::FrameGraphDirty|AbstractRenderer::ComputeDirty);
-        } else if (propertyChange->propertyName() == QByteArrayLiteral("workGroupY")) {
-            m_workGroups[1] = propertyChange->value().toInt();
-            markDirty(AbstractRenderer::FrameGraphDirty|AbstractRenderer::ComputeDirty);
-        } else if (propertyChange->propertyName() == QByteArrayLiteral("workGroupZ")) {
-            m_workGroups[2] = propertyChange->value().toInt();
-            markDirty(AbstractRenderer::FrameGraphDirty|AbstractRenderer::ComputeDirty);
-        }
+    FrameGraphNode::syncFromFrontEnd(frontEnd, firstTime);
+
+    if (m_workGroups[0] != node->workGroupX()) {
+        m_workGroups[0] = node->workGroupX();
+        markDirty(AbstractRenderer::FrameGraphDirty|AbstractRenderer::ComputeDirty);
+    }
+    if (m_workGroups[1] != node->workGroupY()) {
+        m_workGroups[1] = node->workGroupY();
+        markDirty(AbstractRenderer::FrameGraphDirty|AbstractRenderer::ComputeDirty);
+    }
+    if (m_workGroups[2] != node->workGroupZ()) {
+        m_workGroups[2] = node->workGroupZ();
+        markDirty(AbstractRenderer::FrameGraphDirty|AbstractRenderer::ComputeDirty);
     }
-    FrameGraphNode::sceneChangeEvent(e);
 }
 
 } // Render
diff --git a/src/render/framegraph/dispatchcompute_p.h b/src/render/framegraph/dispatchcompute_p.h
index aa88a35c5..24a641938 100644
--- a/src/render/framegraph/dispatchcompute_p.h
+++ b/src/render/framegraph/dispatchcompute_p.h
@@ -68,13 +68,13 @@ public:
 
     void cleanup();
 
-    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e) override;
     inline int x() const Q_DECL_NOTHROW { return m_workGroups[0]; }
     inline int y() const Q_DECL_NOTHROW { return m_workGroups[1]; }
     inline int z() const Q_DECL_NOTHROW { return m_workGroups[2]; }
 
+    void syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime) override;
+
 private:
-    void initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change) final;
 
     int m_workGroups[3];
 };
diff --git a/src/render/framegraph/framegraphnode.cpp b/src/render/framegraph/framegraphnode.cpp
index 458d96d4b..93531fd7d 100644
--- a/src/render/framegraph/framegraphnode.cpp
+++ b/src/render/framegraph/framegraphnode.cpp
@@ -66,14 +66,6 @@ FrameGraphNode::~FrameGraphNode()
 {
 }
 
-void FrameGraphNode::initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change)
-{
-    // Set up the parent child relationship and enabled state
-    const auto creationChange = qSharedPointerCast<QFrameGraphNodeCreatedChangeBase>(change);
-    setParentId(creationChange->parentFrameGraphNodeId());
-    markDirty(AbstractRenderer::FrameGraphDirty);
-}
-
 void FrameGraphNode::setFrameGraphManager(FrameGraphManager *manager)
 {
     if (m_manager != manager)
@@ -129,34 +121,33 @@ QVector<FrameGraphNode *> FrameGraphNode::children() const
     return children;
 }
 
-void FrameGraphNode::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
+void FrameGraphNode::cleanup()
 {
-    switch (e->type()) {
-
-    case Qt3DCore::PropertyUpdated: {
-        Qt3DCore::QPropertyUpdatedChangePtr propertyChange = qSharedPointerCast<Qt3DCore::QPropertyUpdatedChange>(e);
-        if (propertyChange->propertyName() == QByteArrayLiteral("enabled")) {
-            d_func()->m_enabled = propertyChange->value().toBool();
-            markDirty(AbstractRenderer::FrameGraphDirty);
-        } else if (propertyChange->propertyName() == QByteArrayLiteral("parentFrameGraphUpdated")) {
-            auto newParent = propertyChange->value().value<Qt3DCore::QNodeId>();
-            setParentId(newParent);
-            markDirty(AbstractRenderer::AllDirty);
-        }
-        break;
-    }
-    default:
-        markDirty(AbstractRenderer::AllDirty);
-        break;
-    }
+    setParentId({});
 }
 
-void FrameGraphNode::cleanup()
+void FrameGraphNode::syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime)
 {
-    setParentId({});
+    const QFrameGraphNode *node = qobject_cast<const QFrameGraphNode *>(frontEnd);
+
+    const auto parentId = Qt3DCore::qIdForNode(node->parentFrameGraphNode());
+    if (parentId != m_parentId) {
+        setParentId(parentId);
+        // TO DO: Check if FrameGraphDirty wouldn't be enough here
+        markDirty(AbstractRenderer::AllDirty);
+    }
+
+    if (node->isEnabled() != d_func()->m_enabled) {
+        d_func()->m_enabled = node->isEnabled();
+        markDirty(AbstractRenderer::FrameGraphDirty);
+    }
+
+    if (firstTime)
+        markDirty(AbstractRenderer::FrameGraphDirty);
 }
 
 
+
 } // namespace Render
 } // namespace Qt3DRender
 
diff --git a/src/render/framegraph/framegraphnode_p.h b/src/render/framegraph/framegraphnode_p.h
index 3edd4f57d..846dc8060 100644
--- a/src/render/framegraph/framegraphnode_p.h
+++ b/src/render/framegraph/framegraphnode_p.h
@@ -121,11 +121,10 @@ public:
 
     void cleanup();
 
-    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e) override;
+    void syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime) override;
 
 protected:
     FrameGraphNode(FrameGraphNodeType nodeType, QBackendNode::Mode mode = QBackendNode::ReadOnly);
-    void initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change) override;
 
 private:
     FrameGraphNodeType m_nodeType;
diff --git a/src/render/framegraph/layerfilternode.cpp b/src/render/framegraph/layerfilternode.cpp
index f9881be0d..5c53fa681 100644
--- a/src/render/framegraph/layerfilternode.cpp
+++ b/src/render/framegraph/layerfilternode.cpp
@@ -43,6 +43,7 @@
 #include <Qt3DCore/qpropertyupdatedchange.h>
 #include <Qt3DCore/qpropertynodeaddedchange.h>
 #include <Qt3DCore/qpropertynoderemovedchange.h>
+#include <algorithm>
 
 QT_BEGIN_NAMESPACE
 
@@ -57,48 +58,25 @@ LayerFilterNode::LayerFilterNode()
 {
 }
 
-void LayerFilterNode::initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change)
+void LayerFilterNode::syncFromFrontEnd(const QNode *frontEnd, bool firstTime)
 {
-    FrameGraphNode::initializeFromPeer(change);
-    const auto typedChange = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<QLayerFilterData>>(change);
-    const auto &data = typedChange->data;
-    setLayerIds(data.layerIds);
-    m_filterMode = data.filterMode;
-}
+    const QLayerFilter *node = qobject_cast<const QLayerFilter *>(frontEnd);
+    if (!node)
+        return;
 
-void LayerFilterNode::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
-{
-    switch (e->type()) {
-    case PropertyValueAdded: {
-        const auto change = qSharedPointerCast<QPropertyNodeAddedChange>(e);
-        if (change->propertyName() == QByteArrayLiteral("layer"))
-            m_layerIds.append(change->addedNodeId());
-        markDirty(AbstractRenderer::FrameGraphDirty|AbstractRenderer::LayersDirty);
-        break;
-    }
+    FrameGraphNode::syncFromFrontEnd(frontEnd, firstTime);
 
-    case PropertyValueRemoved: {
-        const auto change = qSharedPointerCast<QPropertyNodeRemovedChange>(e);
-        if (change->propertyName() == QByteArrayLiteral("layer"))
-            m_layerIds.removeOne(change->removedNodeId());
+    if (m_filterMode != node->filterMode()) {
+        m_filterMode = node->filterMode();
         markDirty(AbstractRenderer::FrameGraphDirty|AbstractRenderer::LayersDirty);
-        break;
     }
 
-    case PropertyUpdated: {
-        const auto change = qSharedPointerCast<QPropertyUpdatedChange>(e);
-        if (change->propertyName() == QByteArrayLiteral("filterMode")) {
-            m_filterMode = static_cast<QLayerFilter::FilterMode>(change->value().value<int>());
-            markDirty(AbstractRenderer::FrameGraphDirty|AbstractRenderer::LayersDirty);
-            break;
-        }
-    }
-
-    default:
-        break;
+    auto layerIds = qIdsForNodes(node->layers());
+    std::sort(std::begin(layerIds), std::end(layerIds));
+    if (m_layerIds != layerIds) {
+        m_layerIds = layerIds;
+        markDirty(AbstractRenderer::FrameGraphDirty|AbstractRenderer::LayersDirty);
     }
-
-    FrameGraphNode::sceneChangeEvent(e);
 }
 
 QNodeIdVector LayerFilterNode::layerIds() const
diff --git a/src/render/framegraph/layerfilternode_p.h b/src/render/framegraph/layerfilternode_p.h
index 18ba4ee7a..27cdc49d3 100644
--- a/src/render/framegraph/layerfilternode_p.h
+++ b/src/render/framegraph/layerfilternode_p.h
@@ -53,6 +53,7 @@
 
 #include <Qt3DRender/private/framegraphnode_p.h>
 #include <Qt3DRender/QLayerFilter>
+#include <Qt3DRender/QLayer>
 #include <QStringList>
 
 QT_BEGIN_NAMESPACE
@@ -68,15 +69,14 @@ class LayerFilterNode : public FrameGraphNode
 public:
     LayerFilterNode();
 
-    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e) override;
+    void syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime) override;
+
     Qt3DCore::QNodeIdVector layerIds() const;
     void setLayerIds(const Qt3DCore::QNodeIdVector &list);
 
     QLayerFilter::FilterMode filterMode() const;
 
 private:
-    void initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change) final;
-
     Qt3DCore::QNodeIdVector m_layerIds;
     QLayerFilter::FilterMode m_filterMode;
 };
diff --git a/src/render/framegraph/memorybarrier.cpp b/src/render/framegraph/memorybarrier.cpp
index 59b3071ab..6bfaedda7 100644
--- a/src/render/framegraph/memorybarrier.cpp
+++ b/src/render/framegraph/memorybarrier.cpp
@@ -62,24 +62,18 @@ QMemoryBarrier::Operations MemoryBarrier::waitOperations() const
     return m_waitOperations;
 }
 
-void MemoryBarrier::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
+void MemoryBarrier::syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime)
 {
-    if (e->type() == Qt3DCore::PropertyUpdated) {
-        Qt3DCore::QPropertyUpdatedChangePtr propertyChange = qSharedPointerCast<Qt3DCore::QPropertyUpdatedChange>(e);
-        if (propertyChange->propertyName() == QByteArrayLiteral("waitOperations")) {
-            m_waitOperations = propertyChange->value().value<QMemoryBarrier::Operations>();
-            markDirty(AbstractRenderer::FrameGraphDirty);
-        }
-    }
-    FrameGraphNode::sceneChangeEvent(e);
-}
+    const QMemoryBarrier *node = qobject_cast<const QMemoryBarrier *>(frontEnd);
+    if (!node)
+        return;
 
-void MemoryBarrier::initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change)
-{
-    FrameGraphNode::initializeFromPeer(change);
-    const auto typedChange = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<QMemoryBarrierData>>(change);
-    const QMemoryBarrierData &data = typedChange->data;
-    m_waitOperations = data.waitOperations;
+    FrameGraphNode::syncFromFrontEnd(frontEnd, firstTime);
+
+    if (node->waitOperations() != m_waitOperations) {
+        m_waitOperations = node->waitOperations();
+        markDirty(AbstractRenderer::FrameGraphDirty);
+    }
 }
 
 } // Render
diff --git a/src/render/framegraph/memorybarrier_p.h b/src/render/framegraph/memorybarrier_p.h
index e0fd3e9cd..ce545cd09 100644
--- a/src/render/framegraph/memorybarrier_p.h
+++ b/src/render/framegraph/memorybarrier_p.h
@@ -67,10 +67,9 @@ public:
     ~MemoryBarrier();
 
     QMemoryBarrier::Operations waitOperations() const;
-    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e) override;
+    void syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime) override;
 
 private:
-    void initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change) final;
     QMemoryBarrier::Operations m_waitOperations;
 };
 
diff --git a/src/render/framegraph/proximityfilter.cpp b/src/render/framegraph/proximityfilter.cpp
index cdfd7e51e..593e541bc 100644
--- a/src/render/framegraph/proximityfilter.cpp
+++ b/src/render/framegraph/proximityfilter.cpp
@@ -53,29 +53,24 @@ ProximityFilter::ProximityFilter()
 {
 }
 
-void ProximityFilter::initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change)
+void ProximityFilter::syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime)
 {
-    FrameGraphNode::initializeFromPeer(change);
-    const auto typedChange = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<QProximityFilterData>>(change);
-    const QProximityFilterData &data = typedChange->data;
-    m_entityId = data.entityId;
-    m_distanceThreshold = data.distanceThreshold;
-}
+    const QProximityFilter *node = qobject_cast<const QProximityFilter *>(frontEnd);
+    if (!node)
+        return;
 
-void ProximityFilter::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
-{
-    qCDebug(Render::Framegraph) << Q_FUNC_INFO;
-    if (e->type() == Qt3DCore::PropertyUpdated) {
-        Qt3DCore::QPropertyUpdatedChangePtr propertyChange = qSharedPointerCast<Qt3DCore::QPropertyUpdatedChange>(e);
-        if (propertyChange->propertyName() == QByteArrayLiteral("entity")) {
-            m_entityId = propertyChange->value().value<Qt3DCore::QNodeId>();
-            markDirty(AbstractRenderer::FrameGraphDirty);
-        } else if (propertyChange->propertyName() == QByteArrayLiteral("distanceThreshold")) {
-            m_distanceThreshold = propertyChange->value().toFloat();
-            markDirty(AbstractRenderer::FrameGraphDirty);
-        }
+    FrameGraphNode::syncFromFrontEnd(frontEnd, firstTime);
+
+    const auto entityId = Qt3DCore::qIdForNode(node->entity());
+    if (entityId != m_entityId) {
+        m_entityId = entityId;
+        markDirty(AbstractRenderer::FrameGraphDirty);
+    }
+
+    if (node->distanceThreshold() != m_distanceThreshold) {
+        m_distanceThreshold = node->distanceThreshold();
+        markDirty(AbstractRenderer::FrameGraphDirty);
     }
-    FrameGraphNode::sceneChangeEvent(e);
 }
 
 } // namespace Render
diff --git a/src/render/framegraph/proximityfilter_p.h b/src/render/framegraph/proximityfilter_p.h
index e57b53dea..5c2f7ad66 100644
--- a/src/render/framegraph/proximityfilter_p.h
+++ b/src/render/framegraph/proximityfilter_p.h
@@ -64,7 +64,7 @@ class Q_AUTOTEST_EXPORT ProximityFilter : public FrameGraphNode
 public:
     ProximityFilter();
 
-    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e) override;
+    void syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime) override;
 
     float distanceThreshold() const { return m_distanceThreshold; }
     Qt3DCore::QNodeId entityId() const { return m_entityId; }
@@ -76,8 +76,6 @@ public:
 #endif
 
 private:
-    void initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change) final;
-
     float m_distanceThreshold;
     Qt3DCore::QNodeId m_entityId;
 };
diff --git a/src/render/framegraph/qblitframebuffer.cpp b/src/render/framegraph/qblitframebuffer.cpp
index d0e1bdbf3..bf9e547cb 100644
--- a/src/render/framegraph/qblitframebuffer.cpp
+++ b/src/render/framegraph/qblitframebuffer.cpp
@@ -364,6 +364,7 @@ void QBlitFramebuffer::setDestination(QRenderTarget *destination)
     }
 }
 
+// TO DO Qt6: convert QRectF to QRect
 /*!
     Sets the source rectangle to \a inputRect. The coordinates are assumed to
     follow the normal Qt coordinate system, meaning Y runs from top to bottom.
diff --git a/src/render/framegraph/qframegraphnode.cpp b/src/render/framegraph/qframegraphnode.cpp
index d52b728a8..1ef81a081 100644
--- a/src/render/framegraph/qframegraphnode.cpp
+++ b/src/render/framegraph/qframegraphnode.cpp
@@ -258,13 +258,9 @@ Qt3DCore::QNodeCreatedChangeBasePtr QFrameGraphNode::createNodeCreationChange()
 
 void QFrameGraphNode::onParentChanged(QObject *)
 {
-    const auto parentID = parentFrameGraphNode() ? parentFrameGraphNode()->id() : Qt3DCore::QNodeId();
-    auto parentChange = Qt3DCore::QPropertyUpdatedChangePtr::create(id());
-    parentChange->setPropertyName("parentFrameGraphUpdated");
-    parentChange->setValue(QVariant::fromValue(parentID));
-    const bool blocked = blockNotifications(false);
-    notifyObservers(parentChange);
-    blockNotifications(blocked);
+    // Direct sync update request
+    Q_D(QFrameGraphNode);
+    d->update();
 }
 
 } // namespace Qt3DRender
diff --git a/src/render/framegraph/qlayerfilter.cpp b/src/render/framegraph/qlayerfilter.cpp
index 04ebca572..8b0dd5669 100644
--- a/src/render/framegraph/qlayerfilter.cpp
+++ b/src/render/framegraph/qlayerfilter.cpp
@@ -206,11 +206,7 @@ void QLayerFilter::addLayer(QLayer *layer)
         if (!layer->parent())
             layer->setParent(this);
 
-        if (d->m_changeArbiter != nullptr) {
-            const auto change = Qt3DCore::QPropertyNodeAddedChangePtr::create(id(), layer);
-            change->setPropertyName("layer");
-            d->notifyObservers(change);
-        }
+        d->update();
     }
 }
 
@@ -221,11 +217,7 @@ void QLayerFilter::removeLayer(QLayer *layer)
 {
     Q_ASSERT(layer);
     Q_D(QLayerFilter);
-    if (d->m_changeArbiter != nullptr) {
-        const auto change = Qt3DCore::QPropertyNodeRemovedChangePtr::create(id(), layer);
-        change->setPropertyName("layer");
-        d->notifyObservers(change);
-    }
+    d->update();
     d->m_layers.removeOne(layer);
     // Remove bookkeeping connection
     d->unregisterDestructionHelper(layer);
diff --git a/src/render/framegraph/qrendercapture.cpp b/src/render/framegraph/qrendercapture.cpp
index 5bda569f9..2169f72dd 100644
--- a/src/render/framegraph/qrendercapture.cpp
+++ b/src/render/framegraph/qrendercapture.cpp
@@ -326,11 +326,9 @@ QRenderCaptureReply *QRenderCapture::requestCapture(int captureId)
         d->replyDestroyed(reply);
     });
 
-    Qt3DCore::QPropertyUpdatedChangePtr change(new Qt3DCore::QPropertyUpdatedChange(id()));
-    change->setPropertyName(QByteArrayLiteral("renderCaptureRequest"));
     const QRenderCaptureRequest request = { captureId, QRect() };
-    change->setValue(QVariant::fromValue(request));
-    d->notifyObservers(change);
+    d->m_pendingRequests.push_back(request);
+    d->update();
 
     return reply;
 }
@@ -351,11 +349,9 @@ QRenderCaptureReply *QRenderCapture::requestCapture(const QRect &rect)
         d->replyDestroyed(reply);
     });
 
-    Qt3DCore::QPropertyUpdatedChangePtr change(new Qt3DCore::QPropertyUpdatedChange(id()));
-    change->setPropertyName(QByteArrayLiteral("renderCaptureRequest"));
     const QRenderCaptureRequest request = { captureId, rect };
-    change->setValue(QVariant::fromValue(request));
-    d->notifyObservers(change);
+    d->m_pendingRequests.push_back(request);
+    d->update();
 
     captureId++;
 
diff --git a/src/render/framegraph/qrendercapture_p.h b/src/render/framegraph/qrendercapture_p.h
index 4e509cc59..3dec4d280 100644
--- a/src/render/framegraph/qrendercapture_p.h
+++ b/src/render/framegraph/qrendercapture_p.h
@@ -57,6 +57,12 @@ QT_BEGIN_NAMESPACE
 
 namespace Qt3DRender {
 
+struct QRenderCaptureRequest
+{
+    int captureId;
+    QRect rect;
+};
+
 class QRenderCapturePrivate : public QFrameGraphNodePrivate
 {
 public:
@@ -64,6 +70,7 @@ public:
     ~QRenderCapturePrivate();
     QVector<QRenderCaptureReply *> m_waitingReplies;
     QMutex m_mutex;
+    mutable QVector<QRenderCaptureRequest> m_pendingRequests;
 
     QRenderCaptureReply *createReply(int captureId);
     QRenderCaptureReply *takeReply(int captureId);
@@ -82,6 +89,7 @@ public:
     int m_captureId;
     bool m_complete;
 
+
     Q_DECLARE_PUBLIC(QRenderCaptureReply)
 };
 
@@ -100,12 +108,6 @@ struct RenderCaptureData
 
 typedef QSharedPointer<RenderCaptureData> RenderCaptureDataPtr;
 
-struct QRenderCaptureRequest
-{
-    int captureId;
-    QRect rect;
-};
-
 } // Qt3DRender
 
 QT_END_NAMESPACE
diff --git a/src/render/framegraph/qrenderpassfilter.cpp b/src/render/framegraph/qrenderpassfilter.cpp
index 56c229d9c..4ef7e6d2d 100644
--- a/src/render/framegraph/qrenderpassfilter.cpp
+++ b/src/render/framegraph/qrenderpassfilter.cpp
@@ -142,11 +142,7 @@ void QRenderPassFilter::addMatch(QFilterKey *filterKey)
         if (!filterKey->parent())
             filterKey->setParent(this);
 
-        if (d->m_changeArbiter != nullptr) {
-            const auto change = QPropertyNodeAddedChangePtr::create(id(), filterKey);
-            change->setPropertyName("match");
-            d->notifyObservers(change);
-        }
+        d->update();
     }
 }
 
@@ -158,11 +154,7 @@ void QRenderPassFilter::removeMatch(QFilterKey *filterKey)
     Q_ASSERT(filterKey);
     Q_D(QRenderPassFilter);
 
-    if (d->m_changeArbiter != nullptr) {
-        const auto change = QPropertyNodeRemovedChangePtr::create(id(), filterKey);
-        change->setPropertyName("match");
-        d->notifyObservers(change);
-    }
+    d->update();
     d->m_matchList.removeOne(filterKey);
     // Remove bookkeeping connection
     d->unregisterDestructionHelper(filterKey);
@@ -188,11 +180,7 @@ void QRenderPassFilter::addParameter(QParameter *parameter)
         if (!parameter->parent())
             parameter->setParent(this);
 
-        if (d->m_changeArbiter != nullptr) {
-            const auto change = QPropertyNodeAddedChangePtr::create(id(), parameter);
-            change->setPropertyName("parameter");
-            d->notifyObservers(change);
-        }
+        d->update();
     }
 }
 
@@ -204,11 +192,7 @@ void QRenderPassFilter::removeParameter(QParameter *parameter)
     Q_ASSERT(parameter);
     Q_D(QRenderPassFilter);
 
-    if (d->m_changeArbiter != nullptr) {
-        const auto change = QPropertyNodeRemovedChangePtr::create(id(), parameter);
-        change->setPropertyName("parameter");
-        d->notifyObservers(change);
-    }
+    d->update();
     d->m_parameters.removeOne(parameter);
     // Remove bookkeeping connection
     d->unregisterDestructionHelper(parameter);
diff --git a/src/render/framegraph/qrenderstateset.cpp b/src/render/framegraph/qrenderstateset.cpp
index 6f70456ab..d558a939e 100644
--- a/src/render/framegraph/qrenderstateset.cpp
+++ b/src/render/framegraph/qrenderstateset.cpp
@@ -194,11 +194,7 @@ void QRenderStateSet::addRenderState(QRenderState *state)
         if (!state->parent())
             state->setParent(this);
 
-        if (d->m_changeArbiter != nullptr) {
-            const auto change = QPropertyNodeAddedChangePtr::create(id(), state);
-            change->setPropertyName("renderState");
-            d->notifyObservers(change);
-        }
+        d->update();
     }
 }
 
@@ -210,11 +206,7 @@ void QRenderStateSet::removeRenderState(QRenderState *state)
     Q_ASSERT(state);
     Q_D(QRenderStateSet);
 
-    if (d->m_changeArbiter != nullptr) {
-        const auto change = QPropertyNodeRemovedChangePtr::create(id(), state);
-        change->setPropertyName("renderState");
-        d->notifyObservers(change);
-    }
+    d->update();
     d->m_renderStates.removeOne(state);
     // Remove bookkeeping connection
     d->unregisterDestructionHelper(state);
diff --git a/src/render/framegraph/qrendersurfaceselector.cpp b/src/render/framegraph/qrendersurfaceselector.cpp
index 848d86f53..765aa1824 100644
--- a/src/render/framegraph/qrendersurfaceselector.cpp
+++ b/src/render/framegraph/qrendersurfaceselector.cpp
@@ -253,24 +253,10 @@ void QRenderSurfaceSelector::setSurface(QObject *surfaceObject)
 
             if (window) {
                 d->m_widthConn = QObject::connect(window, &QWindow::widthChanged, [=] (int width) {
-                    if (d->m_changeArbiter != nullptr) {
-                        Qt3DCore::QPropertyUpdatedChangePtr change(
-                                    new Qt3DCore::QPropertyUpdatedChange(id()));
-
-                        change->setPropertyName("width");
-                        change->setValue(QVariant::fromValue(width));
-                        d->notifyObservers(change);
-                    }
+                    d->update();
                 });
                 d->m_heightConn = QObject::connect(window, &QWindow::heightChanged, [=] (int height) {
-                    if (d->m_changeArbiter != nullptr) {
-                        Qt3DCore::QPropertyUpdatedChangePtr change(
-                                    new Qt3DCore::QPropertyUpdatedChange(id()));
-
-                        change->setPropertyName("height");
-                        change->setValue(QVariant::fromValue(height));
-                        d->notifyObservers(change);
-                    }
+                    d->update();
                 });
                 d->m_screenConn = QObject::connect(window, &QWindow::screenChanged, [=] (QScreen *screen) {
                     if (screen && surfacePixelRatio() != screen->devicePixelRatio())
diff --git a/src/render/framegraph/qrendertargetselector.cpp b/src/render/framegraph/qrendertargetselector.cpp
index 1b4afc7e6..f4d95d507 100644
--- a/src/render/framegraph/qrendertargetselector.cpp
+++ b/src/render/framegraph/qrendertargetselector.cpp
@@ -153,13 +153,7 @@ void QRenderTargetSelector::setOutputs(const QVector<QRenderTargetOutput::Attach
     Q_D(QRenderTargetSelector);
     if (buffers != d->m_outputs) {
         d->m_outputs = buffers;
-
-        if (d->m_changeArbiter) {
-            auto change = QPropertyUpdatedChangePtr::create(d->m_id);
-            change->setPropertyName("outputs");
-            change->setValue(QVariant::fromValue(d->m_outputs));
-            d->notifyObservers(change);
-        }
+        d->update();
     }
 }
 
diff --git a/src/render/framegraph/qsortpolicy.cpp b/src/render/framegraph/qsortpolicy.cpp
index 6f852afbd..c8e3d23c5 100644
--- a/src/render/framegraph/qsortpolicy.cpp
+++ b/src/render/framegraph/qsortpolicy.cpp
@@ -178,7 +178,10 @@ void QSortPolicy::setSortTypes(const QVector<SortType> &sortTypes)
     if (sortTypes != d->m_sortTypes) {
         d->m_sortTypes = sortTypes;
         emit sortTypesChanged(sortTypes);
+
+        const bool wasBlocked = blockNotifications(true);
         emit sortTypesChanged(sortTypesInt());
+        blockNotifications(wasBlocked);
     }
 }
 
diff --git a/src/render/framegraph/qtechniquefilter.cpp b/src/render/framegraph/qtechniquefilter.cpp
index 404ad6991..28b151fc7 100644
--- a/src/render/framegraph/qtechniquefilter.cpp
+++ b/src/render/framegraph/qtechniquefilter.cpp
@@ -147,11 +147,7 @@ void QTechniqueFilter::addMatch(QFilterKey *filterKey)
         if (!filterKey->parent())
             filterKey->setParent(this);
 
-        if (d->m_changeArbiter != nullptr) {
-            const auto change = QPropertyNodeAddedChangePtr::create(id(), filterKey);
-            change->setPropertyName("matchAll");
-            d->notifyObservers(change);
-        }
+        d->update();
     }
 }
 
@@ -162,11 +158,7 @@ void QTechniqueFilter::removeMatch(QFilterKey *filterKey)
 {
     Q_ASSERT(filterKey);
     Q_D(QTechniqueFilter);
-    if (d->m_changeArbiter != nullptr) {
-        const auto change = QPropertyNodeRemovedChangePtr::create(id(), filterKey);
-        change->setPropertyName("matchAll");
-        d->notifyObservers(change);
-    }
+    d->update();
     d->m_matchList.removeOne(filterKey);
     // Remove bookkeeping connection
     d->unregisterDestructionHelper(filterKey);
@@ -192,11 +184,7 @@ void QTechniqueFilter::addParameter(QParameter *parameter)
         if (!parameter->parent())
             parameter->setParent(this);
 
-        if (d->m_changeArbiter != nullptr) {
-            const auto change = QPropertyNodeAddedChangePtr::create(id(), parameter);
-            change->setPropertyName("parameter");
-            d->notifyObservers(change);
-        }
+        d->update();
     }
 }
 
@@ -207,11 +195,7 @@ void QTechniqueFilter::removeParameter(QParameter *parameter)
 {
     Q_ASSERT(parameter);
     Q_D(QTechniqueFilter);
-    if (d->m_changeArbiter != nullptr) {
-        const auto change = QPropertyNodeRemovedChangePtr::create(id(), parameter);
-        change->setPropertyName("parameter");
-        d->notifyObservers(change);
-    }
+    d->update();
     d->m_parameters.removeOne(parameter);
     // Remove bookkeeping connection
     d->unregisterDestructionHelper(parameter);
diff --git a/src/render/framegraph/rendercapture.cpp b/src/render/framegraph/rendercapture.cpp
index 166294889..68d62b6a5 100644
--- a/src/render/framegraph/rendercapture.cpp
+++ b/src/render/framegraph/rendercapture.cpp
@@ -70,16 +70,23 @@ QRenderCaptureRequest RenderCapture::takeCaptureRequest()
     return m_requestedCaptures.takeFirst();
 }
 
-void RenderCapture::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
+void RenderCapture::syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime)
 {
-    if (e->type() == Qt3DCore::PropertyUpdated) {
-        Qt3DCore::QPropertyUpdatedChangePtr propertyChange = qSharedPointerCast<Qt3DCore::QPropertyUpdatedChange>(e);
-        if (propertyChange->propertyName() == QByteArrayLiteral("renderCaptureRequest")) {
-            requestCapture(propertyChange->value().value<QRenderCaptureRequest>());
-            markDirty(AbstractRenderer::FrameGraphDirty);
-        }
+    const QRenderCapture *node = qobject_cast<const QRenderCapture *>(frontEnd);
+    if (!node)
+        return;
+
+    FrameGraphNode::syncFromFrontEnd(frontEnd, firstTime);
+
+    const QRenderCapturePrivate *d = static_cast<const QRenderCapturePrivate *>(QFrameGraphNodePrivate::get(node));
+    const auto newPendingsCaptures = std::move(d->m_pendingRequests);
+    if (newPendingsCaptures.size() > 0) {
+        m_requestedCaptures.append(newPendingsCaptures);
+        markDirty(AbstractRenderer::FrameGraphDirty);
     }
-    FrameGraphNode::sceneChangeEvent(e);
+
+    if (firstTime)
+        markDirty(AbstractRenderer::FrameGraphDirty);
 }
 
 // called by render thread
diff --git a/src/render/framegraph/rendercapture_p.h b/src/render/framegraph/rendercapture_p.h
index 71fa01ec1..4560c525d 100644
--- a/src/render/framegraph/rendercapture_p.h
+++ b/src/render/framegraph/rendercapture_p.h
@@ -68,8 +68,7 @@ public:
     void addRenderCapture(int captureId, const QImage &image);
     void sendRenderCaptures();
 
-protected:
-    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e) final;
+    void syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime) override;
 
 private:
 
diff --git a/src/render/framegraph/renderpassfilternode.cpp b/src/render/framegraph/renderpassfilternode.cpp
index e3da1e36d..afc49a563 100644
--- a/src/render/framegraph/renderpassfilternode.cpp
+++ b/src/render/framegraph/renderpassfilternode.cpp
@@ -58,16 +58,33 @@ RenderPassFilter::RenderPassFilter()
 {
 }
 
-void RenderPassFilter::initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change)
+void RenderPassFilter::syncFromFrontEnd(const QNode *frontEnd, bool firstTime)
 {
-    FrameGraphNode::initializeFromPeer(change);
-    const auto typedChange = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<QRenderPassFilterData>>(change);
-    const auto &data = typedChange->data;
-    m_filters = data.matchIds;
-    m_parameterPack.clear();
-    m_parameterPack.setParameters(data.parameterIds);
+    const QRenderPassFilter *node = qobject_cast<const QRenderPassFilter *>(frontEnd);
+    if (!node)
+        return;
+
+    FrameGraphNode::syncFromFrontEnd(frontEnd, firstTime);
+
+    if (firstTime)
+        m_parameterPack.clear();
+
+    auto parameters = qIdsForNodes(node->parameters());
+    std::sort(std::begin(parameters), std::end(parameters));
+    if (m_parameterPack.parameters() != parameters) {
+        m_parameterPack.setParameters(parameters);
+        markDirty(AbstractRenderer::FrameGraphDirty);
+    }
+
+    auto filterIds = qIdsForNodes(node->matchAny());
+    std::sort(std::begin(filterIds), std::end(filterIds));
+    if (m_filters != filterIds) {
+        m_filters = filterIds;
+        markDirty(AbstractRenderer::FrameGraphDirty);
+    }
 }
 
+
 QVector<Qt3DCore::QNodeId> RenderPassFilter::filters() const
 {
     return m_filters;
@@ -89,40 +106,6 @@ QVector<Qt3DCore::QNodeId> RenderPassFilter::parameters() const
     return m_parameterPack.parameters();
 }
 
-void RenderPassFilter::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
-{
-
-    switch (e->type()) {
-    case PropertyValueAdded: {
-        const auto change = qSharedPointerCast<QPropertyNodeAddedChange>(e);
-        if (change->propertyName() == QByteArrayLiteral("match")) {
-            appendFilter(change->addedNodeId());
-            markDirty(AbstractRenderer::FrameGraphDirty);
-        } else if (change->propertyName() == QByteArrayLiteral("parameter")) {
-            m_parameterPack.appendParameter(change->addedNodeId());
-            markDirty(AbstractRenderer::FrameGraphDirty);
-        }
-        break;
-    }
-
-    case PropertyValueRemoved: {
-        const auto change = qSharedPointerCast<QPropertyNodeRemovedChange>(e);
-        if (change->propertyName() == QByteArrayLiteral("match")) {
-            removeFilter(change->removedNodeId());
-            markDirty(AbstractRenderer::FrameGraphDirty);
-        } else if (change->propertyName() == QByteArrayLiteral("parameter")) {
-            m_parameterPack.removeParameter(change->removedNodeId());
-            markDirty(AbstractRenderer::FrameGraphDirty);
-        }
-        break;
-    }
-
-    default:
-        break;
-    }
-    FrameGraphNode::sceneChangeEvent(e);
-}
-
 } // namespace Render
 } // namespace Qt3DRender
 
diff --git a/src/render/framegraph/renderpassfilternode_p.h b/src/render/framegraph/renderpassfilternode_p.h
index 398d42049..157a162bb 100644
--- a/src/render/framegraph/renderpassfilternode_p.h
+++ b/src/render/framegraph/renderpassfilternode_p.h
@@ -76,11 +76,9 @@ public:
     QVector<Qt3DCore::QNodeId> parameters() const;
     void appendFilter(Qt3DCore::QNodeId criterionId);
     void removeFilter(Qt3DCore::QNodeId criterionId);
-    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e) override;
+    void syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime) override;
 
 private:
-    void initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change) final;
-
     QVector<Qt3DCore::QNodeId> m_filters;
     ParameterPack m_parameterPack;
 };
diff --git a/src/render/framegraph/rendersurfaceselector.cpp b/src/render/framegraph/rendersurfaceselector.cpp
index 16a1199b5..173da77d6 100644
--- a/src/render/framegraph/rendersurfaceselector.cpp
+++ b/src/render/framegraph/rendersurfaceselector.cpp
@@ -73,6 +73,7 @@ namespace Render {
 
 RenderSurfaceSelector::RenderSurfaceSelector()
     : FrameGraphNode(FrameGraphNode::Surface)
+    , m_surfaceObj(nullptr)
     , m_surface(nullptr)
     , m_width(0)
     , m_height(0)
@@ -80,45 +81,41 @@ RenderSurfaceSelector::RenderSurfaceSelector()
 {
 }
 
-void RenderSurfaceSelector::initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change)
+void RenderSurfaceSelector::syncFromFrontEnd(const QNode *frontEnd, bool firstTime)
 {
-    FrameGraphNode::initializeFromPeer(change);
-    const auto typedChange = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<QRenderSurfaceSelectorData>>(change);
-    const auto &data = typedChange->data;
-    m_surface = surfaceFromQObject(data.surface);
-    m_renderTargetSize = data.externalRenderTargetSize;
-    m_devicePixelRatio = data.surfacePixelRatio;
+    const QRenderSurfaceSelector *node = qobject_cast<const QRenderSurfaceSelector *>(frontEnd);
+    if (!node)
+        return;
 
-    if (m_surface && m_surface->surfaceClass() == QSurface::Window) {
-        QWindow *window = static_cast<QWindow *>(m_surface);
-        m_width = window->width();
-        m_height = window->height();
+    FrameGraphNode::syncFromFrontEnd(frontEnd, firstTime);
+
+    if (node->surface() != m_surfaceObj) {
+        m_surfaceObj = node->surface();
+        m_surface = surfaceFromQObject(m_surfaceObj);
+        markDirty(AbstractRenderer::FrameGraphDirty);
     }
-}
 
-void RenderSurfaceSelector::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
-{
-    qCDebug(Render::Framegraph) << Q_FUNC_INFO;
-    if (e->type() == PropertyUpdated) {
-        QPropertyUpdatedChangePtr propertyChange = qSharedPointerCast<QPropertyUpdatedChange>(e);
-        if (propertyChange->propertyName() == QByteArrayLiteral("surface")) {
-            m_surface = surfaceFromQObject(propertyChange->value().value<QObject *>());
-            markDirty(AbstractRenderer::FrameGraphDirty);
-        } else if (propertyChange->propertyName() == QByteArrayLiteral("externalRenderTargetSize")) {
-            setRenderTargetSize(propertyChange->value().toSize());
-            markDirty(AbstractRenderer::FrameGraphDirty);
-        } else if (propertyChange->propertyName() == QByteArrayLiteral("width")) {
-            m_width = propertyChange->value().toInt();
-            markDirty(AbstractRenderer::FrameGraphDirty);
-        } else if (propertyChange->propertyName() == QByteArrayLiteral("height")) {
-            m_height = propertyChange->value().toInt();
+    if (m_surface && m_surface->surfaceClass() == QSurface::Window) {
+        QWindow *window = static_cast<QWindow *>(m_surface);
+        if (window->width() != m_width) {
+            m_width = window->width();
             markDirty(AbstractRenderer::FrameGraphDirty);
-        } else if (propertyChange->propertyName() == QByteArrayLiteral("surfacePixelRatio")) {
-            m_devicePixelRatio = propertyChange->value().toFloat();
+        }
+        if (window->height() != m_height) {
+            m_height = window->height();
             markDirty(AbstractRenderer::FrameGraphDirty);
         }
     }
-    FrameGraphNode::sceneChangeEvent(e);
+
+    if (node->externalRenderTargetSize() != m_renderTargetSize) {
+        m_renderTargetSize = node->externalRenderTargetSize();
+        markDirty(AbstractRenderer::FrameGraphDirty);
+    }
+
+    if (node->surfacePixelRatio() != m_devicePixelRatio) {
+        m_devicePixelRatio = node->surfacePixelRatio();
+        markDirty(AbstractRenderer::FrameGraphDirty);
+    }
 }
 
 QSize RenderSurfaceSelector::renderTargetSize() const
diff --git a/src/render/framegraph/rendersurfaceselector_p.h b/src/render/framegraph/rendersurfaceselector_p.h
index 74863aa36..f1a139e84 100644
--- a/src/render/framegraph/rendersurfaceselector_p.h
+++ b/src/render/framegraph/rendersurfaceselector_p.h
@@ -68,7 +68,7 @@ public:
     QSize renderTargetSize() const;
     void setRenderTargetSize(const QSize &size) { m_renderTargetSize = size; }
 
-    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e) override;
+    void syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime) override;
 
     QSurface *surface() const { return m_surface; }
     inline int width() const Q_DECL_NOTHROW { return m_width; }
@@ -76,8 +76,7 @@ public:
     inline float devicePixelRatio() const Q_DECL_NOTHROW { return m_devicePixelRatio; }
 
 private:
-    void initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change) final;
-
+    QObject *m_surfaceObj;
     QSurface *m_surface;
     QSize m_renderTargetSize;
     int m_width;
diff --git a/src/render/framegraph/rendertargetselectornode.cpp b/src/render/framegraph/rendertargetselectornode.cpp
index 615608bd2..871a00154 100644
--- a/src/render/framegraph/rendertargetselectornode.cpp
+++ b/src/render/framegraph/rendertargetselectornode.cpp
@@ -59,29 +59,24 @@ RenderTargetSelector::RenderTargetSelector() :
 {
 }
 
-void RenderTargetSelector::initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change)
+void RenderTargetSelector::syncFromFrontEnd(const QNode *frontEnd, bool firstTime)
 {
-    FrameGraphNode::initializeFromPeer(change);
-    const auto typedChange = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<QRenderTargetSelectorData>>(change);
-    const auto &data = typedChange->data;
-    m_renderTargetUuid = data.targetId;
-    m_outputs = data.outputs;
-}
+    const QRenderTargetSelector *node = qobject_cast<const QRenderTargetSelector *>(frontEnd);
+    if (!node)
+        return;
 
-void RenderTargetSelector::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
-{
-    qCDebug(Render::Framegraph) << Q_FUNC_INFO;
-    if (e->type() == PropertyUpdated) {
-        QPropertyUpdatedChangePtr propertyChange = qSharedPointerCast<QPropertyUpdatedChange>(e);
-        if (propertyChange->propertyName() == QByteArrayLiteral("target")) {
-            m_renderTargetUuid = propertyChange->value().value<QNodeId>();
-            markDirty(AbstractRenderer::FrameGraphDirty);
-        } else if (propertyChange->propertyName() == QByteArrayLiteral("outputs")) {
-            m_outputs = propertyChange->value().value<QVector<Qt3DRender::QRenderTargetOutput::AttachmentPoint> >();
-            markDirty(AbstractRenderer::FrameGraphDirty);
-        }
+    FrameGraphNode::syncFromFrontEnd(frontEnd, firstTime);
+
+    const QNodeId renderTargetId = qIdForNode(node->target());
+    if (renderTargetId != m_renderTargetUuid) {
+        m_renderTargetUuid = renderTargetId;
+        markDirty(AbstractRenderer::FrameGraphDirty);
+    }
+
+    if (node->outputs() != m_outputs) {
+        m_outputs = node->outputs();
+        markDirty(AbstractRenderer::FrameGraphDirty);
     }
-    FrameGraphNode::sceneChangeEvent(e);
 }
 
 } // namespace Render
diff --git a/src/render/framegraph/rendertargetselectornode_p.h b/src/render/framegraph/rendertargetselectornode_p.h
index 81ac8a3d3..232ee9ecc 100644
--- a/src/render/framegraph/rendertargetselectornode_p.h
+++ b/src/render/framegraph/rendertargetselectornode_p.h
@@ -66,14 +66,12 @@ class RenderTargetSelector : public FrameGraphNode
 public:
     RenderTargetSelector();
 
-    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e) override;
+    void syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime) override;
 
     Qt3DCore::QNodeId renderTargetUuid() const { return m_renderTargetUuid; }
     QVector<QRenderTargetOutput::AttachmentPoint> outputs() const { return m_outputs; }
 
 private:
-    void initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change) final;
-
     Qt3DCore::QNodeId m_renderTargetUuid;
     QVector<QRenderTargetOutput::AttachmentPoint> m_outputs;
 };
diff --git a/src/render/framegraph/sortpolicy.cpp b/src/render/framegraph/sortpolicy.cpp
index b81d1f6cb..3c7975945 100644
--- a/src/render/framegraph/sortpolicy.cpp
+++ b/src/render/framegraph/sortpolicy.cpp
@@ -53,18 +53,19 @@ SortPolicy::SortPolicy()
 {
 }
 
-void SortPolicy::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
+void SortPolicy::syncFromFrontEnd(const QNode *frontEnd, bool firstTime)
 {
-    if (e->type() == Qt3DCore::PropertyUpdated) {
-        Qt3DCore::QPropertyUpdatedChangePtr propertyChange = qSharedPointerCast<Qt3DCore::QPropertyUpdatedChange>(e);
-        if (propertyChange->propertyName() == QByteArrayLiteral("sortTypes")) {
-            auto sortTypesInt = propertyChange->value().value<QVector<int>>();
-            m_sortTypes.clear();
-            transformVector(sortTypesInt, m_sortTypes);
-            markDirty(AbstractRenderer::FrameGraphDirty);
-        }
+    const QSortPolicy *node = qobject_cast<const QSortPolicy *>(frontEnd);
+    if (!node)
+        return;
+
+    FrameGraphNode::syncFromFrontEnd(frontEnd, firstTime);
+
+    const auto sortTypes = node->sortTypes();
+    if (sortTypes != m_sortTypes) {
+        m_sortTypes = sortTypes;
+        markDirty(AbstractRenderer::FrameGraphDirty);
     }
-    FrameGraphNode::sceneChangeEvent(e);
 }
 
 QVector<QSortPolicy::SortType> SortPolicy::sortTypes() const
@@ -72,14 +73,6 @@ QVector<QSortPolicy::SortType> SortPolicy::sortTypes() const
     return m_sortTypes;
 }
 
-void SortPolicy::initializeFromPeer(const QNodeCreatedChangeBasePtr &change)
-{
-    FrameGraphNode::initializeFromPeer(change);
-    const auto typedChange = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<QSortPolicyData>>(change);
-    const QSortPolicyData &data = typedChange->data;
-    m_sortTypes = data.sortTypes;
-}
-
 } // namepace Render
 } // namespace Qt3DRender
 
diff --git a/src/render/framegraph/sortpolicy_p.h b/src/render/framegraph/sortpolicy_p.h
index ef928af7b..8d572ead7 100644
--- a/src/render/framegraph/sortpolicy_p.h
+++ b/src/render/framegraph/sortpolicy_p.h
@@ -65,13 +65,11 @@ class Q_AUTOTEST_EXPORT SortPolicy : public FrameGraphNode
 public:
     SortPolicy();
 
-    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e) override;
+    void syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime) override;
 
     QVector<Qt3DRender::QSortPolicy::SortType> sortTypes() const;
 
 private:
-    void initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change) final;
-
     QVector<Qt3DRender::QSortPolicy::SortType> m_sortTypes;
 };
 
diff --git a/src/render/framegraph/statesetnode.cpp b/src/render/framegraph/statesetnode.cpp
index 96551684e..32ac5e569 100644
--- a/src/render/framegraph/statesetnode.cpp
+++ b/src/render/framegraph/statesetnode.cpp
@@ -68,40 +68,20 @@ QVector<QNodeId> StateSetNode::renderStates() const
     return m_renderStates;
 }
 
-void StateSetNode::initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change)
+void StateSetNode::syncFromFrontEnd(const QNode *frontEnd, bool firstTime)
 {
-    FrameGraphNode::initializeFromPeer(change);
-    const auto typedChange = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<QRenderStateSetData>>(change);
-    const auto &data = typedChange->data;
-    for (const auto &stateId : qAsConst(data.renderStateIds))
-        addRenderState(stateId);
-}
+    const QRenderStateSet *node = qobject_cast<const QRenderStateSet *>(frontEnd);
+    if (!node)
+        return;
 
-void StateSetNode::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
-{
-    switch (e->type()) {
-    case PropertyValueAdded: {
-        const auto change = qSharedPointerCast<QPropertyNodeAddedChange>(e);
-        if (change->propertyName() == QByteArrayLiteral("renderState")) {
-            addRenderState(change->addedNodeId());
-            markDirty(AbstractRenderer::FrameGraphDirty);
-        }
-        break;
-    }
-
-    case PropertyValueRemoved: {
-        const auto propertyChange = qSharedPointerCast<QPropertyNodeRemovedChange>(e);
-        if (propertyChange->propertyName() == QByteArrayLiteral("renderState")) {
-            removeRenderState(propertyChange->removedNodeId());
-            markDirty(AbstractRenderer::FrameGraphDirty);
-        }
-        break;
-    }
+    FrameGraphNode::syncFromFrontEnd(frontEnd, firstTime);
 
-    default:
-        break;
+    auto stateIds = qIdsForNodes(node->renderStates());
+    std::sort(std::begin(stateIds), std::end(stateIds));
+    if (m_renderStates != stateIds) {
+        m_renderStates = stateIds;
+        markDirty(AbstractRenderer::FrameGraphDirty);
     }
-    FrameGraphNode::sceneChangeEvent(e);
 }
 
 void StateSetNode::addRenderState(QNodeId renderStateId)
diff --git a/src/render/framegraph/statesetnode_p.h b/src/render/framegraph/statesetnode_p.h
index d33e118cb..5081f3215 100644
--- a/src/render/framegraph/statesetnode_p.h
+++ b/src/render/framegraph/statesetnode_p.h
@@ -68,13 +68,13 @@ public:
     inline bool hasRenderStates() const { return !m_renderStates.empty(); }
     QVector<Qt3DCore::QNodeId> renderStates() const;
 
+    void syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime) override;
+
 protected:
-    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e) override;
     void addRenderState(Qt3DCore::QNodeId renderStateId);
     void removeRenderState(Qt3DCore::QNodeId renderStateId);
 
 private:
-    void initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change) final;
     QVector<Qt3DCore::QNodeId> m_renderStates;
 };
 
diff --git a/src/render/framegraph/techniquefilternode.cpp b/src/render/framegraph/techniquefilternode.cpp
index 8816984ee..8739143e6 100644
--- a/src/render/framegraph/techniquefilternode.cpp
+++ b/src/render/framegraph/techniquefilternode.cpp
@@ -59,13 +59,30 @@ TechniqueFilter::TechniqueFilter()
 {
 }
 
-void TechniqueFilter::initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change)
+void TechniqueFilter::syncFromFrontEnd(const QNode *frontEnd, bool firstTime)
 {
-    FrameGraphNode::initializeFromPeer(change);
-    const auto typedChange = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<QTechniqueFilterData>>(change);
-    const auto &data = typedChange->data;
-    m_filters = data.matchIds;
-    m_parameterPack.setParameters(data.parameterIds);
+    const QTechniqueFilter *node = qobject_cast<const QTechniqueFilter *>(frontEnd);
+    if (!node)
+        return;
+
+    FrameGraphNode::syncFromFrontEnd(frontEnd, firstTime);
+
+    if (firstTime)
+        m_parameterPack.clear();
+
+    auto parameters = qIdsForNodes(node->parameters());
+    std::sort(std::begin(parameters), std::end(parameters));
+    if (m_parameterPack.parameters() != parameters) {
+        m_parameterPack.setParameters(parameters);
+        markDirty(AbstractRenderer::FrameGraphDirty);
+    }
+
+    auto filterIds = qIdsForNodes(node->matchAll());
+    std::sort(std::begin(filterIds), std::end(filterIds));
+    if (m_filters != filterIds) {
+        m_filters = filterIds;
+        markDirty(AbstractRenderer::FrameGraphDirty);
+    }
 }
 
 QVector<Qt3DCore::QNodeId> TechniqueFilter::parameters() const
@@ -89,39 +106,6 @@ void TechniqueFilter::removeFilter(Qt3DCore::QNodeId criterionId)
     m_filters.removeOne(criterionId);
 }
 
-void TechniqueFilter::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
-{
-    switch (e->type()) {
-    case PropertyValueAdded: {
-        const auto change = qSharedPointerCast<QPropertyNodeAddedChange>(e);
-        if (change->propertyName() == QByteArrayLiteral("matchAll")) {
-            appendFilter(change->addedNodeId());
-            markDirty(AbstractRenderer::FrameGraphDirty);
-        } else if (change->propertyName() == QByteArrayLiteral("parameter")) {
-            m_parameterPack.appendParameter(change->addedNodeId());
-            markDirty(AbstractRenderer::FrameGraphDirty);
-        }
-        break;
-    }
-
-    case PropertyValueRemoved: {
-        const auto change = qSharedPointerCast<QPropertyNodeRemovedChange>(e);
-        if (change->propertyName() == QByteArrayLiteral("matchAll")) {
-            removeFilter(change->removedNodeId());
-            markDirty(AbstractRenderer::FrameGraphDirty);
-        } else if (change->propertyName() == QByteArrayLiteral("parameter")) {
-            m_parameterPack.removeParameter(change->removedNodeId());
-            markDirty(AbstractRenderer::FrameGraphDirty);
-        }
-        break;
-    }
-
-    default:
-        break;
-    }
-    FrameGraphNode::sceneChangeEvent(e);
-}
-
 } // namespace Render
 } // namespace Qt3DRender
 
diff --git a/src/render/framegraph/techniquefilternode_p.h b/src/render/framegraph/techniquefilternode_p.h
index d7e6c1508..e424e37e5 100644
--- a/src/render/framegraph/techniquefilternode_p.h
+++ b/src/render/framegraph/techniquefilternode_p.h
@@ -79,11 +79,9 @@ public:
     QVector<Qt3DCore::QNodeId> parameters() const;
 
     QVector<Qt3DCore::QNodeId> filters() const;
-    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e) override;
+    void syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime) override;
 
 private:
-    void initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change) final;
-
     void appendFilter(Qt3DCore::QNodeId criterionId);
     void removeFilter(Qt3DCore::QNodeId criterionId);
 
diff --git a/src/render/framegraph/viewportnode.cpp b/src/render/framegraph/viewportnode.cpp
index b3b53b0f9..c37278817 100644
--- a/src/render/framegraph/viewportnode.cpp
+++ b/src/render/framegraph/viewportnode.cpp
@@ -59,16 +59,28 @@ ViewportNode::ViewportNode()
 {
 }
 
-void ViewportNode::initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change)
+
+void ViewportNode::syncFromFrontEnd(const QNode *frontEnd, bool firstTime)
 {
-    FrameGraphNode::initializeFromPeer(change);
-    const auto typedChange = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<QViewportData>>(change);
-    const auto &data = typedChange->data;
-    m_xMin = data.normalizedRect.x();
-    m_xMax = data.normalizedRect.width();
-    m_yMin = data.normalizedRect.y();
-    m_yMax = data.normalizedRect.height();
-    m_gamma = data.gamma;
+    const QViewport *node = qobject_cast<const QViewport *>(frontEnd);
+    if (!node)
+        return;
+
+    FrameGraphNode::syncFromFrontEnd(frontEnd, firstTime);
+
+    const QRectF oldRect(m_xMin, m_yMin, m_xMax, m_yMax);
+    if (oldRect != node->normalizedRect()) {
+        m_xMin = node->normalizedRect().x();
+        m_yMin = node->normalizedRect().y();
+        m_xMax = node->normalizedRect().width();
+        m_yMax = node->normalizedRect().height();
+        markDirty(AbstractRenderer::FrameGraphDirty);
+    }
+
+    if (node->gamma() != m_gamma) {
+        m_gamma = node->gamma();
+        markDirty(AbstractRenderer::FrameGraphDirty);
+    }
 }
 
 float ViewportNode::xMin() const
@@ -118,25 +130,6 @@ void ViewportNode::setGamma(float gamma)
     m_gamma = gamma;
 }
 
-void ViewportNode::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
-{
-    if (e->type() == PropertyUpdated) {
-        QPropertyUpdatedChangePtr propertyChange = qSharedPointerCast<QPropertyUpdatedChange>(e);
-        if (propertyChange->propertyName() == QByteArrayLiteral("normalizedRect")) {
-            QRectF normalizedRect = propertyChange->value().toRectF();
-            setXMin(normalizedRect.x());
-            setYMin(normalizedRect.y());
-            setXMax(normalizedRect.width());
-            setYMax(normalizedRect.height());
-            markDirty(AbstractRenderer::FrameGraphDirty);
-        } else if (propertyChange->propertyName() == QByteArrayLiteral("gamma")) {
-            setGamma(propertyChange->value().toFloat());
-            markDirty(AbstractRenderer::FrameGraphDirty);
-        }
-    }
-    FrameGraphNode::sceneChangeEvent(e);
-}
-
 QRectF ViewportNode::computeViewport(const QRectF &childViewport, const ViewportNode *parentViewport)
 {
     QRectF vp(parentViewport->xMin(),
diff --git a/src/render/framegraph/viewportnode_p.h b/src/render/framegraph/viewportnode_p.h
index 799b9b3dc..3e291a9da 100644
--- a/src/render/framegraph/viewportnode_p.h
+++ b/src/render/framegraph/viewportnode_p.h
@@ -84,13 +84,11 @@ public:
     float gamma() const;
     void setGamma(float gamma);
 
-    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e) override;
+    void syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime) override;
 
     static QRectF computeViewport(const QRectF &childViewport, const ViewportNode *parentViewport);
 
 private:
-    void initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change) final;
-
     float m_xMin;
     float m_yMin;
     float m_xMax;
diff --git a/src/render/framegraph/waitfence.cpp b/src/render/framegraph/waitfence.cpp
index 9480fb7a0..68ddda3d7 100644
--- a/src/render/framegraph/waitfence.cpp
+++ b/src/render/framegraph/waitfence.cpp
@@ -71,33 +71,30 @@ WaitFence::~WaitFence()
 {
 }
 
-void WaitFence::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
+void WaitFence::syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime)
 {
-    if (e->type() == Qt3DCore::PropertyUpdated) {
-        Qt3DCore::QPropertyUpdatedChangePtr propertyChange = qSharedPointerCast<Qt3DCore::QPropertyUpdatedChange>(e);
-        if (propertyChange->propertyName() == QByteArrayLiteral("handle")) {
-            m_data.handle = propertyChange->value();
-            markDirty(AbstractRenderer::FrameGraphDirty);
-        } else if (propertyChange->propertyName() == QByteArrayLiteral("handleType")) {
-            m_data.handleType = static_cast<QWaitFence::HandleType>(propertyChange->value().toInt());
-            markDirty(AbstractRenderer::FrameGraphDirty);
-        } else if (propertyChange->propertyName() == QByteArrayLiteral("timeout")) {
-            m_data.timeout = propertyChange->value().value<quint64>();
-            markDirty(AbstractRenderer::FrameGraphDirty);
-        } else if (propertyChange->propertyName() == QByteArrayLiteral("waitOnCPU")) {
-            m_data.waitOnCPU = propertyChange->value().toBool();
-            markDirty(AbstractRenderer::FrameGraphDirty);
-        }
-    }
-    FrameGraphNode::sceneChangeEvent(e);
-}
+    const QWaitFence *node = qobject_cast<const QWaitFence *>(frontEnd);
+    if (!node)
+        return;
 
-void WaitFence::initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change)
-{
-    FrameGraphNode::initializeFromPeer(change);
-    const auto typedChange = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<QWaitFenceData>>(change);
-    const QWaitFenceData &data = typedChange->data;
-    m_data = data;
+    FrameGraphNode::syncFromFrontEnd(frontEnd, firstTime);
+
+    if (node->handleType() != m_data.handleType) {
+        m_data.handleType = node->handleType();
+        markDirty(AbstractRenderer::FrameGraphDirty);
+    }
+    if (node->handle() != m_data.handle) {
+        m_data.handle = node->handle();
+        markDirty(AbstractRenderer::FrameGraphDirty);
+    }
+    if (node->timeout() != m_data.timeout) {
+        m_data.timeout = node->timeout();
+        markDirty(AbstractRenderer::FrameGraphDirty);
+    }
+    if (node->waitOnCPU() != m_data.waitOnCPU) {
+        m_data.waitOnCPU = node->waitOnCPU();
+        markDirty(AbstractRenderer::FrameGraphDirty);
+    }
 }
 
 } // namespace Render
diff --git a/src/render/framegraph/waitfence_p.h b/src/render/framegraph/waitfence_p.h
index dd48e0efa..811fc80a2 100644
--- a/src/render/framegraph/waitfence_p.h
+++ b/src/render/framegraph/waitfence_p.h
@@ -68,11 +68,9 @@ public:
     ~WaitFence();
 
     inline QWaitFenceData data() const { return m_data; }
-    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e) override;
+    void syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime) override;
 
 private:
-    void initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change) override;
-
     QWaitFenceData m_data;
 };
 
diff --git a/src/render/frontend/qrenderaspect.cpp b/src/render/frontend/qrenderaspect.cpp
index f33af9ebd..67bcb6c02 100644
--- a/src/render/frontend/qrenderaspect.cpp
+++ b/src/render/frontend/qrenderaspect.cpp
@@ -295,29 +295,29 @@ void QRenderAspectPrivate::registerBackendTypes()
     q->registerBackendType<QShaderImage>(QSharedPointer<Render::NodeFunctor<Render::ShaderImage, Render::ShaderImageManager>>::create(m_renderer));
 
     // Framegraph
-    q->registerBackendType<QFrameGraphNode>(QSharedPointer<Render::FrameGraphNodeFunctor<Render::FrameGraphNode, QFrameGraphNode> >::create(m_renderer));
-    q->registerBackendType<QCameraSelector>(QSharedPointer<Render::FrameGraphNodeFunctor<Render::CameraSelector, QCameraSelector> >::create(m_renderer));
-    q->registerBackendType<QClearBuffers>(QSharedPointer<Render::FrameGraphNodeFunctor<Render::ClearBuffers, QClearBuffers> >::create(m_renderer));
-    q->registerBackendType<QDispatchCompute>(QSharedPointer<Render::FrameGraphNodeFunctor<Render::DispatchCompute, QDispatchCompute> >::create(m_renderer));
-    q->registerBackendType<QFrustumCulling>(QSharedPointer<Render::FrameGraphNodeFunctor<Render::FrustumCulling, QFrustumCulling> >::create(m_renderer));
-    q->registerBackendType<QLayerFilter>(QSharedPointer<Render::FrameGraphNodeFunctor<Render::LayerFilterNode, QLayerFilter> >::create(m_renderer));
-    q->registerBackendType<QNoDraw>(QSharedPointer<Render::FrameGraphNodeFunctor<Render::NoDraw, QNoDraw> >::create(m_renderer));
-    q->registerBackendType<QRenderPassFilter>(QSharedPointer<Render::FrameGraphNodeFunctor<Render::RenderPassFilter, QRenderPassFilter> >::create(m_renderer));
-    q->registerBackendType<QRenderStateSet>(QSharedPointer<Render::FrameGraphNodeFunctor<Render::StateSetNode, QRenderStateSet> >::create(m_renderer));
-    q->registerBackendType<QRenderSurfaceSelector>(QSharedPointer<Render::FrameGraphNodeFunctor<Render::RenderSurfaceSelector, QRenderSurfaceSelector> >::create(m_renderer));
-    q->registerBackendType<QRenderTargetSelector>(QSharedPointer<Render::FrameGraphNodeFunctor<Render::RenderTargetSelector, QRenderTargetSelector> >::create(m_renderer));
-    q->registerBackendType<QSortPolicy>(QSharedPointer<Render::FrameGraphNodeFunctor<Render::SortPolicy, QSortPolicy> >::create(m_renderer));
-    q->registerBackendType<QTechniqueFilter>(QSharedPointer<Render::FrameGraphNodeFunctor<Render::TechniqueFilter, QTechniqueFilter> >::create(m_renderer));
-    q->registerBackendType<QViewport>(QSharedPointer<Render::FrameGraphNodeFunctor<Render::ViewportNode, QViewport> >::create(m_renderer));
-    q->registerBackendType<QRenderCapture>(QSharedPointer<Render::FrameGraphNodeFunctor<Render::RenderCapture, QRenderCapture> >::create(m_renderer));
-    q->registerBackendType<QBufferCapture>(QSharedPointer<Render::FrameGraphNodeFunctor<Render::BufferCapture, QBufferCapture> >::create(m_renderer));
-    q->registerBackendType<QMemoryBarrier>(QSharedPointer<Render::FrameGraphNodeFunctor<Render::MemoryBarrier, QMemoryBarrier> >::create(m_renderer));
-    q->registerBackendType<QProximityFilter>(QSharedPointer<Render::FrameGraphNodeFunctor<Render::ProximityFilter, QProximityFilter> >::create(m_renderer));
-    q->registerBackendType<QBlitFramebuffer>(QSharedPointer<Render::FrameGraphNodeFunctor<Render::BlitFramebuffer, QBlitFramebuffer> >::create(m_renderer));
-    q->registerBackendType<QSetFence>(QSharedPointer<Render::FrameGraphNodeFunctor<Render::SetFence, QSetFence> >::create(m_renderer));
-    q->registerBackendType<QWaitFence>(QSharedPointer<Render::FrameGraphNodeFunctor<Render::WaitFence, QWaitFence> >::create(m_renderer));
-    q->registerBackendType<QNoPicking>(QSharedPointer<Render::FrameGraphNodeFunctor<Render::NoPicking, QNoPicking> >::create(m_renderer));
-    q->registerBackendType<QSubtreeEnabler>(QSharedPointer<Render::FrameGraphNodeFunctor<Render::SubtreeEnabler, QSubtreeEnabler> >::create(m_renderer));
+    q->registerBackendType<QFrameGraphNode, true>(QSharedPointer<Render::FrameGraphNodeFunctor<Render::FrameGraphNode, QFrameGraphNode> >::create(m_renderer));
+    q->registerBackendType<QCameraSelector, true>(QSharedPointer<Render::FrameGraphNodeFunctor<Render::CameraSelector, QCameraSelector> >::create(m_renderer));
+    q->registerBackendType<QClearBuffers, true>(QSharedPointer<Render::FrameGraphNodeFunctor<Render::ClearBuffers, QClearBuffers> >::create(m_renderer));
+    q->registerBackendType<QDispatchCompute, true>(QSharedPointer<Render::FrameGraphNodeFunctor<Render::DispatchCompute, QDispatchCompute> >::create(m_renderer));
+    q->registerBackendType<QFrustumCulling, true>(QSharedPointer<Render::FrameGraphNodeFunctor<Render::FrustumCulling, QFrustumCulling> >::create(m_renderer));
+    q->registerBackendType<QLayerFilter, true>(QSharedPointer<Render::FrameGraphNodeFunctor<Render::LayerFilterNode, QLayerFilter> >::create(m_renderer));
+    q->registerBackendType<QNoDraw, true>(QSharedPointer<Render::FrameGraphNodeFunctor<Render::NoDraw, QNoDraw> >::create(m_renderer));
+    q->registerBackendType<QRenderPassFilter, true>(QSharedPointer<Render::FrameGraphNodeFunctor<Render::RenderPassFilter, QRenderPassFilter> >::create(m_renderer));
+    q->registerBackendType<QRenderStateSet, true>(QSharedPointer<Render::FrameGraphNodeFunctor<Render::StateSetNode, QRenderStateSet> >::create(m_renderer));
+    q->registerBackendType<QRenderSurfaceSelector, true>(QSharedPointer<Render::FrameGraphNodeFunctor<Render::RenderSurfaceSelector, QRenderSurfaceSelector> >::create(m_renderer));
+    q->registerBackendType<QRenderTargetSelector, true>(QSharedPointer<Render::FrameGraphNodeFunctor<Render::RenderTargetSelector, QRenderTargetSelector> >::create(m_renderer));
+    q->registerBackendType<QSortPolicy, true>(QSharedPointer<Render::FrameGraphNodeFunctor<Render::SortPolicy, QSortPolicy> >::create(m_renderer));
+    q->registerBackendType<QTechniqueFilter, true>(QSharedPointer<Render::FrameGraphNodeFunctor<Render::TechniqueFilter, QTechniqueFilter> >::create(m_renderer));
+    q->registerBackendType<QViewport, true>(QSharedPointer<Render::FrameGraphNodeFunctor<Render::ViewportNode, QViewport> >::create(m_renderer));
+    q->registerBackendType<QRenderCapture, true>(QSharedPointer<Render::FrameGraphNodeFunctor<Render::RenderCapture, QRenderCapture> >::create(m_renderer));
+    q->registerBackendType<QBufferCapture, true>(QSharedPointer<Render::FrameGraphNodeFunctor<Render::BufferCapture, QBufferCapture> >::create(m_renderer));
+    q->registerBackendType<QMemoryBarrier, true>(QSharedPointer<Render::FrameGraphNodeFunctor<Render::MemoryBarrier, QMemoryBarrier> >::create(m_renderer));
+    q->registerBackendType<QProximityFilter, true>(QSharedPointer<Render::FrameGraphNodeFunctor<Render::ProximityFilter, QProximityFilter> >::create(m_renderer));
+    q->registerBackendType<QBlitFramebuffer, true>(QSharedPointer<Render::FrameGraphNodeFunctor<Render::BlitFramebuffer, QBlitFramebuffer> >::create(m_renderer));
+    q->registerBackendType<QSetFence, true>(QSharedPointer<Render::FrameGraphNodeFunctor<Render::SetFence, QSetFence> >::create(m_renderer));
+    q->registerBackendType<QWaitFence, true>(QSharedPointer<Render::FrameGraphNodeFunctor<Render::WaitFence, QWaitFence> >::create(m_renderer));
+    q->registerBackendType<QNoPicking, true>(QSharedPointer<Render::FrameGraphNodeFunctor<Render::NoPicking, QNoPicking> >::create(m_renderer));
+    q->registerBackendType<QSubtreeEnabler, true>(QSharedPointer<Render::FrameGraphNodeFunctor<Render::SubtreeEnabler, QSubtreeEnabler> >::create(m_renderer));
 
     // Picking
     q->registerBackendType<QObjectPicker>(QSharedPointer<Render::NodeFunctor<Render::ObjectPicker, Render::ObjectPickerManager> >::create(m_renderer));
diff --git a/src/render/jobs/job_common_p.h b/src/render/jobs/job_common_p.h
index 5fe16f933..9c83624b8 100644
--- a/src/render/jobs/job_common_p.h
+++ b/src/render/jobs/job_common_p.h
@@ -109,7 +109,6 @@ namespace JobTypes {
         UpdateLayerEntity,
         SendTextureChangesToFrontend,
         SendSetFenceHandlesToFrontend,
-        UpdateEntityHierarchy,
     };
 
 } // JobTypes
diff --git a/src/render/jobs/jobs.pri b/src/render/jobs/jobs.pri
index 6cdf891fc..2181e4a95 100644
--- a/src/render/jobs/jobs.pri
+++ b/src/render/jobs/jobs.pri
@@ -30,7 +30,6 @@ HEADERS += \
     $$PWD/filterproximitydistancejob_p.h \
     $$PWD/abstractpickingjob_p.h \
     $$PWD/raycastingjob_p.h \
-    $$PWD/updateentityhierarchyjob_p.h \
     $$PWD/updateentitylayersjob_p.h
 
 SOURCES += \
@@ -60,6 +59,5 @@ SOURCES += \
     $$PWD/filterproximitydistancejob.cpp \
     $$PWD/abstractpickingjob.cpp \
     $$PWD/raycastingjob.cpp \
-    $$PWD/updateentityhierarchyjob.cpp \
     $$PWD/updateentitylayersjob.cpp
 
diff --git a/src/render/jobs/updateentityhierarchyjob.cpp b/src/render/jobs/updateentityhierarchyjob.cpp
deleted file mode 100644
index 7c18514bb..000000000
--- a/src/render/jobs/updateentityhierarchyjob.cpp
+++ /dev/null
@@ -1,80 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2019 Klaralvdalens Datakonsult AB (KDAB).
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the Qt3D module of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-** Commercial License Usage
-** Licensees holding valid commercial Qt licenses may use this file in
-** accordance with the commercial license agreement provided with the
-** Software or, alternatively, in accordance with the terms contained in
-** a written agreement between you and The Qt Company. For licensing terms
-** and conditions see https://www.qt.io/terms-conditions. For further
-** information use the contact form at https://www.qt.io/contact-us.
-**
-** GNU Lesser General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU Lesser
-** General Public License version 3 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPL3 included in the
-** packaging of this file. Please review the following information to
-** ensure the GNU Lesser General Public License version 3 requirements
-** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
-**
-** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 2.0 or (at your option) the GNU General
-** Public license version 3 or any later version approved by the KDE Free
-** Qt Foundation. The licenses are as published by the Free Software
-** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
-** included in the packaging of this file. Please review the following
-** information to ensure the GNU General Public License requirements will
-** be met: https://www.gnu.org/licenses/gpl-2.0.html and
-** https://www.gnu.org/licenses/gpl-3.0.html.
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#include "updateentityhierarchyjob_p.h"
-#include <Qt3DRender/private/managers_p.h>
-#include <Qt3DRender/private/nodemanagers_p.h>
-#include <Qt3DRender/private/entity_p.h>
-#include <Qt3DRender/private/job_common_p.h>
-
-QT_BEGIN_NAMESPACE
-
-namespace Qt3DRender {
-
-namespace Render {
-
-UpdateEntityHierarchyJob::UpdateEntityHierarchyJob()
-    : m_manager(nullptr)
-{
-    SET_JOB_RUN_STAT_TYPE(this, JobTypes::UpdateEntityHierarchy, 0);
-}
-
-void UpdateEntityHierarchyJob::run()
-{
-    Q_ASSERT(m_manager);
-    EntityManager *entityManager = m_manager->renderNodesManager();
-
-    const QVector<HEntity> handles = entityManager->activeHandles();
-
-    // Clear the parents and children
-    for (const HEntity &handle : handles) {
-        Entity *entity = entityManager->data(handle);
-        entity->clearEntityHierarchy();
-    }
-    for (const HEntity &handle : handles) {
-        Entity *entity = entityManager->data(handle);
-        entity->rebuildEntityHierarchy();
-    }
-}
-
-} // Render
-
-} // Qt3DRender
-
-QT_END_NAMESPACE
diff --git a/src/render/jobs/updateentityhierarchyjob_p.h b/src/render/jobs/updateentityhierarchyjob_p.h
deleted file mode 100644
index fd2b13631..000000000
--- a/src/render/jobs/updateentityhierarchyjob_p.h
+++ /dev/null
@@ -1,91 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2019 Klaralvdalens Datakonsult AB (KDAB).
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the Qt3D module of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-** Commercial License Usage
-** Licensees holding valid commercial Qt licenses may use this file in
-** accordance with the commercial license agreement provided with the
-** Software or, alternatively, in accordance with the terms contained in
-** a written agreement between you and The Qt Company. For licensing terms
-** and conditions see https://www.qt.io/terms-conditions. For further
-** information use the contact form at https://www.qt.io/contact-us.
-**
-** GNU Lesser General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU Lesser
-** General Public License version 3 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPL3 included in the
-** packaging of this file. Please review the following information to
-** ensure the GNU Lesser General Public License version 3 requirements
-** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
-**
-** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 2.0 or (at your option) the GNU General
-** Public license version 3 or any later version approved by the KDE Free
-** Qt Foundation. The licenses are as published by the Free Software
-** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
-** included in the packaging of this file. Please review the following
-** information to ensure the GNU General Public License requirements will
-** be met: https://www.gnu.org/licenses/gpl-2.0.html and
-** https://www.gnu.org/licenses/gpl-3.0.html.
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-
-#ifndef QT3DRENDER_RENDER_UPDATEENTITYHIERARCHYJOB_P_H
-#define QT3DRENDER_RENDER_UPDATEENTITYHIERARCHYJOB_P_H
-
-//
-//  W A R N I N G
-//  -------------
-//
-// This file is not part of the Qt API.  It exists for the convenience
-// of other Qt classes.  This header file may change from version to
-// version without notice, or even be removed.
-//
-// We mean it.
-//
-
-#include <Qt3DRender/private/qt3drender_global_p.h>
-#include <Qt3DCore/qaspectjob.h>
-
-QT_BEGIN_NAMESPACE
-
-namespace Qt3DRender {
-
-namespace Render {
-
-class Entity;
-class NodeManagers;
-
-class Q_3DRENDERSHARED_PRIVATE_EXPORT UpdateEntityHierarchyJob: public Qt3DCore::QAspectJob
-{
-public:
-    UpdateEntityHierarchyJob();
-
-    inline void setManager(NodeManagers *manager) { m_manager = manager; }
-    inline NodeManagers *manager() const { return m_manager; }
-
-    // QAspectJob interface
-    void run() final;
-
-private:
-    NodeManagers *m_manager;
-};
-
-
-using UpdateEntityHierarchyJobPtr = QSharedPointer<UpdateEntityHierarchyJob>;
-
-} // Render
-
-} // Qt3DRender
-
-QT_END_NAMESPACE
-
-#endif // QT3DRENDER_RENDER_UPDATEENTITYHIERARCHYJOB_P_H
diff --git a/src/render/renderers/opengl/graphicshelpers/graphicscontext.cpp b/src/render/renderers/opengl/graphicshelpers/graphicscontext.cpp
index c9b04fa8f..f4bd8b871 100644
--- a/src/render/renderers/opengl/graphicshelpers/graphicscontext.cpp
+++ b/src/render/renderers/opengl/graphicshelpers/graphicscontext.cpp
@@ -269,7 +269,7 @@ QOpenGLShaderProgram *GraphicsContext::createShaderProgram(Shader *shaderNode)
 // That assumes that the shaderProgram in Shader stays the same
 void GraphicsContext::introspectShaderInterface(Shader *shader, QOpenGLShaderProgram *shaderProgram)
 {
-    GraphicsHelperInterface *glHelper = resolveHighestOpenGLFunctions();
+    QScopedPointer<GraphicsHelperInterface> glHelper(resolveHighestOpenGLFunctions());
     shader->initializeUniforms(glHelper->programUniformsAndLocations(shaderProgram->programId()));
     shader->initializeAttributes(glHelper->programAttributesAndLocations(shaderProgram->programId()));
     if (m_glHelper->supportsFeature(GraphicsHelperInterface::UniformBufferObject))
diff --git a/src/render/renderers/opengl/renderer/renderer.cpp b/src/render/renderers/opengl/renderer/renderer.cpp
index 845a4d8be..2df3d1270 100644
--- a/src/render/renderers/opengl/renderer/renderer.cpp
+++ b/src/render/renderers/opengl/renderer/renderer.cpp
@@ -192,7 +192,6 @@ Renderer::Renderer(QRenderAspect::RenderType type)
     , m_updateMeshTriangleListJob(Render::UpdateMeshTriangleListJobPtr::create())
     , m_filterCompatibleTechniqueJob(Render::FilterCompatibleTechniqueJobPtr::create())
     , m_updateEntityLayersJob(Render::UpdateEntityLayersJobPtr::create())
-    , m_updateEntityHierarchyJob(Render::UpdateEntityHierarchyJobPtr::create())
     , m_bufferGathererJob(Render::GenericLambdaJobPtr<std::function<void ()>>::create([this] { lookForDirtyBuffers(); }, JobTypes::DirtyBufferGathering))
     , m_vaoGathererJob(Render::GenericLambdaJobPtr<std::function<void ()>>::create([this] { lookForAbandonedVaos(); }, JobTypes::DirtyVaoGathering))
     , m_textureGathererJob(Render::GenericLambdaJobPtr<std::function<void ()>>::create([this] { lookForDirtyTextures(); }, JobTypes::DirtyTextureGathering))
@@ -213,9 +212,6 @@ Renderer::Renderer(QRenderAspect::RenderType type)
     if (m_renderThread)
         m_renderThread->waitForStart();
 
-    m_worldTransformJob->addDependency(m_updateEntityHierarchyJob);
-    m_updateEntityLayersJob->addDependency(m_updateEntityHierarchyJob);
-
     // Create jobs to update transforms and bounding volumes
     // We can only update bounding volumes once all world transforms are known
     m_updateWorldBoundingVolumeJob->addDependency(m_worldTransformJob);
@@ -304,7 +300,6 @@ void Renderer::setNodeManagers(NodeManagers *managers)
     m_filterCompatibleTechniqueJob->setManager(m_nodesManager->techniqueManager());
     m_updateEntityLayersJob->setManager(m_nodesManager);
     m_updateTreeEnabledJob->setManagers(m_nodesManager);
-    m_updateEntityHierarchyJob->setManager(m_nodesManager);
 }
 
 void Renderer::setServices(QServiceLocator *services)
@@ -1748,17 +1743,14 @@ QVector<Qt3DCore::QAspectJobPtr> Renderer::renderBinJobs()
 
     // Add jobs
     const bool entitiesEnabledDirty = dirtyBitsForFrame & AbstractRenderer::EntityEnabledDirty;
-    const bool entityHierarchyNeedsToBeRebuilt = dirtyBitsForFrame & AbstractRenderer::EntityHierarchyDirty;
-    if (entitiesEnabledDirty || entityHierarchyNeedsToBeRebuilt) {
+    if (entitiesEnabledDirty) {
         renderBinJobs.push_back(m_updateTreeEnabledJob);
         // This dependency is added here because we clear all dependencies
         // at the start of this function.
         m_calculateBoundingVolumeJob->addDependency(m_updateTreeEnabledJob);
-        m_calculateBoundingVolumeJob->addDependency(m_updateEntityHierarchyJob);
     }
 
-    if (dirtyBitsForFrame & AbstractRenderer::TransformDirty ||
-        dirtyBitsForFrame & AbstractRenderer::EntityHierarchyDirty) {
+    if (dirtyBitsForFrame & AbstractRenderer::TransformDirty) {
         renderBinJobs.push_back(m_worldTransformJob);
         renderBinJobs.push_back(m_updateWorldBoundingVolumeJob);
         renderBinJobs.push_back(m_updateShaderDataTransformJob);
@@ -1771,7 +1763,6 @@ QVector<Qt3DCore::QAspectJobPtr> Renderer::renderBinJobs()
     }
 
     if (dirtyBitsForFrame & AbstractRenderer::GeometryDirty ||
-        dirtyBitsForFrame & AbstractRenderer::EntityHierarchyDirty ||
         dirtyBitsForFrame & AbstractRenderer::TransformDirty) {
         renderBinJobs.push_back(m_expandBoundingVolumeJob);
     }
@@ -1798,7 +1789,7 @@ QVector<Qt3DCore::QAspectJobPtr> Renderer::renderBinJobs()
     // Layer cache is dependent on layers, layer filters (hence FG structure
     // changes) and the enabled flag on entities
     const bool frameGraphDirty = dirtyBitsForFrame & AbstractRenderer::FrameGraphDirty;
-    const bool layersDirty = dirtyBitsForFrame & AbstractRenderer::LayersDirty || entityHierarchyNeedsToBeRebuilt;
+    const bool layersDirty = dirtyBitsForFrame & AbstractRenderer::LayersDirty;
     const bool layersCacheNeedsToBeRebuilt = layersDirty || entitiesEnabledDirty || frameGraphDirty;
     const bool materialDirty = dirtyBitsForFrame & AbstractRenderer::MaterialDirty;
     const bool lightsDirty = dirtyBitsForFrame & AbstractRenderer::LightsDirty;
@@ -1806,10 +1797,6 @@ QVector<Qt3DCore::QAspectJobPtr> Renderer::renderBinJobs()
     const bool renderableDirty = dirtyBitsForFrame & AbstractRenderer::GeometryDirty;
     const bool materialCacheNeedsToBeRebuilt = materialDirty || frameGraphDirty;
 
-    // Rebuild Entity Hierarchy if dirty
-    if (entityHierarchyNeedsToBeRebuilt)
-        renderBinJobs.push_back(m_updateEntityHierarchyJob);
-
     // Rebuild Entity Layers list if layers are dirty
     if (layersDirty)
         renderBinJobs.push_back(m_updateEntityLayersJob);
diff --git a/src/render/renderers/opengl/renderer/renderer_p.h b/src/render/renderers/opengl/renderer/renderer_p.h
index 0f911236a..bfab85e4f 100644
--- a/src/render/renderers/opengl/renderer/renderer_p.h
+++ b/src/render/renderers/opengl/renderer/renderer_p.h
@@ -78,7 +78,6 @@
 #include <Qt3DRender/private/filtercompatibletechniquejob_p.h>
 #include <Qt3DRender/private/updateskinningpalettejob_p.h>
 #include <Qt3DRender/private/updateentitylayersjob_p.h>
-#include <Qt3DRender/private/updateentityhierarchyjob_p.h>
 #include <Qt3DRender/private/renderercache_p.h>
 #include <Qt3DRender/private/texture_p.h>
 #include <Qt3DRender/private/glfence_p.h>
@@ -368,7 +367,6 @@ private:
     UpdateMeshTriangleListJobPtr m_updateMeshTriangleListJob;
     FilterCompatibleTechniqueJobPtr m_filterCompatibleTechniqueJob;
     UpdateEntityLayersJobPtr m_updateEntityLayersJob;
-    UpdateEntityHierarchyJobPtr m_updateEntityHierarchyJob;
 
     QVector<Qt3DCore::QNodeId> m_pendingRenderCaptureSendRequests;
 
diff --git a/tests/auto/animation/additiveclipblend/tst_additiveclipblend.cpp b/tests/auto/animation/additiveclipblend/tst_additiveclipblend.cpp
index 462c02518..d53fd9c2c 100644
--- a/tests/auto/animation/additiveclipblend/tst_additiveclipblend.cpp
+++ b/tests/auto/animation/additiveclipblend/tst_additiveclipblend.cpp
@@ -143,7 +143,7 @@ private Q_SLOTS:
         {
             // WHEN
             AdditiveClipBlend backendAdditiveBlend;
-            simulateInitialization(&additiveBlend, &backendAdditiveBlend);
+            simulateInitializationSync(&additiveBlend, &backendAdditiveBlend);
 
             // THEN
             QCOMPARE(backendAdditiveBlend.isEnabled(), true);
@@ -156,7 +156,7 @@ private Q_SLOTS:
             // WHEN
             AdditiveClipBlend backendAdditiveBlend;
             additiveBlend.setEnabled(false);
-            simulateInitialization(&additiveBlend, &backendAdditiveBlend);
+            simulateInitializationSync(&additiveBlend, &backendAdditiveBlend);
 
             // THEN
             QCOMPARE(backendAdditiveBlend.peerId(), additiveBlend.id());
@@ -167,14 +167,14 @@ private Q_SLOTS:
     void checkSceneChangeEvents()
     {
         // GIVEN
+        Qt3DAnimation::QAdditiveClipBlend additiveBlend;
         AdditiveClipBlend backendAdditiveBlend;
+        simulateInitializationSync(&additiveBlend, &backendAdditiveBlend);
         {
             // WHEN
             const bool newValue = false;
-            const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-            change->setPropertyName("enabled");
-            change->setValue(newValue);
-            backendAdditiveBlend.sceneChangeEvent(change);
+            additiveBlend.setEnabled(newValue);
+            backendAdditiveBlend.syncFromFrontEnd(&additiveBlend, false);
 
             // THEN
             QCOMPARE(backendAdditiveBlend.isEnabled(), newValue);
@@ -182,32 +182,26 @@ private Q_SLOTS:
         {
             // WHEN
             const float newValue = 0.883f;
-            const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-            change->setPropertyName("additiveFactor");
-            change->setValue(QVariant::fromValue(newValue));
-            backendAdditiveBlend.sceneChangeEvent(change);
+            additiveBlend.setAdditiveFactor(newValue);
+            backendAdditiveBlend.syncFromFrontEnd(&additiveBlend, false);
 
             // THEN
             QCOMPARE(backendAdditiveBlend.additiveFactor(), newValue);
         }
         {
             // WHEN
-            const Qt3DAnimation::QAdditiveClipBlend newValue;
-            const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-            change->setPropertyName("baseClip");
-            change->setValue(QVariant::fromValue(newValue.id()));
-            backendAdditiveBlend.sceneChangeEvent(change);
+            Qt3DAnimation::QAdditiveClipBlend newValue;
+            additiveBlend.setBaseClip(&newValue);
+            backendAdditiveBlend.syncFromFrontEnd(&additiveBlend, false);
 
             // THEN
             QCOMPARE(backendAdditiveBlend.baseClipId(), newValue.id());
         }
         {
             // WHEN
-            const Qt3DAnimation::QAdditiveClipBlend newValue;
-            const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-            change->setPropertyName("additiveClip");
-            change->setValue(QVariant::fromValue(newValue.id()));
-            backendAdditiveBlend.sceneChangeEvent(change);
+            Qt3DAnimation::QAdditiveClipBlend newValue;
+            additiveBlend.setAdditiveClip(&newValue);
+            backendAdditiveBlend.syncFromFrontEnd(&additiveBlend, false);
 
             // THEN
             QCOMPARE(backendAdditiveBlend.additiveClipId(), newValue.id());
diff --git a/tests/auto/animation/animationclip/tst_animationclip.cpp b/tests/auto/animation/animationclip/tst_animationclip.cpp
index 15ee60581..a98fbe886 100644
--- a/tests/auto/animation/animationclip/tst_animationclip.cpp
+++ b/tests/auto/animation/animationclip/tst_animationclip.cpp
@@ -55,7 +55,7 @@ private Q_SLOTS:
         clip.setSource(QUrl::fromLocalFile("walk.qlip"));
 
         // WHEN
-        simulateInitialization(&clip, &backendClip);
+        simulateInitializationSync(&clip, &backendClip);
 
         // THEN
         QCOMPARE(backendClip.peerId(), clip.id());
@@ -82,7 +82,7 @@ private Q_SLOTS:
         clip.setSource(QUrl::fromLocalFile("walk.qlip"));
 
         // WHEN
-        simulateInitialization(&clip, &backendClip);
+        simulateInitializationSync(&clip, &backendClip);
         backendClip.setSource(QUrl::fromLocalFile("run.qlip"));
         backendClip.cleanup();
 
@@ -96,27 +96,23 @@ private Q_SLOTS:
     void checkPropertyChanges()
     {
         // GIVEN
+        Qt3DAnimation::QAnimationClipLoader clip;
         AnimationClip backendClip;
         Handler handler;
         backendClip.setHandler(&handler);
-        backendClip.setDataType(Qt3DAnimation::Animation::AnimationClip::File);
-        Qt3DCore::QPropertyUpdatedChangePtr updateChange;
+        simulateInitializationSync(&clip, &backendClip);
 
         // WHEN
-        updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId());
-        updateChange->setPropertyName("enabled");
-        updateChange->setValue(true);
-        backendClip.sceneChangeEvent(updateChange);
+        clip.setEnabled(false);
+        backendClip.syncFromFrontEnd(&clip, false);
 
         // THEN
-        QCOMPARE(backendClip.isEnabled(), true);
+        QCOMPARE(backendClip.isEnabled(), false);
 
         // WHEN
         const QUrl newSource = QUrl::fromLocalFile("fallover.qlip");
-        updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId());
-        updateChange->setPropertyName("source");
-        updateChange->setValue(newSource);
-        backendClip.sceneChangeEvent(updateChange);
+        clip.setSource(newSource);
+        backendClip.syncFromFrontEnd(&clip, false);
 
         // THEN
         QCOMPARE(backendClip.source(), newSource);
diff --git a/tests/auto/animation/blendedclipanimator/tst_blendedclipanimator.cpp b/tests/auto/animation/blendedclipanimator/tst_blendedclipanimator.cpp
index c0e1581f9..bb95fe979 100644
--- a/tests/auto/animation/blendedclipanimator/tst_blendedclipanimator.cpp
+++ b/tests/auto/animation/blendedclipanimator/tst_blendedclipanimator.cpp
@@ -29,6 +29,7 @@
 #include <QtTest/QTest>
 #include <Qt3DAnimation/private/blendedclipanimator_p.h>
 #include <Qt3DAnimation/qanimationcliploader.h>
+#include <Qt3DAnimation/qadditiveclipblend.h>
 #include <Qt3DAnimation/qblendedclipanimator.h>
 #include <Qt3DCore/private/qnode_p.h>
 #include <Qt3DCore/private/qscene_p.h>
@@ -114,7 +115,7 @@ private Q_SLOTS:
             Qt3DAnimation::Animation::Handler handler;
             backendBlendedClipAnimator.setHandler(&handler);
 
-            simulateInitialization(&blendedClipAnimator, &backendBlendedClipAnimator);
+            simulateInitializationSync(&blendedClipAnimator, &backendBlendedClipAnimator);
 
             // THEN
             QCOMPARE(backendBlendedClipAnimator.isEnabled(), true);
@@ -131,7 +132,7 @@ private Q_SLOTS:
             backendBlendedClipAnimator.setHandler(&handler);
 
             blendedClipAnimator.setEnabled(false);
-            simulateInitialization(&blendedClipAnimator, &backendBlendedClipAnimator);
+            simulateInitializationSync(&blendedClipAnimator, &backendBlendedClipAnimator);
 
             // THEN
             QCOMPARE(backendBlendedClipAnimator.peerId(), blendedClipAnimator.id());
@@ -142,61 +143,53 @@ private Q_SLOTS:
     void checkSceneChangeEvents()
     {
         // GIVEN
+        Qt3DAnimation::QBlendedClipAnimator blendedClipAnimator;
         Qt3DAnimation::Animation::BlendedClipAnimator backendBlendedClipAnimator;
         Qt3DAnimation::Animation::Handler handler;
         backendBlendedClipAnimator.setHandler(&handler);
+        simulateInitializationSync(&blendedClipAnimator, &backendBlendedClipAnimator);
 
         {
-             // WHEN
-             const bool newValue = false;
-             const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-             change->setPropertyName("enabled");
-             change->setValue(newValue);
-             backendBlendedClipAnimator.sceneChangeEvent(change);
-
-             // THEN
+            // WHEN
+            const bool newValue = false;
+            blendedClipAnimator.setEnabled(newValue);
+            backendBlendedClipAnimator.syncFromFrontEnd(&blendedClipAnimator, false);
+
+            // THEN
             QCOMPARE(backendBlendedClipAnimator.isEnabled(), newValue);
         }
         {
-             // WHEN
-             const Qt3DCore::QNodeId newValue = Qt3DCore::QNodeId::createId();
-             const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-             change->setPropertyName("blendTree");
-             change->setValue(QVariant::fromValue(newValue));
-             backendBlendedClipAnimator.sceneChangeEvent(change);
-
-             // THEN
-            QCOMPARE(backendBlendedClipAnimator.blendTreeRootId(), newValue);
+            // WHEN
+            auto blendTree = new Qt3DAnimation::QAdditiveClipBlend();
+            blendedClipAnimator.setBlendTree(blendTree);
+            backendBlendedClipAnimator.syncFromFrontEnd(&blendedClipAnimator, false);
+
+            // THEN
+            QCOMPARE(backendBlendedClipAnimator.blendTreeRootId(), blendTree->id());
         }
         {
-             // WHEN
-             const Qt3DCore::QNodeId newValue = Qt3DCore::QNodeId::createId();
-             const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-             change->setPropertyName("channelMapper");
-             change->setValue(QVariant::fromValue(newValue));
-             backendBlendedClipAnimator.sceneChangeEvent(change);
-
-             // THEN
-            QCOMPARE(backendBlendedClipAnimator.mapperId(), newValue);
+            // WHEN
+            auto channelMapper = new Qt3DAnimation::QChannelMapper();
+            blendedClipAnimator.setChannelMapper(channelMapper);
+            backendBlendedClipAnimator.syncFromFrontEnd(&blendedClipAnimator, false);
+
+            // THEN
+            QCOMPARE(backendBlendedClipAnimator.mapperId(), channelMapper->id());
         }
         {
-             // WHEN
-             const bool newValue = true;
-             const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-             change->setPropertyName("running");
-             change->setValue(QVariant::fromValue(newValue));
-             backendBlendedClipAnimator.sceneChangeEvent(change);
-
-             // THEN
+            // WHEN
+            const bool newValue = true;
+            blendedClipAnimator.setRunning(newValue);
+            backendBlendedClipAnimator.syncFromFrontEnd(&blendedClipAnimator, false);
+
+            // THEN
             QCOMPARE(backendBlendedClipAnimator.isRunning(), newValue);
         }
         {
             // WHEN
             const int newValue = 883;
-            const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-            change->setPropertyName("loops");
-            change->setValue(QVariant::fromValue(newValue));
-            backendBlendedClipAnimator.sceneChangeEvent(change);
+            blendedClipAnimator.setLoopCount(newValue);
+            backendBlendedClipAnimator.syncFromFrontEnd(&blendedClipAnimator, false);
 
             // THEN
             QCOMPARE(backendBlendedClipAnimator.loops(), newValue);
diff --git a/tests/auto/animation/channelmapper/tst_channelmapper.cpp b/tests/auto/animation/channelmapper/tst_channelmapper.cpp
index 446e1a0c5..2dfa07a43 100644
--- a/tests/auto/animation/channelmapper/tst_channelmapper.cpp
+++ b/tests/auto/animation/channelmapper/tst_channelmapper.cpp
@@ -60,7 +60,7 @@ private Q_SLOTS:
         mapper.addMapping(new Qt3DAnimation::QChannelMapping);
 
         // WHEN
-        simulateInitialization(&mapper, &backendMapper);
+        simulateInitializationSync(&mapper, &backendMapper);
 
         // THEN
         QCOMPARE(backendMapper.peerId(), mapper.id());
@@ -90,7 +90,7 @@ private Q_SLOTS:
         mapper.addMapping(new Qt3DAnimation::QChannelMapping());
 
         // WHEN
-        simulateInitialization(&mapper, &backendMapper);
+        simulateInitializationSync(&mapper, &backendMapper);
         backendMapper.cleanup();
 
         // THEN
@@ -101,19 +101,18 @@ private Q_SLOTS:
     void checkPropertyChanges()
     {
         // GIVEN
+        Qt3DAnimation::QChannelMapper mapper;
         Qt3DAnimation::Animation::Handler handler;
         Qt3DAnimation::Animation::ChannelMapper backendMapper;
         backendMapper.setHandler(&handler);
-        Qt3DCore::QPropertyUpdatedChangePtr updateChange;
+        simulateInitializationSync(&mapper, &backendMapper);
 
         // WHEN
-        updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId());
-        updateChange->setPropertyName("enabled");
-        updateChange->setValue(true);
-        backendMapper.sceneChangeEvent(updateChange);
+        mapper.setEnabled(false);
+        backendMapper.syncFromFrontEnd(&mapper, false);
 
         // THEN
-        QCOMPARE(backendMapper.isEnabled(), true);
+        QCOMPARE(backendMapper.isEnabled(), false);
 
         // WHEN
         Qt3DAnimation::QChannelMapping mapping;
@@ -121,11 +120,10 @@ private Q_SLOTS:
         Qt3DAnimation::Animation::ChannelMapping *backendMapping
                 = handler.channelMappingManager()->getOrCreateResource(mappingId);
         backendMapping->setHandler(&handler);
-        simulateInitialization(&mapping, backendMapping);
+        simulateInitializationSync(&mapping, backendMapping);
 
-        auto nodeAddedChange = Qt3DCore::QPropertyNodeAddedChangePtr::create(Qt3DCore::QNodeId(), &mapping);
-        nodeAddedChange->setPropertyName("mappings");
-        backendMapper.sceneChangeEvent(nodeAddedChange);
+        mapper.addMapping(&mapping);
+        backendMapper.syncFromFrontEnd(&mapper, false);
 
         // THEN
         QCOMPARE(backendMapper.mappingIds().size(), 1);
@@ -139,11 +137,10 @@ private Q_SLOTS:
         Qt3DAnimation::Animation::ChannelMapping *backendMapping2
                 = handler.channelMappingManager()->getOrCreateResource(mappingId2);
         backendMapping2->setHandler(&handler);
-        simulateInitialization(&mapping2, backendMapping2);
+        simulateInitializationSync(&mapping2, backendMapping2);
 
-        nodeAddedChange = Qt3DCore::QPropertyNodeAddedChangePtr::create(Qt3DCore::QNodeId(), &mapping2);
-        nodeAddedChange->setPropertyName("mappings");
-        backendMapper.sceneChangeEvent(nodeAddedChange);
+        mapper.addMapping(&mapping2);
+        backendMapper.syncFromFrontEnd(&mapper, false);
 
         // THEN
         QCOMPARE(backendMapper.mappingIds().size(), 2);
@@ -154,9 +151,8 @@ private Q_SLOTS:
         QCOMPARE(backendMapper.mappings().last(), backendMapping2);
 
         // WHEN
-        const auto nodeRemovedChange = Qt3DCore::QPropertyNodeRemovedChangePtr::create(Qt3DCore::QNodeId(), &mapping);
-        nodeRemovedChange->setPropertyName("mappings");
-        backendMapper.sceneChangeEvent(nodeRemovedChange);
+        mapper.removeMapping(&mapping);
+        backendMapper.syncFromFrontEnd(&mapper, false);
 
         // THEN
         QCOMPARE(backendMapper.mappingIds().size(), 1);
diff --git a/tests/auto/animation/channelmapping/tst_channelmapping.cpp b/tests/auto/animation/channelmapping/tst_channelmapping.cpp
index 35ffcb10a..e108e3d26 100644
--- a/tests/auto/animation/channelmapping/tst_channelmapping.cpp
+++ b/tests/auto/animation/channelmapping/tst_channelmapping.cpp
@@ -34,6 +34,7 @@
 #include <Qt3DAnimation/qskeletonmapping.h>
 #include <Qt3DAnimation/private/qchannelmapping_p.h>
 #include <Qt3DCore/qentity.h>
+#include <Qt3DCore/qtransform.h>
 #include <Qt3DCore/qskeleton.h>
 #include <Qt3DCore/private/qnode_p.h>
 #include <Qt3DCore/private/qscene_p.h>
@@ -72,7 +73,7 @@ private Q_SLOTS:
         mapping.setProperty(QLatin1String("foo"));
 
         // WHEN
-        simulateInitialization(&mapping, &backendMapping);
+        simulateInitializationSync(&mapping, &backendMapping);
 
         // THEN
         QCOMPARE(backendMapping.peerId(), mapping.id());
@@ -93,7 +94,7 @@ private Q_SLOTS:
         skeletonMapping.setSkeleton(skeleton);
 
         // WHEN
-        simulateInitialization(&skeletonMapping, &backendSkeletonMapping);
+        simulateInitializationSync(&skeletonMapping, &backendSkeletonMapping);
 
         // THEN
         QCOMPARE(backendSkeletonMapping.peerId(), skeletonMapping.id());
@@ -128,7 +129,7 @@ private Q_SLOTS:
         mapping.setProperty(QLatin1String("foo"));
 
         // WHEN
-        simulateInitialization(&mapping, &backendMapping);
+        simulateInitializationSync(&mapping, &backendMapping);
         backendMapping.setSkeletonId(Qt3DCore::QNodeId::createId());
         backendMapping.cleanup();
 
@@ -146,77 +147,50 @@ private Q_SLOTS:
     void checkPropertyChanges()
     {
         // GIVEN
+        Qt3DAnimation::QChannelMapping mapping;
         Qt3DAnimation::Animation::Handler handler;
         Qt3DAnimation::Animation::ChannelMapping backendMapping;
         backendMapping.setHandler(&handler);
-        Qt3DCore::QPropertyUpdatedChangePtr updateChange;
+        simulateInitializationSync(&mapping, &backendMapping);
 
         // WHEN
-        updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId());
-        updateChange->setPropertyName("enabled");
-        updateChange->setValue(true);
-        backendMapping.sceneChangeEvent(updateChange);
+        mapping.setEnabled(false);
+        backendMapping.syncFromFrontEnd(&mapping, false);
 
         // THEN
-        QCOMPARE(backendMapping.isEnabled(), true);
+        QCOMPARE(backendMapping.isEnabled(), false);
 
         // WHEN
-        const QString channelName(QLatin1String("Rotation"));
-        updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId());
-        updateChange->setPropertyName("channelName");
-        updateChange->setValue(channelName);
-        backendMapping.sceneChangeEvent(updateChange);
+        const QString channelName(QLatin1String("Translation"));
+        mapping.setChannelName(channelName);
+        backendMapping.syncFromFrontEnd(&mapping, false);
 
         // THEN
         QCOMPARE(backendMapping.channelName(), channelName);
 
         // WHEN
-        const auto id = Qt3DCore::QNodeId::createId();
-        updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId());
-        updateChange->setPropertyName("target");
-        updateChange->setValue(QVariant::fromValue(id));
-        backendMapping.sceneChangeEvent(updateChange);
-
-        // THEN
-        QCOMPARE(backendMapping.targetId(), id);
-
-        // WHEN
-        updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId());
-        updateChange->setPropertyName("type");
-        updateChange->setValue(QVariant(static_cast<int>(QVariant::Vector3D)));
-        backendMapping.sceneChangeEvent(updateChange);
+        const auto target = new Qt3DCore::QTransform();
+        mapping.setTarget(target);
+        mapping.setProperty("translation");
+        backendMapping.syncFromFrontEnd(&mapping, false);
 
         // THEN
+        QCOMPARE(backendMapping.targetId(), target->id());
         QCOMPARE(backendMapping.type(), static_cast<int>(QVariant::Vector3D));
+        QCOMPARE(backendMapping.componentCount(), 3);
 
-        // WHEN
-        updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId());
-        updateChange->setPropertyName("componentCount");
-        updateChange->setValue(4);
-        backendMapping.sceneChangeEvent(updateChange);
-
-        // THEN
-        QCOMPARE(backendMapping.componentCount(), 4);
-
-        // WHEN
-        const char *testName = "883";
-        updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId());
-        updateChange->setPropertyName("propertyName");
-        updateChange->setValue(QVariant::fromValue(reinterpret_cast<void *>(const_cast<char *>(testName))));
-        backendMapping.sceneChangeEvent(updateChange);
-
-        // THEN
-        QCOMPARE(backendMapping.propertyName(), testName);
+        const char *testName = "translation";
+        QCOMPARE(qstrcmp(testName, backendMapping.propertyName()), 0);
 
-        // WHEN
-        const auto skeletonId = Qt3DCore::QNodeId::createId();
-        updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId());
-        updateChange->setPropertyName("skeleton");
-        updateChange->setValue(QVariant::fromValue(skeletonId));
-        backendMapping.sceneChangeEvent(updateChange);
+//        // WHEN
+//        const auto skeletonId = Qt3DCore::QNodeId::createId();
+//        updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId());
+//        updateChange->setPropertyName("skeleton");
+//        updateChange->setValue(QVariant::fromValue(skeletonId));
+//        backendMapping.sceneChangeEvent(updateChange);
 
-        // THEN
-        QCOMPARE(backendMapping.skeletonId(), skeletonId);
+//        // THEN
+//        QCOMPARE(backendMapping.skeletonId(), skeletonId);
     }
 };
 
diff --git a/tests/auto/animation/clipanimator/tst_clipanimator.cpp b/tests/auto/animation/clipanimator/tst_clipanimator.cpp
index 0272bcfaa..5f297306a 100644
--- a/tests/auto/animation/clipanimator/tst_clipanimator.cpp
+++ b/tests/auto/animation/clipanimator/tst_clipanimator.cpp
@@ -29,6 +29,7 @@
 #include <QtTest/QTest>
 #include <Qt3DAnimation/private/clipanimator_p.h>
 #include <Qt3DAnimation/qanimationcliploader.h>
+#include <Qt3DAnimation/qchannelmapper.h>
 #include <Qt3DAnimation/qclipanimator.h>
 #include <Qt3DAnimation/qclock.h>
 #include <Qt3DCore/private/qnode_p.h>
@@ -59,7 +60,7 @@ private Q_SLOTS:
         animator.setNormalizedTime(0.5f);
 
         // WHEN
-        simulateInitialization(&animator, &backendAnimator);
+        simulateInitializationSync(&animator, &backendAnimator);
 
         // THEN
         QCOMPARE(backendAnimator.peerId(), animator.id());
@@ -98,7 +99,7 @@ private Q_SLOTS:
         animator.setNormalizedTime(1.0f);
 
         // WHEN
-        simulateInitialization(&animator, &backendAnimator);
+        simulateInitializationSync(&animator, &backendAnimator);
         backendAnimator.setClipId(Qt3DCore::QNodeId::createId());
         backendAnimator.setClockId(Qt3DCore::QNodeId::createId());
         backendAnimator.cleanup();
@@ -115,63 +116,60 @@ private Q_SLOTS:
     void checkPropertyChanges()
     {
         // GIVEN
+        Qt3DAnimation::QClipAnimator animator;
         Qt3DAnimation::Animation::Handler handler;
         Qt3DAnimation::Animation::ClipAnimator backendAnimator;
         backendAnimator.setHandler(&handler);
-        Qt3DCore::QPropertyUpdatedChangePtr updateChange;
+        simulateInitializationSync(&animator, &backendAnimator);
 
         // WHEN
-        updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId());
-        updateChange->setPropertyName("enabled");
-        updateChange->setValue(true);
-        backendAnimator.sceneChangeEvent(updateChange);
+        animator.setEnabled(false);
+        backendAnimator.syncFromFrontEnd(&animator, false);
 
         // THEN
-        QCOMPARE(backendAnimator.isEnabled(), true);
+        QCOMPARE(backendAnimator.isEnabled(), false);
 
         // WHEN
         auto newClip = new Qt3DAnimation::QAnimationClipLoader();
-        updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId());
-        updateChange->setPropertyName("clip");
-        updateChange->setValue(QVariant::fromValue(newClip->id()));
-        backendAnimator.sceneChangeEvent(updateChange);
+        animator.setClip(newClip);
+        backendAnimator.syncFromFrontEnd(&animator, false);
 
         // THEN
         QCOMPARE(backendAnimator.clipId(), newClip->id());
 
         // WHEN
+        auto newMapper = new Qt3DAnimation::QChannelMapper();
+        animator.setChannelMapper(newMapper);
+        backendAnimator.syncFromFrontEnd(&animator, false);
+
+        // THEN
+        QCOMPARE(backendAnimator.mapperId(), newMapper->id());
+
+        // WHEN
         auto clock = new Qt3DAnimation::QClock();
-        updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId());
-        updateChange->setPropertyName("clock");
-        updateChange->setValue(QVariant::fromValue(clock->id()));
-        backendAnimator.sceneChangeEvent(updateChange);
+        animator.setClock(clock);
+        backendAnimator.syncFromFrontEnd(&animator, false);
 
         // THEN
         QCOMPARE(backendAnimator.clockId(), clock->id());
 
         // WHEN
-        updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId());
-        updateChange->setPropertyName("running");
-        updateChange->setValue(true);
-        backendAnimator.sceneChangeEvent(updateChange);
+        animator.setRunning(true);
+        backendAnimator.syncFromFrontEnd(&animator, false);
 
         // THEN
         QCOMPARE(backendAnimator.isRunning(), true);
 
         // WHEN
-        updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId());
-        updateChange->setPropertyName("loops");
-        updateChange->setValue(64);
-        backendAnimator.sceneChangeEvent(updateChange);
+        animator.setLoopCount(64);
+        backendAnimator.syncFromFrontEnd(&animator, false);
 
         // THEN
         QCOMPARE(backendAnimator.loops(), 64);
 
         // WHEN
-        updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId());
-        updateChange->setPropertyName("normalizedTime");
-        updateChange->setValue(0.5f);
-        backendAnimator.sceneChangeEvent(updateChange);
+        animator.setNormalizedTime(0.5f);
+        backendAnimator.syncFromFrontEnd(&animator, false);
 
         // THEN
         QVERIFY(qFuzzyCompare(backendAnimator.normalizedLocalTime(), 0.5f));
diff --git a/tests/auto/animation/clipblendnodevisitor/tst_clipblendnodevisitor.cpp b/tests/auto/animation/clipblendnodevisitor/tst_clipblendnodevisitor.cpp
index 3f705e713..54de87b1e 100644
--- a/tests/auto/animation/clipblendnodevisitor/tst_clipblendnodevisitor.cpp
+++ b/tests/auto/animation/clipblendnodevisitor/tst_clipblendnodevisitor.cpp
@@ -73,11 +73,11 @@ private Q_SLOTS:
         manager.appendNode(childBlendNode12.id(), backendChildBlendNode12);
 
         // WHEN
-        simulateInitialization(&rootBlendNode, backendRootBlendNode);
-        simulateInitialization(&childBlendNode1, backendChildBlendNode1);
-        simulateInitialization(&childBlendNode2, backendChildBlendNode2);
-        simulateInitialization(&childBlendNode11, backendChildBlendNode11);
-        simulateInitialization(&childBlendNode12, backendChildBlendNode12);
+        simulateInitializationSync(&rootBlendNode, backendRootBlendNode);
+        simulateInitializationSync(&childBlendNode1, backendChildBlendNode1);
+        simulateInitializationSync(&childBlendNode2, backendChildBlendNode2);
+        simulateInitializationSync(&childBlendNode11, backendChildBlendNode11);
+        simulateInitializationSync(&childBlendNode12, backendChildBlendNode12);
 
         // THEN
         QCOMPARE(backendRootBlendNode->allDependencyIds().size(), 2);
@@ -121,7 +121,7 @@ private Q_SLOTS:
         // We purposely forgot the to do:  manager.appendNode(rootBlendNode.id(), backendRootBlendNode);
 
         // WHEN
-        simulateInitialization(&rootBlendNode, backendRootBlendNode);
+        simulateInitializationSync(&rootBlendNode, backendRootBlendNode);
 
         // THEN
         QCOMPARE(backendRootBlendNode->allDependencyIds().size(), 2);
@@ -159,9 +159,9 @@ private Q_SLOTS:
 
 
         // WHEN
-        simulateInitialization(&rootBlendNode, backendRootBlendNode);
-        simulateInitialization(&childBlendNode1, backendChildBlendNode1);
-        simulateInitialization(&childBlendNode2, backendChildBlendNode2);
+        simulateInitializationSync(&rootBlendNode, backendRootBlendNode);
+        simulateInitializationSync(&childBlendNode1, backendChildBlendNode1);
+        simulateInitializationSync(&childBlendNode2, backendChildBlendNode2);
 
         // THEN
         QCOMPARE(backendRootBlendNode->allDependencyIds().size(), 2);
diff --git a/tests/auto/animation/clipblendvalue/tst_clipblendvalue.cpp b/tests/auto/animation/clipblendvalue/tst_clipblendvalue.cpp
index 197378094..47f309b10 100644
--- a/tests/auto/animation/clipblendvalue/tst_clipblendvalue.cpp
+++ b/tests/auto/animation/clipblendvalue/tst_clipblendvalue.cpp
@@ -80,7 +80,7 @@ private Q_SLOTS:
         {
             // WHEN
             ClipBlendValue backendClipBlendValue;
-            simulateInitialization(&clipBlendValue, &backendClipBlendValue);
+            simulateInitializationSync(&clipBlendValue, &backendClipBlendValue);
 
             // THEN
             QCOMPARE(backendClipBlendValue.isEnabled(), true);
@@ -91,7 +91,7 @@ private Q_SLOTS:
             // WHEN
             ClipBlendValue backendClipBlendValue;
             clipBlendValue.setEnabled(false);
-            simulateInitialization(&clipBlendValue, &backendClipBlendValue);
+            simulateInitializationSync(&clipBlendValue, &backendClipBlendValue);
 
             // THEN
             QCOMPARE(backendClipBlendValue.peerId(), clipBlendValue.id());
@@ -102,25 +102,23 @@ private Q_SLOTS:
     void checkSceneChangeEvents()
     {
         // GIVEN
+        Qt3DAnimation::QClipBlendValue clipBlendValue;
         ClipBlendValue backendClipBlendValue;
+        simulateInitializationSync(&clipBlendValue, &backendClipBlendValue);
         {
             // WHEN
             const bool newValue = false;
-            const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-            change->setPropertyName("enabled");
-            change->setValue(newValue);
-            backendClipBlendValue.sceneChangeEvent(change);
+            clipBlendValue.setEnabled(newValue);
+            backendClipBlendValue.syncFromFrontEnd(&clipBlendValue, false);
 
             // THEN
             QCOMPARE(backendClipBlendValue.isEnabled(), newValue);
         }
         {
             // WHEN
-            const Qt3DAnimation::QAnimationClipLoader newValue;
-            const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-            change->setPropertyName("clip");
-            change->setValue(QVariant::fromValue(newValue.id()));
-            backendClipBlendValue.sceneChangeEvent(change);
+            Qt3DAnimation::QAnimationClipLoader newValue;
+            clipBlendValue.setClip(&newValue);
+            backendClipBlendValue.syncFromFrontEnd(&clipBlendValue, false);
 
             // THEN
             QCOMPARE(backendClipBlendValue.clipId(), newValue.id());
diff --git a/tests/auto/animation/clock/tst_clock.cpp b/tests/auto/animation/clock/tst_clock.cpp
index a81adfe7b..793a01b25 100644
--- a/tests/auto/animation/clock/tst_clock.cpp
+++ b/tests/auto/animation/clock/tst_clock.cpp
@@ -50,7 +50,7 @@ private Q_SLOTS:
         clock.setPlaybackRate(10.5);
 
         // WHEN
-        simulateInitialization(&clock, &backendClock);
+        simulateInitializationSync(&clock, &backendClock);
 
         // THEN
         QCOMPARE(backendClock.playbackRate(), clock.playbackRate());
@@ -69,7 +69,7 @@ private Q_SLOTS:
         clock.setPlaybackRate(10.5);
 
         // WHEN
-        simulateInitialization(&clock, &backendClock);
+        simulateInitializationSync(&clock, &backendClock);
         backendClock.cleanup();
 
         // THEN
@@ -79,15 +79,15 @@ private Q_SLOTS:
     void checkSceneChangeEvents()
     {
         // GIVEN
+        Qt3DAnimation::QClock clock;
         Qt3DAnimation::Animation::Clock backendClock;
+        simulateInitializationSync(&clock, &backendClock);
 
         {
             // WHEN
             const bool newValue = false;
-            const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-            change->setPropertyName("enabled");
-            change->setValue(newValue);
-            backendClock.sceneChangeEvent(change);
+            clock.setEnabled(newValue);
+            backendClock.syncFromFrontEnd(&clock, false);
 
             // THEN
             QCOMPARE(backendClock.isEnabled(), newValue);
@@ -95,10 +95,8 @@ private Q_SLOTS:
         {
             // WHEN
             const double newPlaybackRateValue = 2.0;
-            const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-            change->setPropertyName("playbackRate");
-            change->setValue(newPlaybackRateValue);
-            backendClock.sceneChangeEvent(change);
+            clock.setPlaybackRate(newPlaybackRateValue);
+            backendClock.syncFromFrontEnd(&clock, false);
 
             // THEN
             QCOMPARE(backendClock.playbackRate(), newPlaybackRateValue);
diff --git a/tests/auto/animation/lerpclipblend/tst_lerpclipblend.cpp b/tests/auto/animation/lerpclipblend/tst_lerpclipblend.cpp
index e75c4f2f8..732a87770 100644
--- a/tests/auto/animation/lerpclipblend/tst_lerpclipblend.cpp
+++ b/tests/auto/animation/lerpclipblend/tst_lerpclipblend.cpp
@@ -137,7 +137,7 @@ private Q_SLOTS:
         {
             // WHEN
             LerpClipBlend backendLerpBlend;
-            simulateInitialization(&lerpBlend, &backendLerpBlend);
+            simulateInitializationSync(&lerpBlend, &backendLerpBlend);
 
             // THEN
             QCOMPARE(backendLerpBlend.isEnabled(), true);
@@ -148,7 +148,7 @@ private Q_SLOTS:
             // WHEN
             LerpClipBlend backendLerpBlend;
             lerpBlend.setEnabled(false);
-            simulateInitialization(&lerpBlend, &backendLerpBlend);
+            simulateInitializationSync(&lerpBlend, &backendLerpBlend);
 
             // THEN
             QCOMPARE(backendLerpBlend.peerId(), lerpBlend.id());
@@ -159,27 +159,26 @@ private Q_SLOTS:
     void checkSceneChangeEvents()
     {
         // GIVEN
+        Qt3DAnimation::QLerpClipBlend lerpBlend;
         LerpClipBlend backendLerpBlend;
+        simulateInitializationSync(&lerpBlend, &backendLerpBlend);
+
         {
-             // WHEN
-             const bool newValue = false;
-             const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-             change->setPropertyName("enabled");
-             change->setValue(newValue);
-             backendLerpBlend.sceneChangeEvent(change);
-
-             // THEN
+            // WHEN
+            const bool newValue = false;
+            lerpBlend.setEnabled(newValue);
+            backendLerpBlend.syncFromFrontEnd(&lerpBlend, false);
+
+            // THEN
             QCOMPARE(backendLerpBlend.isEnabled(), newValue);
         }
         {
-             // WHEN
-             const float newValue = 0.883f;
-             const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-             change->setPropertyName("blendFactor");
-             change->setValue(QVariant::fromValue(newValue));
-             backendLerpBlend.sceneChangeEvent(change);
-
-             // THEN
+            // WHEN
+            const float newValue = 0.883f;
+            lerpBlend.setBlendFactor(newValue);
+            backendLerpBlend.syncFromFrontEnd(&lerpBlend, false);
+
+            // THEN
             QCOMPARE(backendLerpBlend.blendFactor(), newValue);
         }
     }
diff --git a/tests/auto/animation/qcallbackmapping/tst_qcallbackmapping.cpp b/tests/auto/animation/qcallbackmapping/tst_qcallbackmapping.cpp
index d217f3b0f..591ff54ce 100644
--- a/tests/auto/animation/qcallbackmapping/tst_qcallbackmapping.cpp
+++ b/tests/auto/animation/qcallbackmapping/tst_qcallbackmapping.cpp
@@ -185,23 +185,11 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 3);
-            auto change = arbiter.events.at(0).staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "type");
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
-            QCOMPARE(change->value().toInt(), int(QVariant::Vector3D));
-
-            change = arbiter.events.at(1).staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "callback");
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
-            QCOMPARE(reinterpret_cast<DummyCallback *>(change->value().value<void *>()), callback);
-
-            change = arbiter.events.at(2).staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "callbackFlags");
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
-            QCOMPARE(change->value().toInt(), static_cast<int>(Qt3DAnimation::QAnimationCallback::OnThreadPool));
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &mapping);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
 
             // WHEN
             mapping.setCallback(QVariant::Vector3D, callback, Qt3DAnimation::QAnimationCallback::OnThreadPool);
@@ -209,6 +197,7 @@ private Q_SLOTS:
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
     }
 };
diff --git a/tests/auto/animation/qchannelmapping/tst_qchannelmapping.cpp b/tests/auto/animation/qchannelmapping/tst_qchannelmapping.cpp
index 37bd3e241..a47061077 100644
--- a/tests/auto/animation/qchannelmapping/tst_qchannelmapping.cpp
+++ b/tests/auto/animation/qchannelmapping/tst_qchannelmapping.cpp
@@ -284,24 +284,11 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 3);
-
-            auto change = arbiter.events.takeFirst().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "type");
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
-            QCOMPARE(change->value().toInt(), static_cast<int>(QVariant::Vector3D));
-
-            change = arbiter.events.takeFirst().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "componentCount");
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
-            QCOMPARE(change->value().toInt(), 3);
-
-            change = arbiter.events.takeFirst().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "propertyName");
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
-            QVERIFY(qstrcmp(reinterpret_cast<const char *>(change->value().value<void *>()), "scale") == 0);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &mapping);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
 
             // WHEN
             mapping.setProperty(QStringLiteral("scale"));
@@ -309,6 +296,7 @@ private Q_SLOTS:
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
     }
 
@@ -340,8 +328,8 @@ private Q_SLOTS:
         QFETCH(int, expectedType);
         QFETCH(int, expectedComponentCount);
 
-        Q_UNUSED(expectedType);
-        Q_UNUSED(expectedComponentCount);
+        Q_UNUSED(expectedType)
+        Q_UNUSED(expectedComponentCount)
 
         TestArbiter arbiter;
         Qt3DAnimation::QChannelMapping mapping;
@@ -363,7 +351,7 @@ private Q_SLOTS:
             mapping.setProperty(QString::fromLatin1(propertyName));
 
             // THEN
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
         }
     }
 
diff --git a/tests/auto/render/blitframebuffer/tst_blitframebuffer.cpp b/tests/auto/render/blitframebuffer/tst_blitframebuffer.cpp
index b10c2e88e..f7a6ce214 100644
--- a/tests/auto/render/blitframebuffer/tst_blitframebuffer.cpp
+++ b/tests/auto/render/blitframebuffer/tst_blitframebuffer.cpp
@@ -78,7 +78,7 @@ private Q_SLOTS:
             // WHEN
             Qt3DRender::Render::BlitFramebuffer backendBlitFramebuffer;
             backendBlitFramebuffer.setRenderer(&renderer);
-            simulateInitialization(&blitFramebuffer, &backendBlitFramebuffer);
+            simulateInitializationSync(&blitFramebuffer, &backendBlitFramebuffer);
 
             // THEN
             QCOMPARE(backendBlitFramebuffer.isEnabled(), true);
@@ -98,7 +98,7 @@ private Q_SLOTS:
             Qt3DRender::Render::BlitFramebuffer backendBlitFramebuffer;
             backendBlitFramebuffer.setRenderer(&renderer);
             blitFramebuffer.setEnabled(false);
-            simulateInitialization(&blitFramebuffer, &backendBlitFramebuffer);
+            simulateInitializationSync(&blitFramebuffer, &backendBlitFramebuffer);
 
             // THEN
             QCOMPARE(backendBlitFramebuffer.peerId(), blitFramebuffer.id());
@@ -111,98 +111,84 @@ private Q_SLOTS:
     {
         // GIVEN
         Qt3DRender::Render::BlitFramebuffer backendBlitFramebuffer;
+        Qt3DRender::QBlitFramebuffer blitFramebuffer;
         TestRenderer renderer;
         backendBlitFramebuffer.setRenderer(&renderer);
+        simulateInitializationSync(&blitFramebuffer, &backendBlitFramebuffer);
 
         {
-             // WHEN
-             const bool newValue = false;
-             const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-             change->setPropertyName("enabled");
-             change->setValue(newValue);
-             backendBlitFramebuffer.sceneChangeEvent(change);
-
-             // THEN
+            // WHEN
+            const bool newValue = false;
+            blitFramebuffer.setEnabled(newValue);
+            backendBlitFramebuffer.syncFromFrontEnd(&blitFramebuffer, false);
+
+            // THEN
             QCOMPARE(backendBlitFramebuffer.isEnabled(), newValue);
             QVERIFY(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::FrameGraphDirty);
             renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty);
         }
         {
-             // WHEN
-            const Qt3DRender::QRenderTarget sourceRenderTarget;
-            const Qt3DCore::QNodeId newValue = sourceRenderTarget.id();
-             const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-             change->setPropertyName("sourceRenderTarget");
-             change->setValue(QVariant::fromValue(newValue));
-             backendBlitFramebuffer.sceneChangeEvent(change);
-
-             // THEN
-            QCOMPARE(backendBlitFramebuffer.sourceRenderTargetId(), newValue);
+            // WHEN
+            Qt3DRender::QRenderTarget sourceRenderTarget;
+            blitFramebuffer.setSource(&sourceRenderTarget);
+            backendBlitFramebuffer.syncFromFrontEnd(&blitFramebuffer, false);
+
+            // THEN
+            QCOMPARE(backendBlitFramebuffer.sourceRenderTargetId(), sourceRenderTarget.id());
             QVERIFY(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::FrameGraphDirty);
             renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty);
         }
         {
-             // WHEN
-            const Qt3DRender::QRenderTarget destinationRenderTarget;
-            const Qt3DCore::QNodeId newValue = destinationRenderTarget.id();
-             const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-             change->setPropertyName("destinationRenderTarget");
-             change->setValue(QVariant::fromValue(newValue));
-             backendBlitFramebuffer.sceneChangeEvent(change);
-
-             // THEN
-            QCOMPARE(backendBlitFramebuffer.destinationRenderTargetId(), newValue);
+            // WHEN
+            Qt3DRender::QRenderTarget destinationRenderTarget;
+            blitFramebuffer.setDestination(&destinationRenderTarget);
+            backendBlitFramebuffer.syncFromFrontEnd(&blitFramebuffer, false);
+
+            // THEN
+            QCOMPARE(backendBlitFramebuffer.destinationRenderTargetId(), destinationRenderTarget.id());
             QVERIFY(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::FrameGraphDirty);
             renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty);
         }
         {
-             // WHEN
+            // WHEN
             const auto newValue = QRect(0,0,1,1);
-             const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-             change->setPropertyName("sourceRect");
-             change->setValue(QVariant::fromValue(newValue));
-             backendBlitFramebuffer.sceneChangeEvent(change);
+            blitFramebuffer.setSourceRect(newValue);
+            backendBlitFramebuffer.syncFromFrontEnd(&blitFramebuffer, false);
 
-             // THEN
+            // THEN
             QCOMPARE(backendBlitFramebuffer.sourceRect(), newValue);
             QVERIFY(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::FrameGraphDirty);
             renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty);
         }
         {
-             // WHEN
+            // WHEN
             const auto newValue = QRect(0,0,1,1);
-             const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-             change->setPropertyName("destinationRect");
-             change->setValue(QVariant::fromValue(newValue));
-             backendBlitFramebuffer.sceneChangeEvent(change);
+            blitFramebuffer.setDestinationRect(newValue);
+            backendBlitFramebuffer.syncFromFrontEnd(&blitFramebuffer, false);
 
-             // THEN
+            // THEN
             QCOMPARE(backendBlitFramebuffer.destinationRect(), newValue);
             QVERIFY(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::FrameGraphDirty);
             renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty);
         }
         {
-             // WHEN
+            // WHEN
             const auto newValue = Qt3DRender::QRenderTargetOutput::Color1;
-             const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-             change->setPropertyName("sourceAttachmentPoint");
-             change->setValue(QVariant::fromValue(newValue));
-             backendBlitFramebuffer.sceneChangeEvent(change);
+            blitFramebuffer.setSourceAttachmentPoint(newValue);
+            backendBlitFramebuffer.syncFromFrontEnd(&blitFramebuffer, false);
 
-             // THEN
+            // THEN
             QCOMPARE(backendBlitFramebuffer.sourceAttachmentPoint(), newValue);
             QVERIFY(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::FrameGraphDirty);
             renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty);
         }
         {
-             // WHEN
+            // WHEN
             const auto newValue = Qt3DRender::QRenderTargetOutput::Color1;
-             const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-             change->setPropertyName("destinationAttachmentPoint");
-             change->setValue(QVariant::fromValue(newValue));
-             backendBlitFramebuffer.sceneChangeEvent(change);
+            blitFramebuffer.setDestinationAttachmentPoint(newValue);
+            backendBlitFramebuffer.syncFromFrontEnd(&blitFramebuffer, false);
 
-             // THEN
+            // THEN
             QCOMPARE(backendBlitFramebuffer.destinationAttachmentPoint(), newValue);
             QVERIFY(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::FrameGraphDirty);
             renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty);
diff --git a/tests/auto/render/boundingsphere/tst_boundingsphere.cpp b/tests/auto/render/boundingsphere/tst_boundingsphere.cpp
index f1c228f17..80298780a 100644
--- a/tests/auto/render/boundingsphere/tst_boundingsphere.cpp
+++ b/tests/auto/render/boundingsphere/tst_boundingsphere.cpp
@@ -55,7 +55,6 @@
 #include <Qt3DRender/private/calcboundingvolumejob_p.h>
 #include <Qt3DRender/private/calcgeometrytrianglevolumes_p.h>
 #include <Qt3DRender/private/loadbufferjob_p.h>
-#include <Qt3DRender/private/updateentityhierarchyjob_p.h>
 #include <Qt3DRender/private/buffermanager_p.h>
 #include <Qt3DRender/private/geometryrenderermanager_p.h>
 #include <Qt3DRender/private/sphere_p.h>
@@ -157,10 +156,6 @@ namespace {
 
 void runRequiredJobs(Qt3DRender::TestAspect *test)
 {
-    Qt3DRender::Render::UpdateEntityHierarchyJob updateEntitiesJob;
-    updateEntitiesJob.setManager(test->nodeManagers());
-    updateEntitiesJob.run();
-
     Qt3DRender::Render::UpdateWorldTransformJob updateWorldTransform;
     updateWorldTransform.setRoot(test->sceneRoot());
     updateWorldTransform.setManagers(test->nodeManagers());
diff --git a/tests/auto/render/entity/tst_entity.cpp b/tests/auto/render/entity/tst_entity.cpp
index 7e5150a77..463fbbb79 100644
--- a/tests/auto/render/entity/tst_entity.cpp
+++ b/tests/auto/render/entity/tst_entity.cpp
@@ -182,7 +182,6 @@ private slots:
         entity.cleanup();
 
         // THEN
-        QVERIFY(entity.parentEntityId().isNull());
         QVERIFY(entity.componentUuid<Transform>().isNull());
         QVERIFY(entity.componentUuid<CameraLens>().isNull());
         QVERIFY(entity.componentUuid<Material>().isNull());
@@ -201,29 +200,18 @@ private slots:
         QVERIFY(!containsAll);
     }
 
-    void checkRebuildingEntityHierarchy()
+    void checkEntityReparenting()
     {
         // GIVEN
         TestRenderer renderer;
         NodeManagers nodeManagers;
         Qt3DCore::QEntity frontendEntityA, frontendEntityB, frontendEntityC;
 
-        auto entityCreator = [&nodeManagers, &renderer](const Qt3DCore::QEntity &frontEndEntity) {
-            Entity *entity = nodeManagers.renderNodesManager()->getOrCreateResource(frontEndEntity.id());
-            entity->setNodeManagers(&nodeManagers);
-            entity->setRenderer(&renderer);
-            return entity;
-        };
-
-        auto backendA = entityCreator(frontendEntityA);
-        auto backendB = entityCreator(frontendEntityB);
-        auto backendC = entityCreator(frontendEntityC);
+        auto backendA = createEntity(renderer, nodeManagers, frontendEntityA);
+        auto backendB = createEntity(renderer, nodeManagers, frontendEntityB);
+        auto backendC = createEntity(renderer, nodeManagers, frontendEntityC);
 
         // THEN
-        QVERIFY(backendA->parentEntityId().isNull());
-        QVERIFY(backendB->parentEntityId().isNull());
-        QVERIFY(backendC->parentEntityId().isNull());
-
         QVERIFY(backendA->parent() == nullptr);
         QVERIFY(backendB->parent() == nullptr);
         QVERIFY(backendC->parent() == nullptr);
@@ -233,9 +221,6 @@ private slots:
         QVERIFY(backendC->childrenHandles().isEmpty());
 
         // WHEN
-        renderer.clearDirtyBits(0);
-        QVERIFY(renderer.dirtyBits() == 0);
-
         auto sendParentChange = [&nodeManagers](const Qt3DCore::QEntity &entity) {
             Entity *backendEntity = nodeManagers.renderNodesManager()->getOrCreateResource(entity.id());
             backendEntity->syncFromFrontEnd(&entity, false);
@@ -248,68 +233,111 @@ private slots:
         sendParentChange(frontendEntityC);
 
         // THEN
-        QVERIFY(renderer.dirtyBits() & AbstractRenderer::EntityHierarchyDirty);
+        QVERIFY(backendA->parent() == nullptr);
+        QVERIFY(backendB->parent() == backendA);
+        QVERIFY(backendC->parent() == backendB);
 
-        QVERIFY(backendA->parentEntityId().isNull());
-        QVERIFY(backendB->parentEntityId() == frontendEntityA.id());
-        QVERIFY(backendC->parentEntityId() == frontendEntityB.id());
+        QCOMPARE(backendA->childrenHandles().count(), 1);
+        QCOMPARE(backendB->childrenHandles().count(), 1);
+        QVERIFY(backendC->childrenHandles().isEmpty());
 
+          // WHEN - reparent C to A
+        frontendEntityC.setParent(&frontendEntityA);
+        sendParentChange(frontendEntityC);
+
+        // THEN
+        QVERIFY(backendA->parent() == nullptr);
+        QVERIFY(backendB->parent() == backendA);
+        QVERIFY(backendC->parent() == backendA);
+
+        QCOMPARE(backendA->childrenHandles().size(), 2);
+        QVERIFY(backendB->childrenHandles().isEmpty());
+        QVERIFY(backendC->childrenHandles().isEmpty());
+
+        // WHEN - reparent B to null.
+        frontendEntityB.setParent(static_cast<Qt3DCore::QNode *>(nullptr));
+        sendParentChange(frontendEntityB);
+
+        // THEN
         QVERIFY(backendA->parent() == nullptr);
         QVERIFY(backendB->parent() == nullptr);
-        QVERIFY(backendC->parent() == nullptr);
+        QVERIFY(backendC->parent() == backendA);
 
-        QVERIFY(backendA->childrenHandles().isEmpty());
+        QCOMPARE(backendA->childrenHandles().count(), 1);
+        QVERIFY(!backendA->childrenHandles().contains(backendB->handle()));
         QVERIFY(backendB->childrenHandles().isEmpty());
         QVERIFY(backendC->childrenHandles().isEmpty());
+      }
+
+    void checkEntityCleanup()
+    {
+        // GIVEN
+        TestRenderer renderer;
+        NodeManagers nodeManagers;
+        Qt3DCore::QEntity frontendEntityA, frontendEntityB, frontendEntityC;
+
+        auto backendA = createEntity(renderer, nodeManagers, frontendEntityA);
+        auto backendB = createEntity(renderer, nodeManagers, frontendEntityB);
+        auto backendC = createEntity(renderer, nodeManagers, frontendEntityC);
 
         // WHEN
-        auto rebuildHierarchy = [](Entity *backend) {
-            backend->clearEntityHierarchy();
-            backend->rebuildEntityHierarchy();
+        auto sendParentChange = [&nodeManagers](const Qt3DCore::QEntity &entity) {
+            Entity *backendEntity = nodeManagers.renderNodesManager()->getOrCreateResource(entity.id());
+            backendEntity->syncFromFrontEnd(&entity, false);
         };
-        rebuildHierarchy(backendA);
-        rebuildHierarchy(backendB);
-        rebuildHierarchy(backendC);
+
+        // reparent B and C to A.
+        frontendEntityB.setParent(&frontendEntityA);
+        sendParentChange(frontendEntityB);
+        frontendEntityC.setParent(&frontendEntityA);
+        sendParentChange(frontendEntityC);
 
         // THEN
         QVERIFY(backendA->parent() == nullptr);
         QVERIFY(backendB->parent() == backendA);
-        QVERIFY(backendC->parent() == backendB);
+        QVERIFY(backendC->parent() == backendA);
 
-        QVERIFY(!backendA->childrenHandles().isEmpty());
-        QVERIFY(!backendB->childrenHandles().isEmpty());
+        QCOMPARE(backendA->childrenHandles().count(), 2);
+        QVERIFY(backendB->childrenHandles().isEmpty());
         QVERIFY(backendC->childrenHandles().isEmpty());
 
-        // WHEN - reparent B to null.
-        frontendEntityB.setParent(static_cast<Qt3DCore::QNode *>(nullptr));
-        sendParentChange(frontendEntityB);
-        rebuildHierarchy(backendA);
-        rebuildHierarchy(backendB);
-        rebuildHierarchy(backendC);
+        // WHEN - cleaning up a child
+        backendC->cleanup();
+
+        // THEN - the child's parent should be null and it
+        // should be removed from its parent's list of children
+        QVERIFY(backendA->parent() == nullptr);
+        QVERIFY(backendB->parent() == backendA);
+        QVERIFY(backendC->parent() == nullptr);
+
+        QCOMPARE(backendA->childrenHandles().count(), 1);
+        QVERIFY(!backendA->childrenHandles().contains(backendC->handle()));
+        QVERIFY(backendB->childrenHandles().isEmpty());
+        QVERIFY(backendC->childrenHandles().isEmpty());
 
-        QVERIFY(backendA->parentEntityId().isNull());
-        QVERIFY(backendB->parentEntityId().isNull());
-        QVERIFY(backendC->parentEntityId() == frontendEntityB.id());
+        // WHEN (cleaning up parent)
+        backendA->cleanup();
 
+        // THEN  (it's children's parent should be set to null)
         QVERIFY(backendA->parent() == nullptr);
         QVERIFY(backendB->parent() == nullptr);
-        QVERIFY(backendC->parent() == backendB);
+        QVERIFY(backendC->parent() == nullptr);
 
         QVERIFY(backendA->childrenHandles().isEmpty());
-        QVERIFY(!backendB->childrenHandles().isEmpty());
+        QVERIFY(backendB->childrenHandles().isEmpty());
         QVERIFY(backendC->childrenHandles().isEmpty());
 
-        // WHEN - cleanup
-        backendA->cleanup();
+        // WHEN
         backendB->cleanup();
-        backendC->cleanup();
 
-        // THEN
-        QVERIFY(backendA->parentEntityId().isNull());
-        QVERIFY(backendB->parentEntityId().isNull());
-        QVERIFY(backendC->parentEntityId().isNull());
+        // THEN nothing should change
+        QVERIFY(backendA->childrenHandles().isEmpty());
+        QVERIFY(backendB->childrenHandles().isEmpty());
+        QVERIFY(backendC->childrenHandles().isEmpty());
 
-        QVERIFY(renderer.dirtyBits() != 0);
+        QVERIFY(backendA->parent() == nullptr);
+        QVERIFY(backendB->parent() == nullptr);
+        QVERIFY(backendC->parent() == nullptr);
     }
 
     void shouldHandleSingleComponentEvents_data()
@@ -441,19 +469,9 @@ private slots:
         NodeManagers nodeManagers;
         Qt3DCore::QEntity frontendEntityA, frontendEntityB, frontendEntityC;
 
-        auto entityCreator = [&nodeManagers, &renderer](const Qt3DCore::QEntity &frontEndEntity) {
-            HEntity renderNodeHandle = nodeManagers.renderNodesManager()->getOrAcquireHandle(frontEndEntity.id());
-            Entity *entity = nodeManagers.renderNodesManager()->data(renderNodeHandle);
-            entity->setNodeManagers(&nodeManagers);
-            entity->setHandle(renderNodeHandle);
-            entity->setRenderer(&renderer);
-            entity->syncFromFrontEnd(&frontEndEntity, true);
-            return entity;
-        };
-
-        auto backendA = entityCreator(frontendEntityA);
-        auto backendB = entityCreator(frontendEntityB);
-        auto backendC = entityCreator(frontendEntityC);
+        auto backendA = createEntity(renderer, nodeManagers, frontendEntityA);
+        auto backendB = createEntity(renderer, nodeManagers, frontendEntityB);
+        auto backendC = createEntity(renderer, nodeManagers, frontendEntityC);
 
         auto sendParentChange = [&nodeManagers](const Qt3DCore::QEntity &entity) {
             Entity *backendEntity = nodeManagers.renderNodesManager()->getOrCreateResource(entity.id());
@@ -466,14 +484,6 @@ private slots:
         frontendEntityC.setParent(&frontendEntityB);
         sendParentChange(frontendEntityC);
 
-        auto rebuildHierarchy = [](Entity *backend) {
-            backend->clearEntityHierarchy();
-            backend->rebuildEntityHierarchy();
-        };
-        rebuildHierarchy(backendA);
-        rebuildHierarchy(backendB);
-        rebuildHierarchy(backendC);
-
         // WHEN
         int visitCount = 0;
         auto counter = [&visitCount](const Entity *) { ++visitCount; };
@@ -494,19 +504,9 @@ private slots:
         frontendEntityB.setEnabled(false);
         frontendEntityC.setEnabled(false);
 
-        auto entityCreator = [&nodeManagers, &renderer](const Qt3DCore::QEntity &frontEndEntity) {
-            HEntity renderNodeHandle = nodeManagers.renderNodesManager()->getOrAcquireHandle(frontEndEntity.id());
-            Entity *entity = nodeManagers.renderNodesManager()->data(renderNodeHandle);
-            entity->setNodeManagers(&nodeManagers);
-            entity->setHandle(renderNodeHandle);
-            entity->setRenderer(&renderer);
-            entity->syncFromFrontEnd(&frontEndEntity, true);
-            return entity;
-        };
-
-        auto backendA = entityCreator(frontendEntityA);
-        auto backendB = entityCreator(frontendEntityB);
-        auto backendC = entityCreator(frontendEntityC);
+        auto backendA = createEntity(renderer, nodeManagers, frontendEntityA);
+        auto backendB = createEntity(renderer, nodeManagers, frontendEntityB);
+        auto backendC = createEntity(renderer, nodeManagers, frontendEntityC);
 
         auto sendParentChange = [&nodeManagers](const Qt3DCore::QEntity &entity) {
             Entity *backendEntity = nodeManagers.renderNodesManager()->getOrCreateResource(entity.id());
@@ -519,14 +519,6 @@ private slots:
         frontendEntityC.setParent(&frontendEntityB);
         sendParentChange(frontendEntityC);
 
-        auto rebuildHierarchy = [](Entity *backend) {
-            backend->clearEntityHierarchy();
-            backend->rebuildEntityHierarchy();
-        };
-        rebuildHierarchy(backendA);
-        rebuildHierarchy(backendB);
-        rebuildHierarchy(backendC);
-
        // WHEN
        CompleteVisitor v1(&nodeManagers);
        EnabledVisitor v2(&nodeManagers);
@@ -553,19 +545,9 @@ private slots:
         frontendEntityB.setEnabled(false);
         frontendEntityC.setEnabled(false);
 
-        auto entityCreator = [&nodeManagers, &renderer](const Qt3DCore::QEntity &frontEndEntity) {
-            HEntity renderNodeHandle = nodeManagers.renderNodesManager()->getOrAcquireHandle(frontEndEntity.id());
-            Entity *entity = nodeManagers.renderNodesManager()->data(renderNodeHandle);
-            entity->setNodeManagers(&nodeManagers);
-            entity->setHandle(renderNodeHandle);
-            entity->setRenderer(&renderer);
-            entity->syncFromFrontEnd(&frontEndEntity, true);
-            return entity;
-        };
-
-        auto backendA = entityCreator(frontendEntityA);
-        auto backendB = entityCreator(frontendEntityB);
-        auto backendC = entityCreator(frontendEntityC);
+        auto backendA = createEntity(renderer, nodeManagers, frontendEntityA);
+        auto backendB = createEntity(renderer, nodeManagers, frontendEntityB);
+        auto backendC = createEntity(renderer, nodeManagers, frontendEntityC);
 
         auto sendParentChange = [&nodeManagers](const Qt3DCore::QEntity &entity) {
             Entity *backendEntity = nodeManagers.renderNodesManager()->getOrCreateResource(entity.id());
@@ -578,14 +560,6 @@ private slots:
         frontendEntityC.setParent(&frontendEntityB);
         sendParentChange(frontendEntityC);
 
-        auto rebuildHierarchy = [](Entity *backend) {
-            backend->clearEntityHierarchy();
-            backend->rebuildEntityHierarchy();
-        };
-        rebuildHierarchy(backendA);
-        rebuildHierarchy(backendB);
-        rebuildHierarchy(backendC);
-
         // WHEN
         EntityAccumulator v1(&nodeManagers);
         EntityAccumulator v2([](Entity *e) { return e->isEnabled(); }, &nodeManagers);
@@ -596,6 +570,18 @@ private slots:
         QCOMPARE(r1.count(), 3);
         QCOMPARE(r2.count(), 0);
     }
+
+private:
+    Entity *createEntity(TestRenderer &renderer, NodeManagers &nodeManagers, const Qt3DCore::QEntity &frontEndEntity) {
+        HEntity renderNodeHandle = nodeManagers.renderNodesManager()->getOrAcquireHandle(frontEndEntity.id());
+        Entity *entity = nodeManagers.renderNodesManager()->data(renderNodeHandle);
+        entity->setNodeManagers(&nodeManagers);
+        entity->setHandle(renderNodeHandle);
+        entity->setRenderer(&renderer);
+        entity->syncFromFrontEnd(&frontEndEntity, true);
+        return entity;
+    }
+
 };
 
 QTEST_APPLESS_MAIN(tst_RenderEntity)
diff --git a/tests/auto/render/framegraphnode/framegraphnode.pro b/tests/auto/render/framegraphnode/framegraphnode.pro
index 577bc9775..f47fc1866 100644
--- a/tests/auto/render/framegraphnode/framegraphnode.pro
+++ b/tests/auto/render/framegraphnode/framegraphnode.pro
@@ -8,3 +8,4 @@ CONFIG += testcase
 SOURCES += tst_framegraphnode.cpp
 
 include(../commons/commons.pri)
+include(../../core/common/common.pri)
diff --git a/tests/auto/render/framegraphnode/tst_framegraphnode.cpp b/tests/auto/render/framegraphnode/tst_framegraphnode.cpp
index 22bd872dc..4ad1ce6f5 100644
--- a/tests/auto/render/framegraphnode/tst_framegraphnode.cpp
+++ b/tests/auto/render/framegraphnode/tst_framegraphnode.cpp
@@ -33,6 +33,7 @@
 #include <Qt3DCore/qpropertyupdatedchange.h>
 #include <Qt3DCore/private/qnodecreatedchangegenerator_p.h>
 #include "testrenderer.h"
+#include "qbackendnodetester.h"
 
 class MyFrameGraphNode : public Qt3DRender::Render::FrameGraphNode
 {
@@ -52,12 +53,12 @@ public:
     {}
 };
 
-class tst_FrameGraphNode : public QObject
+class tst_FrameGraphNode : public  Qt3DCore::QBackendNodeTester
 {
     Q_OBJECT
 public:
     tst_FrameGraphNode(QObject *parent = nullptr)
-        : QObject(parent)
+        : Qt3DCore::QBackendNodeTester(parent)
     {}
 
     ~tst_FrameGraphNode()
@@ -216,10 +217,9 @@ private Q_SLOTS:
     void checkSceneChangeEvents()
     {
         // GIVEN
-        const Qt3DCore::QNodeId fgNode1Id = Qt3DCore::QNodeId::createId();
-
-        Qt3DRender::Render::FrameGraphNode *backendFGNode = new MyFrameGraphNode();
+        Qt3DRender::QFrameGraphNode *frontendFGNode = new MyQFrameGraphNode();
         Qt3DRender::QFrameGraphNode *frontendFGChild = new MyQFrameGraphNode();
+        Qt3DRender::Render::FrameGraphNode *backendFGNode = new MyFrameGraphNode();
         Qt3DRender::Render::FrameGraphNode *backendFGChild = new MyFrameGraphNode();
 
         QScopedPointer<Qt3DRender::Render::FrameGraphManager> manager(new Qt3DRender::Render::FrameGraphManager());
@@ -229,44 +229,41 @@ private Q_SLOTS:
         backendFGNode->setRenderer(&renderer);
         backendFGChild->setRenderer(&renderer);
 
-        setIdInternal(backendFGNode, fgNode1Id);
+        setIdInternal(backendFGNode, frontendFGNode->id());
         setIdInternal(backendFGChild, frontendFGChild->id());
 
-        manager->appendNode(fgNode1Id, backendFGNode);
+        manager->appendNode(frontendFGNode->id(), backendFGNode);
         manager->appendNode(frontendFGChild->id(), backendFGChild);
 
         backendFGNode->setFrameGraphManager(manager.data());
         backendFGChild->setFrameGraphManager(manager.data());
 
-
-        // To geneate the type_info in the QNodePrivate of frontendFGChild
-        Qt3DCore::QNodeCreatedChangeGenerator generator(frontendFGChild);
+        simulateInitializationSync(frontendFGNode, backendFGNode);
+        simulateInitializationSync(frontendFGChild, backendFGChild);
 
         QCOMPARE(backendFGNode->childrenIds().size(), 0);
 
         {
             // WHEN
-            renderer.clearDirtyBits(0);
-            const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(frontendFGChild->id());
-            change->setPropertyName("parentFrameGraphUpdated");
-            change->setValue(QVariant::fromValue(fgNode1Id));
-            backendFGChild->sceneChangeEvent(change);
+            renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty);
+            frontendFGChild->setParent(frontendFGNode);
+            backendFGChild->syncFromFrontEnd(frontendFGChild, false);
 
             // THEN
             QCOMPARE(backendFGNode->childrenIds().size(), 1);
-            QCOMPARE(backendFGChild->parentId(), fgNode1Id);
+            QCOMPARE(backendFGChild->parentId(), frontendFGNode->id());
+            QVERIFY(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::FrameGraphDirty);
         }
         {
             // WHEN
-            renderer.clearDirtyBits(0);
-            const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(frontendFGChild->id());
-            change->setPropertyName("parentFrameGraphUpdated");
-            change->setValue(QVariant::fromValue(Qt3DCore::QNodeId()));
-            backendFGChild->sceneChangeEvent(change);
+            renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty);
+            frontendFGChild->setParent(Q_NODE_NULLPTR);
+            backendFGChild->syncFromFrontEnd(frontendFGChild, false);
 
             // THEN
             QCOMPARE(backendFGNode->childrenIds().size(), 0);
             QVERIFY(backendFGChild->parentId().isNull());
+            QVERIFY(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::FrameGraphDirty);
         }
     }
 
diff --git a/tests/auto/render/layerfiltering/tst_layerfiltering.cpp b/tests/auto/render/layerfiltering/tst_layerfiltering.cpp
index 8c72829e0..255ff5ea8 100644
--- a/tests/auto/render/layerfiltering/tst_layerfiltering.cpp
+++ b/tests/auto/render/layerfiltering/tst_layerfiltering.cpp
@@ -33,7 +33,6 @@
 #include <Qt3DRender/private/entity_p.h>
 #include <Qt3DRender/private/filterlayerentityjob_p.h>
 #include <Qt3DRender/private/updatetreeenabledjob_p.h>
-#include <Qt3DRender/private/updateentityhierarchyjob_p.h>
 #include <Qt3DRender/qlayer.h>
 #include <Qt3DRender/qlayerfilter.h>
 #include "testaspect.h"
@@ -634,10 +633,6 @@ private Q_SLOTS:
         // WHEN
         Qt3DRender::Render::Entity *backendRoot = aspect->nodeManagers()->renderNodesManager()->getOrCreateResource(entitySubtree->id());
 
-        Qt3DRender::Render::UpdateEntityHierarchyJob updateEntitiesJob;
-        updateEntitiesJob.setManager(aspect->nodeManagers());
-        updateEntitiesJob.run();
-
         Qt3DRender::Render::UpdateTreeEnabledJob updateTreeEnabledJob;
         updateTreeEnabledJob.setRoot(backendRoot);
         updateTreeEnabledJob.setManagers(aspect->nodeManagers());
diff --git a/tests/auto/render/memorybarrier/tst_memorybarrier.cpp b/tests/auto/render/memorybarrier/tst_memorybarrier.cpp
index 71cf3f567..708659e4e 100644
--- a/tests/auto/render/memorybarrier/tst_memorybarrier.cpp
+++ b/tests/auto/render/memorybarrier/tst_memorybarrier.cpp
@@ -64,7 +64,7 @@ private Q_SLOTS:
             // WHEN
             Qt3DRender::Render::MemoryBarrier backendMemoryBarrier;
             backendMemoryBarrier.setRenderer(&renderer);
-            simulateInitialization(&memoryBarrier, &backendMemoryBarrier);
+            simulateInitializationSync(&memoryBarrier, &backendMemoryBarrier);
 
             // THEN
             QCOMPARE(backendMemoryBarrier.isEnabled(), true);
@@ -78,7 +78,7 @@ private Q_SLOTS:
             Qt3DRender::Render::MemoryBarrier backendMemoryBarrier;
             backendMemoryBarrier.setRenderer(&renderer);
             memoryBarrier.setEnabled(false);
-            simulateInitialization(&memoryBarrier, &backendMemoryBarrier);
+            simulateInitializationSync(&memoryBarrier, &backendMemoryBarrier);
 
             // THEN
             QCOMPARE(backendMemoryBarrier.peerId(), memoryBarrier.id());
@@ -93,14 +93,15 @@ private Q_SLOTS:
         Qt3DRender::Render::MemoryBarrier backendMemoryBarrier;
         TestRenderer renderer;
         backendMemoryBarrier.setRenderer(&renderer);
+        Qt3DRender::QMemoryBarrier memoryBarrier;
+
+        simulateInitializationSync(&memoryBarrier, &backendMemoryBarrier);
 
         {
              // WHEN
              const bool newValue = false;
-             const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-             change->setPropertyName("enabled");
-             change->setValue(newValue);
-             backendMemoryBarrier.sceneChangeEvent(change);
+             memoryBarrier.setEnabled(newValue);
+             backendMemoryBarrier.syncFromFrontEnd(&memoryBarrier, false);
 
              // THEN
             QCOMPARE(backendMemoryBarrier.isEnabled(), newValue);
@@ -110,10 +111,8 @@ private Q_SLOTS:
         {
              // WHEN
              const Qt3DRender::QMemoryBarrier::Operations newValue(Qt3DRender::QMemoryBarrier::AtomicCounter|Qt3DRender::QMemoryBarrier::ElementArray);
-             const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-             change->setPropertyName("waitOperations");
-             change->setValue(QVariant::fromValue(newValue));
-             backendMemoryBarrier.sceneChangeEvent(change);
+             memoryBarrier.setWaitOperations(newValue);
+             backendMemoryBarrier.syncFromFrontEnd(&memoryBarrier, false);
 
              // THEN
             QCOMPARE(backendMemoryBarrier.waitOperations(), newValue);
diff --git a/tests/auto/render/pickboundingvolumejob/tst_pickboundingvolumejob.cpp b/tests/auto/render/pickboundingvolumejob/tst_pickboundingvolumejob.cpp
index a8ffa9712..1fbdc4d04 100644
--- a/tests/auto/render/pickboundingvolumejob/tst_pickboundingvolumejob.cpp
+++ b/tests/auto/render/pickboundingvolumejob/tst_pickboundingvolumejob.cpp
@@ -48,7 +48,6 @@
 #include <Qt3DRender/private/qrenderaspect_p.h>
 #include <Qt3DRender/private/pickboundingvolumejob_p.h>
 #include <Qt3DRender/private/pickboundingvolumeutils_p.h>
-#include <Qt3DRender/private/updateentityhierarchyjob_p.h>
 #include <Qt3DRender/private/updatemeshtrianglelistjob_p.h>
 #include <Qt3DRender/private/updateworldboundingvolumejob_p.h>
 #include <Qt3DRender/private/updateworldtransformjob_p.h>
@@ -150,10 +149,6 @@ namespace {
 
 void runRequiredJobs(Qt3DRender::TestAspect *test)
 {
-    Qt3DRender::Render::UpdateEntityHierarchyJob updateEntitiesJob;
-    updateEntitiesJob.setManager(test->nodeManagers());
-    updateEntitiesJob.run();
-
     Qt3DRender::Render::UpdateWorldTransformJob updateWorldTransform;
     updateWorldTransform.setRoot(test->sceneRoot());
     updateWorldTransform.setManagers(test->nodeManagers());
diff --git a/tests/auto/render/proximityfilter/tst_proximityfilter.cpp b/tests/auto/render/proximityfilter/tst_proximityfilter.cpp
index c1f1e8ec4..88059e31a 100644
--- a/tests/auto/render/proximityfilter/tst_proximityfilter.cpp
+++ b/tests/auto/render/proximityfilter/tst_proximityfilter.cpp
@@ -66,7 +66,7 @@ private Q_SLOTS:
             // WHEN
             Qt3DRender::Render::ProximityFilter backendProximityFilter;
             backendProximityFilter.setRenderer(&renderer);
-            simulateInitialization(&proximityFilter, &backendProximityFilter);
+            simulateInitializationSync(&proximityFilter, &backendProximityFilter);
 
             // THEN
             QCOMPARE(backendProximityFilter.isEnabled(), true);
@@ -81,7 +81,7 @@ private Q_SLOTS:
             Qt3DRender::Render::ProximityFilter backendProximityFilter;
             backendProximityFilter.setRenderer(&renderer);
             proximityFilter.setEnabled(false);
-            simulateInitialization(&proximityFilter, &backendProximityFilter);
+            simulateInitializationSync(&proximityFilter, &backendProximityFilter);
 
             // THEN
             QCOMPARE(backendProximityFilter.peerId(), proximityFilter.id());
@@ -93,17 +93,17 @@ private Q_SLOTS:
     void checkSceneChangeEvents()
     {
         // GIVEN
+        Qt3DRender::QProximityFilter proximityFilter;
         Qt3DRender::Render::ProximityFilter backendProximityFilter;
         TestRenderer renderer;
         backendProximityFilter.setRenderer(&renderer);
+        simulateInitializationSync(&proximityFilter, &backendProximityFilter);
 
         {
              // WHEN
              const bool newValue = false;
-             const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-             change->setPropertyName("enabled");
-             change->setValue(newValue);
-             backendProximityFilter.sceneChangeEvent(change);
+             proximityFilter.setEnabled(newValue);
+             backendProximityFilter.syncFromFrontEnd(&proximityFilter, &backendProximityFilter);
 
              // THEN
             QCOMPARE(backendProximityFilter.isEnabled(), newValue);
@@ -113,10 +113,9 @@ private Q_SLOTS:
         {
              // WHEN
              const float newValue = 383.0f;
-             const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-             change->setPropertyName("distanceThreshold");
-             change->setValue(QVariant::fromValue(newValue));
-             backendProximityFilter.sceneChangeEvent(change);
+             proximityFilter.setDistanceThreshold(newValue);
+             backendProximityFilter.syncFromFrontEnd(&proximityFilter, &backendProximityFilter);
+
 
              // THEN
             QCOMPARE(backendProximityFilter.distanceThreshold(), newValue);
@@ -125,14 +124,12 @@ private Q_SLOTS:
         }
         {
              // WHEN
-             const Qt3DCore::QNodeId newValue = Qt3DCore::QNodeId::createId();
-             const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-             change->setPropertyName("entity");
-             change->setValue(QVariant::fromValue(newValue));
-             backendProximityFilter.sceneChangeEvent(change);
+             Qt3DCore::QEntity e;
+             proximityFilter.setEntity(&e);
+             backendProximityFilter.syncFromFrontEnd(&proximityFilter, &backendProximityFilter);
 
              // THEN
-            QCOMPARE(backendProximityFilter.entityId(), newValue);
+            QCOMPARE(backendProximityFilter.entityId(), e.id());
             QVERIFY(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::FrameGraphDirty);
             renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty);
         }
diff --git a/tests/auto/render/proximityfiltering/tst_proximityfiltering.cpp b/tests/auto/render/proximityfiltering/tst_proximityfiltering.cpp
index c8d862b2e..07adf12b5 100644
--- a/tests/auto/render/proximityfiltering/tst_proximityfiltering.cpp
+++ b/tests/auto/render/proximityfiltering/tst_proximityfiltering.cpp
@@ -247,10 +247,6 @@ private Q_SLOTS:
         // WHEN
         Qt3DRender::Render::Entity *backendRoot = aspect->nodeManagers()->renderNodesManager()->getOrCreateResource(entitySubtree->id());
 
-        Qt3DRender::Render::UpdateEntityHierarchyJob updateEntitiesJob;
-        updateEntitiesJob.setManager(aspect->nodeManagers());
-        updateEntitiesJob.run();
-
         Qt3DRender::Render::UpdateTreeEnabledJob updateTreeEnabledJob;
         updateTreeEnabledJob.setRoot(backendRoot);
         updateTreeEnabledJob.setManagers(aspect->nodeManagers());
diff --git a/tests/auto/render/qcamera/tst_qcamera.cpp b/tests/auto/render/qcamera/tst_qcamera.cpp
index 4d424a420..229dff565 100644
--- a/tests/auto/render/qcamera/tst_qcamera.cpp
+++ b/tests/auto/render/qcamera/tst_qcamera.cpp
@@ -34,7 +34,6 @@
 #include <qbackendnodetester.h>
 
 #include <Qt3DCore/QEntity>
-#include <Qt3DRender/private/updateentityhierarchyjob_p.h>
 #include <Qt3DCore/private/qaspectjobmanager_p.h>
 #include <Qt3DCore/private/qnodevisitor_p.h>
 #include <Qt3DCore/qpropertyupdatedchange.h>
@@ -141,10 +140,6 @@ namespace {
 
 void runRequiredJobs(Qt3DRender::TestAspect *test)
 {
-    Qt3DRender::Render::UpdateEntityHierarchyJob updateEntitiesJob;
-    updateEntitiesJob.setManager(test->nodeManagers());
-    updateEntitiesJob.run();
-
     Qt3DRender::Render::UpdateWorldTransformJob updateWorldTransform;
     updateWorldTransform.setRoot(test->sceneRoot());
     updateWorldTransform.setManagers(test->nodeManagers());
diff --git a/tests/auto/render/qlayerfilter/tst_qlayerfilter.cpp b/tests/auto/render/qlayerfilter/tst_qlayerfilter.cpp
index c7686bae2..4bc766b58 100644
--- a/tests/auto/render/qlayerfilter/tst_qlayerfilter.cpp
+++ b/tests/auto/render/qlayerfilter/tst_qlayerfilter.cpp
@@ -119,14 +119,11 @@ private Q_SLOTS:
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        auto addChange = arbiter.events.first().staticCast<Qt3DCore::QPropertyNodeAddedChange>();
-        QCOMPARE(addChange->propertyName(), "layer");
-        QCOMPARE(addChange->subjectId(), layerFilter->id());
-        QCOMPARE(addChange->addedNodeId(), layerFilter->layers().at(0)->id());
-        QCOMPARE(addChange->type(), Qt3DCore::PropertyValueAdded);
+        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QVERIFY(arbiter.dirtyNodes.contains(layerFilter.data()));
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
 
         // WHEN
         layer = new Qt3DRender::QLayer(layerFilter.data());
@@ -135,14 +132,11 @@ private Q_SLOTS:
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        addChange = arbiter.events.first().staticCast<Qt3DCore::QPropertyNodeAddedChange>();
-        QCOMPARE(addChange->propertyName(), "layer");
-        QCOMPARE(addChange->subjectId(), layerFilter->id());
-        QCOMPARE(addChange->addedNodeId(), layerFilter->layers().at(1)->id());
-        QCOMPARE(addChange->type(), Qt3DCore::PropertyValueAdded);
+        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QVERIFY(arbiter.dirtyNodes.contains(layerFilter.data()));
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
 
         // WHEN
         layer = layerFilter->layers().at(0);
@@ -150,14 +144,11 @@ private Q_SLOTS:
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        auto removeChange = arbiter.events.first().staticCast<Qt3DCore::QPropertyNodeRemovedChange>();
-        QCOMPARE(removeChange->propertyName(), "layer");
-        QCOMPARE(removeChange->subjectId(), layerFilter->id());
-        QCOMPARE(removeChange->removedNodeId(), layer->id());
-        QCOMPARE(removeChange->type(), Qt3DCore::PropertyValueRemoved);
-
-        arbiter.events.clear();
+        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QVERIFY(arbiter.dirtyNodes.contains(layerFilter.data()));
+
+        arbiter.dirtyNodes.clear();
     }
 
     void checkLayerBookkeeping()
diff --git a/tests/auto/render/qrendercapture/tst_qrendercapture.cpp b/tests/auto/render/qrendercapture/tst_qrendercapture.cpp
index 2fab1e837..b9cb2230f 100644
--- a/tests/auto/render/qrendercapture/tst_qrendercapture.cpp
+++ b/tests/auto/render/qrendercapture/tst_qrendercapture.cpp
@@ -72,17 +72,11 @@ private Q_SLOTS:
         QScopedPointer<Qt3DRender::QRenderCaptureReply> reply(renderCapture->requestCapture(QRect(10, 15, 20, 50)));
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        Qt3DCore::QPropertyUpdatedChangePtr change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "renderCaptureRequest");
-        QCOMPARE(change->subjectId(),renderCapture->id());
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
-        QVERIFY(change->value().canConvert<Qt3DRender::QRenderCaptureRequest>());
-        const Qt3DRender::QRenderCaptureRequest request = change->value().value<Qt3DRender::QRenderCaptureRequest>();
-        QCOMPARE(request.captureId, 1);
-        QCOMPARE(request.rect, QRect(10, 15, 20, 50));
-
-        arbiter.events.clear();
+        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), renderCapture.data());
+
+        arbiter.dirtyNodes.clear();
     }
 
     void checkRenderCaptureReply()
diff --git a/tests/auto/render/qrenderpassfilter/tst_qrenderpassfilter.cpp b/tests/auto/render/qrenderpassfilter/tst_qrenderpassfilter.cpp
index 23544c0c6..f08846ba3 100644
--- a/tests/auto/render/qrenderpassfilter/tst_qrenderpassfilter.cpp
+++ b/tests/auto/render/qrenderpassfilter/tst_qrenderpassfilter.cpp
@@ -154,14 +154,11 @@ private Q_SLOTS:
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        Qt3DCore::QPropertyNodeAddedChangePtr change = arbiter.events.first().staticCast<Qt3DCore::QPropertyNodeAddedChange>();
-        QCOMPARE(change->propertyName(), "parameter");
-        QCOMPARE(change->subjectId(),renderPassFilter->id());
-        QCOMPARE(change->addedNodeId(), param1->id());
-        QCOMPARE(change->type(), Qt3DCore::PropertyValueAdded);
+        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QVERIFY(arbiter.dirtyNodes.contains(renderPassFilter.data()));
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
 
         // WHEN
         renderPassFilter->addParameter(param1);
@@ -169,20 +166,18 @@ private Q_SLOTS:
 
         // THEN
         QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 0);
 
         // WHEN
         renderPassFilter->removeParameter(param1);
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        Qt3DCore::QPropertyNodeRemovedChangePtr nodeRemovedChange = arbiter.events.first().staticCast<Qt3DCore::QPropertyNodeRemovedChange>();
-        QCOMPARE(nodeRemovedChange->propertyName(), "parameter");
-        QCOMPARE(nodeRemovedChange->subjectId(), renderPassFilter->id());
-        QCOMPARE(nodeRemovedChange->removedNodeId(), param1->id());
-        QCOMPARE(nodeRemovedChange->type(), Qt3DCore::PropertyValueRemoved);
+        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QVERIFY(arbiter.dirtyNodes.contains(renderPassFilter.data()));
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
 
         // WHEN
         Qt3DRender::QFilterKey *filterKey1 = new Qt3DRender::QFilterKey();
@@ -190,14 +185,11 @@ private Q_SLOTS:
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        change = arbiter.events.first().staticCast<Qt3DCore::QPropertyNodeAddedChange>();
-        QCOMPARE(change->propertyName(), "match");
-        QCOMPARE(change->subjectId(),renderPassFilter->id());
-        QCOMPARE(change->addedNodeId(), filterKey1->id());
-        QCOMPARE(change->type(), Qt3DCore::PropertyValueAdded);
+        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QVERIFY(arbiter.dirtyNodes.contains(renderPassFilter.data()));
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
 
         // WHEN
         renderPassFilter->addMatch(filterKey1);
@@ -205,20 +197,18 @@ private Q_SLOTS:
 
         // THEN
         QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 0);
 
         // WHEN
         renderPassFilter->removeMatch(filterKey1);
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        nodeRemovedChange = arbiter.events.first().staticCast<Qt3DCore::QPropertyNodeRemovedChange>();
-        QCOMPARE(nodeRemovedChange->propertyName(), "match");
-        QCOMPARE(nodeRemovedChange->subjectId(), renderPassFilter->id());
-        QCOMPARE(nodeRemovedChange->removedNodeId(), filterKey1->id());
-        QCOMPARE(nodeRemovedChange->type(), Qt3DCore::PropertyValueRemoved);
-
-        arbiter.events.clear();
+        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QVERIFY(arbiter.dirtyNodes.contains(renderPassFilter.data()));
+
+        arbiter.dirtyNodes.clear();
     }
 
     void checkParameterBookkeeping()
diff --git a/tests/auto/render/qrenderstateset/tst_qrenderstateset.cpp b/tests/auto/render/qrenderstateset/tst_qrenderstateset.cpp
index 6b200d19d..9eb97ce93 100644
--- a/tests/auto/render/qrenderstateset/tst_qrenderstateset.cpp
+++ b/tests/auto/render/qrenderstateset/tst_qrenderstateset.cpp
@@ -140,14 +140,11 @@ private Q_SLOTS:
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        Qt3DCore::QPropertyNodeAddedChangePtr change = arbiter.events.first().staticCast<Qt3DCore::QPropertyNodeAddedChange>();
-        QCOMPARE(change->propertyName(), "renderState");
-        QCOMPARE(change->subjectId(), stateSet->id());
-        QCOMPARE(change->addedNodeId(), state1->id());
-        QCOMPARE(change->type(), Qt3DCore::PropertyValueAdded);
+        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QVERIFY(arbiter.dirtyNodes.contains(stateSet.data()));
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
 
         // WHEN
         stateSet->addRenderState(state1);
@@ -155,20 +152,17 @@ private Q_SLOTS:
 
         // THEN
         QCOMPARE(arbiter.events.size(), 0);
-
+        QCOMPARE(arbiter.dirtyNodes.size(), 0);
         // WHEN
         stateSet->removeRenderState(state1);
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        Qt3DCore::QPropertyNodeRemovedChangePtr nodeRemovedChange = arbiter.events.first().staticCast<Qt3DCore::QPropertyNodeRemovedChange>();
-        QCOMPARE(nodeRemovedChange->propertyName(), "renderState");
-        QCOMPARE(nodeRemovedChange->subjectId(), stateSet->id());
-        QCOMPARE(nodeRemovedChange->removedNodeId(), state1->id());
-        QCOMPARE(nodeRemovedChange->type(), Qt3DCore::PropertyValueRemoved);
-
-        arbiter.events.clear();
+        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QVERIFY(arbiter.dirtyNodes.contains(stateSet.data()));
+
+        arbiter.dirtyNodes.clear();
     }
 
     void checkRenderStateBookkeeping()
diff --git a/tests/auto/render/qrendertargetselector/tst_qrendertargetselector.cpp b/tests/auto/render/qrendertargetselector/tst_qrendertargetselector.cpp
index f525f1254..7bacc3b6d 100644
--- a/tests/auto/render/qrendertargetselector/tst_qrendertargetselector.cpp
+++ b/tests/auto/render/qrendertargetselector/tst_qrendertargetselector.cpp
@@ -149,14 +149,11 @@ private Q_SLOTS:
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "outputs");
-        QCOMPARE(change->subjectId(), renderTargetSelector->id());
-        QCOMPARE(change->value().value<QVector<Qt3DRender::QRenderTargetOutput::AttachmentPoint> >(), outputs);
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), renderTargetSelector.data());
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
 
         // WHEN
         renderTargetSelector->setOutputs(outputs);
@@ -164,20 +161,18 @@ private Q_SLOTS:
 
         // THEN
         QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 0);
 
         // WHEN
         renderTargetSelector->setOutputs(QVector<Qt3DRender::QRenderTargetOutput::AttachmentPoint>());
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "outputs");
-        QCOMPARE(change->subjectId(), renderTargetSelector->id());
-        QCOMPARE(change->value().value<QVector<Qt3DRender::QRenderTargetOutput::AttachmentPoint> >(), QVector<Qt3DRender::QRenderTargetOutput::AttachmentPoint>());
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
-
-        arbiter.events.clear();
+        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), renderTargetSelector.data());
+
+        arbiter.dirtyNodes.clear();
     }
 
     void checkRenderTargetBookkeeping()
diff --git a/tests/auto/render/qtechniquefilter/tst_qtechniquefilter.cpp b/tests/auto/render/qtechniquefilter/tst_qtechniquefilter.cpp
index 4f6daae8c..648fbd5ce 100644
--- a/tests/auto/render/qtechniquefilter/tst_qtechniquefilter.cpp
+++ b/tests/auto/render/qtechniquefilter/tst_qtechniquefilter.cpp
@@ -159,14 +159,11 @@ private Q_SLOTS:
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        Qt3DCore::QPropertyNodeAddedChangePtr nodeAddedChange = arbiter.events.first().staticCast<Qt3DCore::QPropertyNodeAddedChange>();
-        QCOMPARE(nodeAddedChange->propertyName(), "parameter");
-        QCOMPARE(nodeAddedChange->subjectId(),techniqueFilter->id());
-        QCOMPARE(nodeAddedChange->addedNodeId(), param1->id());
-        QCOMPARE(nodeAddedChange->type(), Qt3DCore::PropertyValueAdded);
+        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), techniqueFilter.data());
+        arbiter.dirtyNodes.clear();
 
-        arbiter.events.clear();
 
         // WHEN
         techniqueFilter->addParameter(param1);
@@ -174,20 +171,17 @@ private Q_SLOTS:
 
         // THEN
         QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 0);
 
         // WHEN
         techniqueFilter->removeParameter(param1);
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        Qt3DCore::QPropertyNodeRemovedChangePtr nodeRemovedChange = arbiter.events.first().staticCast<Qt3DCore::QPropertyNodeRemovedChange>();
-        QCOMPARE(nodeRemovedChange->propertyName(), "parameter");
-        QCOMPARE(nodeRemovedChange->subjectId(), techniqueFilter->id());
-        QCOMPARE(nodeRemovedChange->removedNodeId(), param1->id());
-        QCOMPARE(nodeRemovedChange->type(), Qt3DCore::PropertyValueRemoved);
-
-        arbiter.events.clear();
+        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), techniqueFilter.data());
+        arbiter.dirtyNodes.clear();
 
         // WHEN
         Qt3DRender::QFilterKey *filterKey1 = new Qt3DRender::QFilterKey();
@@ -195,14 +189,10 @@ private Q_SLOTS:
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        nodeAddedChange = arbiter.events.first().staticCast<Qt3DCore::QPropertyNodeAddedChange>();
-        QCOMPARE(nodeAddedChange->propertyName(), "matchAll");
-        QCOMPARE(nodeAddedChange->subjectId(),techniqueFilter->id());
-        QCOMPARE(nodeAddedChange->addedNodeId(), filterKey1->id());
-        QCOMPARE(nodeAddedChange->type(), Qt3DCore::PropertyValueAdded);
-
-        arbiter.events.clear();
+        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), techniqueFilter.data());
+        arbiter.dirtyNodes.clear();
 
         // WHEN
         techniqueFilter->addMatch(filterKey1);
@@ -210,20 +200,17 @@ private Q_SLOTS:
 
         // THEN
         QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 0);
 
         // WHEN
         techniqueFilter->removeMatch(filterKey1);
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        nodeRemovedChange = arbiter.events.first().staticCast<Qt3DCore::QPropertyNodeRemovedChange>();
-        QCOMPARE(nodeRemovedChange->propertyName(), "matchAll");
-        QCOMPARE(nodeRemovedChange->subjectId(), techniqueFilter->id());
-        QCOMPARE(nodeRemovedChange->removedNodeId(), filterKey1->id());
-        QCOMPARE(nodeRemovedChange->type(), Qt3DCore::PropertyValueRemoved);
-
-        arbiter.events.clear();
+        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), techniqueFilter.data());
+        arbiter.dirtyNodes.clear();
     }
 
     void checkParameterBookkeeping()
diff --git a/tests/auto/render/raycastingjob/tst_raycastingjob.cpp b/tests/auto/render/raycastingjob/tst_raycastingjob.cpp
index bc4f2910e..e45ec704e 100644
--- a/tests/auto/render/raycastingjob/tst_raycastingjob.cpp
+++ b/tests/auto/render/raycastingjob/tst_raycastingjob.cpp
@@ -52,7 +52,6 @@
 #include <Qt3DRender/private/updateworldtransformjob_p.h>
 #include <Qt3DRender/private/expandboundingvolumejob_p.h>
 #include <Qt3DRender/private/calcboundingvolumejob_p.h>
-#include <Qt3DRender/private/updateentityhierarchyjob_p.h>
 #include <Qt3DRender/private/calcgeometrytrianglevolumes_p.h>
 #include <Qt3DRender/private/loadbufferjob_p.h>
 #include <Qt3DRender/private/buffermanager_p.h>
@@ -147,10 +146,6 @@ namespace {
 
 void runRequiredJobs(Qt3DRender::TestAspect *test)
 {
-    Qt3DRender::Render::UpdateEntityHierarchyJob updateEntitiesJob;
-    updateEntitiesJob.setManager(test->nodeManagers());
-    updateEntitiesJob.run();
-
     Qt3DRender::Render::UpdateWorldTransformJob updateWorldTransform;
     updateWorldTransform.setRoot(test->sceneRoot());
     updateWorldTransform.setManagers(test->nodeManagers());
diff --git a/tests/auto/render/rendercapture/tst_rendercapture.cpp b/tests/auto/render/rendercapture/tst_rendercapture.cpp
index 78b792b01..194c5cd24 100644
--- a/tests/auto/render/rendercapture/tst_rendercapture.cpp
+++ b/tests/auto/render/rendercapture/tst_rendercapture.cpp
@@ -49,7 +49,7 @@ private Q_SLOTS:
 
         // WHEN
         backend.setRenderer(&renderer);
-        simulateInitialization(&frontend, &backend);
+        simulateInitializationSync(&frontend, &backend);
 
         // THEN
         QVERIFY(!backend.peerId().isNull());
@@ -61,34 +61,33 @@ private Q_SLOTS:
     void checkEnabledPropertyChange()
     {
         // GIVEN
+        Qt3DRender::QRenderCapture frontend;
         Qt3DRender::Render::RenderCapture renderCapture;
         TestRenderer renderer;
         renderCapture.setRenderer(&renderer);
+        simulateInitializationSync(&frontend, &renderCapture);
 
         // WHEN
-        Qt3DCore::QPropertyUpdatedChangePtr change(new Qt3DCore::QPropertyUpdatedChange(renderCapture.peerId()));
-        change->setPropertyName(QByteArrayLiteral("enabled"));
-        change->setValue(QVariant::fromValue(true));
-        sceneChangeEvent(&renderCapture, change);
+        frontend.setEnabled(false);
+        renderCapture.syncFromFrontEnd(&frontend, false);
 
         // THEN
-        QCOMPARE(renderCapture.isEnabled(), true);
+        QCOMPARE(renderCapture.isEnabled(), false);
         QVERIFY(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::FrameGraphDirty);
     }
 
     void checkReceiveRenderCaptureRequest()
     {
         // GIVEN
+        Qt3DRender::QRenderCapture frontend;
         Qt3DRender::Render::RenderCapture renderCapture;
         TestRenderer renderer;
         renderCapture.setRenderer(&renderer);
-        renderCapture.setEnabled(true);
+        simulateInitializationSync(&frontend, &renderCapture);
 
         // WHEN
-        Qt3DCore::QPropertyUpdatedChangePtr change(new Qt3DCore::QPropertyUpdatedChange(renderCapture.peerId()));
-        change->setPropertyName(QByteArrayLiteral("renderCaptureRequest"));
-        change->setValue(QVariant::fromValue(32));
-        sceneChangeEvent(&renderCapture, change);
+        frontend.requestCapture();
+        renderCapture.syncFromFrontEnd(&frontend, false);
 
         // THEN
         QCOMPARE(renderCapture.wasCaptureRequested(), true);
diff --git a/tests/auto/render/renderer/tst_renderer.cpp b/tests/auto/render/renderer/tst_renderer.cpp
index a823c233a..973192d6a 100644
--- a/tests/auto/render/renderer/tst_renderer.cpp
+++ b/tests/auto/render/renderer/tst_renderer.cpp
@@ -315,30 +315,6 @@ private Q_SLOTS:
         renderQueue->reset();
 
         // WHEN
-        renderer.markDirty(Qt3DRender::Render::AbstractRenderer::EntityHierarchyDirty, nullptr);
-        jobs = renderer.renderBinJobs();
-
-        // THEN
-        QCOMPARE(jobs.size(),
-                 1 + // EntityEnabledDirty
-                 1 + // EntityHierarchyJob
-                 1 + // WorldTransformJob
-                 1 + // UpdateWorldBoundingVolume
-                 1 + // UpdateShaderDataTransform
-                 1 + // ExpandBoundingVolumeJob
-                 1 + // UpdateEntityLayersJob
-                 1 + // updateLevelOfDetailJob
-                 1 + // syncLoadingJobs
-                 1 + // updateSkinningPaletteJob
-                 1 + // cleanupJob
-                 1 + // sendBufferCaptureJob
-                 singleRenderViewJobCount +
-                 layerCacheJobCount);
-
-        renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty);
-        renderQueue->reset();
-
-        // WHEN
         renderer.markDirty(Qt3DRender::Render::AbstractRenderer::AllDirty, nullptr);
         jobs = renderer.renderBinJobs();
 
@@ -346,7 +322,6 @@ private Q_SLOTS:
         // and ShaderGathererJob are not added here)
         QCOMPARE(jobs.size(),
                  1 + // EntityEnabledDirty
-                 1 + // EntityHierarchyDirty
                  1 + // WorldTransformJob
                  1 + // UpdateWorldBoundingVolume
                  1 + // UpdateShaderDataTransform
diff --git a/tests/auto/render/renderviews/tst_renderviews.cpp b/tests/auto/render/renderviews/tst_renderviews.cpp
index aef1c3657..f38915bf8 100644
--- a/tests/auto/render/renderviews/tst_renderviews.cpp
+++ b/tests/auto/render/renderviews/tst_renderviews.cpp
@@ -119,7 +119,7 @@ private Q_SLOTS:
 
             // WHEN
             frontendBarrier.setWaitOperations(barriers);
-            simulateInitialization(&frontendBarrier, &backendBarrier);
+            simulateInitializationSync(&frontendBarrier, &backendBarrier);
 
             // THEN
             QCOMPARE(renderView.memoryBarrier(), QMemoryBarrier::None);
diff --git a/tests/auto/render/setfence/tst_setfence.cpp b/tests/auto/render/setfence/tst_setfence.cpp
index b70bf548c..92f7a0acc 100644
--- a/tests/auto/render/setfence/tst_setfence.cpp
+++ b/tests/auto/render/setfence/tst_setfence.cpp
@@ -75,7 +75,7 @@ private Q_SLOTS:
             // WHEN
             Qt3DRender::Render::SetFence backendSetFence;
             backendSetFence.setRenderer(&renderer);
-            simulateInitialization(&setFence, &backendSetFence);
+            simulateInitializationSync(&setFence, &backendSetFence);
 
             // THEN
             QCOMPARE(backendSetFence.isEnabled(), true);
@@ -88,7 +88,7 @@ private Q_SLOTS:
             Qt3DRender::Render::SetFence backendSetFence;
             setFence.setEnabled(false);
             backendSetFence.setRenderer(&renderer);
-            simulateInitialization(&setFence, &backendSetFence);
+            simulateInitializationSync(&setFence, &backendSetFence);
 
             // THEN
             QCOMPARE(backendSetFence.peerId(), setFence.id());
@@ -101,16 +101,16 @@ private Q_SLOTS:
     {
         // GIVEN
         Qt3DRender::Render::SetFence backendSetFence;
+        Qt3DRender::QSetFence setFence;
         TestRenderer renderer;
         backendSetFence.setRenderer(&renderer);
+        simulateInitializationSync(&setFence, &backendSetFence);
 
         {
              // WHEN
              const bool newValue = false;
-             const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-             change->setPropertyName("enabled");
-             change->setValue(newValue);
-             backendSetFence.sceneChangeEvent(change);
+             setFence.setEnabled(newValue);
+             backendSetFence.syncFromFrontEnd(&setFence, false);
 
              // THEN
             QCOMPARE(backendSetFence.isEnabled(), newValue);
diff --git a/tests/auto/render/sortpolicy/tst_sortpolicy.cpp b/tests/auto/render/sortpolicy/tst_sortpolicy.cpp
index d79b0b4f7..a4811d82c 100644
--- a/tests/auto/render/sortpolicy/tst_sortpolicy.cpp
+++ b/tests/auto/render/sortpolicy/tst_sortpolicy.cpp
@@ -70,7 +70,7 @@ private Q_SLOTS:
 
         // WHEN
         backendNode.setRenderer(&renderer);
-        simulateInitialization(&sortPolicy, &backendNode);
+        simulateInitializationSync(&sortPolicy, &backendNode);
 
         // THEN
         QCOMPARE(backendNode.peerId(), sortPolicy.id());
@@ -88,15 +88,14 @@ private Q_SLOTS:
         Qt3DRender::Render::SortPolicy backendNode;
         backendNode.setRenderer(&renderer);
 
+        Qt3DRender::QSortPolicy sortPolicy;
+        sortPolicy.setSortTypes(sortTypes);
+
+        simulateInitializationSync(&sortPolicy, &backendNode);
+
         // WHEN
-        auto sortTypeInts = QVector<int>();
-        std::transform(sortTypes.constBegin(), sortTypes.constEnd(),
-                       std::back_inserter(sortTypeInts),
-                       [] (Qt3DRender::QSortPolicy::SortType type) -> int { return type; });
-        Qt3DCore::QPropertyUpdatedChangePtr updateChange(new Qt3DCore::QPropertyUpdatedChange(Qt3DCore::QNodeId()));
-        updateChange->setValue(QVariant::fromValue(sortTypeInts));
-        updateChange->setPropertyName("sortTypes");
-        backendNode.sceneChangeEvent(updateChange);
+        sortPolicy.setSortTypes(sortTypes);
+        backendNode.syncFromFrontEnd(&sortPolicy, false);
 
         // THEN
         QCOMPARE(backendNode.sortTypes(), sortTypes);
diff --git a/tests/auto/render/updateshaderdatatransformjob/tst_updateshaderdatatransformjob.cpp b/tests/auto/render/updateshaderdatatransformjob/tst_updateshaderdatatransformjob.cpp
index 0d900a202..492aa0fde 100644
--- a/tests/auto/render/updateshaderdatatransformjob/tst_updateshaderdatatransformjob.cpp
+++ b/tests/auto/render/updateshaderdatatransformjob/tst_updateshaderdatatransformjob.cpp
@@ -29,7 +29,6 @@
 #include <QtTest/QTest>
 #include <Qt3DRender/private/updateshaderdatatransformjob_p.h>
 #include <Qt3DRender/private/updateworldtransformjob_p.h>
-#include <Qt3DRender/private/updateentityhierarchyjob_p.h>
 #include <Qt3DRender/private/nodemanagers_p.h>
 #include <Qt3DRender/private/managers_p.h>
 #include <Qt3DRender/qrenderaspect.h>
@@ -129,10 +128,6 @@ namespace {
 
 void runRequiredJobs(Qt3DRender::TestAspect *test)
 {
-    Qt3DRender::Render::UpdateEntityHierarchyJob updateEntitiesJob;
-    updateEntitiesJob.setManager(test->nodeManagers());
-    updateEntitiesJob.run();
-
     Qt3DRender::Render::UpdateWorldTransformJob updateWorldTransform;
     updateWorldTransform.setRoot(test->sceneRoot());
     updateWorldTransform.setManagers(test->nodeManagers());
diff --git a/tests/auto/render/waitfence/tst_waitfence.cpp b/tests/auto/render/waitfence/tst_waitfence.cpp
index e8cd4c30b..e27e4ae19 100644
--- a/tests/auto/render/waitfence/tst_waitfence.cpp
+++ b/tests/auto/render/waitfence/tst_waitfence.cpp
@@ -82,7 +82,7 @@ private Q_SLOTS:
             // WHEN
             Qt3DRender::Render::WaitFence backendWaitFence;
             backendWaitFence.setRenderer(&renderer);
-            simulateInitialization(&waitFence, &backendWaitFence);
+            simulateInitializationSync(&waitFence, &backendWaitFence);
 
             // THEN
             QCOMPARE(backendWaitFence.isEnabled(), true);
@@ -99,7 +99,7 @@ private Q_SLOTS:
             Qt3DRender::Render::WaitFence backendWaitFence;
             waitFence.setEnabled(false);
             backendWaitFence.setRenderer(&renderer);
-            simulateInitialization(&waitFence, &backendWaitFence);
+            simulateInitializationSync(&waitFence, &backendWaitFence);
 
             // THEN
             QCOMPARE(backendWaitFence.peerId(), waitFence.id());
@@ -115,17 +115,17 @@ private Q_SLOTS:
     void checkSceneChangeEvents()
     {
         // GIVEN
+        Qt3DRender::QWaitFence waitFence;
         Qt3DRender::Render::WaitFence backendWaitFence;
         TestRenderer renderer;
         backendWaitFence.setRenderer(&renderer);
+        simulateInitializationSync(&waitFence, &backendWaitFence);
 
         {
             // WHEN
             const bool newValue = false;
-            const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-            change->setPropertyName("enabled");
-            change->setValue(newValue);
-            backendWaitFence.sceneChangeEvent(change);
+            waitFence.setEnabled(newValue);
+            backendWaitFence.syncFromFrontEnd(&waitFence, false);
 
             // THEN
             QCOMPARE(backendWaitFence.isEnabled(), newValue);
@@ -135,10 +135,8 @@ private Q_SLOTS:
         {
             // WHEN
             const QVariant newValue(984);
-            const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-            change->setPropertyName("handle");
-            change->setValue(QVariant::fromValue(newValue));
-            backendWaitFence.sceneChangeEvent(change);
+            waitFence.setHandle(newValue);
+            backendWaitFence.syncFromFrontEnd(&waitFence, false);
 
             // THEN
             QCOMPARE(backendWaitFence.data().handle, QVariant(984));
@@ -148,10 +146,8 @@ private Q_SLOTS:
         {
             // WHEN
             const Qt3DRender::QWaitFence::HandleType newValue = Qt3DRender::QWaitFence::OpenGLFenceId;
-            const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-            change->setPropertyName("handleType");
-            change->setValue(QVariant::fromValue(newValue));
-            backendWaitFence.sceneChangeEvent(change);
+            waitFence.setHandleType(newValue);
+            backendWaitFence.syncFromFrontEnd(&waitFence, false);
 
             // THEN
             QCOMPARE(backendWaitFence.data().handleType, Qt3DRender::QWaitFence::OpenGLFenceId);
@@ -161,10 +157,8 @@ private Q_SLOTS:
         {
             // WHEN
             const bool newValue = true;
-            const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-            change->setPropertyName("waitOnCPU");
-            change->setValue(QVariant::fromValue(newValue));
-            backendWaitFence.sceneChangeEvent(change);
+            waitFence.setWaitOnCPU(newValue);
+            backendWaitFence.syncFromFrontEnd(&waitFence, false);
 
             // THEN
             QCOMPARE(backendWaitFence.data().waitOnCPU, true);
@@ -174,10 +168,8 @@ private Q_SLOTS:
         {
             // WHEN
             const quint64 newValue = 984;
-            const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-            change->setPropertyName("timeout");
-            change->setValue(QVariant::fromValue(newValue));
-            backendWaitFence.sceneChangeEvent(change);
+            waitFence.setTimeout(newValue);
+            backendWaitFence.syncFromFrontEnd(&waitFence, false);
 
             // THEN
             QCOMPARE(backendWaitFence.data().timeout, quint64(984));