Merge "Merge remote-tracking branch 'origin/5.15' into dev"

274 files changed, 3525 insertions, 4534 deletions

diff --git a/dist/changes-5.12.5 b/dist/changes-5.12.5
new file mode 100644
index 000000000..e8be9316f
--- /dev/null
+++ b/dist/changes-5.12.5
@@ -0,0 +1,20 @@
+Qt 5.12.5 is a bug-fix release. It maintains both forward and backward
+compatibility (source and binary) with Qt 5.12.0 through 5.12.4.
+
+For more details, refer to the online documentation included in this
+distribution. The documentation is also available online:
+
+https://doc.qt.io/qt-5/index.html
+
+The Qt version 5.12 series is binary compatible with the 5.11.x series.
+Applications compiled for 5.11 will continue to run with 5.12.
+
+Some of the changes listed in this file include issue tracking numbers
+corresponding to tasks in the Qt Bug Tracker:
+
+https://bugreports.qt.io/
+
+Each of these identifiers can be entered in the bug tracker to obtain more
+information about a particular change.
+
+ - This release contains only minor code improvements.
diff --git a/dist/changes-5.13.1 b/dist/changes-5.13.1
new file mode 100644
index 000000000..fda39f037
--- /dev/null
+++ b/dist/changes-5.13.1
@@ -0,0 +1,24 @@
+Qt 5.13.1 is a bug-fix release. It maintains both forward and backward
+compatibility (source and binary) with Qt 5.13.0.
+
+For more details, refer to the online documentation included in this
+distribution. The documentation is also available online:
+
+https://doc.qt.io/qt-5/index.html
+
+The Qt version 5.13 series is binary compatible with the 5.12.x series.
+Applications compiled for 5.12 will continue to run with 5.13.
+
+Some of the changes listed in this file include issue tracking numbers
+corresponding to tasks in the Qt Bug Tracker:
+
+https://bugreports.qt.io/
+
+Each of these identifiers can be entered in the bug tracker to obtain more
+information about a particular change.
+
+****************************************************************************
+*                                 Quick3D                                  *
+****************************************************************************
+
+ - [QTBUG-75551] Update Qt3D color handing to match QtQuick.
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/animationutils.cpp b/src/animation/backend/animationutils.cpp
index 92e614236..24c484dc2 100644
--- a/src/animation/backend/animationutils.cpp
+++ b/src/animation/backend/animationutils.cpp
@@ -453,6 +453,7 @@ QVector<Qt3DCore::QSceneChangePtr> preparePropertyChanges(Qt3DCore::QNodeId anim
                 break;
             }
         } else {
+            // TODOSYNC remove once we've found a way to propagate animation changes
             // Construct a property update change, set target, property and delivery options
             auto e = Qt3DCore::QPropertyUpdatedChangePtr::create(mappingData.targetId);
             e->setDeliveryFlags(Qt3DCore::QSceneChange::DeliverToAll);
@@ -469,6 +470,7 @@ QVector<Qt3DCore::QSceneChangePtr> preparePropertyChanges(Qt3DCore::QNodeId anim
         skeleton->sendLocalPoses();
 
     if (isValidNormalizedTime(normalizedLocalTime)) {
+        // TODOSYNC remove once we've found a way to propagate animation changes
         auto e = Qt3DCore::QPropertyUpdatedChangePtr::create(animatorId);
         e->setDeliveryFlags(Qt3DCore::QSceneChange::DeliverToAll);
         e->setPropertyName("normalizedTime");
@@ -479,6 +481,7 @@ QVector<Qt3DCore::QSceneChangePtr> preparePropertyChanges(Qt3DCore::QNodeId anim
 
     // If it's the final frame, notify the frontend that we've stopped
     if (finalFrame) {
+        // TODOSYNC remove once we've found a way to propagate animation changes
         auto e = Qt3DCore::QPropertyUpdatedChangePtr::create(animatorId);
         e->setDeliveryFlags(Qt3DCore::QSceneChange::DeliverToAll);
         e->setPropertyName("running");
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/animation/frontend/qclipblendvalue.cpp b/src/animation/frontend/qclipblendvalue.cpp
index c20609050..72a7dd796 100644
--- a/src/animation/frontend/qclipblendvalue.cpp
+++ b/src/animation/frontend/qclipblendvalue.cpp
@@ -59,10 +59,21 @@ QClipBlendValuePrivate::QClipBlendValuePrivate()
    \brief Class used for including a clip in a blend tree.
 */
 /*!
+   \qmltype ClipBlendValue
+   \instantiates QClipBlendValue
+   \inqmlmodule Qt3D.Animation
+   \brief Type used for including a clip in a blend tree.
+*/
+/*!
    \property Qt3DAnimation::QClipBlendValue::clip
 
    The animation clip that needs to be included in the blend tree.
 */
+/*!
+   \qmlproperty AbstractAnimationClip ClipBlendValue::clip
+
+   The animation clip that needs to be included in the blend tree.
+*/
 QClipBlendValue::QClipBlendValue(Qt3DCore::QNode *parent)
     : QAbstractClipBlendNode(*new QClipBlendValuePrivate(), parent)
 {
diff --git a/src/animation/frontend/qlerpclipblend.cpp b/src/animation/frontend/qlerpclipblend.cpp
index fd9dd248c..89ce3ca6f 100644
--- a/src/animation/frontend/qlerpclipblend.cpp
+++ b/src/animation/frontend/qlerpclipblend.cpp
@@ -43,7 +43,7 @@ QT_BEGIN_NAMESPACE
 namespace Qt3DAnimation {
 
 /*!
-    \qmltype LerpBlend
+    \qmltype LerpClipBlend
     \instantiates Qt3DAnimation::QLerpClipBlend
     \inqmlmodule Qt3D.Animation
 
@@ -52,7 +52,7 @@ namespace Qt3DAnimation {
 
     \since 5.9
 
-    LerpBlend can be useful to create advanced animation effects based on
+    LerpClipBlend can be useful to create advanced animation effects based on
     individual animation clips. For instance, given a player character,, lerp
     blending could be used to combine a walking animation clip with an injured
     animation clip based on a blend factor that increases the more the player
@@ -118,7 +118,7 @@ Qt3DCore::QNodeCreatedChangeBasePtr QLerpClipBlend::createNodeCreationChange() c
 }
 
 /*!
-    \qmlproperty real LerpBlend::blendFactor
+    \qmlproperty real LerpClipBlend::blendFactor
 
     Specifies the blending factor between 0 and 1 to control the blending of
     two animation clips.
diff --git a/src/core/aspects/qabstractaspect.cpp b/src/core/aspects/qabstractaspect.cpp
index 2ad3248e5..866a0ce25 100644
--- a/src/core/aspects/qabstractaspect.cpp
+++ b/src/core/aspects/qabstractaspect.cpp
@@ -191,12 +191,6 @@ void QAbstractAspect::unregisterBackendType(const QMetaObject &obj)
     d->m_backendCreatorFunctors.remove(&obj);
 }
 
-void QAbstractAspectPrivate::sceneNodeRemoved(QSceneChangePtr &change)
-{
-    QNodeDestroyedChangePtr destructionChange = qSharedPointerCast<QNodeDestroyedChange>(change);
-    clearBackendNode(destructionChange);
-}
-
 QVariant QAbstractAspect::executeCommand(const QStringList &args)
 {
     Q_UNUSED(args);
@@ -215,9 +209,9 @@ void QAbstractAspect::syncDirtyFrontEndNodes(const QVector<QNode *> &nodes)
     d->syncDirtyFrontEndNodes(nodes);
 }
 
-QAbstractAspectPrivate::BackendNodeMapperAndInfo QAbstractAspectPrivate::mapperForNode(QNode *n) const
+QAbstractAspectPrivate::BackendNodeMapperAndInfo QAbstractAspectPrivate::mapperForNode(const QMetaObject *metaObj) const
 {
-    const QMetaObject *metaObj = n->metaObject();
+    Q_ASSERT(metaObj);
     BackendNodeMapperAndInfo info;
 
     while (metaObj != nullptr && info.first.isNull()) {
@@ -230,7 +224,8 @@ QAbstractAspectPrivate::BackendNodeMapperAndInfo QAbstractAspectPrivate::mapperF
 void QAbstractAspectPrivate::syncDirtyFrontEndNodes(const QVector<QNode *> &nodes)
 {
     for (auto node: qAsConst(nodes)) {
-        const BackendNodeMapperAndInfo backendNodeMapperInfo = mapperForNode(node);
+        const QMetaObject *metaObj = QNodePrivate::get(node)->m_typeInfo;
+        const BackendNodeMapperAndInfo backendNodeMapperInfo = mapperForNode(metaObj);
         const QBackendNodeMapperPtr backendNodeMapper = backendNodeMapperInfo.first;
 
         if (!backendNodeMapper)
@@ -300,42 +295,37 @@ void QAbstractAspectPrivate::sendPropertyMessages(QNode *node, QBackendNode *bac
     }
 }
 
-QBackendNode *QAbstractAspectPrivate::createBackendNode(const QNodeCreatedChangeBasePtr &change) const
+QBackendNode *QAbstractAspectPrivate::createBackendNode(const NodeTreeChange &change) const
 {
-    Q_UNUSED(change);
-    Q_ASSERT(false); // should not be here
-    return nullptr;
-}
-
-QBackendNode *QAbstractAspectPrivate::createBackendNode(QNode *node) const
-{
-    const BackendNodeMapperAndInfo backendNodeMapperInfo = mapperForNode(node);
+    const QMetaObject *metaObj = change.metaObj;
+    const BackendNodeMapperAndInfo backendNodeMapperInfo = mapperForNode(metaObj);
     const QBackendNodeMapperPtr backendNodeMapper = backendNodeMapperInfo.first;
 
     if (!backendNodeMapper)
         return nullptr;
 
-    QBackendNode *backend = backendNodeMapper->get(node->id());
+    QBackendNode *backend = backendNodeMapper->get(change.id);
     if (backend != nullptr)
         return backend;
 
-    QNodeCreatedChangeBasePtr change;
+    QNode *node = change.node;
+    QNodeCreatedChangeBasePtr creationChange;
     const bool supportsSyncing = backendNodeMapperInfo.second & SupportsSyncing;
     if (supportsSyncing) {
         // All objects modified to use syncing should only use the id in the creation functor
         QNodeCreatedChangeBase changeObj(node);
-        change = QNodeCreatedChangeBasePtr(&changeObj, [](QNodeCreatedChangeBase *) {});
-        backend = backendNodeMapper->create(change);
+        creationChange = QNodeCreatedChangeBasePtr(&changeObj, [](QNodeCreatedChangeBase *) {});
+        backend = backendNodeMapper->create(creationChange);
     } else {
-        change = node->createNodeCreationChange();
-        backend = backendNodeMapper->create(change);
+        creationChange = node->createNodeCreationChange();
+        backend = backendNodeMapper->create(creationChange);
     }
 
     if (!backend)
         return nullptr;
 
     // TODO: Find some place else to do all of this function from the arbiter
-    backend->setPeerId(node->id());
+    backend->setPeerId(change.id);
 
     // Backend could be null if the user decides that his functor should only
     // perform some action when encountering a given type of item but doesn't need to
@@ -348,7 +338,7 @@ QBackendNode *QAbstractAspectPrivate::createBackendNode(QNode *node) const
     // Register backendNode with QChangeArbiter
     if (m_arbiter != nullptr) { // Unit tests may not have the arbiter registered
         qCDebug(Nodes) << q_func()->objectName() << "Creating backend node for node id"
-                       << node->id() << "of type" << node->metaObject()->className();
+                       << node->id() << "of type" << QNodePrivate::get(node)->m_typeInfo->className();
         m_arbiter->registerObserver(backendPriv, backend->peerId(), AllChanges);
         if (backend->mode() == QBackendNode::ReadWrite)
             m_arbiter->scene()->addObservable(backendPriv, backend->peerId());
@@ -357,44 +347,34 @@ QBackendNode *QAbstractAspectPrivate::createBackendNode(QNode *node) const
     if (supportsSyncing)
         syncDirtyFrontEndNode(node, backend, true);
     else
-        backend->initializeFromPeer(change);
+        backend->initializeFromPeer(creationChange);
 
     return backend;
 }
 
-void QAbstractAspectPrivate::clearBackendNode(const QNodeDestroyedChangePtr &change) const
+void QAbstractAspectPrivate::clearBackendNode(const NodeTreeChange &change) const
 {
-    // Each QNodeDestroyedChange may contain info about a whole sub-tree of nodes that
-    // are being destroyed. Iterate over them and process each in turn
-    const auto subTree = change->subtreeIdsAndTypes();
-    for (const auto &idAndType : subTree) {
-        const QMetaObject *metaObj = idAndType.type;
-        QBackendNodeMapperPtr backendNodeMapper;
-
-        // Find backend node mapper for this type
-        while (metaObj != nullptr && backendNodeMapper.isNull()) {
-            backendNodeMapper = m_backendCreatorFunctors.value(metaObj).first;
-            metaObj = metaObj->superClass();
-        }
+    const QMetaObject *metaObj = change.metaObj;
+    const BackendNodeMapperAndInfo backendNodeMapperInfo = mapperForNode(metaObj);
+    const QBackendNodeMapperPtr backendNodeMapper = backendNodeMapperInfo.first;
 
-        if (!backendNodeMapper)
-            continue;
+    if (!backendNodeMapper)
+        return;
 
-        // Request the mapper to destroy the corresponding backend node
-        QBackendNode *backend = backendNodeMapper->get(idAndType.id);
-        if (backend) {
-            qCDebug(Nodes) << q_func()->objectName() << "Deleting backend node for node id"
-                           << idAndType.id << "of type" << idAndType.type->className();
-            QBackendNodePrivate *backendPriv = QBackendNodePrivate::get(backend);
-            m_arbiter->unregisterObserver(backendPriv, backend->peerId());
-            if (backend->mode() == QBackendNode::ReadWrite)
-                m_arbiter->scene()->removeObservable(backendPriv, backend->peerId());
-            backendNodeMapper->destroy(idAndType.id);
-        }
+    // Request the mapper to destroy the corresponding backend node
+    QBackendNode *backend = backendNodeMapper->get(change.id);
+    if (backend) {
+        qCDebug(Nodes) << "Deleting backend node for node id"
+                       << change.id << "of type" << metaObj->className();
+        QBackendNodePrivate *backendPriv = QBackendNodePrivate::get(backend);
+        m_arbiter->unregisterObserver(backendPriv, backend->peerId());
+        if (backend->mode() == QBackendNode::ReadWrite)
+            m_arbiter->scene()->removeObservable(backendPriv, backend->peerId());
+        backendNodeMapper->destroy(change.id);
     }
 }
 
-void QAbstractAspectPrivate::setRootAndCreateNodes(QEntity *rootObject, const QVector<QNode *> &nodes)
+void QAbstractAspectPrivate::setRootAndCreateNodes(QEntity *rootObject, const QVector<NodeTreeChange> &nodesChanges)
 {
     qCDebug(Aspects) << Q_FUNC_INFO << "rootObject =" << rootObject;
     if (rootObject == m_root)
@@ -403,14 +383,10 @@ void QAbstractAspectPrivate::setRootAndCreateNodes(QEntity *rootObject, const QV
     m_root = rootObject;
     m_rootId = rootObject->id();
 
-    createNodes(nodes);
+    for (const NodeTreeChange &change : nodesChanges)
+        createBackendNode(change);
 }
 
-void QAbstractAspectPrivate::createNodes(const QVector<QNode *> &nodes)
-{
-    for (const auto node : nodes)
-        createBackendNode(node);
-}
 
 QServiceLocator *QAbstractAspectPrivate::services() const
 {
diff --git a/src/core/aspects/qabstractaspect_p.h b/src/core/aspects/qabstractaspect_p.h
index ea2712fe5..8bd26cf00 100644
--- a/src/core/aspects/qabstractaspect_p.h
+++ b/src/core/aspects/qabstractaspect_p.h
@@ -56,8 +56,6 @@
 
 #include <Qt3DCore/private/qaspectjobproviderinterface_p.h>
 #include <Qt3DCore/private/qbackendnode_p.h>
-#include <Qt3DCore/private/qbackendnodefactory_p.h>
-#include <Qt3DCore/private/qsceneobserverinterface_p.h>
 #include <Qt3DCore/private/qt3dcore_global_p.h>
 #include <QtCore/private/qobject_p.h>
 
@@ -102,33 +100,39 @@ private:
 
 } // Debug
 
+struct NodeTreeChange
+{
+    enum NodeTreeChangeType {
+        Added = 0,
+        Removed = 1
+    };
+    Qt3DCore::QNodeId id;
+    const QMetaObject *metaObj;
+    NodeTreeChangeType type;
+    Qt3DCore::QNode *node;
+};
+
 class Q_3DCORE_PRIVATE_EXPORT QAbstractAspectPrivate
         : public QObjectPrivate
-        , public QBackendNodeFactory
-        , public QSceneObserverInterface
         , public QAspectJobProviderInterface
 {
 public:
     QAbstractAspectPrivate();
     ~QAbstractAspectPrivate();
 
-    void setRootAndCreateNodes(QEntity *rootObject, const QVector<QNode *> &nodes);
-    void createNodes(const QVector<QNode *> &nodes);
+    void setRootAndCreateNodes(QEntity *rootObject, const QVector<NodeTreeChange> &nodesTreeChanges);
 
     QServiceLocator *services() const;
     QAbstractAspectJobManager *jobManager() const;
 
     QVector<QAspectJobPtr> jobsToExecute(qint64 time) override;
 
-    QBackendNode *createBackendNode(const QNodeCreatedChangeBasePtr &change) const override;
-    QBackendNode *createBackendNode(QNode *node) const;
-    void clearBackendNode(const QNodeDestroyedChangePtr &change) const;
+    QBackendNode *createBackendNode(const NodeTreeChange &change) const;
+    void clearBackendNode(const NodeTreeChange &change) const;
     void syncDirtyFrontEndNodes(const QVector<QNode *> &nodes);
     virtual void syncDirtyFrontEndNode(QNode *node, QBackendNode *backend, bool firstTime) const;
     void sendPropertyMessages(QNode *node, QBackendNode *backend) const;
 
-    void sceneNodeRemoved(Qt3DCore::QSceneChangePtr &e) override;
-
     virtual void onEngineAboutToShutdown();
 
     // TODO: Make these public in 5.8
@@ -143,7 +147,7 @@ public:
         SupportsSyncing = 1 << 0
     };
     using BackendNodeMapperAndInfo = QPair<QBackendNodeMapperPtr, NodeMapperInfo>;
-    BackendNodeMapperAndInfo mapperForNode(QNode *n) const;
+    BackendNodeMapperAndInfo mapperForNode(const QMetaObject *metaObj) const;
 
     QEntity *m_root;
     QNodeId m_rootId;
diff --git a/src/core/aspects/qaspectengine.cpp b/src/core/aspects/qaspectengine.cpp
index 41662e2a3..426741a61 100644
--- a/src/core/aspects/qaspectengine.cpp
+++ b/src/core/aspects/qaspectengine.cpp
@@ -89,6 +89,23 @@ QVector<Qt3DCore::QNode *> getNodesForCreation(Qt3DCore::QNode *root)
     return nodes;
 }
 
+QVector<Qt3DCore::QNode *> getNodesForRemoval(Qt3DCore::QNode *root)
+{
+    using namespace Qt3DCore;
+
+    QVector<QNode *> nodes;
+    QNodeVisitor visitor;
+    visitor.traverse(root, [&nodes](QNode *node) {
+        nodes.append(node);
+
+        // Mark this node as having been handled for destruction so we don't
+        // repeat it unnecessarily in an O(n^2) manner
+        QNodePrivate::get(node)->m_hasBackendNode = false;
+    });
+
+    return nodes;
+}
+
 }
 
 namespace Qt3DCore {
@@ -152,6 +169,11 @@ void QAspectEnginePrivate::addNode(QNode *node)
     m_aspectManager->addNodes(getNodesForCreation(node));
 }
 
+void QAspectEnginePrivate::removeNode(QNode *node)
+{
+    m_aspectManager->removeNodes(getNodesForRemoval(node));
+}
+
 /*!
  * \class Qt3DCore::QAspectEngine
  * \inheaderfile Qt3DCore/QAspectEngine
@@ -253,6 +275,7 @@ void QAspectEnginePrivate::initialize()
     arbiter->setPostman(m_postman);
     arbiter->setScene(m_scene);
     m_initialized = true;
+    m_aspectManager->setPostConstructorInit(m_scene->postConstructorInit());
 #if QT_CONFIG(qt3d_profile_jobs)
     m_commandDebugger->setAspectEngine(q_func());
     m_commandDebugger->initialize();
diff --git a/src/core/aspects/qaspectengine_p.h b/src/core/aspects/qaspectengine_p.h
index 3e68a2caa..c83940435 100644
--- a/src/core/aspects/qaspectengine_p.h
+++ b/src/core/aspects/qaspectengine_p.h
@@ -106,6 +106,7 @@ public:
     void initNode(QNode *node);
     void initEntity(QEntity *entity);
     void addNode(QNode *node);
+    void removeNode(QNode *node);
 
     static QAspectEnginePrivate *get(QAspectEngine *engine);
 };
diff --git a/src/core/aspects/qaspectmanager.cpp b/src/core/aspects/qaspectmanager.cpp
index b6e6122a1..a33f771e9 100644
--- a/src/core/aspects/qaspectmanager.cpp
+++ b/src/core/aspects/qaspectmanager.cpp
@@ -61,6 +61,7 @@
 #include <Qt3DCore/private/qtickclock_p.h>
 #include <Qt3DCore/private/qtickclockservice_p.h>
 #include <Qt3DCore/private/qnodevisitor_p.h>
+#include <Qt3DCore/private/qnode_p.h>
 
 #include <QtCore/QCoreApplication>
 
@@ -224,9 +225,6 @@ void QAspectManager::shutdown()
 {
     qCDebug(Aspects) << Q_FUNC_INFO;
 
-    for (QAbstractAspect *aspect : qAsConst(m_aspects))
-        m_changeArbiter->unregisterSceneObserver(aspect->d_func());
-
     // Aspects must be deleted in the Thread they were created in
 }
 
@@ -246,15 +244,71 @@ void QAspectManager::setRootEntity(Qt3DCore::QEntity *root, const QVector<QNode
     m_root = root;
 
     if (m_root) {
+
+        QVector<NodeTreeChange> nodeTreeChanges;
+        nodeTreeChanges.reserve(nodes.size());
+
+        for (QNode *n : nodes) {
+            nodeTreeChanges.push_back({
+                                          n->id(),
+                                          QNodePrivate::get(n)->m_typeInfo,
+                                          NodeTreeChange::Added,
+                                          n
+                                      });
+        }
+
         for (QAbstractAspect *aspect : qAsConst(m_aspects))
-            aspect->d_func()->setRootAndCreateNodes(m_root, nodes);
+            aspect->d_func()->setRootAndCreateNodes(m_root, nodeTreeChanges);
     }
 }
 
+
+// Main Thread -> immediately following node insertion
 void QAspectManager::addNodes(const QVector<QNode *> &nodes)
 {
-    for (QAbstractAspect *aspect : qAsConst(m_aspects))
-        aspect->d_func()->createNodes(nodes);
+    // We record the nodes added information, which we will actually use when
+    // processFrame is called (later but within the same loop of the even loop
+    // as this call) The idea is we want to avoid modifying the backend tree if
+    // the Renderer hasn't allowed processFrame to continue yet
+
+    QVector<NodeTreeChange> treeChanges;
+    treeChanges.reserve(nodes.size());
+
+    for (QNode *node : nodes) {
+        treeChanges.push_back({ node->id(),
+                                QNodePrivate::get(node)->m_typeInfo,
+                                NodeTreeChange::Added,
+                                node });
+    }
+
+    m_nodeTreeChanges += treeChanges;
+}
+
+// Main Thread -> immediately following node destruction (call from QNode dtor)
+void QAspectManager::removeNodes(const QVector<QNode *> &nodes)
+{
+    // We record the nodes removed information, which we will actually use when
+    // processFrame is called (later but within the same loop of the even loop
+    // as this call) The idea is we want to avoid modifying the backend tree if
+    // the Renderer hasn't allowed processFrame to continue yet The drawback is
+    // that when processFrame is processed, the QNode* pointer might be invalid by
+    // that point. Therefore we record all we need to remove the object.
+
+    for (QNode *node : nodes) {
+        // In addition, we check if we contain an Added change for a given node
+        // that is now about to be destroyed. If so we remove the Added change
+        // entirely
+
+        m_nodeTreeChanges.erase(std::remove_if(m_nodeTreeChanges.begin(),
+                                               m_nodeTreeChanges.end(),
+                                               [&node] (const NodeTreeChange &change) { return change.id == node->id(); }),
+                                m_nodeTreeChanges.end());
+
+        m_nodeTreeChanges.push_back({ node->id(),
+                                      QNodePrivate::get(node)->m_typeInfo,
+                                      NodeTreeChange::Removed,
+                                      nullptr });
+    }
 }
 
 /*!
@@ -271,8 +325,6 @@ void QAspectManager::registerAspect(QAbstractAspect *aspect)
         QAbstractAspectPrivate::get(aspect)->m_aspectManager = this;
         QAbstractAspectPrivate::get(aspect)->m_jobManager = m_jobManager;
         QAbstractAspectPrivate::get(aspect)->m_arbiter = m_changeArbiter;
-        // Register sceneObserver with the QChangeArbiter
-        m_changeArbiter->registerSceneObserver(aspect->d_func());
 
         // Allow the aspect to do some work now that it is registered
         aspect->onRegistered();
@@ -295,7 +347,6 @@ void QAspectManager::unregisterAspect(Qt3DCore::QAbstractAspect *aspect)
     qCDebug(Aspects) << "Unregistering aspect";
     Q_ASSERT(aspect);
     aspect->onUnregistered();
-    m_changeArbiter->unregisterSceneObserver(aspect->d_func());
     QAbstractAspectPrivate::get(aspect)->m_arbiter = nullptr;
     QAbstractAspectPrivate::get(aspect)->m_jobManager = nullptr;
     QAbstractAspectPrivate::get(aspect)->m_aspectManager = nullptr;
@@ -323,6 +374,11 @@ QServiceLocator *QAspectManager::serviceLocator() const
     return m_serviceLocator.data();
 }
 
+void QAspectManager::setPostConstructorInit(NodePostConstructorInit *postConstructorInit)
+{
+    m_postConstructorInit = postConstructorInit;
+}
+
 /*!
     \internal
     \brief Drives the Qt3D simulation loop in the main thread
@@ -377,6 +433,30 @@ void QAspectManager::processFrame()
     changeArbiterStats.threadId = reinterpret_cast<quint64>(QThread::currentThreadId());
     changeArbiterStats.startTime = QThreadPooler::m_jobsStatTimer.nsecsElapsed();
 #endif
+
+    // Tell the NodePostConstructorInit to process any pending nodes which will add them to our list of
+    // tree changes
+    m_postConstructorInit->processNodes();
+
+    // Add and Remove Nodes
+    const QVector<NodeTreeChange> nodeTreeChanges = std::move(m_nodeTreeChanges);
+    for (const NodeTreeChange &change : nodeTreeChanges) {
+        // Buckets ensure that even if we have intermingled node added / removed
+        // buckets, we preserve the order of the sequences
+
+        for (QAbstractAspect *aspect : qAsConst(m_aspects)) {
+            switch (change.type) {
+            case NodeTreeChange::Added:
+                aspect->d_func()->createBackendNode(change);
+                break;
+            case NodeTreeChange::Removed:
+                aspect->d_func()->clearBackendNode(change);
+                break;
+            }
+        }
+    }
+
+    // Sync property updates
     const auto dirtyFrontEndNodes = m_changeArbiter->takeDirtyFrontEndNodes();
     if (dirtyFrontEndNodes.size())
         for (QAbstractAspect *aspect : qAsConst(m_aspects))
diff --git a/src/core/aspects/qaspectmanager_p.h b/src/core/aspects/qaspectmanager_p.h
index e984244ff..38ddbc55d 100644
--- a/src/core/aspects/qaspectmanager_p.h
+++ b/src/core/aspects/qaspectmanager_p.h
@@ -73,14 +73,15 @@ class QScheduler;
 class QChangeArbiter;
 class QAbstractAspect;
 class QAbstractAspectJobManager;
-class QSceneObserverInterface;
 class QServiceLocator;
+class NodePostConstructorInit;
+struct NodeTreeChange;
 
 class Q_3DCORE_PRIVATE_EXPORT QAspectManager : public QObject
 {
     Q_OBJECT
 public:
-    explicit QAspectManager(QObject *parent = 0);
+    explicit QAspectManager(QObject *parent = nullptr);
     ~QAspectManager();
 
     void setRunMode(QAspectEngine::RunMode mode);
@@ -96,6 +97,7 @@ public Q_SLOTS:
 
     void setRootEntity(Qt3DCore::QEntity *root, const QVector<QNode *> &nodes);
     void addNodes(const QVector<QNode *> &nodes);
+    void removeNodes(const QVector<QNode *> &nodes);
     void registerAspect(Qt3DCore::QAbstractAspect *aspect);
     void unregisterAspect(Qt3DCore::QAbstractAspect *aspect);
 
@@ -104,6 +106,7 @@ public:
     QAbstractAspectJobManager *jobManager() const;
     QChangeArbiter *changeArbiter() const;
     QServiceLocator *serviceLocator() const;
+    void setPostConstructorInit(NodePostConstructorInit *postConstructorInit);
 
 private:
     bool event(QEvent *event) override;
@@ -119,6 +122,8 @@ private:
     bool m_mainLoopRunning;
     bool m_simulationLoopRunning;
     QAspectEngine::RunMode m_driveMode;
+    QVector<NodeTreeChange> m_nodeTreeChanges;
+    NodePostConstructorInit* m_postConstructorInit;
 
 };
 
diff --git a/src/core/core.pri b/src/core/core.pri
index 458a0328d..ea95ab10d 100644
--- a/src/core/core.pri
+++ b/src/core/core.pri
@@ -5,13 +5,11 @@ HEADERS += \
     $$PWD/qtickclock_p.h \
     $$PWD/qscheduler_p.h \
     $$PWD/corelogging_p.h \
-    $$PWD/qsceneobserverinterface_p.h \
     $$PWD/qpostman_p.h \
     $$PWD/qobservableinterface_p.h \
     $$PWD/qobserverinterface_p.h \
     $$PWD/qlockableobserverinterface_p.h \
     $$PWD/qchangearbiter_p.h \
-    $$PWD/qbackendnodefactory_p.h \
     $$PWD/qt3dcore_global_p.h \
     $$PWD/qscene_p.h \
     $$PWD/qpostman_p_p.h
@@ -24,7 +22,5 @@ SOURCES += \
     $$PWD/qobservableinterface.cpp \
     $$PWD/qobserverinterface.cpp \
     $$PWD/qlockableobserverinterface.cpp \
-    $$PWD/qsceneobserverinterface.cpp \
     $$PWD/qpostman.cpp \
-    $$PWD/qscene.cpp \
-    $$PWD/qbackendnodefactory.cpp
+    $$PWD/qscene.cpp
diff --git a/src/core/jobs/qthreadpooler.cpp b/src/core/jobs/qthreadpooler.cpp
index 0e9af58dd..a9f4e7a31 100644
--- a/src/core/jobs/qthreadpooler.cpp
+++ b/src/core/jobs/qthreadpooler.cpp
@@ -183,7 +183,7 @@ int QThreadPooler::currentCount() const
 {
     // The caller have to set the mutex
 
-    return m_taskCount.load();
+    return m_taskCount.loadRelaxed();
 }
 
 int QThreadPooler::maxThreadCount() const
diff --git a/src/core/jobs/task.cpp b/src/core/jobs/task.cpp
index 4291a4779..091aabfd6 100644
--- a/src/core/jobs/task.cpp
+++ b/src/core/jobs/task.cpp
@@ -118,7 +118,7 @@ void SyncTaskRunnable::run()
     m_atomicCount->deref();
 
     // Wait for the other worker threads to be done
-    while (m_atomicCount->load() > 0)
+    while (m_atomicCount->loadRelaxed() > 0)
         QThread::currentThread()->yieldCurrentThread();
 
     if (m_pooler)
diff --git a/src/core/nodes/qentity.cpp b/src/core/nodes/qentity.cpp
index 546f1d670..0ff8c4646 100644
--- a/src/core/nodes/qentity.cpp
+++ b/src/core/nodes/qentity.cpp
@@ -295,13 +295,7 @@ void QEntity::onParentChanged(QObject *)
     if (!d->m_hasBackendNode)
         return;
 
-    const auto parentID = parentEntity() ? parentEntity()->id() : Qt3DCore::QNodeId();
-    auto parentChange = Qt3DCore::QPropertyUpdatedChangePtr::create(id());
-    parentChange->setPropertyName("parentEntityUpdated");
-    parentChange->setValue(QVariant::fromValue(parentID));
-    const bool blocked = blockNotifications(false);
-    notifyObservers(parentChange);
-    blockNotifications(blocked);
+    d->update();
 }
 
 } // namespace Qt3DCore
diff --git a/src/core/nodes/qentity.h b/src/core/nodes/qentity.h
index f1a369c48..62398faa1 100644
--- a/src/core/nodes/qentity.h
+++ b/src/core/nodes/qentity.h
@@ -66,8 +66,8 @@ public:
     QVector<T *> componentsOfType() const
     {
         QVector<T*> matchComponents;
-        const QComponentVector components = this->components();
-        for (QComponent *component : components) {
+        const QComponentVector comps = this->components();
+        for (QComponent *component : comps) {
             T *typedComponent = qobject_cast<T*>(component);
             if (typedComponent != nullptr)
                 matchComponents.append(typedComponent);
diff --git a/src/core/nodes/qnode.cpp b/src/core/nodes/qnode.cpp
index 5f9468124..5c37e337e 100644
--- a/src/core/nodes/qnode.cpp
+++ b/src/core/nodes/qnode.cpp
@@ -149,11 +149,8 @@ void QNodePrivate::notifyDestructionChangesAndRemoveFromScene()
     }
 
     // Tell the backend we are about to be destroyed
-    if (m_hasBackendNode) {
-        const QDestructionIdAndTypeCollector collector(q);
-        const auto destroyedChange = QNodeDestroyedChangePtr::create(q, collector.subtreeIdsAndTypes());
-        notifyObservers(destroyedChange);
-    }
+    if (m_hasBackendNode && m_scene && m_scene->engine())
+        QAspectEnginePrivate::get(m_scene->engine())->removeNode(q);
 
     // We unset the scene from the node as its backend node was/is about to be destroyed
     QNodeVisitor visitor;
@@ -690,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 491059ff9..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>
@@ -194,7 +195,7 @@ public:
     void removeNode(QNode *node);
     void addNode(QNode *node);
 
-private Q_SLOTS:
+public Q_SLOTS:
     void processNodes();
 
 private:
diff --git a/src/core/qbackendnodefactory.cpp b/src/core/qbackendnodefactory.cpp
deleted file mode 100644
index 6fd5b33d1..000000000
--- a/src/core/qbackendnodefactory.cpp
+++ /dev/null
@@ -1,52 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2015 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 "qbackendnodefactory_p.h"
-
-QT_BEGIN_NAMESPACE
-
-namespace Qt3DCore {
-
-QBackendNodeFactory::~QBackendNodeFactory()
-{
-}
-
-} // namespace Qt3DCore
-
-QT_END_NAMESPACE
diff --git a/src/core/qbackendnodefactory_p.h b/src/core/qbackendnodefactory_p.h
deleted file mode 100644
index 5752205c0..000000000
--- a/src/core/qbackendnodefactory_p.h
+++ /dev/null
@@ -1,75 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2015 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 QT3DCORE_QBACKENDNODEFACTORY_P_H
-#define QT3DCORE_QBACKENDNODEFACTORY_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 <Qt3DCore/qnodecreatedchange.h>
-
-#include <Qt3DCore/private/qt3dcore_global_p.h>
-
-QT_BEGIN_NAMESPACE
-
-namespace Qt3DCore {
-
-class QBackendNode;
-
-class Q_3DCORE_PRIVATE_EXPORT QBackendNodeFactory
-{
-public:
-    virtual ~QBackendNodeFactory();
-    virtual QBackendNode *createBackendNode(const QNodeCreatedChangeBasePtr &change) const = 0;
-};
-
-} // namespace Qt3DCore
-
-QT_END_NAMESPACE
-
-#endif // QT3DCORE_QBACKENDNODEFACTORY_P_H
diff --git a/src/core/qchangearbiter.cpp b/src/core/qchangearbiter.cpp
index 34e773f59..60cdc3bd2 100644
--- a/src/core/qchangearbiter.cpp
+++ b/src/core/qchangearbiter.cpp
@@ -49,7 +49,6 @@
 #include <Qt3DCore/private/qabstractaspectjobmanager_p.h>
 #include <Qt3DCore/private/qpostman_p.h>
 #include <Qt3DCore/private/qscene_p.h>
-#include <Qt3DCore/private/qsceneobserverinterface_p.h>
 
 #include <mutex>
 
@@ -117,11 +116,8 @@ void QChangeArbiter::distributeQueueChanges(QChangeQueue *changeQueue)
         if (change.isNull())
             continue;
 
-        if (change->type() == NodeCreated) {
+        if (change->type() == NodeCreated || change->type() == NodeDeleted) {
             Q_ASSERT(false); // messages no longer used
-        } else if (change->type() == NodeDeleted) {
-            for (QSceneObserverInterface *observer : qAsConst(m_sceneObservers))
-                observer->sceneNodeRemoved(change);
         }
 
         const QNodeId nodeId = change->subjectId();
@@ -207,13 +203,6 @@ void QChangeArbiter::registerObserver(QObserverInterface *observer,
     observerList.append(QObserverPair(changeFlags, observer));
 }
 
-// Called from the QAspectThread context, no need to lock
-void QChangeArbiter::registerSceneObserver(QSceneObserverInterface *observer)
-{
-    if (!m_sceneObservers.contains(observer))
-        m_sceneObservers << observer;
-}
-
 void QChangeArbiter::unregisterObserver(QObserverInterface *observer, QNodeId nodeId)
 {
     const std::lock_guard<QRecursiveMutex> locker(m_mutex);;
@@ -229,13 +218,6 @@ void QChangeArbiter::unregisterObserver(QObserverInterface *observer, QNodeId no
     }
 }
 
-// Called from the QAspectThread context, no need to lock
-void QChangeArbiter::unregisterSceneObserver(QSceneObserverInterface *observer)
-{
-    if (observer != nullptr)
-        m_sceneObservers.removeOne(observer);
-}
-
 void QChangeArbiter::sceneChangeEvent(const QSceneChangePtr &e)
 {
     //    qCDebug(ChangeArbiter) << Q_FUNC_INFO << QThread::currentThread();
diff --git a/src/core/qchangearbiter_p.h b/src/core/qchangearbiter_p.h
index 48fc4ca8c..0a6196756 100644
--- a/src/core/qchangearbiter_p.h
+++ b/src/core/qchangearbiter_p.h
@@ -104,9 +104,6 @@ public:
     void unregisterObserver(QObserverInterface *observer,
                             QNodeId nodeId);
 
-    void registerSceneObserver(QSceneObserverInterface *observer);
-    void unregisterSceneObserver(QSceneObserverInterface *observer);
-
     void sceneChangeEvent(const QSceneChangePtr &e) override;         // QLockableObserverInterface impl
     void sceneChangeEventWithLock(const QSceneChangePtr &e) override; // QLockableObserverInterface impl
     void sceneChangeEventWithLock(const QSceneChangeList &e) override; // QLockableObserverInterface impl
@@ -149,7 +146,6 @@ private:
     // The lists of observers indexed by observable (QNodeId).
     // m_nodeObservations is for observables in the main thread's object tree
     QHash<QNodeId, QObserverList> m_nodeObservations;
-    QList<QSceneObserverInterface *> m_sceneObservers;
 
     // Each thread has a TLS ChangeQueue so we never need to lock whilst
     // receiving a QSceneChange.
diff --git a/src/core/qsceneobserverinterface.cpp b/src/core/qsceneobserverinterface.cpp
deleted file mode 100644
index 784ff654e..000000000
--- a/src/core/qsceneobserverinterface.cpp
+++ /dev/null
@@ -1,52 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2014 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 "qsceneobserverinterface_p.h"
-
-QT_BEGIN_NAMESPACE
-
-namespace Qt3DCore {
-
-QSceneObserverInterface::~QSceneObserverInterface()
-{
-}
-
-} // Qt3D
-
-QT_END_NAMESPACE
diff --git a/src/core/qsceneobserverinterface_p.h b/src/core/qsceneobserverinterface_p.h
deleted file mode 100644
index db6c68b73..000000000
--- a/src/core/qsceneobserverinterface_p.h
+++ /dev/null
@@ -1,81 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2014 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 QT3DCORE_QSCENEOBSERVERINTERFACE_P_H
-#define QT3DCORE_QSCENEOBSERVERINTERFACE_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 <Qt3DCore/qscenechange.h>
-
-#include <Qt3DCore/private/qt3dcore_global_p.h>
-
-QT_BEGIN_NAMESPACE
-
-namespace Qt3DCore {
-
-class QChangeArbiter;
-
-class Q_3DCORE_PRIVATE_EXPORT QSceneObserverInterface
-{
-public:
-    virtual ~QSceneObserverInterface();
-
-private:
-    virtual void sceneNodeRemoved(QSceneChangePtr &e) = 0;
-
-    friend class QChangeArbiter;
-};
-
-} // Qt3D
-
-QT_END_NAMESPACE
-
-Q_DECLARE_METATYPE(Qt3DCore::QSceneObserverInterface *) // LCOV_EXCL_LINE
-
-#endif // QT3DCORE_QSCENEOBSERVERINTERFACE_P_H
diff --git a/src/core/transforms/matrix4x4_avx2_p.h b/src/core/transforms/matrix4x4_avx2_p.h
index 74e7c911c..63858b35c 100644
--- a/src/core/transforms/matrix4x4_avx2_p.h
+++ b/src/core/transforms/matrix4x4_avx2_p.h
@@ -473,15 +473,13 @@ public:
 
     Vector3D_SSE mapVector(const Vector3D_SSE &vector) const
     {
-        const __m128 row1 = _mm_set_ps(0.0f, m13(), m12(), m11());
-        const __m128 row2 = _mm_set_ps(0.0f, m23(), m22(), m21());
-        const __m128 row3 = _mm_set_ps(0.0f, m33(), m32(), m31());
+        const Vector3D_SSE row1(m11(), m12(), m13());
+        const Vector3D_SSE row2(m21(), m22(), m23());
+        const Vector3D_SSE row3(m31(), m32(), m33());
 
-        const __m128 tmp = _mm_add_ps(_mm_mul_ps(vector.m_xyzw, row1), _mm_mul_ps(vector.m_xyzw, row2));
-
-        Vector3D_SSE v(Qt::Uninitialized);
-        v.m_xyzw = _mm_add_ps(tmp, _mm_mul_ps(vector.m_xyzw, row3));
-        return v;
+        return Vector3D(Vector3D_SSE::dotProduct(row1, vector),
+                        Vector3D_SSE::dotProduct(row2, vector),
+                        Vector3D_SSE::dotProduct(row3, vector));
     }
 
     friend Vector4D operator*(const Vector4D &vector, const Matrix4x4_AVX2 &matrix);
diff --git a/src/core/transforms/matrix4x4_sse_p.h b/src/core/transforms/matrix4x4_sse_p.h
index 287094be5..0ea2e37ad 100644
--- a/src/core/transforms/matrix4x4_sse_p.h
+++ b/src/core/transforms/matrix4x4_sse_p.h
@@ -356,15 +356,13 @@ public:
 
     Q_ALWAYS_INLINE Vector3D_SSE mapVector(const Vector3D_SSE &vector) const
     {
-        const __m128 row1 = _mm_set_ps(0.0f, m13(), m12(), m11());
-        const __m128 row2 = _mm_set_ps(0.0f, m23(), m22(), m21());
-        const __m128 row3 = _mm_set_ps(0.0f, m33(), m32(), m31());
+        const Vector3D_SSE row1(m11(), m12(), m13());
+        const Vector3D_SSE row2(m21(), m22(), m23());
+        const Vector3D_SSE row3(m31(), m32(), m33());
 
-        const __m128 tmp = _mm_add_ps(_mm_mul_ps(vector.m_xyzw, row1), _mm_mul_ps(vector.m_xyzw, row2));
-
-        Vector3D_SSE v(Qt::Uninitialized);
-        v.m_xyzw = _mm_add_ps(tmp, _mm_mul_ps(vector.m_xyzw, row3));
-        return v;
+        return Vector3D(Vector3D_SSE::dotProduct(row1, vector),
+                        Vector3D_SSE::dotProduct(row2, vector),
+                        Vector3D_SSE::dotProduct(row3, vector));
     }
 
     friend Q_ALWAYS_INLINE Vector4D operator*(const Vector4D &vector, const Matrix4x4_SSE &matrix);
diff --git a/src/core/transforms/qjoint.cpp b/src/core/transforms/qjoint.cpp
index 017773ff6..553fbd654 100644
--- a/src/core/transforms/qjoint.cpp
+++ b/src/core/transforms/qjoint.cpp
@@ -352,11 +352,8 @@ void QJoint::addChildJoint(QJoint *joint)
         // Ensures proper bookkeeping
         d->registerDestructionHelper(joint, &QJoint::removeChildJoint, d->m_childJoints);
 
-        if (d->m_changeArbiter != nullptr) {
-            const auto change = QPropertyNodeAddedChangePtr::create(id(), joint);
-            change->setPropertyName("childJoint");
-            d->notifyObservers(change);
-        }
+        if (d->m_changeArbiter != nullptr)
+            d->update();
     }
 }
 
@@ -369,11 +366,8 @@ void QJoint::removeChildJoint(QJoint *joint)
     Q_D(QJoint);
     if (d->m_childJoints.contains(joint)) {
 
-        if (d->m_changeArbiter != nullptr) {
-            const auto change = QPropertyNodeRemovedChangePtr::create(id(), joint);
-            change->setPropertyName("childJoint");
-            d->notifyObservers(change);
-        }
+        if (d->m_changeArbiter != nullptr)
+            d->update();
 
         d->m_childJoints.removeOne(joint);
 
diff --git a/src/core/transforms/qtransform.cpp b/src/core/transforms/qtransform.cpp
index bedf108f2..e5902f11f 100644
--- a/src/core/transforms/qtransform.cpp
+++ b/src/core/transforms/qtransform.cpp
@@ -239,12 +239,13 @@ QTransform::QTransform(QTransformPrivate &dd, QNode *parent)
  */
 void QTransform::sceneChangeEvent(const QSceneChangePtr &change)
 {
+    Q_D(QTransform);
     switch (change->type()) {
     case PropertyUpdated: {
         Qt3DCore::QPropertyUpdatedChangePtr propertyChange = qSharedPointerCast<Qt3DCore::QPropertyUpdatedChange>(change);
         if (propertyChange->propertyName() == QByteArrayLiteral("worldMatrix")) {
             const bool blocked = blockNotifications(true);
-            setWorldMatrix(propertyChange->value().value<QMatrix4x4>());
+            d->setWorldMatrix(propertyChange->value().value<QMatrix4x4>());
             blockNotifications(blocked);
         }
         break;
@@ -254,13 +255,13 @@ void QTransform::sceneChangeEvent(const QSceneChangePtr &change)
     }
 }
 
-void QTransform::setWorldMatrix(const QMatrix4x4 &worldMatrix)
+void QTransformPrivate::setWorldMatrix(const QMatrix4x4 &worldMatrix)
 {
-    Q_D(QTransform);
-    if (d->m_worldMatrix == worldMatrix)
+    Q_Q(QTransform);
+    if (m_worldMatrix == worldMatrix)
         return;
-    d->m_worldMatrix = worldMatrix;
-    emit worldMatrixChanged(worldMatrix);
+    m_worldMatrix = worldMatrix;
+    emit q->worldMatrixChanged(worldMatrix);
 }
 
 void QTransform::setMatrix(const QMatrix4x4 &m)
diff --git a/src/core/transforms/qtransform.h b/src/core/transforms/qtransform.h
index 527760df7..503ea4d4a 100644
--- a/src/core/transforms/qtransform.h
+++ b/src/core/transforms/qtransform.h
@@ -120,7 +120,6 @@ Q_SIGNALS:
 protected:
     explicit QTransform(QTransformPrivate &dd, QNode *parent = nullptr);
     void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &change) override;
-    void setWorldMatrix(const QMatrix4x4 &worldMatrix);
 
 private:
     Q_DECLARE_PRIVATE(QTransform)
diff --git a/src/core/transforms/qtransform_p.h b/src/core/transforms/qtransform_p.h
index d44e5e157..028a9aba7 100644
--- a/src/core/transforms/qtransform_p.h
+++ b/src/core/transforms/qtransform_p.h
@@ -77,6 +77,8 @@ public:
     mutable bool m_matrixDirty;
 
     QMatrix4x4 m_worldMatrix;
+
+    void setWorldMatrix(const QMatrix4x4 &worldMatrix);
 };
 
 struct QTransformData
diff --git a/src/extras/defaults/qabstractcameracontroller.cpp b/src/extras/defaults/qabstractcameracontroller.cpp
index 527ee7e8d..27df65d7b 100644
--- a/src/extras/defaults/qabstractcameracontroller.cpp
+++ b/src/extras/defaults/qabstractcameracontroller.cpp
@@ -209,7 +209,8 @@ void QAbstractCameraControllerPrivate::init()
     // Disable the logical device when the entity is disabled
     QObject::connect(q, &Qt3DCore::QEntity::enabledChanged,
                      m_logicalDevice, &Qt3DInput::QLogicalDevice::setEnabled);
-
+    QObject::connect(q, &Qt3DCore::QEntity::enabledChanged,
+                     m_frameAction, &Qt3DLogic::QFrameAction::setEnabled);
 
     QObject::connect(m_escapeButtonAction, &Qt3DInput::QAction::activeChanged,
                      q, [this](bool isActive) {
diff --git a/src/extras/defaults/qforwardrenderer.cpp b/src/extras/defaults/qforwardrenderer.cpp
index 22a471cec..dd3c872cc 100644
--- a/src/extras/defaults/qforwardrenderer.cpp
+++ b/src/extras/defaults/qforwardrenderer.cpp
@@ -239,11 +239,13 @@ QColor QForwardRenderer::clearColor() const
     \qmlproperty color ForwardRenderer::clearBuffers
 
     Holds the current buffers to be cleared. Default value is ColorDepthBuffer
+    \since 5.14
 */
 /*!
     \property QForwardRenderer::clearBuffers
 
     Holds the current buffers to be cleared. Default value is ColorDepthBuffer
+    \since 5.14
 */
 QClearBuffers::BufferType QForwardRenderer::clearBuffers() const
 {
diff --git a/src/extras/defaults/qforwardrenderer.h b/src/extras/defaults/qforwardrenderer.h
index 6d01a0ded..0b53a094b 100644
--- a/src/extras/defaults/qforwardrenderer.h
+++ b/src/extras/defaults/qforwardrenderer.h
@@ -61,7 +61,7 @@ class Q_3DEXTRASSHARED_EXPORT QForwardRenderer : public Qt3DRender::QTechniqueFi
     Q_PROPERTY(QObject *window READ surface WRITE setSurface NOTIFY surfaceChanged)
     Q_PROPERTY(QRectF viewportRect READ viewportRect WRITE setViewportRect NOTIFY viewportRectChanged)
     Q_PROPERTY(QColor clearColor READ clearColor WRITE setClearColor NOTIFY clearColorChanged)
-    Q_PROPERTY(Qt3DRender::QClearBuffers::BufferType clearBuffers READ clearBuffers WRITE setClearBuffers NOTIFY clearBuffersChanged)
+    Q_PROPERTY(Qt3DRender::QClearBuffers::BufferType clearBuffers READ clearBuffers WRITE setClearBuffers NOTIFY clearBuffersChanged REVISION 14)
     Q_PROPERTY(Qt3DCore::QEntity *camera READ camera WRITE setCamera NOTIFY cameraChanged)
     Q_PROPERTY(QSize externalRenderTargetSize READ externalRenderTargetSize WRITE setExternalRenderTargetSize NOTIFY externalRenderTargetSizeChanged)
     Q_PROPERTY(bool frustumCulling READ isFrustumCullingEnabled WRITE setFrustumCullingEnabled NOTIFY frustumCullingEnabledChanged)
diff --git a/src/extras/defaults/qmetalroughmaterial.cpp b/src/extras/defaults/qmetalroughmaterial.cpp
index 572bfecfd..a969593db 100644
--- a/src/extras/defaults/qmetalroughmaterial.cpp
+++ b/src/extras/defaults/qmetalroughmaterial.cpp
@@ -212,7 +212,7 @@ QMetalRoughMaterial::~QMetalRoughMaterial()
     color value or a texture. By default the value of this property is "grey".
 */
 /*!
-    \qmlproperty color Qt3D.Extras::MetalRoughMaterial::baseColor
+    \qmlproperty variant Qt3D.Extras::MetalRoughMaterial::baseColor
 
     Holds the current base color of the material. This can be either a plain
     color value or a texture. By default the value of this property is "grey".
@@ -232,7 +232,7 @@ QVariant QMetalRoughMaterial::baseColor() const
     property is 0.
 */
 /*!
-    \qmlproperty real Qt3D.Extras::MetalRoughMaterial::metalness
+    \qmlproperty variant Qt3D.Extras::MetalRoughMaterial::metalness
 
     Holds the current metalness level of the material, as a value between
     0 (purely dielectric, the default) and 1 (purely metallic). This can be
@@ -253,7 +253,7 @@ QVariant QMetalRoughMaterial::metalness() const
     0.
 */
 /*!
-    \qmlproperty real Qt3D.Extras::MetalRoughMaterial::roughness
+    \qmlproperty variant Qt3D.Extras::MetalRoughMaterial::roughness
 
     Holds the current roughness level of the material. This can be either a
     plain uniform value or a texture. By default the value of this property is
diff --git a/src/extras/defaults/qskyboxentity.cpp b/src/extras/defaults/qskyboxentity.cpp
index e82a30950..8d01e8d82 100644
--- a/src/extras/defaults/qskyboxentity.cpp
+++ b/src/extras/defaults/qskyboxentity.cpp
@@ -240,7 +240,7 @@ void QSkyboxEntityPrivate::reloadTexture()
 /*!
  * \qmltype SkyboxEntity
  * \instantiates Qt3DExtras::QSkyboxEntity
-   \inqmlmodule Qt3D.Extras
+ * \inqmlmodule Qt3D.Extras
  *
  * \brief SkyboxEntity is a convenience Entity subclass that can be used to
  * insert a skybox in a 3D scene.
diff --git a/src/extras/defaults/qspritegrid.cpp b/src/extras/defaults/qspritegrid.cpp
index 31d4dd5c0..15016a891 100644
--- a/src/extras/defaults/qspritegrid.cpp
+++ b/src/extras/defaults/qspritegrid.cpp
@@ -57,7 +57,7 @@ QSpriteGridPrivate::QSpriteGridPrivate()
 
 int QSpriteGridPrivate::maxIndex() const
 {
-    return m_numColumns * m_numRows;
+    return m_numColumns * m_numRows - 1;
 }
 
 void QSpriteGridPrivate::updateSizes()
@@ -65,10 +65,10 @@ void QSpriteGridPrivate::updateSizes()
     Q_Q(QSpriteGrid);
     if (m_texture && m_numColumns && m_numRows) {
         m_textureSize = QSize(m_texture->width(), m_texture->height());
-        m_cellSize = QSize(m_texture->width() / m_numColumns, m_texture->height() / m_numRows);
+        m_cellSize = QSizeF((float) m_texture->width() / m_numColumns, (float) m_texture->height() / m_numRows);
     } else {
         m_textureSize = QSize();
-        m_cellSize = QSize();
+        m_cellSize = QSizeF();
     }
 
     if (m_cellSize.isEmpty() || m_numColumns == 0 || m_numRows == 0) {
diff --git a/src/extras/defaults/qspritegrid_p.h b/src/extras/defaults/qspritegrid_p.h
index 6135ebf0d..8d05b2bcc 100644
--- a/src/extras/defaults/qspritegrid_p.h
+++ b/src/extras/defaults/qspritegrid_p.h
@@ -69,7 +69,7 @@ class QSpriteGridPrivate : public QAbstractSpriteSheetPrivate
 
     int m_numColumns;
     int m_numRows;
-    QSize m_cellSize;
+    QSizeF m_cellSize;
 
     Q_DECLARE_PUBLIC(QSpriteGrid)
 };
diff --git a/src/extras/defaults/qspritesheet.cpp b/src/extras/defaults/qspritesheet.cpp
index 87f664ce4..8eb1e33e6 100644
--- a/src/extras/defaults/qspritesheet.cpp
+++ b/src/extras/defaults/qspritesheet.cpp
@@ -56,7 +56,7 @@ QSpriteSheetPrivate::QSpriteSheetPrivate()
 
 int QSpriteSheetPrivate::maxIndex() const
 {
-    return m_sprites.count();
+    return m_sprites.count() - 1;
 }
 
 void QSpriteSheetPrivate::updateSizes()
@@ -77,7 +77,7 @@ void QSpriteSheetPrivate::updateSizes()
         return;
     }
 
-    if (m_currentIndex < 0 || m_currentIndex > m_sprites.size()) {
+    if (m_currentIndex < 0 || m_currentIndex >= m_sprites.size()) {
         m_currentIndex = 0;
         emit q->currentIndexChanged(m_currentIndex);
     }
diff --git a/src/quick3d/imports/extras/qt3dquick3dextrasplugin.cpp b/src/quick3d/imports/extras/qt3dquick3dextrasplugin.cpp
index 91ec85795..b675ec283 100644
--- a/src/quick3d/imports/extras/qt3dquick3dextrasplugin.cpp
+++ b/src/quick3d/imports/extras/qt3dquick3dextrasplugin.cpp
@@ -87,6 +87,7 @@ void Qt3DQuick3DExtrasPlugin::registerTypes(const char *uri)
     // Framegraphs
     qmlRegisterType<Qt3DExtras::QForwardRenderer>(uri, 2, 0, "ForwardRenderer");
     qmlRegisterType<Qt3DExtras::QForwardRenderer, 9>(uri, 2, 9, "ForwardRenderer");
+    qmlRegisterType<Qt3DExtras::QForwardRenderer, 14>(uri, 2, 14, "ForwardRenderer");
 
     // Entities
     qmlRegisterType<Qt3DExtras::QSkyboxEntity>(uri, 2, 0, "SkyboxEntity");
diff --git a/src/quick3d/imports/render/qt3dquick3drenderplugin.cpp b/src/quick3d/imports/render/qt3dquick3drenderplugin.cpp
index ce19d35ed..e16314c8e 100644
--- a/src/quick3d/imports/render/qt3dquick3drenderplugin.cpp
+++ b/src/quick3d/imports/render/qt3dquick3drenderplugin.cpp
@@ -239,6 +239,7 @@ void Qt3DQuick3DRenderPlugin::registerTypes(const char *uri)
     qmlRegisterType<Qt3DRender::QObjectPicker, 9>(uri, 2, 9, "ObjectPicker");
     qmlRegisterType<Qt3DRender::QObjectPicker, 13>(uri, 2, 13, "ObjectPicker");
     qmlRegisterUncreatableType<Qt3DRender::QPickEvent>(uri, 2, 0, "PickEvent", QStringLiteral("Events cannot be created"));
+    qmlRegisterUncreatableType<Qt3DRender::QPickEvent, 14>(uri, 2, 14, "PickEvent", QStringLiteral("Events cannot be created"));
     qmlRegisterType<Qt3DRender::Render::Quick::Quick3DRayCaster>(uri, 2, 11, "RayCaster");
     qmlRegisterType<Qt3DRender::Render::Quick::Quick3DScreenRayCaster>(uri, 2, 11, "ScreenRayCaster");
 
@@ -297,7 +298,7 @@ void Qt3DQuick3DRenderPlugin::registerTypes(const char *uri)
     qmlRegisterType<Qt3DRender::QBlendEquationArguments>(uri, 2, 0, "BlendEquationArguments");
     qmlRegisterType<Qt3DRender::QBlendEquation>(uri, 2, 0, "BlendEquation");
     qmlRegisterType<Qt3DRender::QAlphaTest>(uri, 2, 0, "AlphaTest");
-    qmlRegisterType<Qt3DRender::QDepthRange>(uri, 2, 13, "DepthRange");
+    qmlRegisterType<Qt3DRender::QDepthRange>(uri, 2, 14, "DepthRange");
     qmlRegisterType<Qt3DRender::QDepthTest>(uri, 2, 0, "DepthTest");
     qmlRegisterType<Qt3DRender::QMultiSampleAntiAliasing>(uri, 2, 0, "MultiSampleAntiAliasing");
     qmlRegisterType<Qt3DRender::QNoDepthMask>(uri, 2, 0, "NoDepthMask");
diff --git a/src/quick3d/quick3dscene2d/items/scene2d.cpp b/src/quick3d/quick3dscene2d/items/scene2d.cpp
index 27ab7f010..562f0d2c7 100644
--- a/src/quick3d/quick3dscene2d/items/scene2d.cpp
+++ b/src/quick3d/quick3dscene2d/items/scene2d.cpp
@@ -443,7 +443,7 @@ void Scene2D::cleanup()
     }
     if (m_renderThread) {
         renderThreadClientCount->fetchAndSubAcquire(1);
-        if (renderThreadClientCount->load() == 0)
+        if (renderThreadClientCount->loadRelaxed() == 0)
             renderThread->quit();
     }
 }
diff --git a/src/render/backend/abstractrenderer_p.h b/src/render/backend/abstractrenderer_p.h
index 6e6f4898c..006919512 100644
--- a/src/render/backend/abstractrenderer_p.h
+++ b/src/render/backend/abstractrenderer_p.h
@@ -67,7 +67,6 @@ class QSize;
 
 namespace Qt3DCore {
 class QAbstractFrameAdvanceService;
-class QBackendNodeFactory;
 class QEventFilterService;
 class QAbstractAspectJobManager;
 class QServiceLocator;
@@ -114,7 +113,6 @@ public:
         JointDirty          = 1 << 11,
         LayersDirty         = 1 << 12,
         TechniquesDirty     = 1 << 13,
-        EntityHierarchyDirty= 1 << 14,
         LightsDirty         = 1 << 15,
         AllDirty            = 0xffffff
     };
@@ -162,7 +160,7 @@ public:
     virtual Qt3DCore::QAspectJobPtr syncLoadingJobs() = 0;
     virtual Qt3DCore::QAspectJobPtr expandBoundingVolumeJob() = 0;
 
-    virtual void setSceneRoot(Qt3DCore::QBackendNodeFactory *factory, Entity *root) = 0;
+    virtual void setSceneRoot(Entity *root) = 0;
 
     virtual Entity *sceneRoot() const = 0;
     virtual FrameGraphNode *frameGraphRoot() const = 0;
diff --git a/src/render/backend/backendnode.cpp b/src/render/backend/backendnode.cpp
index 0dc8da237..188e017e6 100644
--- a/src/render/backend/backendnode.cpp
+++ b/src/render/backend/backendnode.cpp
@@ -41,6 +41,7 @@
 #include <private/renderer_p.h>
 #include <private/resourceaccessor_p.h>
 #include <private/nodemanagers_p.h>
+#include <Qt3DCore/private/qbackendnode_p.h>
 
 QT_BEGIN_NAMESPACE
 
@@ -81,6 +82,13 @@ QSharedPointer<RenderBackendResourceAccessor> BackendNode::resourceAccessor()
     return r->nodeManagers()->resourceAccessor();
 }
 
+void BackendNode::syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime)
+{
+    Q_UNUSED(firstTime);
+
+    d_ptr->setEnabled(frontEnd->isEnabled());
+}
+
 } // namespace Render
 } // namespace Qt3DRender
 
diff --git a/src/render/backend/backendnode_p.h b/src/render/backend/backendnode_p.h
index f94033c1a..167cb87f2 100644
--- a/src/render/backend/backendnode_p.h
+++ b/src/render/backend/backendnode_p.h
@@ -70,6 +70,8 @@ public:
     BackendNode(Qt3DCore::QBackendNode::Mode mode = ReadOnly);
     ~BackendNode();
 
+    virtual void syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime);
+
     void setRenderer(AbstractRenderer *renderer);
     AbstractRenderer *renderer() const;
 
diff --git a/src/render/backend/entity.cpp b/src/render/backend/entity.cpp
index bf128b508..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))
@@ -145,44 +160,6 @@ void Entity::setHandle(HEntity handle)
     m_handle = handle;
 }
 
-void Entity::initializeFromPeer(const QNodeCreatedChangeBasePtr &change)
-{
-    const auto typedChange = qSharedPointerCast<QNodeCreatedChange<Qt3DCore::QEntityData>>(change);
-    const auto &data = typedChange->data;
-
-    // Note this is *not* the parentId as that is the ID of the parent QNode, which is not
-    // necessarily the same as the parent QEntity (which may be further up the tree).
-    m_parentEntityId = data.parentEntityId;
-    qCDebug(Render::RenderNodes) << "Creating Entity id =" << peerId() << "parentId =" << m_parentEntityId;
-
-    // TODO: Store string id instead and only in debug mode
-    //m_objectName = peer->objectName();
-    m_worldTransform = m_nodeManagers->worldMatrixManager()->getOrAcquireHandle(peerId());
-
-    // TODO: Suboptimal -> Maybe have a Hash<QComponent, QEntityList> instead
-    m_transformComponent = QNodeId();
-    m_materialComponent = QNodeId();
-    m_cameraComponent = QNodeId();
-    m_geometryRendererComponent = QNodeId();
-    m_objectPickerComponent = QNodeId();
-    m_boundingVolumeDebugComponent = QNodeId();
-    m_computeComponent = QNodeId();
-    m_layerComponents.clear();
-    m_levelOfDetailComponents.clear();
-    m_rayCasterComponents.clear();
-    m_shaderDataComponents.clear();
-    m_lightComponents.clear();
-    m_environmentLightComponents.clear();
-    m_localBoundingVolume = QSharedPointer<Sphere>::create(peerId());
-    m_worldBoundingVolume = QSharedPointer<Sphere>::create(peerId());
-    m_worldBoundingVolumeWithChildren = QSharedPointer<Sphere>::create(peerId());
-
-    for (const auto &idAndType : qAsConst(data.componentIdsAndTypes))
-        addComponent(idAndType);
-
-    markDirty(AbstractRenderer::EntityHierarchyDirty);
-}
-
 void Entity::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
 {
     switch (e->type()) {
@@ -192,7 +169,6 @@ void Entity::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
         const auto componentIdAndType = QNodeIdTypePair(change->componentId(), change->componentMetaObject());
         addComponent(componentIdAndType);
         qCDebug(Render::RenderNodes) << Q_FUNC_INFO << "Component Added. Id =" << change->componentId();
-        markDirty(AbstractRenderer::AllDirty);
         break;
     }
 
@@ -200,27 +176,6 @@ void Entity::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
         QComponentRemovedChangePtr change = qSharedPointerCast<QComponentRemovedChange>(e);
         removeComponent(change->componentId());
         qCDebug(Render::RenderNodes) << Q_FUNC_INFO << "Component Removed. Id =" << change->componentId();
-        markDirty(AbstractRenderer::AllDirty);
-        break;
-    }
-
-    case PropertyUpdated: {
-        QPropertyUpdatedChangePtr change = qSharedPointerCast<QPropertyUpdatedChange>(e);
-        if (change->propertyName() == QByteArrayLiteral("enabled")) {
-            // We only mark as dirty the renderer
-            markDirty(AbstractRenderer::EntityEnabledDirty);
-            // We let QBackendNode::sceneChangeEvent change the enabled property
-        } else if (change->propertyName() == QByteArrayLiteral("parentEntityUpdated")) {
-            auto newParent = change->value().value<Qt3DCore::QNodeId>();
-            qCDebug(Render::RenderNodes) << "Setting parent for " << peerId() << ", new parentId =" << newParent;
-            if (m_parentEntityId != newParent) {
-                m_parentEntityId = newParent;
-                // TODO: change to EventHierarchyDirty and update renderer to
-                //       ensure all jobs are run that depend on Entity hierarchy.
-                markDirty(AbstractRenderer::AllDirty);
-            }
-        }
-
         break;
     }
 
@@ -230,6 +185,62 @@ void Entity::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
     BackendNode::sceneChangeEvent(e);
 }
 
+void Entity::syncFromFrontEnd(const QNode *frontEnd, bool firstTime)
+{
+    const Qt3DCore::QEntity *node = qobject_cast<const Qt3DCore::QEntity *>(frontEnd);
+    if (!node)
+        return;
+
+    if (this->isEnabled() != node->isEnabled()) {
+        markDirty(AbstractRenderer::EntityEnabledDirty);
+        // We let QBackendNode::syncFromFrontEnd change the enabled property
+    }
+
+    const auto parentID = node->parentEntity() ? node->parentEntity()->id() : Qt3DCore::QNodeId();
+    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());
+
+        // TODO: Suboptimal -> Maybe have a Hash<QComponent, QEntityList> instead
+        m_transformComponent = QNodeId();
+        m_materialComponent = QNodeId();
+        m_cameraComponent = QNodeId();
+        m_geometryRendererComponent = QNodeId();
+        m_objectPickerComponent = QNodeId();
+        m_boundingVolumeDebugComponent = QNodeId();
+        m_computeComponent = QNodeId();
+        m_layerComponents.clear();
+        m_levelOfDetailComponents.clear();
+        m_rayCasterComponents.clear();
+        m_shaderDataComponents.clear();
+        m_lightComponents.clear();
+        m_environmentLightComponents.clear();
+        m_localBoundingVolume = QSharedPointer<Sphere>::create(peerId());
+        m_worldBoundingVolume = QSharedPointer<Sphere>::create(peerId());
+        m_worldBoundingVolumeWithChildren = QSharedPointer<Sphere>::create(peerId());
+
+        const QComponentVector &components = node->components();
+        for (QComponent *c : components) {
+            const auto idAndType = QNodeIdTypePair(c->id(), QNodePrivate::findStaticMetaObject(c->metaObject()));
+            addComponent(idAndType);
+        }
+    }
+
+    BackendNode::syncFromFrontEnd(frontEnd, firstTime);
+}
+
 void Entity::dump() const
 {
     static int depth = 0;
@@ -246,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)
@@ -358,6 +356,7 @@ void Entity::addComponent(Qt3DCore::QNodeIdTypePair idAndType)
     } else if (type->inherits(&QArmature::staticMetaObject)) {
         m_armatureComponent = id;
     }
+    markDirty(AbstractRenderer::AllDirty);
 }
 
 void Entity::removeComponent(Qt3DCore::QNodeId nodeId)
@@ -392,6 +391,7 @@ void Entity::removeComponent(Qt3DCore::QNodeId nodeId)
     } else if (m_armatureComponent == nodeId) {
         m_armatureComponent = QNodeId();
     }
+    markDirty(AbstractRenderer::AllDirty);
 }
 
 bool Entity::isBoundingVolumeDirty() const
diff --git a/src/render/backend/entity_p.h b/src/render/backend/entity_p.h
index b4c9541f2..403f5568c 100644
--- a/src/render/backend/entity_p.h
+++ b/src/render/backend/entity_p.h
@@ -90,6 +90,7 @@ public:
     void setParentHandle(HEntity parentHandle);
     void setNodeManagers(NodeManagers *manager);
     void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e) override;
+    void syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime) override;
 
     void dump() const;
 
@@ -97,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; }
@@ -178,17 +176,12 @@ public:
         return containsComponentsOfType<T>() && containsComponentsOfType<Ts, Ts2...>();
     }
 
-
 private:
-    void initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change) final;
-
     NodeManagers *m_nodeManagers;
     HEntity m_handle;
     HEntity m_parentHandle;
     QVector<HEntity > m_childrenHandles;
 
-    Qt3DCore::QNodeId m_parentEntityId;
-
     HMatrix m_worldTransform;
     QSharedPointer<Sphere> m_localBoundingVolume;
     QSharedPointer<Sphere> m_worldBoundingVolume;
@@ -306,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/backend/transform.cpp b/src/render/backend/transform.cpp
index 390ed4f05..6659657fa 100644
--- a/src/render/backend/transform.cpp
+++ b/src/render/backend/transform.cpp
@@ -68,17 +68,6 @@ void Transform::cleanup()
     QBackendNode::setEnabled(false);
 }
 
-void Transform::initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change)
-{
-    const auto typedChange = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<QTransformData>>(change);
-    const auto &data = typedChange->data;
-    m_rotation = data.rotation;
-    m_scale = data.scale;
-    m_translation = data.translation;
-    updateMatrix();
-    markDirty(AbstractRenderer::TransformDirty);
-}
-
 Matrix4x4 Transform::transformMatrix() const
 {
     return m_transformMatrix;
@@ -99,6 +88,7 @@ QVector3D Transform::translation() const
     return m_translation;
 }
 
+// TODOSYNC remove once we've found a way to propagate animation changes
 void Transform::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
 {
     // TODO: Flag the matrix as dirty and update all matrices batched in a job
@@ -120,6 +110,27 @@ void Transform::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
     BackendNode::sceneChangeEvent(e);
 }
 
+void Transform::syncFromFrontEnd(const QNode *frontEnd, bool firstTime)
+{
+    const Qt3DCore::QTransform *transform = qobject_cast<const Qt3DCore::QTransform *>(frontEnd);
+    if (!transform)
+        return;
+
+    bool dirty = m_rotation != transform->rotation();
+    m_rotation = transform->rotation();
+    dirty |= m_scale != transform->scale3D();
+    m_scale = transform->scale3D();
+    dirty |= m_translation != transform->translation();
+    m_translation = transform->translation();
+
+    if (dirty || firstTime) {
+        updateMatrix();
+        markDirty(AbstractRenderer::TransformDirty);
+    }
+
+    BackendNode::syncFromFrontEnd(frontEnd, firstTime);
+}
+
 void Transform::notifyWorldTransformChanged(const Matrix4x4 &worldMatrix)
 {
     auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(peerId());
diff --git a/src/render/backend/transform_p.h b/src/render/backend/transform_p.h
index e3bcad317..50857ac94 100644
--- a/src/render/backend/transform_p.h
+++ b/src/render/backend/transform_p.h
@@ -77,12 +77,11 @@ public:
     QVector3D translation() const;
 
     void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e) override;
+    void syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime) final;
     void notifyWorldTransformChanged(const Matrix4x4 &worldMatrix);
 
 private:
     void updateMatrix();
-    void initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change) final;
-
     Matrix4x4 m_transformMatrix;
     QQuaternion m_rotation;
     QVector3D m_scale;
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 21eee51f6..cc74553b2 100644
--- a/src/render/framegraph/qrendercapture.cpp
+++ b/src/render/framegraph/qrendercapture.cpp
@@ -330,11 +330,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;
 }
@@ -355,11 +353,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/qcamera.cpp b/src/render/frontend/qcamera.cpp
index 1bf8caad9..2dcec7ed6 100644
--- a/src/render/frontend/qcamera.cpp
+++ b/src/render/frontend/qcamera.cpp
@@ -348,6 +348,18 @@ void QCameraPrivate::updateViewMatrixAndTransform(bool doEmit)
  * Holds the current projection matrix of the camera.
  */
 
+/*!
+ * \qmlproperty real Qt3D.Render::Camera::exposure
+ * Holds the current exposure of the camera.
+ *
+ * The default value is 0.0.
+ *
+ * The MetalRoughMaterial in Qt 3D Extras is currently the only provided
+ * material that makes use of camera exposure. Negative values will cause
+ * the material to be darker, and positive values will cause it to be lighter.
+ *
+ * Custom materials may choose to interpret the value differently.
+ */
 
 /*!
  * \qmlproperty vector3d Qt3D.Render::Camera::position
@@ -493,6 +505,14 @@ void QCameraPrivate::updateViewMatrixAndTransform(bool doEmit)
 /*!
  * \property QCamera::exposure
  * Holds the current exposure of the camera.
+ *
+ * The default value is 0.0.
+ *
+ * The MetalRoughMaterial in Qt 3D Extras is currently the only provided
+ * material that makes use of camera exposure. Negative values will cause
+ * the material to be darker, and positive values will cause it to be lighter.
+ *
+ * Custom materials may choose to interpret the value differently.
  */
 
 /*!
diff --git a/src/render/frontend/qrenderaspect.cpp b/src/render/frontend/qrenderaspect.cpp
index 8a0defceb..67bcb6c02 100644
--- a/src/render/frontend/qrenderaspect.cpp
+++ b/src/render/frontend/qrenderaspect.cpp
@@ -96,6 +96,7 @@
 #include <Qt3DCore/qjoint.h>
 #include <Qt3DCore/qskeletonloader.h>
 
+#include <Qt3DRender/private/backendnode_p.h>
 #include <Qt3DRender/private/cameraselectornode_p.h>
 #include <Qt3DRender/private/layerfilternode_p.h>
 #include <Qt3DRender/private/cameralens_p.h>
@@ -232,6 +233,12 @@ QRenderAspectPrivate *QRenderAspectPrivate::findPrivate(Qt3DCore::QAspectEngine
     return nullptr;
 }
 
+void QRenderAspectPrivate::syncDirtyFrontEndNode(QNode *node, QBackendNode *backend, bool firstTime) const
+{
+    Render::BackendNode *renderBackend = static_cast<Render::BackendNode *>(backend);
+    renderBackend->syncFromFrontEnd(node, firstTime);
+}
+
 /*! \internal */
 void QRenderAspectPrivate::registerBackendTypes()
 {
@@ -245,8 +252,8 @@ void QRenderAspectPrivate::registerBackendTypes()
     qRegisterMetaType<Qt3DRender::QViewport*>();
     qRegisterMetaType<Qt3DCore::QJoint*>();
 
-    q->registerBackendType<Qt3DCore::QEntity>(QSharedPointer<Render::RenderEntityFunctor>::create(m_renderer, m_nodeManagers));
-    q->registerBackendType<Qt3DCore::QTransform>(QSharedPointer<Render::NodeFunctor<Render::Transform, Render::TransformManager> >::create(m_renderer));
+    q->registerBackendType<Qt3DCore::QEntity, true>(QSharedPointer<Render::RenderEntityFunctor>::create(m_renderer, m_nodeManagers));
+    q->registerBackendType<Qt3DCore::QTransform, true>(QSharedPointer<Render::NodeFunctor<Render::Transform, Render::TransformManager> >::create(m_renderer));
 
     q->registerBackendType<Qt3DRender::QCameraLens>(QSharedPointer<Render::CameraLensFunctor>::create(m_renderer, q));
     q->registerBackendType<QLayer>(QSharedPointer<Render::NodeFunctor<Render::Layer, Render::LayerManager> >::create(m_renderer));
@@ -259,58 +266,58 @@ void QRenderAspectPrivate::registerBackendTypes()
     q->registerBackendType<QRenderState>(QSharedPointer<Render::NodeFunctor<Render::RenderStateNode, Render::RenderStateManager> >::create(m_renderer));
 
     // Geometry + Compute
-    q->registerBackendType<QAttribute>(QSharedPointer<Render::NodeFunctor<Render::Attribute, Render::AttributeManager> >::create(m_renderer));
-    q->registerBackendType<QBuffer>(QSharedPointer<Render::BufferFunctor>::create(m_renderer, m_nodeManagers->bufferManager()));
+    q->registerBackendType<QAttribute, true>(QSharedPointer<Render::NodeFunctor<Render::Attribute, Render::AttributeManager> >::create(m_renderer));
+    q->registerBackendType<QBuffer, true>(QSharedPointer<Render::BufferFunctor>::create(m_renderer, m_nodeManagers->bufferManager()));
     q->registerBackendType<QComputeCommand>(QSharedPointer<Render::NodeFunctor<Render::ComputeCommand, Render::ComputeCommandManager> >::create(m_renderer));
-    q->registerBackendType<QGeometry>(QSharedPointer<Render::NodeFunctor<Render::Geometry, Render::GeometryManager> >::create(m_renderer));
-    q->registerBackendType<QGeometryRenderer>(QSharedPointer<Render::GeometryRendererFunctor>::create(m_renderer, m_nodeManagers->geometryRendererManager()));
-    q->registerBackendType<Qt3DCore::QArmature>(QSharedPointer<Render::NodeFunctor<Render::Armature, Render::ArmatureManager>>::create(m_renderer));
-    q->registerBackendType<Qt3DCore::QAbstractSkeleton>(QSharedPointer<Render::SkeletonFunctor>::create(m_renderer, m_nodeManagers->skeletonManager(), m_nodeManagers->jointManager()));
-    q->registerBackendType<Qt3DCore::QJoint>(QSharedPointer<Render::JointFunctor>::create(m_renderer, m_nodeManagers->jointManager(), m_nodeManagers->skeletonManager()));
+    q->registerBackendType<QGeometry, true>(QSharedPointer<Render::NodeFunctor<Render::Geometry, Render::GeometryManager> >::create(m_renderer));
+    q->registerBackendType<QGeometryRenderer, true>(QSharedPointer<Render::GeometryRendererFunctor>::create(m_renderer, m_nodeManagers->geometryRendererManager()));
+    q->registerBackendType<Qt3DCore::QArmature, true>(QSharedPointer<Render::NodeFunctor<Render::Armature, Render::ArmatureManager>>::create(m_renderer));
+    q->registerBackendType<Qt3DCore::QAbstractSkeleton, true>(QSharedPointer<Render::SkeletonFunctor>::create(m_renderer, m_nodeManagers->skeletonManager(), m_nodeManagers->jointManager()));
+    q->registerBackendType<Qt3DCore::QJoint, true>(QSharedPointer<Render::JointFunctor>::create(m_renderer, m_nodeManagers->jointManager(), m_nodeManagers->skeletonManager()));
 
     // Textures
-    q->registerBackendType<QAbstractTexture>(QSharedPointer<Render::TextureFunctor>::create(m_renderer, m_nodeManagers->textureManager()));
+    q->registerBackendType<QAbstractTexture, true>(QSharedPointer<Render::TextureFunctor>::create(m_renderer, m_nodeManagers->textureManager()));
     q->registerBackendType<QAbstractTextureImage>(QSharedPointer<Render::TextureImageFunctor>::create(m_renderer,
                                                                                                       m_nodeManagers->textureImageManager()));
 
     // Material system
-    q->registerBackendType<QEffect>(QSharedPointer<Render::NodeFunctor<Render::Effect, Render::EffectManager> >::create(m_renderer));
+    q->registerBackendType<QEffect, true>(QSharedPointer<Render::NodeFunctor<Render::Effect, Render::EffectManager> >::create(m_renderer));
     q->registerBackendType<QFilterKey>(QSharedPointer<Render::NodeFunctor<Render::FilterKey, Render::FilterKeyManager> >::create(m_renderer));
-    q->registerBackendType<QAbstractLight>(QSharedPointer<Render::RenderLightFunctor>::create(m_renderer, m_nodeManagers));
-    q->registerBackendType<QEnvironmentLight>(QSharedPointer<Render::NodeFunctor<Render::EnvironmentLight, Render::EnvironmentLightManager> >::create(m_renderer));
-    q->registerBackendType<QMaterial>(QSharedPointer<Render::NodeFunctor<Render::Material, Render::MaterialManager> >::create(m_renderer));
-    q->registerBackendType<QParameter>(QSharedPointer<Render::NodeFunctor<Render::Parameter, Render::ParameterManager> >::create(m_renderer));
-    q->registerBackendType<QRenderPass>(QSharedPointer<Render::NodeFunctor<Render::RenderPass, Render::RenderPassManager> >::create(m_renderer));
+    q->registerBackendType<QAbstractLight, true>(QSharedPointer<Render::RenderLightFunctor>::create(m_renderer, m_nodeManagers));
+    q->registerBackendType<QEnvironmentLight, true>(QSharedPointer<Render::NodeFunctor<Render::EnvironmentLight, Render::EnvironmentLightManager> >::create(m_renderer));
+    q->registerBackendType<QMaterial, true>(QSharedPointer<Render::NodeFunctor<Render::Material, Render::MaterialManager> >::create(m_renderer));
+    q->registerBackendType<QParameter, true>(QSharedPointer<Render::NodeFunctor<Render::Parameter, Render::ParameterManager> >::create(m_renderer));
+    q->registerBackendType<QRenderPass, true>(QSharedPointer<Render::NodeFunctor<Render::RenderPass, Render::RenderPassManager> >::create(m_renderer));
     q->registerBackendType<QShaderData>(QSharedPointer<Render::RenderShaderDataFunctor>::create(m_renderer, m_nodeManagers));
     q->registerBackendType<QShaderProgram>(QSharedPointer<Render::NodeFunctor<Render::Shader, Render::ShaderManager> >::create(m_renderer));
     q->registerBackendType<QShaderProgramBuilder>(QSharedPointer<Render::NodeFunctor<Render::ShaderBuilder, Render::ShaderBuilderManager> >::create(m_renderer));
-    q->registerBackendType<QTechnique>(QSharedPointer<Render::TechniqueFunctor>::create(m_renderer, m_nodeManagers));
+    q->registerBackendType<QTechnique, true>(QSharedPointer<Render::TechniqueFunctor>::create(m_renderer, m_nodeManagers));
     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));
@@ -542,7 +549,7 @@ void QRenderAspect::onEngineStartup()
     Render::NodeManagers *managers = d->m_renderer->nodeManagers();
     Render::Entity *rootEntity = managers->lookupResource<Render::Entity, Render::EntityManager>(rootEntityId());
     Q_ASSERT(rootEntity);
-    d->m_renderer->setSceneRoot(d, rootEntity);
+    d->m_renderer->setSceneRoot(rootEntity);
 }
 
 void QRenderAspect::onRegistered()
diff --git a/src/render/frontend/qrenderaspect_p.h b/src/render/frontend/qrenderaspect_p.h
index 657e6a301..8ef4ecd12 100644
--- a/src/render/frontend/qrenderaspect_p.h
+++ b/src/render/frontend/qrenderaspect_p.h
@@ -85,6 +85,8 @@ public:
 
     static QRenderAspectPrivate* findPrivate(Qt3DCore::QAspectEngine *engine);
 
+    void syncDirtyFrontEndNode(Qt3DCore::QNode *node, Qt3DCore::QBackendNode *backend, bool firstTime) const override;
+
     void registerBackendTypes();
     void unregisterBackendTypes();
     void loadSceneParsers();
diff --git a/src/render/geometry/armature.cpp b/src/render/geometry/armature.cpp
index 15a26c9ec..cfa2e572a 100644
--- a/src/render/geometry/armature.cpp
+++ b/src/render/geometry/armature.cpp
@@ -36,6 +36,8 @@
 
 #include "armature_p.h"
 
+#include <Qt3DCore/qarmature.h>
+#include <Qt3DCore/qabstractskeleton.h>
 #include <Qt3DCore/qpropertyupdatedchange.h>
 
 #include <Qt3DCore/private/qarmature_p.h>
@@ -52,32 +54,20 @@ Armature::Armature()
 {
 }
 
-void Armature::cleanup()
+void Armature::syncFromFrontEnd(const QNode *frontEnd, bool firstTime)
 {
-    m_skeletonId = Qt3DCore::QNodeId();
-    setEnabled(false);
-}
+    BackendNode::syncFromFrontEnd(frontEnd, firstTime);
+    const QArmature *node = qobject_cast<const QArmature *>(frontEnd);
+    if (!node)
+        return;
 
-void Armature::initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change)
-{
-    const auto typedChange = qSharedPointerCast<QNodeCreatedChange<QArmatureData>>(change);
-    m_skeletonId = typedChange->data.skeletonId;
+    m_skeletonId = node->skeleton() ? node->skeleton()->id() : QNodeId{};
 }
 
-void Armature::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
+void Armature::cleanup()
 {
-    switch (e->type()) {
-    case Qt3DCore::PropertyUpdated: {
-        const auto change = qSharedPointerCast<QPropertyUpdatedChange>(e);
-        if (change->propertyName() == QByteArrayLiteral("skeleton"))
-            m_skeletonId = change->value().value<QNodeId>();
-        break;
-    }
-
-    default:
-        break;
-    }
-    QBackendNode::sceneChangeEvent(e);
+    m_skeletonId = Qt3DCore::QNodeId();
+    setEnabled(false);
 }
 
 } // namespace Render
diff --git a/src/render/geometry/armature_p.h b/src/render/geometry/armature_p.h
index 3e6e52a3f..39baa4a79 100644
--- a/src/render/geometry/armature_p.h
+++ b/src/render/geometry/armature_p.h
@@ -63,7 +63,7 @@ class Q_AUTOTEST_EXPORT Armature : public BackendNode
 public:
     Armature();
 
-    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e) override;
+    void syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime) override;
     void cleanup();
 
     Qt3DCore::QNodeId skeletonId() const { return m_skeletonId; }
@@ -73,8 +73,6 @@ public:
     const UniformValue &skinningPaletteUniform() const { return m_skinningPaletteUniform; }
 
 private:
-    void initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change) final;
-
     Qt3DCore::QNodeId m_skeletonId;
     UniformValue m_skinningPaletteUniform;
 };
diff --git a/src/render/geometry/attribute.cpp b/src/render/geometry/attribute.cpp
index bc6b27851..f241a85e5 100644
--- a/src/render/geometry/attribute.cpp
+++ b/src/render/geometry/attribute.cpp
@@ -83,78 +83,54 @@ void Attribute::cleanup()
     m_nameId = 0;
 }
 
-void Attribute::initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change)
+void Attribute::syncFromFrontEnd(const QNode *frontEnd, bool firstTime)
 {
-    const auto typedChange = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<QAttributeData>>(change);
-    const auto &data = typedChange->data;
-    m_bufferId = data.bufferId;
-    m_name = data.name;
-    m_nameId = StringToInt::lookupId(m_name);
-    m_vertexBaseType = data.vertexBaseType;
-    m_vertexSize = data.vertexSize;
-    m_count = data.count;
-    m_byteStride = data.byteStride;
-    m_byteOffset = data.byteOffset;
-    m_divisor = data.divisor;
-    m_attributeType = data.attributeType;
-    m_attributeDirty = true;
-}
-
-/*!
-    \fn Qt3DRender::QAttribute::dataSizeChanged(uint vertexSize)
-
-    The signal is emitted with \a vertexSize when the dataSize changes.
-
-*/
-/*!
-    \fn Qt3DRender::QAttribute::dataTypeChanged(Qt3DRender::QAttribute::VertexBaseType vertexBaseType)
-
-    The signal is emitted with \a vertexBaseType when the dataType changed.
-*/
-void Attribute::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
-{
-    switch (e->type()) {
-    case PropertyUpdated: {
-        QPropertyUpdatedChangePtr propertyChange = qSharedPointerCast<QPropertyUpdatedChange>(e);
-        QByteArray propertyName = propertyChange->propertyName();
-
-        if (propertyName == QByteArrayLiteral("name")) {
-            m_name = propertyChange->value().toString();
-            m_nameId = StringToInt::lookupId(m_name);
-            m_attributeDirty = true;
-        } else if (propertyName == QByteArrayLiteral("vertexBaseType")) {
-            m_vertexBaseType = static_cast<QAttribute::VertexBaseType>(propertyChange->value().value<int>());
-            m_attributeDirty = true;
-        } else if (propertyName == QByteArrayLiteral("vertexSize")) {
-            m_vertexSize = propertyChange->value().value<uint>();
-            m_attributeDirty = true;
-        } else if (propertyName == QByteArrayLiteral("count")) {
-            m_count = propertyChange->value().value<uint>();
-            m_attributeDirty = true;
-        } else if (propertyName == QByteArrayLiteral("byteStride")) {
-            m_byteStride = propertyChange->value().value<uint>();
-            m_attributeDirty = true;
-        } else if (propertyName == QByteArrayLiteral("byteOffset")) {
-            m_byteOffset = propertyChange->value().value<uint>();
-            m_attributeDirty = true;
-        } else if (propertyName == QByteArrayLiteral("divisor")) {
-            m_divisor = propertyChange->value().value<uint>();
-            m_attributeDirty = true;
-        } else if (propertyName == QByteArrayLiteral("attributeType")) {
-            m_attributeType = static_cast<QAttribute::AttributeType>(propertyChange->value().value<int>());
-            m_attributeDirty = true;
-        } else  if (propertyName == QByteArrayLiteral("buffer")) {
-            m_bufferId = propertyChange->value().value<QNodeId>();
-            m_attributeDirty = true;
-        }
-        markDirty(AbstractRenderer::AllDirty);
-        break;
+    BackendNode::syncFromFrontEnd(frontEnd, firstTime);
+    const QAttribute *node = qobject_cast<const QAttribute *>(frontEnd);
+    if (!node)
+        return;
+
+    m_attributeDirty = firstTime;
+    if (m_name != node->name()) {
+        m_name = node->name();
+        m_nameId = StringToInt::lookupId(m_name);
+        m_attributeDirty = true;
     }
-
-    default:
-        break;
+    if (m_vertexBaseType != node->vertexBaseType()) {
+        m_vertexBaseType = node->vertexBaseType();
+        m_attributeDirty = true;
     }
-    BackendNode::sceneChangeEvent(e);
+    if (m_vertexSize != node->vertexSize()) {
+        m_vertexSize = node->vertexSize();
+        m_attributeDirty = true;
+    }
+    if (m_count != node->count()) {
+        m_count = node->count();
+        m_attributeDirty = true;
+    }
+    if (m_byteStride != node->byteStride()) {
+        m_byteStride = node->byteStride();
+        m_attributeDirty = true;
+    }
+    if (m_byteOffset != node->byteOffset()) {
+        m_byteOffset = node->byteOffset();
+        m_attributeDirty = true;
+    }
+    if (m_divisor != node->divisor()) {
+        m_divisor = node->divisor();
+        m_attributeDirty = true;
+    }
+    if (m_attributeType != node->attributeType()) {
+        m_attributeType = node->attributeType();
+        m_attributeDirty = true;
+    }
+    const auto bufferId = node->buffer() ? node->buffer()->id() : QNodeId{};
+    if (bufferId != m_bufferId) {
+        m_bufferId = bufferId;
+        m_attributeDirty = true;
+    }
+
+    markDirty(AbstractRenderer::AllDirty);
 }
 
 void Attribute::unsetDirty()
diff --git a/src/render/geometry/attribute_p.h b/src/render/geometry/attribute_p.h
index e01537605..4b47146e1 100644
--- a/src/render/geometry/attribute_p.h
+++ b/src/render/geometry/attribute_p.h
@@ -68,7 +68,7 @@ public:
 
     void cleanup();
 
-    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e) override;
+    void syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime) override;
 
     inline Qt3DCore::QNodeId bufferId() const { return m_bufferId; }
     inline QString name() const { return m_name; }
@@ -84,8 +84,6 @@ public:
     void unsetDirty();
 
 private:
-    void initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change) final;
-
     Qt3DCore::QNodeId m_bufferId;
     QString m_name;
     int m_nameId;
diff --git a/src/render/geometry/buffer.cpp b/src/render/geometry/buffer.cpp
index d60f89c7d..998db3640 100644
--- a/src/render/geometry/buffer.cpp
+++ b/src/render/geometry/buffer.cpp
@@ -113,28 +113,6 @@ void Buffer::updateDataFromGPUToCPU(QByteArray data)
     notifyObservers(e);
 }
 
-void Buffer::initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change)
-{
-    const auto typedChange = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<QBufferData>>(change);
-    const auto &data = typedChange->data;
-    m_data = data.data;
-    m_usage = data.usage;
-    m_syncData = data.syncData;
-    m_access = data.access;
-    m_bufferDirty = true;
-
-    if (!m_data.isEmpty())
-        forceDataUpload();
-
-    m_functor = data.functor;
-    Q_ASSERT(m_manager);
-    if (m_functor)
-        m_manager->addDirtyBuffer(peerId());
-
-    m_manager->addBufferReference(peerId());
-    markDirty(AbstractRenderer::BuffersDirty);
-}
-
 void Buffer::forceDataUpload()
 {
     // We push back an update with offset = -1
@@ -145,40 +123,50 @@ void Buffer::forceDataUpload()
     m_bufferUpdates.push_back(updateNewData);
 }
 
-void Buffer::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
+void Buffer::syncFromFrontEnd(const QNode *frontEnd, bool firstTime)
 {
-    if (e->type() == PropertyUpdated) {
-        QPropertyUpdatedChangePtr propertyChange = qSharedPointerCast<QPropertyUpdatedChange>(e);
-        QByteArray propertyName = propertyChange->propertyName();
-        if (propertyName == QByteArrayLiteral("data")) {
-            QByteArray newData = propertyChange->value().toByteArray();
+    BackendNode::syncFromFrontEnd(frontEnd, firstTime);
+    const QBuffer *node = qobject_cast<const QBuffer *>(frontEnd);
+    if (!node)
+        return;
+
+    if (firstTime && m_manager != nullptr)
+        m_manager->addBufferReference(peerId());
+
+    m_syncData = node->isSyncData();
+    m_access = node->accessType();
+    if (m_usage != node->usage()) {
+        m_usage = node->usage();
+        m_bufferDirty = true;
+    }
+    {
+        QBufferDataGeneratorPtr newGenerator = node->dataGenerator();
+        bool dirty = (newGenerator && m_functor && !(*newGenerator == *m_functor)) ||
+                     (newGenerator.isNull() && !m_functor.isNull()) ||
+                     (!newGenerator.isNull() && m_functor.isNull());
+        m_bufferDirty |= dirty;
+        m_functor = newGenerator;
+        if (m_functor && m_manager != nullptr)
+            m_manager->addDirtyBuffer(peerId());
+    }
+    {
+        QVariant v = node->property("QT3D_updateData");
+        if (v.isValid()) {
+            Qt3DRender::QBufferUpdate updateData = v.value<Qt3DRender::QBufferUpdate>();
+            m_data.replace(updateData.offset, updateData.data.size(), updateData.data);
+            m_bufferUpdates.push_back(updateData);
+            m_bufferDirty = true;
+            const_cast<QBuffer *>(node)->setProperty("QT3D_updateData", {});
+        } else {
+            QByteArray newData = node->data();
             bool dirty = m_data != newData;
             m_bufferDirty |= dirty;
             m_data = newData;
-            if (dirty)
+            if (dirty && !m_data.isEmpty())
                 forceDataUpload();
-        } else if (propertyName == QByteArrayLiteral("updateData")) {
-            Qt3DRender::QBufferUpdate updateData = propertyChange->value().value<Qt3DRender::QBufferUpdate>();
-            m_data.replace(updateData.offset, updateData.data.size(), updateData.data);
-            m_bufferUpdates.push_back(updateData);
-            m_bufferDirty = true;
-        } else if (propertyName == QByteArrayLiteral("usage")) {
-            m_usage = static_cast<QBuffer::UsageType>(propertyChange->value().value<int>());
-            m_bufferDirty = true;
-        } else if (propertyName == QByteArrayLiteral("accessType")) {
-            m_access = static_cast<QBuffer::AccessType>(propertyChange->value().value<int>());
-        } else if (propertyName == QByteArrayLiteral("dataGenerator")) {
-            QBufferDataGeneratorPtr newGenerator = propertyChange->value().value<QBufferDataGeneratorPtr>();
-            m_bufferDirty |= !(newGenerator && m_functor && *newGenerator == *m_functor);
-            m_functor = newGenerator;
-            if (m_functor && m_manager != nullptr)
-                m_manager->addDirtyBuffer(peerId());
-        } else if (propertyName == QByteArrayLiteral("syncData")) {
-            m_syncData = propertyChange->value().toBool();
         }
-        markDirty(AbstractRenderer::BuffersDirty);
     }
-    BackendNode::sceneChangeEvent(e);
+    markDirty(AbstractRenderer::BuffersDirty);
 }
 
 // Called by Renderer once the buffer has been uploaded to OpenGL
diff --git a/src/render/geometry/buffer_p.h b/src/render/geometry/buffer_p.h
index 9a171599d..a3f52d1b3 100644
--- a/src/render/geometry/buffer_p.h
+++ b/src/render/geometry/buffer_p.h
@@ -73,7 +73,7 @@ public:
     ~Buffer();
     void cleanup();
 
-    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e) override;
+    void syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime) override;
 
     void setManager(BufferManager *manager);
     void executeFunctor();
@@ -88,7 +88,6 @@ public:
     void unsetDirty();
 
 private:
-    void initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change) final;
     void forceDataUpload();
 
     QBuffer::UsageType m_usage;
diff --git a/src/render/geometry/geometry.cpp b/src/render/geometry/geometry.cpp
index 4ee02a74d..cb401df5b 100644
--- a/src/render/geometry/geometry.cpp
+++ b/src/render/geometry/geometry.cpp
@@ -45,6 +45,8 @@
 #include <Qt3DCore/qpropertynodeaddedchange.h>
 #include <Qt3DCore/qpropertynoderemovedchange.h>
 
+#include <algorithm>
+
 QT_BEGIN_NAMESPACE
 
 using namespace Qt3DCore;
@@ -76,51 +78,29 @@ void Geometry::cleanup()
     m_shouldNotifyMaxExtentChanged = false;
 }
 
-void Geometry::initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change)
-{
-    const auto typedChange = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<QGeometryData>>(change);
-    const auto &data = typedChange->data;
-    m_attributes = data.attributeIds;
-    m_boundingPositionAttribute = data.boundingVolumePositionAttributeId;
-    m_geometryDirty = true;
-    markDirty(AbstractRenderer::GeometryDirty);
-}
-
-void Geometry::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
+void Geometry::syncFromFrontEnd(const QNode *frontEnd, bool firstTime)
 {
-    switch (e->type()) {
-    case PropertyValueAdded: {
-        const auto change = qSharedPointerCast<QPropertyNodeAddedChange>(e);
-        if (change->propertyName() == QByteArrayLiteral("attribute")) {
-            m_attributes.push_back(change->addedNodeId());
-            m_geometryDirty = true;
-        }
-        break;
-    }
-
-    case PropertyValueRemoved: {
-        const auto change = qSharedPointerCast<QPropertyNodeRemovedChange>(e);
-        if (change->propertyName() == QByteArrayLiteral("attribute")) {
-            m_attributes.removeOne(change->removedNodeId());
-            m_geometryDirty = true;
-        }
-        break;
+    BackendNode::syncFromFrontEnd(frontEnd, firstTime);
+    const QGeometry *node = qobject_cast<const QGeometry *>(frontEnd);
+    if (!node)
+        return;
+
+    m_geometryDirty |= firstTime;
+
+    QNodeIdVector attribs = qIdsForNodes(node->attributes());
+    std::sort(std::begin(attribs), std::end(attribs));
+    if (m_attributes != attribs) {
+        m_attributes = attribs;
+        m_geometryDirty = true;
     }
 
-    case PropertyUpdated: {
+    if ((node->boundingVolumePositionAttribute() && node->boundingVolumePositionAttribute()->id() != m_boundingPositionAttribute) ||
         // Note: doesn't set dirtyness as this parameter changing doesn't need a new VAO update.
-        const auto change = qSharedPointerCast<QPropertyUpdatedChange>(e);
-        if (change->propertyName() == QByteArrayLiteral("boundingVolumePositionAttribute")) {
-            m_boundingPositionAttribute = change->value().value<QNodeId>();
-            break;
-        }
+        (!node->boundingVolumePositionAttribute() && !m_boundingPositionAttribute.isNull())) {
+        m_boundingPositionAttribute = node->boundingVolumePositionAttribute() ? node->boundingVolumePositionAttribute()->id() : QNodeId{};
     }
 
-    default:
-        break;
-    }
     markDirty(AbstractRenderer::GeometryDirty);
-    BackendNode::sceneChangeEvent(e);
 }
 
 void Geometry::unsetDirty()
diff --git a/src/render/geometry/geometry_p.h b/src/render/geometry/geometry_p.h
index e66524787..429a577b0 100644
--- a/src/render/geometry/geometry_p.h
+++ b/src/render/geometry/geometry_p.h
@@ -68,7 +68,7 @@ public:
 
     void cleanup();
 
-    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e) override;
+    void syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime) override;
 
     inline QVector<Qt3DCore::QNodeId> attributes() const { return m_attributes; }
     inline bool isDirty() const { return m_geometryDirty; }
@@ -82,8 +82,6 @@ public:
     void notifyExtentChanged();
 
 private:
-    void initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change) final;
-
     QVector<Qt3DCore::QNodeId> m_attributes;
     bool m_geometryDirty;
     Qt3DCore::QNodeId m_boundingPositionAttribute;
diff --git a/src/render/geometry/geometryrenderer.cpp b/src/render/geometry/geometryrenderer.cpp
index ea059c6ee..b5c741659 100644
--- a/src/render/geometry/geometryrenderer.cpp
+++ b/src/render/geometry/geometryrenderer.cpp
@@ -105,95 +105,47 @@ void GeometryRenderer::setManager(GeometryRendererManager *manager)
     m_manager = manager;
 }
 
-void GeometryRenderer::initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change)
+void GeometryRenderer::syncFromFrontEnd(const QNode *frontEnd, bool firstTime)
 {
-    const auto typedChange = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<QGeometryRendererData>>(change);
-    const auto &data = typedChange->data;
-    m_geometryId = data.geometryId;
-    m_instanceCount = data.instanceCount;
-    m_vertexCount = data.vertexCount;
-    m_indexOffset = data.indexOffset;
-    m_firstInstance = data.firstInstance;
-    m_firstVertex = data.firstVertex;
-    m_indexBufferByteOffset = data.indexBufferByteOffset;
-    m_restartIndexValue = data.restartIndexValue;
-    m_verticesPerPatch = data.verticesPerPatch;
-    m_primitiveRestartEnabled = data.primitiveRestart;
-    m_primitiveType = data.primitiveType;
-
-    Q_ASSERT(m_manager);
-    m_geometryFactory = data.geometryFactory;
-    if (m_geometryFactory)
-        m_manager->addDirtyGeometryRenderer(peerId());
-
-    m_dirty = true;
-    markDirty(AbstractRenderer::GeometryDirty);
-}
-
-void GeometryRenderer::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
-{
-    switch (e->type()) {
-    case PropertyUpdated: {
-        QPropertyUpdatedChangePtr propertyChange = qSharedPointerCast<QPropertyUpdatedChange>(e);
-        QByteArray propertyName = propertyChange->propertyName();
-
-        if (propertyName == QByteArrayLiteral("instanceCount")) {
-            m_instanceCount = propertyChange->value().value<int>();
-            m_dirty = true;
-        } else if (propertyName == QByteArrayLiteral("vertexCount")) {
-            m_vertexCount = propertyChange->value().value<int>();
-            m_dirty = true;
-        } else if (propertyName == QByteArrayLiteral("indexOffset")) {
-            m_indexOffset = propertyChange->value().value<int>();
-            m_dirty = true;
-        } else if (propertyName == QByteArrayLiteral("firstInstance")) {
-            m_firstInstance = propertyChange->value().value<int>();
-            m_dirty = true;
-        } else if (propertyName == QByteArrayLiteral("firstVertex")) {
-            m_firstVertex = propertyChange->value().value<int>();
-            m_dirty = true;
-        } else if (propertyName == QByteArrayLiteral("indexBufferByteOffset")) {
-            m_indexBufferByteOffset = propertyChange->value().value<int>();
-            m_dirty = true;
-        } else if (propertyName == QByteArrayLiteral("restartIndexValue")) {
-            m_restartIndexValue = propertyChange->value().value<int>();
-            m_dirty = true;
-        } else if (propertyName == QByteArrayLiteral("verticesPerPatch")) {
-            m_verticesPerPatch = propertyChange->value().value<int>();
-            m_dirty = true;
-        } else if (propertyName == QByteArrayLiteral("primitiveRestartEnabled")) {
-            m_primitiveRestartEnabled = propertyChange->value().toBool();
-            m_dirty = true;
-        } else if (propertyName == QByteArrayLiteral("primitiveType")) {
-            m_primitiveType = static_cast<QGeometryRenderer::PrimitiveType>(propertyChange->value().value<int>());
-            m_dirty = true;
-        } else if (propertyName == QByteArrayLiteral("geometryFactory")) {
-            QGeometryFactoryPtr newFunctor = propertyChange->value().value<QGeometryFactoryPtr>();
-            const bool functorDirty = ((m_geometryFactory && !newFunctor)
-                                    || (!m_geometryFactory && newFunctor)
-                                    || (m_geometryFactory && newFunctor && !(*newFunctor == *m_geometryFactory)));
-            m_dirty |= functorDirty;
-            if (functorDirty) {
-                m_geometryFactory = newFunctor;
-                if (m_geometryFactory && m_manager != nullptr)
-                    m_manager->addDirtyGeometryRenderer(peerId());
-            }
-        } else if (propertyName == QByteArrayLiteral("geometry")) {
-            m_geometryId = propertyChange->value().value<Qt3DCore::QNodeId>();
-            m_dirty = true;
-        }
-        break;
-    }
-
-    default:
-        break;
+    BackendNode::syncFromFrontEnd(frontEnd, firstTime);
+    const QGeometryRenderer *node = qobject_cast<const QGeometryRenderer *>(frontEnd);
+    if (!node)
+        return;
+
+    m_dirty |= m_instanceCount != node->instanceCount();
+    m_instanceCount = node->instanceCount();
+    m_dirty |= m_vertexCount != node->vertexCount();
+    m_vertexCount = node->vertexCount();
+    m_dirty |= m_indexOffset != node->indexOffset();
+    m_indexOffset = node->indexOffset();
+    m_dirty |= m_firstInstance != node->firstInstance();
+    m_firstInstance = node->firstInstance();
+    m_dirty |= m_firstVertex != node->firstVertex();
+    m_firstVertex = node->firstVertex();
+    m_dirty |= m_indexBufferByteOffset != node->indexBufferByteOffset();
+    m_indexBufferByteOffset = node->indexBufferByteOffset();
+    m_dirty |= m_restartIndexValue != node->restartIndexValue();
+    m_restartIndexValue = node->restartIndexValue();
+    m_dirty |= m_verticesPerPatch != node->verticesPerPatch();
+    m_verticesPerPatch = node->verticesPerPatch();
+    m_dirty |= m_primitiveRestartEnabled != node->primitiveRestartEnabled();
+    m_primitiveRestartEnabled = node->primitiveRestartEnabled();
+    m_dirty |= m_primitiveType != node->primitiveType();
+    m_primitiveType = node->primitiveType();
+    m_dirty |= (node->geometry() && m_geometryId != node->geometry()->id()) || (!node->geometry() && !m_geometryId.isNull());
+    m_geometryId = node->geometry() ? node->geometry()->id() : Qt3DCore::QNodeId();
+    QGeometryFactoryPtr newFunctor = node->geometryFactory();
+    const bool functorDirty = ((m_geometryFactory && !newFunctor)
+                               || (!m_geometryFactory && newFunctor)
+                               || (m_geometryFactory && newFunctor && !(*newFunctor == *m_geometryFactory)));
+    if (functorDirty) {
+        m_dirty = true;
+        m_geometryFactory = newFunctor;
+        if (m_geometryFactory && m_manager != nullptr)
+            m_manager->addDirtyGeometryRenderer(peerId());
     }
 
     markDirty(AbstractRenderer::GeometryDirty);
-
-    BackendNode::sceneChangeEvent(e);
-
-    // Add to dirty list in manager
 }
 
 void GeometryRenderer::executeFunctor()
diff --git a/src/render/geometry/geometryrenderer_p.h b/src/render/geometry/geometryrenderer_p.h
index 57d1ca0be..da538a00d 100644
--- a/src/render/geometry/geometryrenderer_p.h
+++ b/src/render/geometry/geometryrenderer_p.h
@@ -74,7 +74,7 @@ public:
 
     void cleanup();
     void setManager(GeometryRendererManager *manager);
-    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e) override;
+    void syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime) override;
     void executeFunctor();
 
     inline Qt3DCore::QNodeId geometryId() const { return m_geometryId; }
@@ -98,8 +98,6 @@ public:
     QVector<RayCasting::QBoundingVolume *> triangleData() const;
 
 private:
-    void initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change) final;
-
     Qt3DCore::QNodeId m_geometryId;
     int m_instanceCount;
     int m_vertexCount;
diff --git a/src/render/geometry/joint.cpp b/src/render/geometry/joint.cpp
index c770564f9..86d583f51 100644
--- a/src/render/geometry/joint.cpp
+++ b/src/render/geometry/joint.cpp
@@ -39,11 +39,14 @@
 
 #include "joint_p.h"
 #include <Qt3DRender/private/managers_p.h>
+#include <Qt3DCore/QJoint>
 #include <Qt3DCore/private/qjoint_p.h>
 #include <Qt3DCore/qpropertyupdatedchange.h>
 #include <Qt3DCore/qpropertynodeaddedchange.h>
 #include <Qt3DCore/qpropertynoderemovedchange.h>
 
+#include <algorithm>
+
 QT_BEGIN_NAMESPACE
 
 using namespace Qt3DCore;
@@ -69,21 +72,7 @@ void Joint::cleanup()
     setEnabled(false);
 }
 
-void Joint::initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change)
-{
-    Q_ASSERT(m_jointManager);
-    const auto typedChange = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<QJointData>>(change);
-    const auto &data = typedChange->data;
-    m_inverseBindMatrix = data.inverseBindMatrix;
-    m_localPose.rotation = data.rotation;
-    m_localPose.scale = data.scale;
-    m_localPose.translation = data.translation;
-    m_childJointIds = data.childJointIds;
-    m_name = data.name;
-    markDirty(AbstractRenderer::JointDirty);
-    m_jointManager->addDirtyJoint(peerId());
-}
-
+// TODOSYNC remove once animation changes don't use messages anymore
 void Joint::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
 {
     if (e->type() == PropertyUpdated) {
@@ -123,10 +112,60 @@ void Joint::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
         if (removedChange->propertyName() == QByteArrayLiteral("childJoint"))
             m_childJointIds.removeOne(removedChange->removedNodeId());
     }
-
     BackendNode::sceneChangeEvent(e);
 }
 
+void Joint::syncFromFrontEnd(const QNode *frontEnd, bool firstTime)
+{
+    const Qt3DCore::QJoint *joint = qobject_cast<const Qt3DCore::QJoint *>(frontEnd);
+    if (!joint)
+        return;
+
+    if (m_localPose.scale != joint->scale()) {
+        m_localPose.scale = joint->scale();
+        markDirty(AbstractRenderer::JointDirty);
+        m_jointManager->addDirtyJoint(peerId());
+    }
+    if (m_localPose.rotation != joint->rotation()) {
+        m_localPose.rotation = joint->rotation();
+        markDirty(AbstractRenderer::JointDirty);
+        m_jointManager->addDirtyJoint(peerId());
+    }
+    if (m_localPose.translation != joint->translation()) {
+        m_localPose.translation = joint->translation();
+        markDirty(AbstractRenderer::JointDirty);
+        m_jointManager->addDirtyJoint(peerId());
+    }
+    if (m_inverseBindMatrix != joint->inverseBindMatrix()) {
+        // Setting the inverse bind matrix should be a rare operation. Usually it is
+        // set once and then remains constant for the duration of the skeleton. So just
+        // trigger a rebuild of the skeleton's SkeletonData which will include obtaining
+        // the inverse bind matrix.
+        m_inverseBindMatrix = joint->inverseBindMatrix();
+        m_skeletonManager->addDirtySkeleton(SkeletonManager::SkeletonDataDirty, m_owningSkeleton);
+    }
+    if (m_name != joint->name()) {
+        // Joint name doesn't affect anything in the render aspect so no need
+        // to mark anything as dirty.
+        m_name = joint->name();
+
+        // TODO: Notify other aspects (animation) about the name change.
+    }
+
+    Qt3DCore::QNodeIdVector childIds = qIdsForNodes(joint->childJoints());
+    std::sort(std::begin(childIds), std::end(childIds));
+    if (m_childJointIds != childIds) {
+        m_childJointIds = childIds;
+    }
+
+    if (firstTime) {
+        markDirty(AbstractRenderer::JointDirty);
+        m_jointManager->addDirtyJoint(peerId());
+    }
+
+    BackendNode::syncFromFrontEnd(frontEnd, firstTime);
+}
+
 
 JointFunctor::JointFunctor(AbstractRenderer *renderer,
                            JointManager *jointManager,
diff --git a/src/render/geometry/joint_p.h b/src/render/geometry/joint_p.h
index e144ac489..d0530ac04 100644
--- a/src/render/geometry/joint_p.h
+++ b/src/render/geometry/joint_p.h
@@ -70,6 +70,7 @@ public:
 
     void cleanup();
     void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e) override;
+    void syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime) override;
 
     Qt3DCore::Sqt localPose() const { return m_localPose; }
     QMatrix4x4 inverseBindMatrix() const { return m_inverseBindMatrix; }
@@ -90,8 +91,6 @@ public:
     SkeletonManager *skeletonManager() const { return m_skeletonManager; }
 
 private:
-    void initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change) final;
-
     QMatrix4x4 m_inverseBindMatrix;
     Qt3DCore::Sqt m_localPose;
     QVector<Qt3DCore::QNodeId> m_childJointIds;
diff --git a/src/render/geometry/qattribute.cpp b/src/render/geometry/qattribute.cpp
index ca467fda9..a28d0baa6 100644
--- a/src/render/geometry/qattribute.cpp
+++ b/src/render/geometry/qattribute.cpp
@@ -505,6 +505,19 @@ Qt3DCore::QNodeCreatedChangeBasePtr QAttribute::createNodeCreationChange() const
     return creationChange;
 }
 
+
+/*!
+\fn Qt3DRender::QAttribute::dataSizeChanged(uint vertexSize)
+
+The signal is emitted with \a vertexSize when the dataSize changes.
+*/
+/*!
+\fn Qt3DRender::QAttribute::dataTypeChanged(Qt3DRender::QAttribute::VertexBaseType vertexBaseType)
+
+The signal is emitted with \a vertexBaseType when the dataType changed.
+*/
+
+
 } // Qt3DRender
 
 QT_END_NAMESPACE
diff --git a/src/render/geometry/qbuffer.cpp b/src/render/geometry/qbuffer.cpp
index e0574a4c5..f27005f2b 100644
--- a/src/render/geometry/qbuffer.cpp
+++ b/src/render/geometry/qbuffer.cpp
@@ -329,7 +329,7 @@ void QBuffer::setData(const QByteArray &bytes)
     Q_D(QBuffer);
     if (bytes != d->m_data) {
         d->m_data = bytes;
-        Qt3DCore::QNodePrivate::get(this)->notifyPropertyChange("data", QVariant::fromValue(d->m_data));
+        Qt3DCore::QNodePrivate::get(this)->update();
         emit dataChanged(bytes);
     }
 }
@@ -351,11 +351,8 @@ void QBuffer::updateData(int offset, const QByteArray &bytes)
     QBufferUpdate updateData;
     updateData.offset = offset;
     updateData.data = bytes;
-
-    auto e = QPropertyUpdatedChangePtr::create(id());
-    e->setPropertyName("updateData");
-    e->setValue(QVariant::fromValue(updateData));
-    notifyObservers(e);
+    setProperty("QT3D_updateData", QVariant::fromValue(updateData));
+    d->update();
 }
 
 /*!
@@ -409,12 +406,7 @@ void QBuffer::setDataGenerator(const QBufferDataGeneratorPtr &functor)
     if (functor && d->m_functor && *functor == *d->m_functor)
         return;
     d->m_functor = functor;
-    if (d->m_changeArbiter != nullptr) {
-        auto change = QPropertyUpdatedChangePtr::create(d->m_id);
-        change->setPropertyName("dataGenerator");
-        change->setValue(QVariant::fromValue(d->m_functor));
-        d->notifyObservers(change);
-    }
+    d->update();
 }
 
 /*!
diff --git a/src/render/geometry/qgeometry.cpp b/src/render/geometry/qgeometry.cpp
index ec80e2657..47fad4302 100644
--- a/src/render/geometry/qgeometry.cpp
+++ b/src/render/geometry/qgeometry.cpp
@@ -196,11 +196,7 @@ void QGeometry::addAttribute(QAttribute *attribute)
         if (!attribute->parent())
             attribute->setParent(this);
 
-        if (d->m_changeArbiter != nullptr) {
-            const auto change = QPropertyNodeAddedChangePtr::create(id(), attribute);
-            change->setPropertyName("attribute");
-            d->notifyObservers(change);
-        }
+        d->update();
     }
 }
 
@@ -212,14 +208,10 @@ void QGeometry::removeAttribute(QAttribute *attribute)
 {
     Q_ASSERT(attribute);
     Q_D(QGeometry);
-    if (d->m_changeArbiter != nullptr) {
-        const auto change = QPropertyNodeRemovedChangePtr::create(id(), attribute);
-        change->setPropertyName("attribute");
-        d->notifyObservers(change);
-    }
     d->m_attributes.removeOne(attribute);
     // Remove bookkeeping connection
     d->unregisterDestructionHelper(attribute);
+    d->update();
 }
 
 void QGeometry::setBoundingVolumePositionAttribute(QAttribute *boundingVolumePositionAttribute)
diff --git a/src/render/geometry/qgeometryrenderer.cpp b/src/render/geometry/qgeometryrenderer.cpp
index 6bff3462f..ddea873a7 100644
--- a/src/render/geometry/qgeometryrenderer.cpp
+++ b/src/render/geometry/qgeometryrenderer.cpp
@@ -480,12 +480,7 @@ void QGeometryRenderer::setGeometryFactory(const QGeometryFactoryPtr &factory)
     if (factory && d->m_geometryFactory && *factory == *d->m_geometryFactory)
         return;
     d->m_geometryFactory = factory;
-    if (d->m_changeArbiter != nullptr) {
-        auto change = QPropertyUpdatedChangePtr::create(d->m_id);
-        change->setPropertyName("geometryFactory");
-        change->setValue(QVariant::fromValue(d->m_geometryFactory));
-        d->notifyObservers(change);
-    }
+    d->update();
 }
 
 /*!
diff --git a/src/render/geometry/skeleton.cpp b/src/render/geometry/skeleton.cpp
index 615b76c88..d4af1fe3c 100644
--- a/src/render/geometry/skeleton.cpp
+++ b/src/render/geometry/skeleton.cpp
@@ -80,39 +80,68 @@ void Skeleton::cleanup()
     setEnabled(false);
 }
 
-void Skeleton::initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change)
+void Skeleton::syncFromFrontEnd(const QNode *frontEnd, bool firstTime)
 {
-    Q_ASSERT(m_skeletonManager);
-    m_skeletonHandle = m_skeletonManager->lookupHandle(peerId());
-
-    const auto skeletonCreatedChange = qSharedPointerCast<QSkeletonCreatedChangeBase>(change);
-    switch (skeletonCreatedChange->type()) {
-    case QSkeletonCreatedChangeBase::SkeletonLoader: {
-        const auto loaderTypedChange = qSharedPointerCast<QSkeletonCreatedChange<QSkeletonLoaderData>>(change);
-        const auto &data = loaderTypedChange->data;
-        m_dataType = File;
-        m_source = data.source;
-        m_createJoints = data.createJoints;
-        if (!m_source.isEmpty()) {
-            markDirty(AbstractRenderer::SkeletonDataDirty);
-            m_skeletonManager->addDirtySkeleton(SkeletonManager::SkeletonDataDirty, m_skeletonHandle);
+    BackendNode::syncFromFrontEnd(frontEnd, firstTime);
+    const QAbstractSkeleton *node = qobject_cast<const QAbstractSkeleton *>(frontEnd);
+    if (!node)
+        return;
+    const QSkeleton *skeletonNode = qobject_cast<const QSkeleton *>(frontEnd);
+    const QSkeletonLoader *loaderNode = qobject_cast<const QSkeletonLoader *>(frontEnd);
+
+    if (firstTime) {
+        m_skeletonHandle = m_skeletonManager->lookupHandle(peerId());
+
+        if (skeletonNode) {
+            m_dataType = Data;
+            m_rootJointId = skeletonNode->rootJoint()->id();
+            if (!m_rootJointId.isNull()) {
+                markDirty(AbstractRenderer::SkeletonDataDirty);
+                m_skeletonManager->addDirtySkeleton(SkeletonManager::SkeletonDataDirty, m_skeletonHandle);
+            }
+        }
+
+        if (loaderNode) {
+            m_dataType = File;
+            m_source = loaderNode->source();
+            if (!m_source.isEmpty()) {
+                markDirty(AbstractRenderer::SkeletonDataDirty);
+                m_skeletonManager->addDirtySkeleton(SkeletonManager::SkeletonDataDirty, m_skeletonHandle);
+            }
         }
-        break;
     }
 
-    case QSkeletonCreatedChangeBase::Skeleton:
-        const auto typedChange = qSharedPointerCast<QSkeletonCreatedChange<QSkeletonData>>(change);
-        const auto &data = typedChange->data;
-        m_dataType = Data;
-        m_rootJointId = data.rootJointId;
-        if (!m_rootJointId.isNull()) {
+    if (loaderNode) {
+        if (loaderNode->source() != m_source) {
+            m_source = loaderNode->source();
             markDirty(AbstractRenderer::SkeletonDataDirty);
             m_skeletonManager->addDirtySkeleton(SkeletonManager::SkeletonDataDirty, m_skeletonHandle);
         }
-        break;
+        m_createJoints = loaderNode->isCreateJointsEnabled();
+
+        if ((loaderNode->rootJoint() && loaderNode->rootJoint()->id() != m_rootJointId) ||
+            (!loaderNode->rootJoint() && !m_rootJointId.isNull())) {
+            m_rootJointId = loaderNode->rootJoint() ? loaderNode->rootJoint()->id() : Qt3DCore::QNodeId{};
+
+            // If using a QSkeletonLoader to create frontend QJoints, when those joints are
+            // set on the skeleton, we end up here. In order to allow the subsequent call
+            // to loadSkeleton(), see below, to build the internal data from the frontend
+            // joints rather than from the source url again, we need to change the data type
+            // to Data.
+            m_dataType = Data;
+
+            // If the joint changes, we need to rebuild our internal SkeletonData and
+            // the relationships between joints and skeleton. Mark the skeleton data as
+            // dirty so that we get a loadSkeletonJob executed to process this skeleton.
+            if (!m_rootJointId.isNull()) {
+                markDirty(AbstractRenderer::SkeletonDataDirty);
+                m_skeletonManager->addDirtySkeleton(SkeletonManager::SkeletonDataDirty, m_skeletonHandle);
+            }
+        }
     }
 }
 
+// TODOSYNC remove once animation aspect no longer requires messages
 void Skeleton::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
 {
     switch (e->type()) {
@@ -123,31 +152,6 @@ void Skeleton::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
             // need to do is copy them into place. The existing jobs will then update
             // the skinning matrix palette.
             m_skeletonData.localPoses = change->value().value<QVector<Qt3DCore::Sqt>>();
-        } else if (change->propertyName() == QByteArrayLiteral("source")) {
-            Q_ASSERT(m_dataType == File);
-            const auto source = change->value().toUrl();
-            if (source != m_source) {
-                m_source = source;
-                markDirty(AbstractRenderer::SkeletonDataDirty);
-                m_skeletonManager->addDirtySkeleton(SkeletonManager::SkeletonDataDirty, m_skeletonHandle);
-            }
-        } else if (change->propertyName() == QByteArrayLiteral("createJointsEnabled")) {
-            m_createJoints = change->value().toBool();
-        } else if (change->propertyName() == QByteArrayLiteral("rootJoint")) {
-            m_rootJointId = change->value().value<QNodeId>();
-
-            // If using a QSkeletonLoader to create frontend QJoints, when those joints are
-            // set on the skeleton, we end up here. In order to allow the subsequent call
-            // to loadSkeleton(), see below, to build the internal data from the frontend
-            // joints rather than from the source url again, we need to change the data type
-            // to Data.
-            m_dataType = Data;
-
-            // If the joint changes, we need to rebuild our internal SkeletonData and
-            // the relationships between joints and skeleton. Mark the skeleton data as
-            // dirty so that we get a loadSkeletonJob executed to process this skeleton.
-            markDirty(AbstractRenderer::SkeletonDataDirty);
-            m_skeletonManager->addDirtySkeleton(SkeletonManager::SkeletonDataDirty, m_skeletonHandle);
         }
 
         break;
diff --git a/src/render/geometry/skeleton_p.h b/src/render/geometry/skeleton_p.h
index 4a14e5c1c..d71b404e5 100644
--- a/src/render/geometry/skeleton_p.h
+++ b/src/render/geometry/skeleton_p.h
@@ -85,6 +85,7 @@ public:
 
     void cleanup();
     void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e) override;
+    void syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime) override;
     void setStatus(Qt3DCore::QSkeletonLoader::Status status);
     Qt3DCore::QSkeletonLoader::Status status() const { return m_status; }
 
@@ -120,7 +121,6 @@ public:
 #endif
 
 private:
-    void initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change) final;
     void loadSkeletonFromUrl();
     void loadSkeletonFromData();
     Qt3DCore::QJoint *createFrontendJoints(const SkeletonData &skeletonData) const;
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/lights/environmentlight.cpp b/src/render/lights/environmentlight.cpp
index d4245fb6e..20364fdfa 100644
--- a/src/render/lights/environmentlight.cpp
+++ b/src/render/lights/environmentlight.cpp
@@ -53,11 +53,17 @@ QNodeId EnvironmentLight::shaderData() const
     return m_shaderDataId;
 }
 
-void EnvironmentLight::initializeFromPeer(const QNodeCreatedChangeBasePtr &change)
+void EnvironmentLight::syncFromFrontEnd(const QNode *frontEnd, bool firstTime)
 {
-    const auto typedChange = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<QEnvironmentLightData>>(change);
-    const auto &data = typedChange->data;
-    m_shaderDataId = data.shaderDataId;
+    BackendNode::syncFromFrontEnd(frontEnd, firstTime);
+    const QEnvironmentLight *node = qobject_cast<const QEnvironmentLight *>(frontEnd);
+    if (!node)
+        return;
+
+    if (firstTime) {
+        QEnvironmentLightPrivate *d = static_cast<QEnvironmentLightPrivate *>(QEnvironmentLightPrivate::get(const_cast<Qt3DCore::QNode *>(frontEnd)));
+        m_shaderDataId = d->m_shaderData ? d->m_shaderData->id() : QNodeId{};
+    }
 }
 
 } // namespace Render
diff --git a/src/render/lights/environmentlight_p.h b/src/render/lights/environmentlight_p.h
index 00d49d298..92f6ce100 100644
--- a/src/render/lights/environmentlight_p.h
+++ b/src/render/lights/environmentlight_p.h
@@ -63,10 +63,9 @@ class Q_AUTOTEST_EXPORT EnvironmentLight : public BackendNode
 {
 public:
     Qt3DCore::QNodeId shaderData() const;
+    void syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime) override;
 
 private:
-    void initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change) final;
-
     Qt3DCore::QNodeId m_shaderDataId;
 };
 
diff --git a/src/render/lights/light.cpp b/src/render/lights/light.cpp
index e8474b728..30d71082b 100644
--- a/src/render/lights/light.cpp
+++ b/src/render/lights/light.cpp
@@ -58,14 +58,18 @@ QNodeId Light::shaderData() const
     return m_shaderDataId;
 }
 
-void Light::initializeFromPeer(const QNodeCreatedChangeBasePtr &change)
+void Light::syncFromFrontEnd(const QNode *frontEnd, bool firstTime)
 {
-    const auto typedChange = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<QAbstractLightData>>(change);
-    const auto &data = typedChange->data;
-    m_shaderDataId = data.shaderDataId;
+    BackendNode::syncFromFrontEnd(frontEnd, firstTime);
+    const QAbstractLight *node = qobject_cast<const QAbstractLight *>(frontEnd);
+    if (!node)
+        return;
 
-    Q_ASSERT(m_renderer);
-    BackendNode::markDirty(AbstractRenderer::LightsDirty);
+    if (firstTime) {
+        QAbstractLightPrivate *d = static_cast<QAbstractLightPrivate *>(QAbstractLightPrivate::get(const_cast<Qt3DCore::QNode *>(frontEnd)));
+        m_shaderDataId = d->m_shaderData ? d->m_shaderData->id() : QNodeId{};
+        BackendNode::markDirty(AbstractRenderer::LightsDirty);
+    }
 }
 
 RenderLightFunctor::RenderLightFunctor(AbstractRenderer *renderer, NodeManagers *managers)
diff --git a/src/render/lights/light_p.h b/src/render/lights/light_p.h
index 8ecc87585..5f5f8140e 100644
--- a/src/render/lights/light_p.h
+++ b/src/render/lights/light_p.h
@@ -66,9 +66,9 @@ class Q_AUTOTEST_EXPORT Light : public BackendNode
 public:
     Qt3DCore::QNodeId shaderData() const;
 
-private:
-    void initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change) final;
+    void syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime) override;
 
+private:
     Qt3DCore::QNodeId m_shaderDataId;
 };
 
diff --git a/src/render/lights/qenvironmentlight.cpp b/src/render/lights/qenvironmentlight.cpp
index b3dac56ff..86ef04f95 100644
--- a/src/render/lights/qenvironmentlight.cpp
+++ b/src/render/lights/qenvironmentlight.cpp
@@ -55,7 +55,21 @@ namespace Qt3DRender
  * \since 5.9
  *
  * EnvironmentLight uses cubemaps to implement image-based lighting (IBL), a technique
- * often used in conjunction with physically-based rendering (PBR).
+ * often used in conjunction with physically-based rendering (PBR). The cubemaps are
+ * typically expected be based on high dynamic range (HDR) images, with a suitable
+ * OpenGL format (such as RGBA16F) that can handle the increased range of values.
+ *
+ * There are a variety of tools that can be used to produce the cubemaps needed by
+ * EnvironmentLight. Some examples include
+ *
+ * \list
+ * \li \l {https://github.com/dariomanesku/cmftStudio}{cmftStudio}
+ * \li \l {https://github.com/derkreature/IBLBaker}{IBLBaker}
+ * \li \l {https://www.knaldtech.com/lys/}{Lys}
+ * \endlist
+ *
+ * \l {https://hdrihaven.com/hdris/}{HDRI Haven} provides many CC0-licensed HDR images
+ * that can be used as source material for the above tools.
  */
 
 QEnvironmentLightPrivate::QEnvironmentLightPrivate()
@@ -101,8 +115,22 @@ Qt3DCore::QNodeCreatedChangeBasePtr QEnvironmentLight::createNodeCreationChange(
     \brief Encapsulate an environment light object in a Qt 3D scene.
     \since 5.9
 
-    EnvironmentLight uses cubemaps to implement image-based lighting (IBL), a technique
-    often used in conjunction with physically-based rendering (PBR).
+    QEnvironmentLight uses cubemaps to implement image-based lighting (IBL), a technique
+    often used in conjunction with physically-based rendering (PBR). The cubemaps are
+    typically expected be based on high dynamic range (HDR) images, with a suitable
+    OpenGL format (such as RGBA16F) that can handle the increased range of values.
+
+    There are a variety of tools that can be used to produce the cubemaps needed by
+    QEnvironmentLight. Some examples include
+
+    \list
+    \li \l {https://github.com/dariomanesku/cmftStudio}{cmftStudio}
+    \li \l {https://github.com/derkreature/IBLBaker}{IBLBaker}
+    \li \l {https://www.knaldtech.com/lys/}{Lys}
+    \endlist
+
+    \l {https://hdrihaven.com/hdris/}{HDRI Haven} provides many CC0-licensed HDR images
+    that can be used as source material for the above tools.
 */
 
 QEnvironmentLight::QEnvironmentLight(Qt3DCore::QNode *parent)
diff --git a/src/render/materialsystem/effect.cpp b/src/render/materialsystem/effect.cpp
index 29d05ed01..76036bd1f 100644
--- a/src/render/materialsystem/effect.cpp
+++ b/src/render/materialsystem/effect.cpp
@@ -48,6 +48,7 @@
 #include <Qt3DCore/qpropertynoderemovedchange.h>
 
 #include <QVariant>
+#include <algorithm>
 
 QT_BEGIN_NAMESPACE
 
@@ -73,41 +74,25 @@ void Effect::cleanup()
     m_techniques.clear();
 }
 
-void Effect::initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change)
+void Effect::syncFromFrontEnd(const QNode *frontEnd, bool firstTime)
 {
-    const auto typedChange = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<QEffectData>>(change);
-    const auto &data = typedChange->data;
-    m_techniques = data.techniqueIds;
-    m_parameterPack.setParameters(data.parameterIds);
-}
-
-void Effect::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
-{
-    switch (e->type()) {
-    case PropertyValueAdded: {
-        const auto change = qSharedPointerCast<QPropertyNodeAddedChange>(e);
-        if (change->propertyName() == QByteArrayLiteral("technique"))
-            appendRenderTechnique(change->addedNodeId());
-        else if (change->propertyName() == QByteArrayLiteral("parameter"))
-            m_parameterPack.appendParameter(change->addedNodeId());
-        break;
-    }
-
-    case PropertyValueRemoved: {
-        const auto change = qSharedPointerCast<QPropertyNodeRemovedChange>(e);
-        if (change->propertyName() == QByteArrayLiteral("technique"))
-            m_techniques.removeOne(change->removedNodeId());
-        else if (change->propertyName() == QByteArrayLiteral("parameter"))
-            m_parameterPack.removeParameter(change->removedNodeId());
-        break;
-    }
-
-    default:
-        break;
-    }
-
-    markDirty(AbstractRenderer::AllDirty);
-    BackendNode::sceneChangeEvent(e);
+    BackendNode::syncFromFrontEnd(frontEnd, firstTime);
+    const QEffect *node = qobject_cast<const QEffect *>(frontEnd);
+    if (!node)
+        return;
+
+    auto parameters = qIdsForNodes(node->parameters());
+    std::sort(std::begin(parameters), std::end(parameters));
+    if (m_parameterPack.parameters() != parameters)
+        m_parameterPack.setParameters(parameters);
+
+    auto techniques = qIdsForNodes(node->techniques());
+    std::sort(std::begin(techniques), std::end(techniques));
+    if (m_techniques != techniques)
+        m_techniques = techniques;
+
+    if (!firstTime)
+        markDirty(AbstractRenderer::AllDirty);
 }
 
 void Effect::appendRenderTechnique(Qt3DCore::QNodeId technique)
diff --git a/src/render/materialsystem/effect_p.h b/src/render/materialsystem/effect_p.h
index 87ff4a803..e81be2b8d 100644
--- a/src/render/materialsystem/effect_p.h
+++ b/src/render/materialsystem/effect_p.h
@@ -70,15 +70,13 @@ public:
     ~Effect();
     void cleanup();
 
-    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e) override;
+    void syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime) override;
     void appendRenderTechnique(Qt3DCore::QNodeId t);
 
     QVector<Qt3DCore::QNodeId> techniques() const;
     QVector<Qt3DCore::QNodeId> parameters() const;
 
 private:
-    void initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change) final;
-
     QVector<Qt3DCore::QNodeId> m_techniques;
     ParameterPack m_parameterPack;
 };
diff --git a/src/render/materialsystem/material.cpp b/src/render/materialsystem/material.cpp
index a69ff8a13..07764c207 100644
--- a/src/render/materialsystem/material.cpp
+++ b/src/render/materialsystem/material.cpp
@@ -73,47 +73,26 @@ void Material::cleanup()
     m_parameterPack.clear();
 }
 
-void Material::initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change)
+void Material::syncFromFrontEnd(const QNode *frontEnd, bool firstTime)
 {
-    const auto typedChange = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<QMaterialData>>(change);
-    const auto &data = typedChange->data;
-    m_effectUuid = data.effectId;
-    m_parameterPack.setParameters(data.parameterIds);
-
-    markDirty(AbstractRenderer::MaterialDirty);
-}
-
-void Material::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
-{
-
-    switch (e->type()) {
-    case PropertyUpdated: {
-        const auto change = qSharedPointerCast<QPropertyUpdatedChange>(e);
-        if (change->propertyName() == QByteArrayLiteral("effect"))
-            m_effectUuid = change->value().value<QNodeId>();
-        break;
-    }
-
-    case PropertyValueAdded: {
-        const auto change = qSharedPointerCast<QPropertyNodeAddedChange>(e);
-        if (change->propertyName() == QByteArrayLiteral("parameter"))
-            m_parameterPack.appendParameter(change->addedNodeId());
-        break;
-    }
-
-    case PropertyValueRemoved: {
-        const auto change = qSharedPointerCast<QPropertyNodeRemovedChange>(e);
-        if (change->propertyName() == QByteArrayLiteral("parameter"))
-            m_parameterPack.removeParameter(change->removedNodeId());
-        break;
-    }
-
-    default:
-        break;
-    }
-    markDirty(AbstractRenderer::AllDirty);
-
-    BackendNode::sceneChangeEvent(e);
+    BackendNode::syncFromFrontEnd(frontEnd, firstTime);
+    const QMaterial *node = qobject_cast<const QMaterial *>(frontEnd);
+    if (!node)
+        return;
+
+    auto parameters = qIdsForNodes(node->parameters());
+    std::sort(std::begin(parameters), std::end(parameters));
+    if (m_parameterPack.parameters() != parameters)
+        m_parameterPack.setParameters(parameters);
+
+    const auto effectId = node->effect() ? node->effect()->id() : QNodeId{};
+    if (effectId != m_effectUuid)
+        m_effectUuid = effectId;
+
+    if (firstTime)
+        markDirty(AbstractRenderer::MaterialDirty);
+    else
+        markDirty(AbstractRenderer::AllDirty);
 }
 
 QVector<Qt3DCore::QNodeId> Material::parameters() const
diff --git a/src/render/materialsystem/material_p.h b/src/render/materialsystem/material_p.h
index 3b55dc657..7a02c6691 100644
--- a/src/render/materialsystem/material_p.h
+++ b/src/render/materialsystem/material_p.h
@@ -79,14 +79,12 @@ public:
     ~Material();
     void cleanup();
 
-    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e) override;
+    void syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime) override;
 
     QVector<Qt3DCore::QNodeId> parameters() const;
     Qt3DCore::QNodeId effect() const;
 
 private:
-    void initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change) final;
-
     ParameterPack m_parameterPack;
     Qt3DCore::QNodeId m_effectUuid;
 };
diff --git a/src/render/materialsystem/parameter.cpp b/src/render/materialsystem/parameter.cpp
index 86ca418aa..d32e60a2d 100644
--- a/src/render/materialsystem/parameter.cpp
+++ b/src/render/materialsystem/parameter.cpp
@@ -70,34 +70,33 @@ void Parameter::cleanup()
     m_uniformValue = UniformValue();
 }
 
-void Parameter::initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change)
+void Parameter::syncFromFrontEnd(const QNode *frontEnd, bool firstTime)
 {
-    const auto typedChange = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<QParameterData>>(change);
-    const auto &data = typedChange->data;
-    m_name = data.name;
-    m_nameId = StringToInt::lookupId(m_name);
-    m_uniformValue = UniformValue::fromVariant(data.backendValue);
-    markDirty(AbstractRenderer::ParameterDirty);
-}
+    const QParameter *node = qobject_cast<const QParameter *>(frontEnd);
+    if (!node)
+        return;
 
-void Parameter::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
-{
-    QPropertyUpdatedChangePtr propertyChange = qSharedPointerCast<QPropertyUpdatedChange>(e);
-
-    if (e->type() == PropertyUpdated) {
-        if (propertyChange->propertyName() == QByteArrayLiteral("name")) {
-            m_name = propertyChange->value().toString();
-            m_nameId = StringToInt::lookupId(m_name);
-            markDirty(AbstractRenderer::MaterialDirty | AbstractRenderer::ParameterDirty);
-        } else if (propertyChange->propertyName() == QByteArrayLiteral("value")) {
-            m_uniformValue = UniformValue::fromVariant(propertyChange->value());
-            markDirty(AbstractRenderer::ParameterDirty);
-        } else if (propertyChange->propertyName() == QByteArrayLiteral("enabled")) {
-            markDirty(AbstractRenderer::MaterialDirty | AbstractRenderer::ParameterDirty);
-        }
+    AbstractRenderer::BackendNodeDirtySet dirty = firstTime ? AbstractRenderer::ParameterDirty : static_cast<AbstractRenderer::BackendNodeDirtyFlag>(0);
+    if (node->isEnabled() != isEnabled())
+        dirty |= (AbstractRenderer::MaterialDirty | AbstractRenderer::ParameterDirty);
+
+    if (node->name() != m_name) {
+        m_name = node->name();
+        m_nameId = StringToInt::lookupId(m_name);
+        dirty |= (AbstractRenderer::MaterialDirty | AbstractRenderer::ParameterDirty);
     }
 
-    BackendNode::sceneChangeEvent(e);
+    QParameterPrivate* d = static_cast<QParameterPrivate *>(QParameterPrivate::get(const_cast<QParameter *>(node)));
+    if (d->m_backendValue != m_backendValue) {
+        m_backendValue = d->m_backendValue;
+        m_uniformValue = UniformValue::fromVariant(m_backendValue);
+        dirty |= (AbstractRenderer::ParameterDirty);
+    }
+
+    if (dirty)
+        markDirty(dirty);
+
+    BackendNode::syncFromFrontEnd(frontEnd, firstTime);
 }
 
 QString Parameter::name() const
diff --git a/src/render/materialsystem/parameter_p.h b/src/render/materialsystem/parameter_p.h
index 4ab04bc8e..9deaa11f3 100644
--- a/src/render/materialsystem/parameter_p.h
+++ b/src/render/materialsystem/parameter_p.h
@@ -71,16 +71,15 @@ public:
 
     void cleanup();
 
-    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e) override;
+    void syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime) override;
 
     QString name() const;
     int nameId() const Q_DECL_NOTHROW { return m_nameId; }
     const UniformValue &uniformValue() const { return m_uniformValue; }
 
 private:
-    void initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change) final;
-
     QString m_name;
+    QVariant m_backendValue;
     UniformValue m_uniformValue;
     int m_nameId;
 };
diff --git a/src/render/materialsystem/qeffect.cpp b/src/render/materialsystem/qeffect.cpp
index b611657c4..35ac662fb 100644
--- a/src/render/materialsystem/qeffect.cpp
+++ b/src/render/materialsystem/qeffect.cpp
@@ -192,11 +192,7 @@ void QEffect::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,14 +203,10 @@ void QEffect::removeParameter(QParameter *parameter)
 {
     Q_D(QEffect);
 
-    if (parameter && d->m_changeArbiter != nullptr) {
-        const auto change = QPropertyNodeRemovedChangePtr::create(id(), parameter);
-        change->setPropertyName("parameter");
-        d->notifyObservers(change);
-    }
     d->m_parameters.removeOne(parameter);
     // Remove bookkeeping connection
     d->unregisterDestructionHelper(parameter);
+    d->update();
 }
 
 /*!
@@ -246,11 +238,7 @@ void QEffect::addTechnique(QTechnique *t)
         if (!t->parent())
             t->setParent(this);
 
-        if (d->m_changeArbiter != nullptr) {
-            const auto change = QPropertyNodeAddedChangePtr::create(id(), t);
-            change->setPropertyName("technique");
-            d->notifyObservers(change);
-        }
+        d->update();
     }
 }
 
@@ -260,11 +248,8 @@ void QEffect::addTechnique(QTechnique *t)
 void QEffect::removeTechnique(QTechnique *t)
 {
     Q_D(QEffect);
-    if (t && d->m_changeArbiter != nullptr) {
-        const auto change = QPropertyNodeRemovedChangePtr::create(id(), t);
-        change->setPropertyName("technique");
-        d->notifyObservers(change);
-    }
+    if (t)
+        d->update();
     d->m_techniques.removeOne(t);
     // Remove bookkeeping connection
     d->unregisterDestructionHelper(t);
diff --git a/src/render/materialsystem/qgraphicsapifilter.cpp b/src/render/materialsystem/qgraphicsapifilter.cpp
index 70f329172..9b5557930 100644
--- a/src/render/materialsystem/qgraphicsapifilter.cpp
+++ b/src/render/materialsystem/qgraphicsapifilter.cpp
@@ -107,6 +107,11 @@ QGraphicsApiFilterPrivate *QGraphicsApiFilterPrivate::get(QGraphicsApiFilter *q)
     return q->d_func();
 }
 
+const QGraphicsApiFilterPrivate *QGraphicsApiFilterPrivate::get(const QGraphicsApiFilter *q)
+{
+    return q->d_func();
+}
+
 /*!
     \class Qt3DRender::QGraphicsApiFilter
     \inmodule Qt3DRender
diff --git a/src/render/materialsystem/qgraphicsapifilter_p.h b/src/render/materialsystem/qgraphicsapifilter_p.h
index 3961d4f93..435451c27 100644
--- a/src/render/materialsystem/qgraphicsapifilter_p.h
+++ b/src/render/materialsystem/qgraphicsapifilter_p.h
@@ -84,6 +84,7 @@ public:
     }
 
     static QGraphicsApiFilterPrivate *get(QGraphicsApiFilter *q);
+    static const QGraphicsApiFilterPrivate *get(const QGraphicsApiFilter *q);
 
     Q_DECLARE_PUBLIC(QGraphicsApiFilter)
     GraphicsApiFilterData m_data;
diff --git a/src/render/materialsystem/qmaterial.cpp b/src/render/materialsystem/qmaterial.cpp
index c6913441e..db523a700 100644
--- a/src/render/materialsystem/qmaterial.cpp
+++ b/src/render/materialsystem/qmaterial.cpp
@@ -275,11 +275,7 @@ void QMaterial::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();
     }
 }
 
@@ -290,11 +286,7 @@ void QMaterial::removeParameter(QParameter *parameter)
 {
     Q_ASSERT(parameter);
     Q_D(QMaterial);
-    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);
 }
 
diff --git a/src/render/materialsystem/qrenderpass.cpp b/src/render/materialsystem/qrenderpass.cpp
index 111bb7b5f..d0821c49c 100644
--- a/src/render/materialsystem/qrenderpass.cpp
+++ b/src/render/materialsystem/qrenderpass.cpp
@@ -231,12 +231,6 @@ void QRenderPass::setShaderProgram(QShaderProgram *shaderProgram)
     Q_D(QRenderPass);
     if (d->m_shader != shaderProgram) {
 
-        if (d->m_shader != nullptr && d->m_changeArbiter != nullptr) {
-            const auto change = QPropertyNodeRemovedChangePtr::create(id(), d->m_shader);
-            change->setPropertyName("shaderProgram");
-            d->notifyObservers(change);
-        }
-
         if (d->m_shader)
             d->unregisterDestructionHelper(d->m_shader);
 
@@ -283,11 +277,7 @@ void QRenderPass::addFilterKey(QFilterKey *filterKey)
         if (!filterKey->parent())
             filterKey->setParent(this);
 
-        if (d->m_changeArbiter != nullptr) {
-            const auto change = QPropertyNodeAddedChangePtr::create(id(), filterKey);
-            change->setPropertyName("filterKeys");
-            d->notifyObservers(change);
-        }
+        d->update();
     }
 }
 
@@ -298,11 +288,7 @@ void QRenderPass::removeFilterKey(QFilterKey *filterKey)
 {
     Q_ASSERT(filterKey);
     Q_D(QRenderPass);
-    if (d->m_changeArbiter != nullptr) {
-        const auto change = QPropertyNodeRemovedChangePtr::create(id(), filterKey);
-        change->setPropertyName("filterKeys");
-        d->notifyObservers(change);
-    }
+    d->update();
     d->m_filterKeyList.removeOne(filterKey);
     // Remove bookkeeping connection
     d->unregisterDestructionHelper(filterKey);
@@ -339,11 +325,7 @@ void QRenderPass::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();
     }
 }
 
@@ -354,11 +336,7 @@ void QRenderPass::removeRenderState(QRenderState *state)
 {
     Q_ASSERT(state);
     Q_D(QRenderPass);
-    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);
@@ -394,11 +372,7 @@ void QRenderPass::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();
     }
 }
 
@@ -409,11 +383,7 @@ void QRenderPass::removeParameter(QParameter *parameter)
 {
     Q_ASSERT(parameter);
     Q_D(QRenderPass);
-    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/materialsystem/qtechnique.cpp b/src/render/materialsystem/qtechnique.cpp
index b668eb25f..dadeb98bd 100644
--- a/src/render/materialsystem/qtechnique.cpp
+++ b/src/render/materialsystem/qtechnique.cpp
@@ -234,12 +234,7 @@ QTechnique::QTechnique(QTechniquePrivate &dd, QNode *parent)
 /*! \internal */
 void QTechniquePrivate::_q_graphicsApiFilterChanged()
 {
-    if (m_changeArbiter != nullptr) {
-        auto change = QPropertyUpdatedChangePtr::create(m_id);
-        change->setPropertyName("graphicsApiFilterData");
-        change->setValue(QVariant::fromValue(QGraphicsApiFilterPrivate::get(const_cast<QGraphicsApiFilter *>(&m_graphicsApiFilter))->m_data));
-        notifyObservers(change);
-    }
+    update();
 }
 
 /*!
@@ -262,11 +257,7 @@ void QTechnique::addFilterKey(QFilterKey *filterKey)
         if (!filterKey->parent())
             filterKey->setParent(this);
 
-        if (d->m_changeArbiter != nullptr) {
-            const auto change = QPropertyNodeAddedChangePtr::create(id(), filterKey);
-            change->setPropertyName("filterKeys");
-            d->notifyObservers(change);
-        }
+        d->update();
     }
 }
 
@@ -277,11 +268,7 @@ void QTechnique::removeFilterKey(QFilterKey *filterKey)
 {
     Q_ASSERT(filterKey);
     Q_D(QTechnique);
-    if (d->m_changeArbiter != nullptr) {
-        const auto change = QPropertyNodeRemovedChangePtr::create(id(), filterKey);
-        change->setPropertyName("filterKeys");
-        d->notifyObservers(change);
-    }
+    d->update();
     d->m_filterKeys.removeOne(filterKey);
     // Remove bookkeeping connection
     d->unregisterDestructionHelper(filterKey);
@@ -317,11 +304,7 @@ void QTechnique::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();
     }
 }
 
@@ -332,11 +315,7 @@ void QTechnique::removeParameter(QParameter *parameter)
 {
     Q_ASSERT(parameter);
     Q_D(QTechnique);
-    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);
@@ -362,11 +341,7 @@ void QTechnique::addRenderPass(QRenderPass *pass)
         if (!pass->parent())
             pass->setParent(this);
 
-        if (d->m_changeArbiter != nullptr) {
-            const auto change = QPropertyNodeAddedChangePtr::create(id(), pass);
-            change->setPropertyName("pass");
-            d->notifyObservers(change);
-        }
+        d->update();
     }
 }
 
@@ -377,11 +352,7 @@ void QTechnique::removeRenderPass(QRenderPass *pass)
 {
     Q_ASSERT(pass);
     Q_D(QTechnique);
-    if (d->m_changeArbiter) {
-        const auto change = QPropertyNodeRemovedChangePtr::create(id(), pass);
-        change->setPropertyName("pass");
-        d->notifyObservers(change);
-    }
+    d->update();
     d->m_renderPasses.removeOne(pass);
     // Remove bookkeeping connection
     d->unregisterDestructionHelper(pass);
@@ -405,12 +376,19 @@ QVector<QParameter *> QTechnique::parameters() const
     return d->m_parameters;
 }
 
+// TODO Qt 6 -> Remove
 QGraphicsApiFilter *QTechnique::graphicsApiFilter()
 {
     Q_D(QTechnique);
     return &d->m_graphicsApiFilter;
 }
 
+const QGraphicsApiFilter *QTechnique::graphicsApiFilter() const
+{
+    Q_D(const QTechnique);
+    return &d->m_graphicsApiFilter;
+}
+
 Qt3DCore::QNodeCreatedChangeBasePtr QTechnique::createNodeCreationChange() const
 {
     auto creationChange = Qt3DCore::QNodeCreatedChangePtr<QTechniqueData>::create(this);
diff --git a/src/render/materialsystem/qtechnique.h b/src/render/materialsystem/qtechnique.h
index 7711cd67f..f0c857c2b 100644
--- a/src/render/materialsystem/qtechnique.h
+++ b/src/render/materialsystem/qtechnique.h
@@ -76,7 +76,8 @@ public:
     void removeRenderPass(QRenderPass *pass);
     QVector<QRenderPass *> renderPasses() const;
 
-    QGraphicsApiFilter *graphicsApiFilter();
+    Q_DECL_DEPRECATED QGraphicsApiFilter *graphicsApiFilter();
+    const QGraphicsApiFilter *graphicsApiFilter() const;
 
 protected:
     explicit QTechnique(QTechniquePrivate &dd, Qt3DCore::QNode *parent = nullptr);
diff --git a/src/render/materialsystem/renderpass.cpp b/src/render/materialsystem/renderpass.cpp
index e0fadddd9..aaeca3bb4 100644
--- a/src/render/materialsystem/renderpass.cpp
+++ b/src/render/materialsystem/renderpass.cpp
@@ -52,6 +52,8 @@
 #include <Qt3DCore/qpropertynodeaddedchange.h>
 #include <Qt3DCore/qpropertynoderemovedchange.h>
 
+#include <algorithm>
+
 QT_BEGIN_NAMESPACE
 
 using namespace Qt3DCore;
@@ -77,58 +79,33 @@ void RenderPass::cleanup()
     m_shaderUuid = Qt3DCore::QNodeId();
 }
 
-void RenderPass::initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change)
-{
-    const auto typedChange = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<QRenderPassData>>(change);
-    const auto &data = typedChange->data;
-    m_filterKeyList = data.filterKeyIds;
-    m_parameterPack.setParameters(data.parameterIds);
-    for (const auto &renderStateId : qAsConst(data.renderStateIds))
-        addRenderState(renderStateId);
-    m_shaderUuid = data.shaderId;
-}
-
-void RenderPass::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
+void RenderPass::syncFromFrontEnd(const QNode *frontEnd, bool firstTime)
 {
-    switch (e->type()) {
-    case PropertyValueAdded: {
-        const auto change = qSharedPointerCast<QPropertyNodeAddedChange>(e);
-        if (change->propertyName() == QByteArrayLiteral("filterKeys"))
-            appendFilterKey(change->addedNodeId());
-        else if (change->propertyName() == QByteArrayLiteral("shaderProgram"))
-            m_shaderUuid = change->addedNodeId();
-        else if (change->propertyName() == QByteArrayLiteral("renderState"))
-            addRenderState(change->addedNodeId());
-        else if (change->propertyName() == QByteArrayLiteral("parameter"))
-            m_parameterPack.appendParameter(change->addedNodeId());
-        break;
+    BackendNode::syncFromFrontEnd(frontEnd, firstTime);
+    const QRenderPass *node = qobject_cast<const QRenderPass *>(frontEnd);
+    if (!node)
+        return;
+
+    if ((node->shaderProgram() && node->shaderProgram()->id() != m_shaderUuid) ||
+        (!node->shaderProgram() && !m_shaderUuid.isNull())) {
+        m_shaderUuid = node->shaderProgram() ? node->shaderProgram()->id() : QNodeId{};
     }
 
-    case PropertyUpdated: {
-        const auto change = qSharedPointerCast<QPropertyUpdatedChange>(e);
-        if (change->propertyName() == QByteArrayLiteral("shaderProgram"))
-            m_shaderUuid = change->value().value<Qt3DCore::QNodeId>();
-        break;
-    }
+    auto filterList = qIdsForNodes(node->filterKeys());
+    std::sort(std::begin(filterList), std::end(filterList));
+    if (m_filterKeyList != filterList)
+        m_filterKeyList = filterList;
 
-    case PropertyValueRemoved: {
-        const auto change = qSharedPointerCast<QPropertyNodeRemovedChange>(e);
-        if (change->propertyName() == QByteArrayLiteral("filterKeys"))
-            removeFilterKey(change->removedNodeId());
-        else if (change->propertyName() == QByteArrayLiteral("shaderProgram"))
-            m_shaderUuid = QNodeId();
-        else if (change->propertyName() == QByteArrayLiteral("renderState"))
-            removeRenderState(change->removedNodeId());
-        else if (change->propertyName() == QByteArrayLiteral("parameter"))
-            m_parameterPack.removeParameter(change->removedNodeId());
-        break;
-    }
+    auto parameters = qIdsForNodes(node->parameters());
+    std::sort(std::begin(parameters), std::end(parameters));
+    if (m_parameterPack.parameters() != parameters)
+        m_parameterPack.setParameters(parameters);
 
-    default:
-        break;
-    }
+    auto renderStates = qIdsForNodes(node->renderStates());
+    std::sort(std::begin(renderStates), std::end(renderStates));
+    if (m_renderStates != renderStates)
+        m_renderStates = renderStates;
 
-    BackendNode::sceneChangeEvent(e);
     markDirty(AbstractRenderer::AllDirty);
 }
 
diff --git a/src/render/materialsystem/renderpass_p.h b/src/render/materialsystem/renderpass_p.h
index 1ca02b1ad..314386ad1 100644
--- a/src/render/materialsystem/renderpass_p.h
+++ b/src/render/materialsystem/renderpass_p.h
@@ -79,7 +79,7 @@ public:
 
     void cleanup();
 
-    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e) override;
+    void syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime) override;
 
     Qt3DCore::QNodeId shaderProgram() const;
     QVector<Qt3DCore::QNodeId> filterKeys() const;
@@ -95,8 +95,6 @@ private:
     void addRenderState(Qt3DCore::QNodeId renderStateId);
     void removeRenderState(Qt3DCore::QNodeId renderStateId);
 
-    void initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change) final;
-
     Qt3DCore::QNodeId m_shaderUuid;
     QVector<Qt3DCore::QNodeId> m_filterKeyList;
     ParameterPack m_parameterPack;
diff --git a/src/render/materialsystem/technique.cpp b/src/render/materialsystem/technique.cpp
index 42430883e..d4199b7e3 100644
--- a/src/render/materialsystem/technique.cpp
+++ b/src/render/materialsystem/technique.cpp
@@ -85,72 +85,48 @@ void Technique::cleanup()
     m_isCompatibleWithRenderer = false;
 }
 
-void Technique::initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change)
+void Technique::syncFromFrontEnd(const QNode *frontEnd, bool firstTime)
 {
-    const auto typedChange = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<QTechniqueData>>(change);
-    const QTechniqueData &data = typedChange->data;
-
-    m_graphicsApiFilterData = data.graphicsApiFilterData;
-    m_filterKeyList = data.filterKeyIds;
-    m_parameterPack.setParameters(data.parameterIds);
-    m_renderPasses = data.renderPassIds;
-    m_nodeManager->techniqueManager()->addDirtyTechnique(peerId());
-    markDirty(AbstractRenderer::TechniquesDirty);
-}
+    const QTechnique *node = qobject_cast<const QTechnique *>(frontEnd);
 
-void Technique::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
-{
-    switch (e->type()) {
-    case PropertyUpdated: {
-        const auto change = qSharedPointerCast<QPropertyUpdatedChange>(e);
-        if (change->propertyName() == QByteArrayLiteral("enabled")) {
-            markDirty(AbstractRenderer::TechniquesDirty);
-        } else if (change->propertyName() == QByteArrayLiteral("graphicsApiFilterData")) {
-            GraphicsApiFilterData filterData = change->value().value<GraphicsApiFilterData>();
-            m_graphicsApiFilterData = filterData;
-            // Notify the manager that our graphicsApiFilterData has changed
-            // and that we therefore need to be check for compatibility again
-            m_isCompatibleWithRenderer = false;
-            m_nodeManager->techniqueManager()->addDirtyTechnique(peerId());
-            markDirty(AbstractRenderer::TechniquesDirty);
-        }
-        break;
+    if (!node)
+        return;
+
+    bool dirty = isEnabled() != frontEnd->isEnabled();
+    BackendNode::syncFromFrontEnd(frontEnd, firstTime);
+
+    auto renderPasses = qIdsForNodes(node->renderPasses());
+    std::sort(std::begin(renderPasses), std::end(renderPasses));
+    if (m_renderPasses != renderPasses) {
+        m_renderPasses = renderPasses;
+        dirty = true;
     }
 
-    case PropertyValueAdded: {
-        const auto change = qSharedPointerCast<QPropertyNodeAddedChange>(e);
-        if (change->propertyName() == QByteArrayLiteral("pass")) {
-            appendRenderPass(change->addedNodeId());
-            markDirty(AbstractRenderer::TechniquesDirty);
-        } else if (change->propertyName() == QByteArrayLiteral("parameter")) {
-            m_parameterPack.appendParameter(change->addedNodeId());
-            markDirty(AbstractRenderer::TechniquesDirty);
-        } else if (change->propertyName() == QByteArrayLiteral("filterKeys")) {
-            appendFilterKey(change->addedNodeId());
-            markDirty(AbstractRenderer::TechniquesDirty);
-        }
-        break;
+    auto parameters = qIdsForNodes(node->parameters());
+    std::sort(std::begin(parameters), std::end(parameters));
+    if (m_parameterPack.parameters() != parameters) {
+        m_parameterPack.setParameters(parameters);
+        dirty = true;
     }
 
-    case PropertyValueRemoved: {
-        const auto change = qSharedPointerCast<QPropertyNodeRemovedChange>(e);
-        if (change->propertyName() == QByteArrayLiteral("pass")) {
-            removeRenderPass(change->removedNodeId());
-            markDirty(AbstractRenderer::TechniquesDirty);
-        } else if (change->propertyName() == QByteArrayLiteral("parameter")) {
-            m_parameterPack.removeParameter(change->removedNodeId());
-            markDirty(AbstractRenderer::TechniquesDirty);
-        } else if (change->propertyName() == QByteArrayLiteral("filterKeys")) {
-            removeFilterKey(change->removedNodeId());
-            markDirty(AbstractRenderer::TechniquesDirty);
-        }
-        break;
+    auto filterKeys = qIdsForNodes(node->filterKeys());
+    std::sort(std::begin(filterKeys), std::end(filterKeys));
+    if (m_filterKeyList != filterKeys) {
+        m_filterKeyList = filterKeys;
+        dirty = true;
+    }
+
+    auto graphicsApiFilterData = QGraphicsApiFilterPrivate::get(node->graphicsApiFilter())->m_data;
+    if (m_graphicsApiFilterData != graphicsApiFilterData) {
+        m_graphicsApiFilterData = graphicsApiFilterData;
+        m_isCompatibleWithRenderer = false;
+        dirty = true;
     }
 
-    default:
-        break;
+    if (dirty) {
+        m_nodeManager->techniqueManager()->addDirtyTechnique(peerId());
+        markDirty(AbstractRenderer::TechniquesDirty);
     }
-    BackendNode::sceneChangeEvent(e);
 }
 
 QVector<Qt3DCore::QNodeId> Technique::parameters() const
diff --git a/src/render/materialsystem/technique_p.h b/src/render/materialsystem/technique_p.h
index d885c1b87..1d0d0a9dd 100644
--- a/src/render/materialsystem/technique_p.h
+++ b/src/render/materialsystem/technique_p.h
@@ -80,7 +80,8 @@ public:
     ~Technique();
     void cleanup();
 
-    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e) override;
+    void syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime) override;
+
     QVector<Qt3DCore::QNodeId> parameters() const;
 
     void appendRenderPass(Qt3DCore::QNodeId renderPassId);
@@ -102,7 +103,6 @@ public:
     NodeManagers *nodeManager() const;
 
 private:
-    void initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change) final;
 
     GraphicsApiFilterData m_graphicsApiFilterData;
     ParameterPack m_parameterPack;
diff --git a/src/render/picking/qpickevent.cpp b/src/render/picking/qpickevent.cpp
index a18c6ead8..ae5748082 100644
--- a/src/render/picking/qpickevent.cpp
+++ b/src/render/picking/qpickevent.cpp
@@ -309,14 +309,14 @@ int QPickEvent::modifiers() const
  * The viewport in which this event originated. A null value means the event originated from a frame graph branch without a Viewport.
  * If a frame graph branch has a Viewport inside a Viewport the property will contain the leaf viewport.
  *
- * \since 5.13
+ * \since 5.14
  */
 /*!
  * \property Qt3DRender::QPickEvent::viewport
  * The viewport in which this event originated. A null value means the event originated from a frame graph branch without a QViewport.
  * If a frame graph branch has a Viewport inside a Viewport the property will contain the leaf viewport.
  *
- * \since 5.13
+ * \since 5.14
  */
 QViewport *QPickEvent::viewport() const
 {
@@ -332,7 +332,7 @@ QViewport *QPickEvent::viewport() const
  * If the object picker is not attached to a leaf node in the scene graph,
  * this is useful to find which child entity was actually picked.
  *
- * \since 5.13
+ * \since 5.14
  */
 /*!
  * \property Qt3DRender::QPickEvent::entity
@@ -341,7 +341,7 @@ QViewport *QPickEvent::viewport() const
  * If the object picker is not attached to a leaf node in the scene graph,
  * this is useful to find which child entity was actually picked.
  *
- * \since 5.13
+ * \since 5.14
  */
 Qt3DCore::QEntity *QPickEvent::entity() const
 {
diff --git a/src/render/picking/qpickevent.h b/src/render/picking/qpickevent.h
index 21d072ffe..854008aaf 100644
--- a/src/render/picking/qpickevent.h
+++ b/src/render/picking/qpickevent.h
@@ -70,8 +70,8 @@ class Q_3DRENDERSHARED_EXPORT QPickEvent : public QObject
     Q_PROPERTY(Qt3DRender::QPickEvent::Buttons button READ button CONSTANT)
     Q_PROPERTY(int buttons READ buttons CONSTANT)
     Q_PROPERTY(int modifiers READ modifiers CONSTANT)
-    Q_PROPERTY(Qt3DRender::QViewport *viewport READ viewport CONSTANT)
-    Q_PROPERTY(Qt3DCore::QEntity *entity READ entity CONSTANT)
+    Q_PROPERTY(Qt3DRender::QViewport *viewport READ viewport CONSTANT REVISION 14)
+    Q_PROPERTY(Qt3DCore::QEntity *entity READ entity CONSTANT REVISION 14)
 public:
     enum Buttons {
         LeftButton = Qt::LeftButton,
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/jobs/renderviewjobutils.cpp b/src/render/renderers/opengl/jobs/renderviewjobutils.cpp
index 24978fd87..c70f82dea 100644
--- a/src/render/renderers/opengl/jobs/renderviewjobutils.cpp
+++ b/src/render/renderers/opengl/jobs/renderviewjobutils.cpp
@@ -197,7 +197,7 @@ void setRenderViewConfigFromFrameGraphLeafNode(RenderView *rv, const FrameGraphN
                 // Add states from new stateSet we might be missing
                 // but don' t override existing states (lower StateSetNode always has priority)
                 if (rStateSet->hasRenderStates())
-                    addUniqueStatesToRenderStateSet(stateSet, rStateSet->renderStates(), manager->renderStateManager());
+                    addStatesToRenderStateSet(stateSet, rStateSet->renderStates(), manager->renderStateManager());
                 break;
             }
 
@@ -436,13 +436,13 @@ void parametersFromMaterialEffectTechnique(ParameterInfoList *infoList,
 }
 
 // Only add states with types we don't already have
-void addUniqueStatesToRenderStateSet(RenderStateSet *stateSet,
-                                     const QVector<Qt3DCore::QNodeId> stateIds,
-                                     RenderStateManager *manager)
+void addStatesToRenderStateSet(RenderStateSet *stateSet,
+                               const QVector<Qt3DCore::QNodeId> stateIds,
+                               RenderStateManager *manager)
 {
     for (const Qt3DCore::QNodeId &stateId : stateIds) {
         RenderStateNode *node = manager->lookupResource(stateId);
-        if (node->isEnabled() && !stateSet->hasStateOfType(node->type())) {
+        if (node->isEnabled() && stateSet->canAddStateOfType(node->type())) {
             stateSet->addState(node->impl());
         }
     }
diff --git a/src/render/renderers/opengl/jobs/renderviewjobutils_p.h b/src/render/renderers/opengl/jobs/renderviewjobutils_p.h
index bd2e12534..b2fa59785 100644
--- a/src/render/renderers/opengl/jobs/renderviewjobutils_p.h
+++ b/src/render/renderers/opengl/jobs/renderviewjobutils_p.h
@@ -150,9 +150,9 @@ void parametersFromParametersProvider(ParameterInfoList *infoList,
 Q_AUTOTEST_EXPORT ParameterInfoList::const_iterator findParamInfo(ParameterInfoList *infoList,
                                                                   const int nameId);
 
-Q_AUTOTEST_EXPORT void addUniqueStatesToRenderStateSet(RenderStateSet *stateSet,
-                                                       const QVector<Qt3DCore::QNodeId> stateIds,
-                                                       RenderStateManager *manager);
+Q_AUTOTEST_EXPORT void addStatesToRenderStateSet(RenderStateSet *stateSet,
+                                                 const QVector<Qt3DCore::QNodeId> stateIds,
+                                                 RenderStateManager *manager);
 
 typedef QHash<int, QVariant> UniformBlockValueBuilderHash;
 
diff --git a/src/render/renderers/opengl/renderer/commandthread.cpp b/src/render/renderers/opengl/renderer/commandthread.cpp
index dcaacadcc..a518d3b68 100644
--- a/src/render/renderers/opengl/renderer/commandthread.cpp
+++ b/src/render/renderers/opengl/renderer/commandthread.cpp
@@ -176,7 +176,7 @@ void CommandThread::run()
         m_commandRequestedSemaphore.acquire();
 
         // Are we still running?
-        if (!m_running.load()) {
+        if (!m_running.loadRelaxed()) {
             m_graphicsContext->doneCurrent();
             // to prevent executeCommand being locked
             m_commandExecutionSemaphore.release();
diff --git a/src/render/renderers/opengl/renderer/renderer.cpp b/src/render/renderers/opengl/renderer/renderer.cpp
index e7112b3f4..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)
@@ -448,7 +443,7 @@ void Renderer::shutdown()
     QMutexLocker lock(&m_hasBeenInitializedMutex);
 
     qCDebug(Backend) << Q_FUNC_INFO << "Requesting renderer shutdown";
-    m_running.store(0);
+    m_running.storeRelaxed(0);
 
     // We delete any renderqueue that we may not have had time to render
     // before the surface was destroyed
@@ -559,10 +554,9 @@ Render::FrameGraphNode *Renderer::frameGraphRoot() const
 // 2) setSceneRoot waits to acquire initialization
 // 3) submitRenderView -> check for surface
 //    -> make surface current + create proper glHelper if needed
-void Renderer::setSceneRoot(QBackendNodeFactory *factory, Entity *sgRoot)
+void Renderer::setSceneRoot(Entity *sgRoot)
 {
     Q_ASSERT(sgRoot);
-    Q_UNUSED(factory);
 
     // If initialization hasn't been completed we must wait
     m_waitForInitializationToBeCompleted.acquire();
@@ -620,7 +614,7 @@ void Renderer::render()
     // One scene description
     // One framegraph description
 
-    while (m_running.load() > 0) {
+    while (m_running.loadRelaxed() > 0) {
         doRender();
         // TO DO: Restore windows exposed detection
         // Probably needs to happens some place else though
@@ -790,7 +784,7 @@ void Renderer::enqueueRenderView(Render::RenderView *renderView, int submitOrder
     const bool isQueueComplete = m_renderQueue->queueRenderView(renderView, submitOrder);
     locker.unlock(); // We're done protecting the queue at this point
     if (isQueueComplete) {
-        if (m_renderThread && m_running.load())
+        if (m_renderThread && m_running.loadRelaxed())
             Q_ASSERT(m_submitRenderViewsSemaphore.available() == 0);
         m_submitRenderViewsSemaphore.release(1);
     }
@@ -799,7 +793,7 @@ void Renderer::enqueueRenderView(Render::RenderView *renderView, int submitOrder
 bool Renderer::canRender() const
 {
     // Make sure that we've not been told to terminate
-    if (m_renderThread && !m_running.load()) {
+    if (m_renderThread && !m_running.loadRelaxed()) {
         qCDebug(Rendering) << "RenderThread termination requested whilst waiting";
         return false;
     }
@@ -818,7 +812,7 @@ bool Renderer::isReadyToSubmit()
     m_submitRenderViewsSemaphore.acquire(1);
 
     // Check if shutdown has been requested
-    if (m_running.load() == 0)
+    if (m_running.loadRelaxed() == 0)
         return false;
 
     // The semaphore should only
@@ -1425,7 +1419,7 @@ Renderer::ViewSubmissionResultData Renderer::submitRenderViews(const QVector<Ren
 
     const int renderViewsCount = renderViews.size();
     quint64 frameElapsed = queueElapsed;
-    m_lastFrameCorrect.store(1);    // everything fine until now.....
+    m_lastFrameCorrect.storeRelaxed(1);    // everything fine until now.....
 
     qCDebug(Memory) << Q_FUNC_INFO << "rendering frame ";
 
@@ -1458,7 +1452,7 @@ Renderer::ViewSubmissionResultData Renderer::submitRenderViews(const QVector<Ren
         //       to use when surface is null. Or if we should instead expose an
         //       offscreensurface to Qt3D.
         if (!surface || !surfaceLock.isSurfaceValid()) {
-            m_lastFrameCorrect.store(0);
+            m_lastFrameCorrect.storeRelaxed(0);
             continue;
         }
 
@@ -1478,7 +1472,7 @@ Renderer::ViewSubmissionResultData Renderer::submitRenderViews(const QVector<Ren
             // next RenderView. We won't get the full frame but we may get something
             if (!m_submissionContext->beginDrawing(surface)) {
                 qWarning() << "Failed to make OpenGL context current on surface";
-                m_lastFrameCorrect.store(0);
+                m_lastFrameCorrect.storeRelaxed(0);
                 continue;
             }
 
@@ -1579,7 +1573,7 @@ Renderer::ViewSubmissionResultData Renderer::submitRenderViews(const QVector<Ren
 
         // Execute the render commands
         if (!executeCommandsSubmission(renderView))
-            m_lastFrameCorrect.store(0);    // something went wrong; make sure to render the next frame!
+            m_lastFrameCorrect.storeRelaxed(0);    // something went wrong; make sure to render the next frame!
 
         // executeCommandsSubmission takes care of restoring the stateset to the value
         // of gc->currentContext() at the moment it was called (either
@@ -1682,7 +1676,7 @@ bool Renderer::shouldRender()
             || m_renderThread == nullptr // <==> we use Scene3D
             || m_dirtyBits.marked != 0
             || m_dirtyBits.remaining != 0
-            || !m_lastFrameCorrect.load());
+            || !m_lastFrameCorrect.loadRelaxed());
 }
 
 void Renderer::skipNextFrame()
@@ -1749,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);
@@ -1772,7 +1763,6 @@ QVector<Qt3DCore::QAspectJobPtr> Renderer::renderBinJobs()
     }
 
     if (dirtyBitsForFrame & AbstractRenderer::GeometryDirty ||
-        dirtyBitsForFrame & AbstractRenderer::EntityHierarchyDirty ||
         dirtyBitsForFrame & AbstractRenderer::TransformDirty) {
         renderBinJobs.push_back(m_expandBoundingVolumeJob);
     }
@@ -1799,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;
@@ -1807,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 5b566b3e7..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>
@@ -185,9 +184,9 @@ public:
     void doRender(bool swapBuffers = true) override;
     void cleanGraphicsResources() override;
 
-    bool isRunning() const override { return m_running.load(); }
+    bool isRunning() const override { return m_running.loadRelaxed(); }
 
-    void setSceneRoot(Qt3DCore::QBackendNodeFactory *factory, Entity *sgRoot) override;
+    void setSceneRoot(Entity *sgRoot) override;
     Entity *sceneRoot() const override { return m_renderSceneRoot; }
 
     FrameGraphNode *frameGraphRoot() const override;
@@ -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/src/render/renderers/opengl/renderer/renderview.cpp b/src/render/renderers/opengl/renderer/renderview.cpp
index 5845fe147..b00f2c473 100644
--- a/src/render/renderers/opengl/renderer/renderview.cpp
+++ b/src/render/renderers/opengl/renderer/renderview.cpp
@@ -425,7 +425,6 @@ struct SubRangeSorter<QSortPolicy::Texture>
             QVector<ShaderParameterPack::NamedResource> texturesB = b->m_parameterPack.textures();
 
             const int originalTextureASize = texturesA.size();
-            const bool isSuperior = originalTextureASize > texturesB.size();
 
             if (texturesB.size() > texturesA.size())
                 qSwap(texturesA, texturesB);
@@ -656,7 +655,7 @@ QVector<RenderCommand *> RenderView::buildDrawRenderCommands(const QVector<Entit
                 RenderPass *pass = passData.pass;
                 if (pass->hasRenderStates()) {
                     command->m_stateSet = new RenderStateSet();
-                    addUniqueStatesToRenderStateSet(command->m_stateSet, pass->renderStates(), m_manager->renderStateManager());
+                    addStatesToRenderStateSet(command->m_stateSet, pass->renderStates(), m_manager->renderStateManager());
                     if (m_stateSet != nullptr)
                         command->m_stateSet->merge(m_stateSet);
                     command->m_changeCost = m_renderer->defaultRenderState()->changeCost(command->m_stateSet);
@@ -781,7 +780,7 @@ QVector<RenderCommand *> RenderView::buildComputeRenderCommands(const QVector<En
 
                 if (pass->hasRenderStates()) {
                     command->m_stateSet = new RenderStateSet();
-                    addUniqueStatesToRenderStateSet(command->m_stateSet, pass->renderStates(), m_manager->renderStateManager());
+                    addStatesToRenderStateSet(command->m_stateSet, pass->renderStates(), m_manager->renderStateManager());
 
                     // Merge per pass stateset with global stateset
                     // so that the local stateset only overrides
diff --git a/src/render/renderers/opengl/renderstates/renderstateset.cpp b/src/render/renderers/opengl/renderstates/renderstateset.cpp
index b14695c77..d667d9c76 100644
--- a/src/render/renderers/opengl/renderstates/renderstateset.cpp
+++ b/src/render/renderers/opengl/renderstates/renderstateset.cpp
@@ -112,17 +112,28 @@ void RenderStateSet::merge(RenderStateSet *other)
 
     // We only add states which are new (different type)
     for (const StateVariant &otherState : otherStates) {
-        const bool hasFoundStateOfSameType = hasStateOfType(otherState.type);
-        if (!hasFoundStateOfSameType)
+        const bool canAdd = canAddStateOfType(otherState.type);
+        if (canAdd)
             m_states.push_back(otherState);
     }
 }
 
+bool RenderStateSet::canAddStateOfType(StateMask type) const
+{
+    return !hasStateOfType(type) || allowMultipleStatesOfType(type);
+}
+
 bool RenderStateSet::hasStateOfType(StateMask type) const
 {
     return (type & stateMask());
 }
 
+bool RenderStateSet::allowMultipleStatesOfType(StateMask type) const
+{
+    return (type == BlendEquationArgumentsMask) ||
+           (type == ClipPlaneMask);
+}
+
 bool RenderStateSet::contains(const StateVariant &ds) const
 {
     // trivial reject using the state mask bits
diff --git a/src/render/renderers/opengl/renderstates/renderstateset_p.h b/src/render/renderers/opengl/renderstates/renderstateset_p.h
index 29be4d2f1..c2f3a0219 100644
--- a/src/render/renderers/opengl/renderstates/renderstateset_p.h
+++ b/src/render/renderers/opengl/renderstates/renderstateset_p.h
@@ -93,8 +93,7 @@ public:
 
     QVector<StateVariant> states() const { return m_states; }
 
-    bool hasStateOfType(StateMask type) const;
-
+    bool canAddStateOfType(StateMask type) const;
 
     /**
      * @brief contains - check if this set contains a matching piece of state
@@ -102,6 +101,11 @@ public:
      * @return
      */
     bool contains(const StateVariant &ds) const;
+
+private:
+    bool hasStateOfType(StateMask type) const;
+    bool allowMultipleStatesOfType(StateMask type) const;
+
 private:
     StateMaskSet m_stateMask;
     QVector<StateVariant> m_states;
diff --git a/src/render/renderers/opengl/textures/gltexture.cpp b/src/render/renderers/opengl/textures/gltexture.cpp
index 93348d0b0..11d2c2be9 100644
--- a/src/render/renderers/opengl/textures/gltexture.cpp
+++ b/src/render/renderers/opengl/textures/gltexture.cpp
@@ -474,15 +474,15 @@ QOpenGLTexture *GLTexture::buildGLTexture()
     QAbstractTexture::TextureFormat format = m_properties.format;
     if (ctx->isOpenGLES() && ctx->format().majorVersion() < 3) {
         switch (m_properties.format) {
-        case QOpenGLTexture::RGBA8_UNorm:
-        case QOpenGLTexture::RGBAFormat:
+        case QAbstractTexture::RGBA8_UNorm:
+        case QAbstractTexture::RGBAFormat:
             format = QAbstractTexture::RGBAFormat;
             break;
-        case QOpenGLTexture::RGB8_UNorm:
-        case QOpenGLTexture::RGBFormat:
+        case QAbstractTexture::RGB8_UNorm:
+        case QAbstractTexture::RGBFormat:
             format = QAbstractTexture::RGBFormat;
             break;
-        case QOpenGLTexture::DepthFormat:
+        case QAbstractTexture::DepthFormat:
             format = QAbstractTexture::DepthFormat;
             break;
         default:
@@ -682,8 +682,8 @@ void GLTexture::introspectPropertiesFromSharedTextureId()
     const QPair<int, int> ctxGLVersion = ctx->format().version();
     if (ctxGLVersion.first > 4 || (ctxGLVersion.first == 4 && ctxGLVersion.second >= 5)) {
         // Only for GL 4.5+
-        QOpenGLFunctions_4_5_Core *gl5 = ctx->versionFunctions<QOpenGLFunctions_4_5_Core>();
 #ifdef GL_TEXTURE_TARGET
+        QOpenGLFunctions_4_5_Core *gl5 = ctx->versionFunctions<QOpenGLFunctions_4_5_Core>();
         if (gl5 != nullptr)
             gl5->glGetTextureParameteriv(m_sharedTextureId, GL_TEXTURE_TARGET, reinterpret_cast<int *>(&m_properties.target));
 #endif
diff --git a/src/render/renderstates/qdepthrange.cpp b/src/render/renderstates/qdepthrange.cpp
index 58b8b744a..ec5bbce9f 100644
--- a/src/render/renderstates/qdepthrange.cpp
+++ b/src/render/renderstates/qdepthrange.cpp
@@ -48,7 +48,7 @@ namespace Qt3DRender {
 /*!
     \class Qt3DRender::QDepthRange
     \inmodule Qt3DRender
-    \since 5.13
+    \since 5.14
     \ingroup renderstates
     \brief Enables remapping depth values written into the depth buffer.
 
@@ -65,7 +65,7 @@ namespace Qt3DRender {
     \inherits RenderState
     \inqmlmodule Qt3D.Render
     \ingroup renderstates
-    \since 5.13
+    \since 5.14
     \brief Enables remapping depth values written into the depth buffer.
 
     By default, OpenGL writes scene depth information into the depth buffer in
diff --git a/src/render/texture/qabstracttexture.cpp b/src/render/texture/qabstracttexture.cpp
index 399314f24..229d773ad 100644
--- a/src/render/texture/qabstracttexture.cpp
+++ b/src/render/texture/qabstracttexture.cpp
@@ -81,10 +81,7 @@ void QAbstractTexturePrivate::setDataFunctor(const QTextureGeneratorPtr &generat
 {
     if (generator != m_dataFunctor) {
         m_dataFunctor = generator;
-        auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(m_id);
-        change->setPropertyName("generator");
-        change->setValue(QVariant::fromValue(generator));
-        notifyObservers(change);
+        update();
     }
 }
 
@@ -811,24 +808,15 @@ void QAbstractTexture::setWrapMode(const QTextureWrapMode &wrapMode)
     Q_D(QAbstractTexture);
     if (d->m_wrapMode.x() != wrapMode.x()) {
         d->m_wrapMode.setX(wrapMode.x());
-        auto e = QPropertyUpdatedChangePtr::create(d->m_id);
-        e->setPropertyName("wrapModeX");
-        e->setValue(static_cast<int>(d->m_wrapMode.x()));
-        d->notifyObservers(e);
+        d->update();
     }
     if (d->m_wrapMode.y() != wrapMode.y()) {
         d->m_wrapMode.setY(wrapMode.y());
-        auto e = QPropertyUpdatedChangePtr::create(d->m_id);
-        e->setPropertyName("wrapModeY");
-        e->setValue(static_cast<int>(d->m_wrapMode.y()));
-        d->notifyObservers(e);
+        d->update();
     }
     if (d->m_wrapMode.z() != wrapMode.z()) {
         d->m_wrapMode.setZ(wrapMode.z());
-        auto e = QPropertyUpdatedChangePtr::create(d->m_id);
-        e->setPropertyName("wrapModeZ");
-        e->setValue(static_cast<int>(d->m_wrapMode.z()));
-        d->notifyObservers(e);
+        d->update();
     }
 }
 
@@ -983,16 +971,8 @@ void QAbstractTexture::updateData(const QTextureDataUpdate &update)
 {
     Q_D(QAbstractTexture);
 
-    // Send update to backend if we have the changeArbiter
-    if (d->m_changeArbiter != nullptr) {
-        auto e = QPropertyUpdatedChangePtr::create(id());
-        e->setPropertyName("updateData");
-        e->setValue(QVariant::fromValue(update));
-        notifyObservers(e);
-    } else {
-        // If we have no arbiter (no backend), record the update as part of the creation changes
-        d->m_initialDataUpdates.push_back(update);
-    }
+    d->m_pendingDataUpdates.push_back(update);
+    d->update();
 }
 
 Qt3DCore::QNodeCreatedChangeBasePtr QAbstractTexture::createNodeCreationChange() const
@@ -1019,8 +999,8 @@ Qt3DCore::QNodeCreatedChangeBasePtr QAbstractTexture::createNodeCreationChange()
     data.samples = d->m_samples;
     data.dataFunctor = d->m_dataFunctor;
     data.sharedTextureId = d->m_sharedTextureId;
-    data.initialDataUpdates = d->m_initialDataUpdates;
-    return creationChange;
+    data.initialDataUpdates = d->m_pendingDataUpdates;
+    return std::move(creationChange);
 }
 
 /*!
diff --git a/src/render/texture/qabstracttexture_p.h b/src/render/texture/qabstracttexture_p.h
index 072bd8159..573eac8c7 100644
--- a/src/render/texture/qabstracttexture_p.h
+++ b/src/render/texture/qabstracttexture_p.h
@@ -96,7 +96,7 @@ public :
     QTextureGeneratorPtr dataFunctor() const;
     void setDataFunctor(const QTextureGeneratorPtr &generator);
 
-    QVector<QTextureDataUpdate> m_initialDataUpdates;
+    QVector<QTextureDataUpdate> m_pendingDataUpdates;
 
 private:
     QTextureGeneratorPtr m_dataFunctor;
diff --git a/src/render/texture/qabstracttextureimage.cpp b/src/render/texture/qabstracttextureimage.cpp
index a95e1fffd..42f8eb747 100644
--- a/src/render/texture/qabstracttextureimage.cpp
+++ b/src/render/texture/qabstracttextureimage.cpp
@@ -255,12 +255,7 @@ void QAbstractTextureImage::setFace(QAbstractTexture::CubeMapFace face)
 void QAbstractTextureImage::notifyDataGeneratorChanged()
 {
     Q_D(QAbstractTextureImage);
-    if (d->m_changeArbiter != nullptr) {
-        auto change = QPropertyUpdatedChangePtr::create(d->m_id);
-        change->setPropertyName("dataGenerator");
-        change->setValue(QVariant::fromValue(dataGenerator()));
-        d->notifyObservers(change);
-    }
+    d->update();
 }
 
 /*! \internal */
diff --git a/src/render/texture/qtexturedataupdate.cpp b/src/render/texture/qtexturedataupdate.cpp
index f196a6b7b..e3d5220f0 100644
--- a/src/render/texture/qtexturedataupdate.cpp
+++ b/src/render/texture/qtexturedataupdate.cpp
@@ -68,6 +68,7 @@ static bool operator==(const QTextureDataUpdatePrivate &lhs, const QTextureDataU
     as well as the eventual layer, mipLevel and face.
 
     \sa QAbstractTexture
+    \since 5.14
  */
 
 QTextureDataUpdate::QTextureDataUpdate()
diff --git a/src/render/texture/texture.cpp b/src/render/texture/texture.cpp
index c7a739724..53216d27d 100644
--- a/src/render/texture/texture.cpp
+++ b/src/render/texture/texture.cpp
@@ -61,6 +61,7 @@ Texture::Texture()
     // We need backend -> frontend notifications to update the status of the texture
     : BackendNode(ReadWrite)
     , m_dirty(DirtyImageGenerators|DirtyProperties|DirtyParameters|DirtyDataGenerator)
+    , m_sharedTextureId(-1)
 {
 }
 
@@ -130,67 +131,6 @@ void Texture::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
     DirtyFlags dirty;
 
     switch (e->type()) {
-    case PropertyUpdated: {
-        QPropertyUpdatedChangePtr propertyChange = qSharedPointerCast<QPropertyUpdatedChange>(e);
-        if (propertyChange->propertyName() == QByteArrayLiteral("width")) {
-            m_properties.width = propertyChange->value().toInt();
-            dirty = DirtyProperties;
-        } else if (propertyChange->propertyName() == QByteArrayLiteral("height")) {
-            m_properties.height = propertyChange->value().toInt();
-            dirty = DirtyProperties;
-        } else if (propertyChange->propertyName() == QByteArrayLiteral("depth")) {
-            m_properties.depth = propertyChange->value().toInt();
-            dirty = DirtyProperties;
-        } else if (propertyChange->propertyName() == QByteArrayLiteral("format")) {
-            m_properties.format = static_cast<QAbstractTexture::TextureFormat>(propertyChange->value().toInt());
-            dirty = DirtyProperties;
-        } else if (propertyChange->propertyName() == QByteArrayLiteral("target")) {
-            m_properties.target = static_cast<QAbstractTexture::Target>(propertyChange->value().toInt());
-            dirty = DirtyProperties;
-        } else if (propertyChange->propertyName() == QByteArrayLiteral("mipmaps")) {
-            m_properties.generateMipMaps = propertyChange->value().toBool();
-            dirty = DirtyProperties;
-        } else if (propertyChange->propertyName() == QByteArrayLiteral("minificationFilter")) {
-            m_parameters.minificationFilter = static_cast<QAbstractTexture::Filter>(propertyChange->value().toInt());
-            dirty = DirtyParameters;
-        } else if (propertyChange->propertyName() == QByteArrayLiteral("magnificationFilter")) {
-            m_parameters.magnificationFilter = static_cast<QAbstractTexture::Filter>(propertyChange->value().toInt());
-            dirty = DirtyParameters;
-        } else if (propertyChange->propertyName() == QByteArrayLiteral("wrapModeX")) {
-            m_parameters.wrapModeX = static_cast<QTextureWrapMode::WrapMode>(propertyChange->value().toInt());
-            dirty = DirtyParameters;
-        } else if (propertyChange->propertyName() == QByteArrayLiteral("wrapModeY")) {
-            m_parameters.wrapModeY = static_cast<QTextureWrapMode::WrapMode>(propertyChange->value().toInt());
-            dirty = DirtyParameters;
-        } else if (propertyChange->propertyName() == QByteArrayLiteral("wrapModeZ")) {
-            m_parameters.wrapModeZ =static_cast<QTextureWrapMode::WrapMode>(propertyChange->value().toInt());
-            dirty = DirtyParameters;
-        } else if (propertyChange->propertyName() == QByteArrayLiteral("maximumAnisotropy")) {
-            m_parameters.maximumAnisotropy = propertyChange->value().toFloat();
-            dirty = DirtyParameters;
-        } else if (propertyChange->propertyName() == QByteArrayLiteral("comparisonFunction")) {
-            m_parameters.comparisonFunction = propertyChange->value().value<QAbstractTexture::ComparisonFunction>();
-            dirty = DirtyParameters;
-        } else if (propertyChange->propertyName() == QByteArrayLiteral("comparisonMode")) {
-            m_parameters.comparisonMode = propertyChange->value().value<QAbstractTexture::ComparisonMode>();
-            dirty = DirtyParameters;
-        } else if (propertyChange->propertyName() == QByteArrayLiteral("layers")) {
-            m_properties.layers = propertyChange->value().toInt();
-            dirty = DirtyProperties;
-        } else if (propertyChange->propertyName() == QByteArrayLiteral("samples")) {
-            m_properties.samples = propertyChange->value().toInt();
-            dirty = DirtyProperties;
-        } else if (propertyChange->propertyName() == QByteArrayLiteral("generator")) {
-            setDataGenerator(propertyChange->value().value<QTextureGeneratorPtr>());
-        } else if (propertyChange->propertyName() == QByteArrayLiteral("textureId")) {
-            m_sharedTextureId = propertyChange->value().toInt();
-            dirty = DirtySharedTextureId;
-        } else if (propertyChange->propertyName() == QByteArrayLiteral("updateData")) {
-            Qt3DRender::QTextureDataUpdate updateData = propertyChange->value().value<Qt3DRender::QTextureDataUpdate>();
-            addTextureDataUpdate(updateData);
-        }
-        break;
-    }
 
     case PropertyValueAdded: {
         const auto change = qSharedPointerCast<QPropertyNodeAddedChange>(e);
@@ -217,6 +157,62 @@ void Texture::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
     BackendNode::sceneChangeEvent(e);
 }
 
+void Texture::syncFromFrontEnd(const QNode *frontEnd, bool firstTime)
+{
+    BackendNode::syncFromFrontEnd(frontEnd, firstTime);
+    const QAbstractTexture *node = qobject_cast<const QAbstractTexture *>(frontEnd);
+    if (!node)
+        return;
+
+    TextureProperties p = m_properties;
+    p.width = node->width();
+    p.height = node->height();
+    p.depth = node->depth();
+    p.format = node->format();
+    p.target = node->target();
+    p.generateMipMaps = node->generateMipMaps();
+    p.layers = node->layers();
+    p.samples = node->samples();
+    if (p != m_properties) {
+        m_properties = p;
+        addDirtyFlag(DirtyProperties);
+    }
+
+    TextureParameters q = m_parameters;
+    q.magnificationFilter = node->magnificationFilter();
+    q.minificationFilter = node->minificationFilter();
+    q.wrapModeX = const_cast<QAbstractTexture *>(node)->wrapMode()->x();
+    q.wrapModeY = const_cast<QAbstractTexture *>(node)->wrapMode()->y();
+    q.wrapModeZ = const_cast<QAbstractTexture *>(node)->wrapMode()->z();
+    q.maximumAnisotropy = node->maximumAnisotropy();
+    q.comparisonFunction = node->comparisonFunction();
+    q.comparisonMode = node->comparisonMode();
+    if (q != m_parameters) {
+        m_parameters = q;
+        addDirtyFlag(DirtyParameters);
+    }
+
+    auto newGenerator = node->dataGenerator();
+    if (newGenerator != m_dataFunctor) {
+        setDataGenerator(newGenerator);
+    }
+
+    QAbstractTexturePrivate *dnode = dynamic_cast<QAbstractTexturePrivate *>(QAbstractTexturePrivate::get(const_cast<QAbstractTexture *>(node)));
+    if (dnode) {
+        for (const QTextureDataUpdate &pendingUpdate : dnode->m_pendingDataUpdates)
+            addTextureDataUpdate(pendingUpdate);
+        dnode->m_pendingDataUpdates.clear();
+
+        for (const auto imgNode : dnode->m_textureImages)
+            addTextureImage(imgNode->id());
+    }
+
+    if (dnode->m_sharedTextureId != m_sharedTextureId) {
+        m_sharedTextureId = dnode->m_sharedTextureId;
+        addDirtyFlag(DirtySharedTextureId);
+    }
+}
+
 // Called by sceneChangeEvent or TextureDownloadRequest (both in AspectThread context)
 void Texture::setDataGenerator(const QTextureGeneratorPtr &generator)
 {
@@ -308,7 +304,7 @@ void Texture::updatePropertiesAndNotify(const TextureUpdateInfo &updateInfo)
 
 bool Texture::isValid(TextureImageManager *manager) const
 {
-    for (const QNodeId id : m_textureImageIds) {
+    for (const QNodeId &id : m_textureImageIds) {
         TextureImage *img = manager->lookupResource(id);
         if (img == nullptr)
             return false;
@@ -340,7 +336,7 @@ void Texture::initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &chan
     m_dataFunctor = data.dataFunctor;
     m_sharedTextureId = data.sharedTextureId;
 
-    for (const QNodeId imgId : data.textureImageIds)
+    for (const QNodeId &imgId : data.textureImageIds)
         addTextureImage(imgId);
 
     const QVector<QTextureDataUpdate> initialDataUpdates = data.initialDataUpdates;
diff --git a/src/render/texture/texture_p.h b/src/render/texture/texture_p.h
index 28580c92a..967b2a44a 100644
--- a/src/render/texture/texture_p.h
+++ b/src/render/texture/texture_p.h
@@ -164,6 +164,7 @@ public:
     QVector<QTextureDataUpdate> takePendingTextureDataUpdates() { return std::move(m_pendingTextureDataUpdates); }
 
     void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e) override;
+    void syncFromFrontEnd(const Qt3DCore::QNode *frontEnd, bool firstTime) override;
 
     inline const TextureProperties& properties() const { return m_properties; }
     inline const TextureParameters& parameters() const { return m_parameters; }
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/qanimationcliploader/tst_qanimationcliploader.cpp b/tests/auto/animation/qanimationcliploader/tst_qanimationcliploader.cpp
index f446f1b0f..c52986055 100644
--- a/tests/auto/animation/qanimationcliploader/tst_qanimationcliploader.cpp
+++ b/tests/auto/animation/qanimationcliploader/tst_qanimationcliploader.cpp
@@ -190,6 +190,9 @@ private Q_SLOTS:
         QCOMPARE(spy.count(), 0);
         QCOMPARE(arbiter.events.size(), 0);
         QCOMPARE(status(), newStatus);
+
+        // Cleanup
+        Qt3DCore::QNodePrivate::get(this)->setArbiter(nullptr);
     }
 };
 
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/core/common/qbackendnodetester.cpp b/tests/auto/core/common/qbackendnodetester.cpp
index 5d4a10b81..a2685f556 100644
--- a/tests/auto/core/common/qbackendnodetester.cpp
+++ b/tests/auto/core/common/qbackendnodetester.cpp
@@ -36,7 +36,6 @@
 
 #include "qbackendnodetester.h"
 #include <Qt3DCore/qbackendnode.h>
-#include <Qt3DCore/qnode.h>
 
 QT_BEGIN_NAMESPACE
 
diff --git a/tests/auto/core/common/qbackendnodetester.h b/tests/auto/core/common/qbackendnodetester.h
index a9738dff0..a0b89e503 100644
--- a/tests/auto/core/common/qbackendnodetester.h
+++ b/tests/auto/core/common/qbackendnodetester.h
@@ -41,13 +41,13 @@
 #include <Qt3DCore/qnodeid.h>
 #include <Qt3DCore/qscenechange.h>
 #include <Qt3DCore/qnodecreatedchange.h>
+#include <Qt3DCore/qnode.h>
 
 QT_BEGIN_NAMESPACE
 
 namespace Qt3DCore {
 
 class QBackendNode;
-class QNode;
 
 class QBackendNodeTester : public QObject
 {
@@ -57,9 +57,21 @@ public:
 
     // Proxies to allow test classes to call private methods on QBackendNode
     void setPeerId(QBackendNode *backend, QNodeId id);
-    void simulateInitialization(QNode *frontend, QBackendNode *backend);
     void sceneChangeEvent(QBackendNode *backend, const Qt3DCore::QSceneChangePtr &e);
     Qt3DCore::QNodeCreatedChangeBasePtr creationChange(QNode *frontend) const;
+
+    template<class Backend>
+    void simulateInitializationSync(QNode *frontend, Backend *backend)
+    {
+        Q_ASSERT(frontend);
+        Q_ASSERT(backend);
+
+        backend->setPeerId(frontend->id());
+        backend->setEnabled(frontend->isEnabled());
+        backend->syncFromFrontEnd(frontend, true);
+    }
+
+    void simulateInitialization(QNode *frontend, QBackendNode *backend);
 };
 
 } // namespace Qt3DCore
diff --git a/tests/auto/core/matrix4x4_avx2/tst_matrix4x4_avx2.cpp b/tests/auto/core/matrix4x4_avx2/tst_matrix4x4_avx2.cpp
index 144df6711..12eaab263 100644
--- a/tests/auto/core/matrix4x4_avx2/tst_matrix4x4_avx2.cpp
+++ b/tests/auto/core/matrix4x4_avx2/tst_matrix4x4_avx2.cpp
@@ -474,6 +474,55 @@ private Q_SLOTS:
             QCOMPARE(row.w(), 44.0f);
         }
     }
+
+    void checkVectorMapVector()
+    {
+        {
+            // GIVEN
+            QMatrix4x4 tmpMat;
+            QVector3D tmpVec3(1.0f, 0.0f, 0.0f);
+            tmpMat.rotate(90.f, 0.f, 1.f, 0.f);
+
+            Matrix4x4_AVX2 mat(tmpMat);
+            Vector3D vec3(tmpVec3);
+
+            // WHEN
+            const Vector3D resultingVec = mat.mapVector(vec3);
+
+            // THEN
+            QCOMPARE(resultingVec.toQVector3D(), tmpMat.mapVector(tmpVec3));
+        }
+        {
+            // GIVEN
+            QMatrix4x4 tmpMat;
+            QVector3D tmpVec3(0.0f, 0.0f, -1.0f);
+            tmpMat.rotate(90.f, 0.f, 1.f, 0.f);
+
+            Matrix4x4_AVX2 mat(tmpMat);
+            Vector3D vec3(tmpVec3);
+
+            // WHEN
+            const Vector3D resultingVec = mat.mapVector(vec3);
+
+            // THEN
+            QCOMPARE(resultingVec.toQVector3D(), tmpMat.mapVector(tmpVec3));
+        }
+        {
+            // GIVEN
+            QMatrix4x4 tmpMat;
+            QVector3D tmpVec3(3.0f, -3.0f, -1.0f);
+            tmpMat.rotate(90.f, 0.33f, 0.33f, 0.33f);
+
+            Matrix4x4_AVX2 mat(tmpMat);
+            Vector3D vec3(tmpVec3);
+
+            // WHEN
+            const Vector3D resultingVec = mat.mapVector(vec3);
+
+            // THEN
+            QCOMPARE(resultingVec.toQVector3D(), tmpMat.mapVector(tmpVec3));
+        }
+    }
 };
 
 QTEST_MAIN(tst_Matrix4x4_AVX2)
diff --git a/tests/auto/core/matrix4x4_sse/tst_matrix4x4_sse.cpp b/tests/auto/core/matrix4x4_sse/tst_matrix4x4_sse.cpp
index bbd6596d4..dccf90d10 100644
--- a/tests/auto/core/matrix4x4_sse/tst_matrix4x4_sse.cpp
+++ b/tests/auto/core/matrix4x4_sse/tst_matrix4x4_sse.cpp
@@ -471,6 +471,55 @@ private Q_SLOTS:
             QCOMPARE(row.w(), 44.0f);
         }
     }
+
+    void checkVectorMapVector()
+    {
+        {
+            // GIVEN
+            QMatrix4x4 tmpMat;
+            QVector3D tmpVec3(1.0f, 0.0f, 0.0f);
+            tmpMat.rotate(90.f, 0.f, 1.f, 0.f);
+
+            Matrix4x4_SSE mat(tmpMat);
+            Vector3D vec3(tmpVec3);
+
+            // WHEN
+            const Vector3D resultingVec = mat.mapVector(vec3);
+
+            // THEN
+            QCOMPARE(resultingVec.toQVector3D(), tmpMat.mapVector(tmpVec3));
+        }
+        {
+            // GIVEN
+            QMatrix4x4 tmpMat;
+            QVector3D tmpVec3(0.0f, 0.0f, -1.0f);
+            tmpMat.rotate(90.f, 0.f, 1.f, 0.f);
+
+            Matrix4x4_SSE mat(tmpMat);
+            Vector3D vec3(tmpVec3);
+
+            // WHEN
+            const Vector3D resultingVec = mat.mapVector(vec3);
+
+            // THEN
+            QCOMPARE(resultingVec.toQVector3D(), tmpMat.mapVector(tmpVec3));
+        }
+        {
+            // GIVEN
+            QMatrix4x4 tmpMat;
+            QVector3D tmpVec3(3.0f, -3.0f, -1.0f);
+            tmpMat.rotate(90.f, 0.33f, 0.33f, 0.33f);
+
+            Matrix4x4_SSE mat(tmpMat);
+            Vector3D vec3(tmpVec3);
+
+            // WHEN
+            const Vector3D resultingVec = mat.mapVector(vec3);
+
+            // THEN
+            QCOMPARE(resultingVec.toQVector3D(), tmpMat.mapVector(tmpVec3));
+        }
+    }
 };
 
 QTEST_MAIN(tst_Matrix4x4_SSE)
diff --git a/tests/auto/core/nodes/tst_nodes.cpp b/tests/auto/core/nodes/tst_nodes.cpp
index ec07c158d..c5369ab3e 100644
--- a/tests/auto/core/nodes/tst_nodes.cpp
+++ b/tests/auto/core/nodes/tst_nodes.cpp
@@ -31,6 +31,7 @@
 #include <Qt3DCore/qentity.h>
 #include <Qt3DCore/qcomponent.h>
 #include <Qt3DCore/qaspectengine.h>
+#include <Qt3DCore/qabstractaspect.h>
 #include <Qt3DCore/private/qscene_p.h>
 #include <Qt3DCore/qpropertyupdatedchange.h>
 #include <Qt3DCore/qcomponentaddedchange.h>
@@ -40,6 +41,7 @@
 #include <Qt3DCore/qpropertynoderemovedchange.h>
 #include <Qt3DCore/private/qnodecreatedchangegenerator_p.h>
 #include <Qt3DCore/private/qaspectengine_p.h>
+#include <private/qabstractaspect_p.h>
 #include <private/qpostman_p.h>
 
 #include <Qt3DCore/private/qlockableobserverinterface_p.h>
@@ -76,6 +78,8 @@ private slots:
     void checkParentChangeToOtherParent();
     void checkParentChangeFromExistingBackendParentToNewlyCreatedParent();
     void checkBackendNodesCreatedFromTopDown();   //QTBUG-74106
+    void checkBackendNodesCreatedFromTopDownWithReparenting();
+    void checkAllBackendCreationDoneInSingleFrame();
 
     void removingSingleChildNodeFromNode();
     void removingMultipleChildNodesFromNode();
@@ -425,6 +429,124 @@ public:
     }
 };
 
+class TestAspectPrivate;
+class TestAspect : public Qt3DCore::QAbstractAspect
+{
+    Q_OBJECT
+public:
+    explicit TestAspect(QObject *parent = nullptr);
+
+    enum ChangeType { Creation, Destruction };
+
+    void clearNodes()
+    {
+        events.clear();
+        allNodes.clear();
+    }
+
+    void addEvent(const Qt3DCore::QNodeId &id, ChangeType change)
+    {
+        events.push_back(Event{ change, id});
+    }
+
+    QVector<Qt3DCore::QNodeId> filteredEvents(ChangeType change) const
+    {
+        QVector<Qt3DCore::QNodeId> result;
+        for (const auto &event : events) {
+            if (event.type == change)
+                result.push_back(event.nodeId);
+        }
+        return result;
+    }
+
+    struct Event{
+        ChangeType type;
+        Qt3DCore::QNodeId nodeId;
+    };
+
+    mutable QVector<Event> events;
+    mutable QHash<Qt3DCore::QNodeId, Qt3DCore::QNode *> allNodes;
+
+private:
+    Q_DECLARE_PRIVATE(TestAspect)
+    explicit TestAspect(TestAspectPrivate &dd, QObject *parent);
+};
+
+class TestFunctor : public Qt3DCore::QBackendNodeMapper
+{
+public:
+    TestFunctor(TestAspect *aspect) : m_aspect(aspect) {}
+
+    Qt3DCore::QBackendNode *create(const Qt3DCore::QNodeCreatedChangeBasePtr &change) const override
+    {
+        auto node = new Qt3DCore::QBackendNode;
+        m_Nodes.insert(change->subjectId(), node);
+        m_aspect->addEvent(change->subjectId(), TestAspect::Creation);
+        return node;
+    }
+
+    Qt3DCore::QBackendNode *get(Qt3DCore::QNodeId id) const override
+    {
+        return m_Nodes.value(id, nullptr);
+    }
+
+    void destroy(Qt3DCore::QNodeId id) const override
+    {
+        if (m_Nodes.contains(id)) {
+            m_aspect->addEvent(id, TestAspect::Destruction);
+            delete m_Nodes.take(id);
+        }
+    }
+
+private:
+    mutable QHash<Qt3DCore::QNodeId, Qt3DCore::QBackendNode *> m_Nodes;
+    TestAspect *m_aspect;
+};
+
+class TestAspectPrivate : public Qt3DCore::QAbstractAspectPrivate
+{
+public:
+    TestAspectPrivate() = default;
+    void syncDirtyFrontEndNode(Qt3DCore::QNode *node, Qt3DCore::QBackendNode *backend,
+                               bool firstTime) const override
+    {
+        Q_UNUSED(backend);
+        auto q = q_func();
+        if (firstTime)
+            q->allNodes.insert(node->id(), node);
+    }
+
+    Q_DECLARE_PUBLIC(TestAspect)
+};
+
+TestAspect::TestAspect(QObject *parent) : TestAspect(*new TestAspectPrivate, parent)
+{
+    registerBackendType<Qt3DCore::QEntity, true>(QSharedPointer<TestFunctor>::create(this));
+    registerBackendType<MyQEntity, true>(QSharedPointer<TestFunctor>::create(this));
+    registerBackendType<MyQNode, true>(QSharedPointer<TestFunctor>::create(this));
+    registerBackendType<Qt3DCore::QNode, true>(QSharedPointer<TestFunctor>::create(this));
+}
+
+TestAspect::TestAspect(TestAspectPrivate &dd, QObject *parent)
+    : Qt3DCore::QAbstractAspect(dd, parent)
+{
+    setObjectName(QStringLiteral("Test Aspect"));
+}
+
+namespace {
+void verifyChildrenCreatedBeforeParents(Qt3DCore::QNode *root, TestAspect *aspect)
+{
+    QSet<Qt3DCore::QNodeId> processedNodes;
+    processedNodes.insert(root->id());
+    for (const auto &nodeId : aspect->filteredEvents(TestAspect::Creation)) {
+        const auto node = aspect->allNodes.value(nodeId);
+        Q_ASSERT(node);
+        const auto parentNode = node->parentNode();
+        QVERIFY(parentNode == nullptr || processedNodes.contains(parentNode->id()));
+        processedNodes.insert(nodeId);
+    }
+}
+}
 
 void tst_Nodes::initTestCase()
 {
@@ -802,17 +924,27 @@ void tst_Nodes::checkParentChangeFromExistingBackendParentToNewlyCreatedParent()
     Qt3DCore::QAspectEngine engine;
     QScopedPointer<MyQEntity> root(new MyQEntity());
     root->setArbiterAndEngine(&spy, &engine);
+    auto aspect = new TestAspect;
+    engine.registerAspect(aspect);
+
     MyQNode *child(new MyQNode(root.data()));
     MyQNode *child2(new MyQNode(root.data()));
+
     QCoreApplication::processEvents();
 
     // Due to the way we create root, it has a backend
     QVERIFY(Qt3DCore::QNodePrivate::get(root.data())->m_hasBackendNode == true);
+    QCOMPARE(aspect->events.count(), 2);
+    QCOMPARE(aspect->events[0].type, TestAspect::Creation);
+    QCOMPARE(aspect->events[0].nodeId, child->id());
+    QCOMPARE(aspect->events[1].type, TestAspect::Creation);
+    QCOMPARE(aspect->events[1].nodeId, child2->id());
 
     // THEN
     QCOMPARE(spy.events.size(), 2); // 2 x (1 child added to parent change)
 
     // WHEN -> Reparenting child with backend node to new parent with no backend yet
+    aspect->clearNodes();
     spy.events.clear();
     QScopedPointer<Qt3DCore::QNode> newParent(new MyQNode(root.data()));
     child->setParent(newParent.data());
@@ -831,8 +963,8 @@ void tst_Nodes::checkParentChangeFromExistingBackendParentToNewlyCreatedParent()
     QCoreApplication::processEvents();
 
     // THEN
-    QCOMPARE(spy.events.size(), 3);
-    // 1 node removed change, 1 node destroyed change
+    QCOMPARE(spy.events.size(), 2);
+    // 1 node removed change
     // 1 node added to children change
     QVERIFY(Qt3DCore::QNodePrivate::get(newParent.data())->m_hasBackendNode == true);
     QVERIFY(Qt3DCore::QNodePrivate::get(child)->m_hasBackendNode == true);
@@ -846,33 +978,27 @@ void tst_Nodes::checkParentChangeFromExistingBackendParentToNewlyCreatedParent()
         QCOMPARE(event->removedNodeId(), child->id());
         QCOMPARE(event->metaObject(), child->metaObject());
 
-        // CHECK event 2 is a Node Destroyed
-        QVERIFY(spy.events.first().wasLocked());
-        const Qt3DCore::QNodeDestroyedChangePtr event2 = spy.events.takeFirst().change().staticCast<Qt3DCore::QNodeDestroyedChange>();
-        QCOMPARE(event2->type(), Qt3DCore::NodeDeleted);
-        QCOMPARE(event2->subtreeIdsAndTypes().size(), 1);
-        QCOMPARE(event2->subtreeIdsAndTypes().first().id, child->id());
-
-//        // CHECK event 3 and 4 are Node Created events
-//        const Qt3DCore::QNodeCreatedChangeBasePtr event3 = spy.events.takeFirst().change().staticCast<Qt3DCore::QNodeCreatedChangeBase>();
-//        const Qt3DCore::QNodeCreatedChangeBasePtr event4 = spy.events.takeFirst().change().staticCast<Qt3DCore::QNodeCreatedChangeBase>();
-
-//        QCOMPARE(event3->type(), Qt3DCore::NodeCreated);
-//        QCOMPARE(event3->parentId(), root->id());
-//        QCOMPARE(event3->subjectId(), newParent->id());
-
-//        QCOMPARE(event4->type(), Qt3DCore::NodeCreated);
-//        QCOMPARE(event4->parentId(), newParent->id());
-//        QCOMPARE(event4->subjectId(), child->id());
-
-        const Qt3DCore::QPropertyNodeAddedChangePtr event5 = spy.events.takeFirst().change().staticCast<Qt3DCore::QPropertyNodeAddedChange>();
-        QCOMPARE(event5->type(), Qt3DCore::PropertyValueAdded);
-        QCOMPARE(event5->addedNodeId(), newParent->id());
-        QCOMPARE(event5->metaObject(), newParent->metaObject());
-        QCOMPARE(event5->subjectId(), root->id());
+        const Qt3DCore::QPropertyNodeAddedChangePtr event2 = spy.events.takeFirst().change().staticCast<Qt3DCore::QPropertyNodeAddedChange>();
+        QCOMPARE(event2->type(), Qt3DCore::PropertyValueAdded);
+        QCOMPARE(event2->addedNodeId(), newParent->id());
+        QCOMPARE(event2->metaObject(), newParent->metaObject());
+        QCOMPARE(event2->subjectId(), root->id());
+
+        QCOMPARE(aspect->events.count(), 3);
+
+        // child backend is destroyed because it was reparented to node without backend (newParent)
+        QCOMPARE(aspect->events[0].type, TestAspect::Destruction);
+        QCOMPARE(aspect->events[0].nodeId, child->id());
+
+        // newParent and child both get backends created
+        QCOMPARE(aspect->events[1].type, TestAspect::Creation);
+        QCOMPARE(aspect->events[1].nodeId, newParent->id());
+        QCOMPARE(aspect->events[2].type, TestAspect::Creation);
+        QCOMPARE(aspect->events[2].nodeId, child->id());
     }
 
     // WHEN -> Changing parent to node with existing backend
+    aspect->clearNodes();
     child->setParent(child2);
 
     // THEN
@@ -913,8 +1039,8 @@ void tst_Nodes::checkParentChangeFromExistingBackendParentToNewlyCreatedParent()
     QCoreApplication::processEvents();
 
     // THEN
-    QCOMPARE(spy.events.size(), 3);
-    // 1 node removed change, 1 node destroyed change,
+    QCOMPARE(spy.events.size(), 2);
+    // 1 node removed change
     // 1 node added to children change
     {
         // CHECK event 1 is a Node Removed event
@@ -925,30 +1051,15 @@ void tst_Nodes::checkParentChangeFromExistingBackendParentToNewlyCreatedParent()
         QCOMPARE(event->removedNodeId(), child->id());
         QCOMPARE(event->metaObject(), child->metaObject());
 
-        // CHECK event 2 is a Node Destroyed
-        QVERIFY(spy.events.first().wasLocked());
-        const Qt3DCore::QNodeDestroyedChangePtr event2 = spy.events.takeFirst().change().staticCast<Qt3DCore::QNodeDestroyedChange>();
-        QCOMPARE(event2->type(), Qt3DCore::NodeDeleted);
-        QCOMPARE(event2->subtreeIdsAndTypes().size(), 1);
-        QCOMPARE(event2->subtreeIdsAndTypes().first().id, child->id());
-
-//        // CHECK event 3 and 4 are Node Created events
-//        const Qt3DCore::QNodeCreatedChangeBasePtr event3 = spy.events.takeFirst().change().staticCast<Qt3DCore::QNodeCreatedChangeBase>();
-//        const Qt3DCore::QNodeCreatedChangeBasePtr event4 = spy.events.takeFirst().change().staticCast<Qt3DCore::QNodeCreatedChangeBase>();
-
-//        QCOMPARE(event3->type(), Qt3DCore::NodeCreated);
-//        QCOMPARE(event3->parentId(), root->id());
-//        QCOMPARE(event3->subjectId(), newParent2->id());
-
-//        QCOMPARE(event4->type(), Qt3DCore::NodeCreated);
-//        QCOMPARE(event4->parentId(), newParent2->id());
-//        QCOMPARE(event4->subjectId(), child->id());
-
-        const Qt3DCore::QPropertyNodeAddedChangePtr event5 = spy.events.takeFirst().change().staticCast<Qt3DCore::QPropertyNodeAddedChange>();
-        QCOMPARE(event5->type(), Qt3DCore::PropertyValueAdded);
-        QCOMPARE(event5->addedNodeId(), newParent2->id());
-        QCOMPARE(event5->metaObject(), newParent2->metaObject());
-        QCOMPARE(event5->subjectId(), root->id());
+        const Qt3DCore::QPropertyNodeAddedChangePtr event2 = spy.events.takeFirst().change().staticCast<Qt3DCore::QPropertyNodeAddedChange>();
+        QCOMPARE(event2->type(), Qt3DCore::PropertyValueAdded);
+        QCOMPARE(event2->addedNodeId(), newParent2->id());
+        QCOMPARE(event2->metaObject(), newParent2->metaObject());
+        QCOMPARE(event2->subjectId(), root->id());
+
+        // child backend is destroyed because it was reparented to node without backend (newParent)
+        QCOMPARE(aspect->events[0].type, TestAspect::Destruction);
+        QCOMPARE(aspect->events[0].nodeId, child->id());
     }
 }
 
@@ -960,7 +1071,10 @@ void tst_Nodes::checkBackendNodesCreatedFromTopDown()
     // GIVEN
     ObserverSpy spy;
     Qt3DCore::QAspectEngine engine;
+    auto aspect = new TestAspect;
+    engine.registerAspect(aspect);
     QScopedPointer<MyQEntity> root(new MyQEntity());
+
     root->setArbiterAndEngine(&spy, &engine);
     QScopedPointer<Qt3DCore::QNode> parentWithBackend(new MyQNode(root.data()));
 
@@ -974,7 +1088,7 @@ void tst_Nodes::checkBackendNodesCreatedFromTopDown()
     MyQNode *dummyParent(new MyQNode(parentWithBackend.data()));
     MyQNode *child1(new MyQNode(parentWithBackend.data()));
     MyQNode *child2(new MyQNode(dummyParent));
-    child2->setNodeProperty(child1);
+    child1->setNodeProperty(child2);
 
     // THEN - we should have no events because the new nodes have no backend yet
     QCOMPARE(spy.events.count(), 0);
@@ -997,41 +1111,68 @@ void tst_Nodes::checkBackendNodesCreatedFromTopDown()
         QVERIFY(Qt3DCore::QNodePrivate::get(child1)->m_hasBackendNode);
         QVERIFY(Qt3DCore::QNodePrivate::get(child2)->m_hasBackendNode);
 
-        // 1st event: dummyParent creation
-//        const auto event1 = spy.events.takeFirst().change().dynamicCast<Qt3DCore::QNodeCreatedChangeBase>();
-//        QVERIFY(!event1.isNull());
-//        QCOMPARE(event1->type(), Qt3DCore::NodeCreated);
-//        QCOMPARE(event1->parentId(), parentWithBackend->id());
-//        QCOMPARE(event1->subjectId(), dummyParent->id());
-
-//        // 2nd event: child2 creation (even though we constructed child1 first)
-//        const auto event2 = spy.events.takeFirst().change().dynamicCast<Qt3DCore::QNodeCreatedChangeBase>();
-//        QVERIFY(!event2.isNull());
-//        QCOMPARE(event2->type(), Qt3DCore::NodeCreated);
-//        QCOMPARE(event2->parentId(), dummyParent->id());
-//        QCOMPARE(event2->subjectId(), child2->id());
-
-        // 3rd event: dummyParent added to parent
-        const auto event3 = spy.events.takeFirst().change().dynamicCast<Qt3DCore::QPropertyNodeAddedChange>();
-        QCOMPARE(event3->type(), Qt3DCore::PropertyValueAdded);
-        QCOMPARE(event3->addedNodeId(), dummyParent->id());
-        QCOMPARE(event3->subjectId(), parentWithBackend->id());
-
-        // 4th event: child1 creation
-//        const auto event4 = spy.events.takeFirst().change().dynamicCast<Qt3DCore::QNodeCreatedChangeBase>();
-//        QVERIFY(!event4.isNull());
-//        QCOMPARE(event4->type(), Qt3DCore::NodeCreated);
-//        QCOMPARE(event4->parentId(), parentWithBackend->id());
-//        QCOMPARE(event4->subjectId(), child1->id());
-
-        // 5th event: child 1 added to parent
-        const auto event5 = spy.events.takeFirst().change().dynamicCast<Qt3DCore::QPropertyNodeAddedChange>();
-        QCOMPARE(event5->type(), Qt3DCore::PropertyValueAdded);
-        QCOMPARE(event5->addedNodeId(), child1->id());
-        QCOMPARE(event5->subjectId(), parentWithBackend->id());
+        // 1st event: dummyParent added to parent
+        const auto event = spy.events.takeFirst().change().dynamicCast<Qt3DCore::QPropertyNodeAddedChange>();
+        QCOMPARE(event->type(), Qt3DCore::PropertyValueAdded);
+        QCOMPARE(event->addedNodeId(), dummyParent->id());
+        QCOMPARE(event->subjectId(), parentWithBackend->id());
+
+        // 2nd event: child 1 added to parent
+        const auto event2 = spy.events.takeFirst().change().dynamicCast<Qt3DCore::QPropertyNodeAddedChange>();
+        QCOMPARE(event2->type(), Qt3DCore::PropertyValueAdded);
+        QCOMPARE(event2->addedNodeId(), child1->id());
+        QCOMPARE(event2->subjectId(), parentWithBackend->id());
+
+        verifyChildrenCreatedBeforeParents(root.get(), aspect);
     }
+
 }
 
+void tst_Nodes::checkBackendNodesCreatedFromTopDownWithReparenting()
+{
+    // GIVEN
+    ObserverSpy spy;
+    Qt3DCore::QAspectEngine engine;
+    auto aspect = new TestAspect;
+    engine.registerAspect(aspect);
+    QScopedPointer<MyQEntity> root(new MyQEntity());
+
+    root->setArbiterAndEngine(&spy, &engine);
+    QScopedPointer<Qt3DCore::QNode> parentWithBackend(new MyQNode(root.data()));
+
+    // create parent backend node
+    QCoreApplication::processEvents();
+    QCoreApplication::processEvents();
+    QVERIFY(Qt3DCore::QNodePrivate::get(parentWithBackend.get())->m_hasBackendNode);
+
+    // WHEN -> creating a node with a parent with backend, then reparenting it to another
+    // parent with backend created after it.
+    spy.events.clear();
+    auto node1 = new MyQNode(parentWithBackend.data());
+    auto parent1 = new MyQNode(parentWithBackend.data());
+    node1->setParent(parent1);
+
+    QCoreApplication::processEvents();
+
+    // THEN
+    QVERIFY(node1->parent() == parent1);
+    QVERIFY(parent1->parent() == parentWithBackend.data());
+    verifyChildrenCreatedBeforeParents(root.get(), aspect);
+
+
+    // WHEN -> creating 2 nodes with no parent and reparenting the first to the second
+    auto node2 = new MyQNode(nullptr);
+    auto parent2 = new MyQNode(nullptr);
+    node2->setParent(parent2);
+    parent2->setParent(parentWithBackend.get());
+
+    QCoreApplication::processEvents();
+
+    // THEN
+    QVERIFY(node2->parent() == parent2);
+    QVERIFY(parent2->parent() == parentWithBackend.data());
+    verifyChildrenCreatedBeforeParents(root.get(), aspect);
+}
 
 void tst_Nodes::removingSingleChildNodeFromNode()
 {
@@ -1060,21 +1201,59 @@ void tst_Nodes::removingSingleChildNodeFromNode()
     QVERIFY(child->parent() == nullptr);
     QVERIFY(root->children().count() == 0);
 
-    QCOMPARE(spy.events.size(), 2);
+    QCOMPARE(spy.events.size(), 1);
 
     QVERIFY(spy.events.first().wasLocked());
     const Qt3DCore::QPropertyNodeRemovedChangePtr removalEvent = spy.events.takeFirst().change().dynamicCast<Qt3DCore::QPropertyNodeRemovedChange>();
     QCOMPARE(removalEvent->subjectId(), root->id());
     QCOMPARE(removalEvent->removedNodeId(), child->id());
     QCOMPARE(removalEvent->metaObject(), child->metaObject());
+}
 
-    QVERIFY(spy.events.first().wasLocked());
-    const Qt3DCore::QNodeDestroyedChangePtr destructionEvent = spy.events.takeFirst().change().dynamicCast<Qt3DCore::QNodeDestroyedChange>();
-    QCOMPARE(destructionEvent->type(), Qt3DCore::NodeDeleted);
-    QCOMPARE(destructionEvent->subjectId(), child->id());
-    QCOMPARE(destructionEvent->subtreeIdsAndTypes().size(), 1);
-    QCOMPARE(destructionEvent->subtreeIdsAndTypes().first().id, child->id());
-    QCOMPARE(destructionEvent->subtreeIdsAndTypes().first().type, child->metaObject());
+void tst_Nodes::checkAllBackendCreationDoneInSingleFrame()
+{
+    // GIVEN
+    ObserverSpy spy;
+    Qt3DCore::QAspectEngine engine;
+    auto aspect = new TestAspect;
+    engine.registerAspect(aspect);
+
+    QScopedPointer<MyQEntity> root(new MyQEntity());
+    root->setArbiterAndEngine(&spy, &engine);
+
+    QCoreApplication::processEvents();
+
+    // THEN
+    // Due to the way we create root, it has a backend
+    QVERIFY(Qt3DCore::QNodePrivate::get(root.data())->m_hasBackendNode == true);
+    QCOMPARE(aspect->events.count(), 1);
+    QCOMPARE(aspect->events[0].type, TestAspect::Creation);
+    QCOMPARE(aspect->events[0].nodeId, root->id());
+
+    // WHEN -> create 2 children:
+    //  1. a child with parent with backend node
+    //  2. a child with no parent that is then reparented to a parent with backend node
+    aspect->clearNodes();
+    auto child1 = new MyQNode(root.data());
+    auto child2 = new MyQNode;
+    child2->setParent(root.data());
+
+    // THEN - reparented child should have a backend node, but other child should
+    //        still be waiting
+    QCOMPARE(child1->parent(), root.data());
+    QCOMPARE(child2->parent(), root.data());
+    QVERIFY(Qt3DCore::QNodePrivate::get(child1)->m_hasBackendNode == false);
+    QVERIFY(Qt3DCore::QNodePrivate::get(child2)->m_hasBackendNode == true);
+
+    // WHEN
+    QCoreApplication::processEvents();
+
+    // THEN - both children have their backend nodes actually created.
+    QCOMPARE(aspect->events.count(), 2);
+    QCOMPARE(aspect->events[0].type, TestAspect::Creation);
+    QCOMPARE(aspect->events[0].nodeId, child2->id());
+    QCOMPARE(aspect->events[1].type, TestAspect::Creation);
+    QCOMPARE(aspect->events[1].nodeId, child1->id());
 }
 
 void tst_Nodes::removingMultipleChildNodesFromNode()
@@ -1109,24 +1288,15 @@ void tst_Nodes::removingMultipleChildNodesFromNode()
 
     // THEN
     QVERIFY(root->children().count() == 0);
-    QCOMPARE(spy.events.size(), 20);
+    QCOMPARE(spy.events.size(), 10);
     int i = 0;
     for (const ObserverSpy::ChangeRecord &r : qAsConst(spy.events)) {
         QVERIFY(r.wasLocked());
-        const Qt3DCore::QNodeId childId = childIds.at(i / 2);
-        if (i % 2 == 0) {
-            Qt3DCore::QPropertyNodeRemovedChangePtr additionEvent = r.change().dynamicCast<Qt3DCore::QPropertyNodeRemovedChange>();
-            QCOMPARE(additionEvent->subjectId(), root->id());
-            QCOMPARE(additionEvent->removedNodeId(), childId);
-            QCOMPARE(additionEvent->metaObject(), &MyQNode::staticMetaObject);
-        } else {
-            const Qt3DCore::QNodeDestroyedChangePtr event = r.change().dynamicCast<Qt3DCore::QNodeDestroyedChange>();
-            QCOMPARE(event->subjectId(), childId);
-            QCOMPARE(event->subtreeIdsAndTypes().count(), 1);
-            QCOMPARE(event->subtreeIdsAndTypes().first().id, childId);
-            QCOMPARE(event->subtreeIdsAndTypes().first().type, &MyQNode::staticMetaObject);
-            QCOMPARE(event->type(), Qt3DCore::NodeDeleted);
-        }
+        const Qt3DCore::QNodeId childId = childIds.at(i);
+        Qt3DCore::QPropertyNodeRemovedChangePtr additionEvent = r.change().dynamicCast<Qt3DCore::QPropertyNodeRemovedChange>();
+        QCOMPARE(additionEvent->subjectId(), root->id());
+        QCOMPARE(additionEvent->removedNodeId(), childId);
+        QCOMPARE(additionEvent->metaObject(), &MyQNode::staticMetaObject);
         ++i;
     }
 }
@@ -1174,6 +1344,8 @@ void tst_Nodes::checkConstructionSetParentMix()
     // GIVEN
     ObserverSpy spy;
     Qt3DCore::QAspectEngine engine;
+    auto aspect = new TestAspect;
+    engine.registerAspect(aspect);
     QScopedPointer<MyQEntity> root(new MyQEntity());
 
     // WHEN
@@ -1198,10 +1370,7 @@ void tst_Nodes::checkConstructionSetParentMix()
     QCOMPARE(spy.events.size(), 1); // 1 child added (subTree to root)
 
     // Ensure first event is subTreeRoot
-//    const Qt3DCore::QNodeCreatedChangeBasePtr firstEvent = spy.events.takeFirst().change().dynamicCast<Qt3DCore::QNodeCreatedChangeBase>();
-//    QVERIFY(!firstEvent.isNull());
-//    QCOMPARE(firstEvent->subjectId(), subTreeRoot->id());
-//    QCOMPARE(firstEvent->parentId(), root->id());
+    verifyChildrenCreatedBeforeParents(root.data(), aspect);
 
     const Qt3DCore::QPropertyNodeAddedChangePtr lastEvent = spy.events.takeLast().change().dynamicCast<Qt3DCore::QPropertyNodeAddedChange>();
     QVERIFY(!lastEvent.isNull());
@@ -1238,28 +1407,7 @@ void tst_Nodes::checkParentingQEntityToQNode()
     QVERIFY(Qt3DCore::QNodePrivate::get(childEntity)->m_hasBackendNode);
     QVERIFY(Qt3DCore::QNodePrivate::get(childNode)->m_hasBackendNode);
 
-
-    // Ensure first event is subTreeRoot creation
-//    const Qt3DCore::QNodeCreatedChangeBasePtr firstEvent = spy.events.takeFirst().change().dynamicCast<Qt3DCore::QNodeCreatedChangeBase>();
-//    QVERIFY(!firstEvent.isNull());
-//    QCOMPARE(firstEvent->subjectId(), subTreeRoot->id());
-//    QCOMPARE(firstEvent->parentId(), root->id());
-
-//    // Ensure 2nd event is childEntity creation
-//    const Qt3DCore::QNodeCreatedChangeBasePtr secondEvent = spy.events.takeFirst().change().dynamicCast<Qt3DCore::QNodeCreatedChangeBase>();
-//    QVERIFY(!secondEvent.isNull());
-//    QCOMPARE(secondEvent->subjectId(), childEntity->id());
-//    QCOMPARE(secondEvent->parentId(), subTreeRoot->id());
-
-//    // Ensure 3rd event is childNode creation
-//    const Qt3DCore::QNodeCreatedChangeBasePtr thirdEvent = spy.events.takeFirst().change().dynamicCast<Qt3DCore::QNodeCreatedChangeBase>();
-//    QVERIFY(!thirdEvent.isNull());
-//    QCOMPARE(thirdEvent->subjectId(), childNode->id());
-//    QCOMPARE(thirdEvent->parentId(), subTreeRoot->id());
-
-
     // WHEN we reparent the childEntity to the childNode (QNode)
-
     spy.events.clear();
     childEntity->setParent(childNode);
     QCoreApplication::processEvents();
@@ -1267,8 +1415,7 @@ void tst_Nodes::checkParentingQEntityToQNode()
     // THEN we should get
     // - one child removed change for childEntity->subTreeRoot,
     // - one child added change for childEntity->childNode,
-    // - and one property updated event specifying the correct QEntity parent (subTreeRoot)
-    QCOMPARE(spy.events.size(), 3);
+    QCOMPARE(spy.events.size(), 2);
 
     const auto removedEvent = spy.events.takeFirst().change().dynamicCast<Qt3DCore::QPropertyNodeRemovedChange>();
     QVERIFY(!removedEvent.isNull());
@@ -1278,11 +1425,15 @@ void tst_Nodes::checkParentingQEntityToQNode()
     QVERIFY(!addedEvent.isNull());
     QCOMPARE(addedEvent->subjectId(), childNode->id());
 
-    const auto parentChangeEvent = spy.events.takeFirst().change().dynamicCast<Qt3DCore::QPropertyUpdatedChange>();
-    QVERIFY(!parentChangeEvent.isNull());
-    QCOMPARE(parentChangeEvent->subjectId(), childEntity->id());
-    QCOMPARE(parentChangeEvent->propertyName(), "parentEntityUpdated");
-    QCOMPARE(parentChangeEvent->value().value<Qt3DCore::QNodeId>(), subTreeRoot->id());
+    // The arbiter's dirtyNodes should contain the childEntity and
+    //  - the dirty node's parent should be childNode
+    //  - the dirty node's parent entity should be the subTreeRoot
+    QCOMPARE(spy.dirtyNodes.size(), 1);
+    const auto dirtyEntity = qobject_cast<Qt3DCore::QEntity*>(spy.dirtyNodes.takeFirst());
+    QVERIFY(dirtyEntity);
+    QCOMPARE(dirtyEntity, childEntity);
+    QCOMPARE(dirtyEntity->parent(), childNode);
+    QCOMPARE(dirtyEntity->parentEntity(), subTreeRoot);
 }
 
 void tst_Nodes::checkConstructionWithParent()
@@ -1303,8 +1454,7 @@ void tst_Nodes::checkConstructionWithParent()
     auto *node = new MyQNode(root.data());
     root->setNodeProperty(node);
 
-    // THEN we should get one creation change, one child added change
-    // in that order.
+    // THEN we should get one child added change
     QCoreApplication::processEvents();
     QCOMPARE(root->children().count(), 1);
     QCOMPARE(spy.events.size(), 1); // 1 child added change
diff --git a/tests/auto/core/qchangearbiter/tst_qchangearbiter.cpp b/tests/auto/core/qchangearbiter/tst_qchangearbiter.cpp
index 79790d467..e54193398 100644
--- a/tests/auto/core/qchangearbiter/tst_qchangearbiter.cpp
+++ b/tests/auto/core/qchangearbiter/tst_qchangearbiter.cpp
@@ -43,7 +43,6 @@
 #include <Qt3DCore/qentity.h>
 #include <Qt3DCore/qcomponent.h>
 #include <Qt3DCore/qbackendnode.h>
-#include <Qt3DCore/private/qsceneobserverinterface_p.h>
 #include <Qt3DCore/private/qnode_p.h>
 #include <Qt3DCore/private/qbackendnode_p.h>
 #include <QThread>
@@ -350,38 +349,6 @@ private:
     bool m_allowFrontendNotifications;
 };
 
-class tst_SceneObserver : public Qt3DCore::QSceneObserverInterface
-{
-    // QSceneObserverInterface interface
-public:
-//    void sceneNodeAdded(Qt3DCore::QSceneChangePtr &e)
-//    {
-//        QVERIFY(!e.isNull());
-//        QVERIFY(e->type() == Qt3DCore::NodeCreated);
-//        m_lastChange = e;
-//    }
-
-    void sceneNodeRemoved(Qt3DCore::QSceneChangePtr &e)
-    {
-        QVERIFY(!e.isNull());
-        QVERIFY((e->type() == Qt3DCore::NodeDeleted));
-        m_lastChange = e;
-    }
-
-    void sceneNodeUpdated(Qt3DCore::QSceneChangePtr &e)
-    {
-        m_lastChange = e;
-    }
-
-    Qt3DCore::QSceneChangePtr lastChange() const
-    {
-        return m_lastChange;
-    }
-
-private:
-    Qt3DCore::QSceneChangePtr m_lastChange;
-};
-
 void tst_QChangeArbiter::registerObservers()
 {
     // GIVEN
@@ -452,20 +419,11 @@ void tst_QChangeArbiter::registerSceneObserver()
         observers << s;
     }
 
-    QList<tst_SceneObserver *> sceneObservers;
-    for (int i = 0; i < 5; i++) {
-        tst_SceneObserver *s = new tst_SceneObserver();
-        arbiter->registerSceneObserver(s);
-        sceneObservers << s;
-    }
-
     arbiter->syncChanges();
 
     // THEN
     for (tst_SimpleObserver *o : qAsConst(observers))
         QVERIFY(o->lastChange().isNull());
-    for (tst_SceneObserver *s : qAsConst(sceneObservers))
-        QVERIFY(s->lastChange().isNull());
 
     // WHEN
     child->setParent(root);
@@ -476,10 +434,6 @@ void tst_QChangeArbiter::registerSceneObserver()
         QVERIFY(!o->lastChange().isNull());
         QVERIFY(o->lastChange()->type() == Qt3DCore::PropertyValueAdded);
     }
-//    for (tst_SceneObserver *s : qAsConst(sceneObservers)) {
-//        QVERIFY(!s->lastChange().isNull());
-//        QVERIFY(s->lastChange()->type() == Qt3DCore::NodeCreated);
-//    }
 
     // WHEN
     root->sendComponentAddedNotification(&dummyComponent);
@@ -490,10 +444,6 @@ void tst_QChangeArbiter::registerSceneObserver()
         QVERIFY(!o->lastChange().isNull());
         QVERIFY(o->lastChange()->type() == Qt3DCore::ComponentAdded);
     }
-//    for (tst_SceneObserver *s : qAsConst(sceneObservers)) {
-//        QVERIFY(!s->lastChange().isNull());
-//        QVERIFY(s->lastChange()->type() == Qt3DCore::NodeCreated);
-//    }
 
     Qt3DCore::QChangeArbiter::destroyThreadLocalChangeQueue(arbiter.data());
 }
@@ -585,20 +535,11 @@ void tst_QChangeArbiter::unregisterSceneObservers()
         observers << s;
     }
 
-    QList<tst_SceneObserver *> sceneObservers;
-    for (int i = 0; i < 5; i++) {
-        tst_SceneObserver *s = new tst_SceneObserver();
-        arbiter->registerSceneObserver(s);
-        sceneObservers << s;
-    }
-
     arbiter->syncChanges();
 
     // THEN
     for (tst_SimpleObserver *o : qAsConst(observers))
         QVERIFY(o->lastChange().isNull());
-    for (tst_SceneObserver *s : qAsConst(sceneObservers))
-        QVERIFY(s->lastChange().isNull());
 
     // WHEN
     child->setParent(root);
@@ -609,10 +550,6 @@ void tst_QChangeArbiter::unregisterSceneObservers()
         QVERIFY(!o->lastChange().isNull());
         QVERIFY(o->lastChange()->type() == Qt3DCore::PropertyValueAdded);
     }
-//    for (tst_SceneObserver *s : qAsConst(sceneObservers)) {
-//        QVERIFY(!s->lastChange().isNull());
-//        QVERIFY(s->lastChange()->type() == Qt3DCore::NodeCreated);
-//    }
 
     // WHEN
     root->sendComponentAddedNotification(&dummyComponent);
@@ -623,10 +560,6 @@ void tst_QChangeArbiter::unregisterSceneObservers()
         QVERIFY(!o->lastChange().isNull());
         QVERIFY(o->lastChange()->type() == Qt3DCore::ComponentAdded);
     }
-//    for (tst_SceneObserver *s : qAsConst(sceneObservers)) {
-//        QVERIFY(!s->lastChange().isNull());
-//        QVERIFY(s->lastChange()->type() == Qt3DCore::NodeCreated);
-//    }
 
     // WHEN
     child->setParent(Q_NODE_NULLPTR);
@@ -637,13 +570,6 @@ void tst_QChangeArbiter::unregisterSceneObservers()
         QVERIFY(!o->lastChange().isNull());
         QVERIFY(o->lastChange()->type() == Qt3DCore::PropertyValueRemoved);
     }
-    for (tst_SceneObserver *s : qAsConst(sceneObservers)) {
-        QVERIFY(!s->lastChange().isNull());
-        QVERIFY(s->lastChange()->type() == Qt3DCore::NodeDeleted);
-    }
-
-    for (tst_SceneObserver *s : qAsConst(sceneObservers))
-        arbiter->unregisterSceneObserver(s);
 
     // WHEN
     child->setParent(root);
@@ -654,10 +580,6 @@ void tst_QChangeArbiter::unregisterSceneObservers()
         QVERIFY(!o->lastChange().isNull());
         QVERIFY(o->lastChange()->type() == Qt3DCore::PropertyValueAdded);
     }
-    for (tst_SceneObserver *s : qAsConst(sceneObservers)) {
-        QVERIFY(!s->lastChange().isNull());
-        QVERIFY(s->lastChange()->type() == Qt3DCore::NodeDeleted);
-    }
 
     Qt3DCore::QChangeArbiter::destroyThreadLocalChangeQueue(arbiter.data());
 }
diff --git a/tests/auto/core/qskeleton/tst_qskeleton.cpp b/tests/auto/core/qskeleton/tst_qskeleton.cpp
index 6ad6e538c..04c9bf7a1 100644
--- a/tests/auto/core/qskeleton/tst_qskeleton.cpp
+++ b/tests/auto/core/qskeleton/tst_qskeleton.cpp
@@ -193,6 +193,9 @@ private Q_SLOTS:
         QCOMPARE(spy.count(), 0);
         QCOMPARE(arbiter.events.size(), 0);
         QCOMPARE(jointCount(), newJointCount);
+
+        // Cleanup
+        QNodePrivate::get(this)->setArbiter(nullptr);
     }
 };
 
diff --git a/tests/auto/quick3d/3dcore/3dcore.qml b/tests/auto/quick3d/3dcore/3dcore.qml
index 72514591c..d0a5c6f09 100644
--- a/tests/auto/quick3d/3dcore/3dcore.qml
+++ b/tests/auto/quick3d/3dcore/3dcore.qml
@@ -30,6 +30,7 @@
 import Qt3D.Core 2.0 as QQ3Core20
 import Qt3D.Core 2.9 as QQ3Core29
 import Qt3D.Core 2.10 as QQ3Core210
+import Qt3D.Core 2.14 as QQ3Core214
 import QtQuick 2.0
 
 Item {
@@ -47,4 +48,6 @@ Item {
     QQ3Core210.Armature {}
     QQ3Core210.SkeletonLoader {}
     QQ3Core210.Joint {}
+
+    QQ3Core214.Transform {}
 }
diff --git a/tests/auto/quick3d/3drender/3drender.qml b/tests/auto/quick3d/3drender/3drender.qml
index 150b7c1fe..8c200f3c0 100644
--- a/tests/auto/quick3d/3drender/3drender.qml
+++ b/tests/auto/quick3d/3drender/3drender.qml
@@ -163,4 +163,7 @@ Item {
     QQ3Render20.StencilOperation {}            //Qt3DRender::QStencilOperation
     QQ3Render20.StencilMask {}                 //Qt3DRender::QStencilMask
 
+    QQ3Render214.DepthRange {}
+    QQ3Render214.RasterMode {}
+
 }
diff --git a/tests/auto/render/armature/tst_armature.cpp b/tests/auto/render/armature/tst_armature.cpp
index 2c481db7a..4f9380a3b 100644
--- a/tests/auto/render/armature/tst_armature.cpp
+++ b/tests/auto/render/armature/tst_armature.cpp
@@ -56,7 +56,7 @@ private Q_SLOTS:
         armature.setSkeleton(skeleton);
 
         // WHEN
-        simulateInitialization(&armature, &backendArmature);
+        simulateInitializationSync(&armature, &backendArmature);
 
         // THEN
         QCOMPARE(backendArmature.peerId(), armature.id());
@@ -80,7 +80,7 @@ private Q_SLOTS:
         armature.setSkeleton(skeleton);
 
         // WHEN
-        simulateInitialization(&armature, &backendArmature);
+        simulateInitializationSync(&armature, &backendArmature);
         backendArmature.cleanup();
 
         // THEN
@@ -91,24 +91,21 @@ private Q_SLOTS:
     void checkPropertyChanges()
     {
         // GIVEN
+        QArmature armature;
         Armature backendArmature;
-        Qt3DCore::QPropertyUpdatedChangePtr updateChange;
+        simulateInitializationSync(&armature, &backendArmature);
 
         // WHEN
-        updateChange.reset(new Qt3DCore::QPropertyUpdatedChange(Qt3DCore::QNodeId()));
-        updateChange->setPropertyName("enabled");
-        updateChange->setValue(true);
-        backendArmature.sceneChangeEvent(updateChange);
+        armature.setEnabled(false);
+        backendArmature.syncFromFrontEnd(&armature, false);
 
         // THEN
-        QCOMPARE(backendArmature.isEnabled(), true);
+        QCOMPARE(backendArmature.isEnabled(), false);
 
         // WHEN
         auto newSkeleton = new QSkeleton();
-        updateChange.reset(new Qt3DCore::QPropertyUpdatedChange(Qt3DCore::QNodeId()));
-        updateChange->setPropertyName("skeleton");
-        updateChange->setValue(QVariant::fromValue(newSkeleton->id()));
-        backendArmature.sceneChangeEvent(updateChange);
+        armature.setSkeleton(newSkeleton);
+        backendArmature.syncFromFrontEnd(&armature, false);
 
         // THEN
         QCOMPARE(backendArmature.skeletonId(), newSkeleton->id());
diff --git a/tests/auto/render/attribute/tst_attribute.cpp b/tests/auto/render/attribute/tst_attribute.cpp
index e0f6f6b5c..12b99b37d 100644
--- a/tests/auto/render/attribute/tst_attribute.cpp
+++ b/tests/auto/render/attribute/tst_attribute.cpp
@@ -36,12 +36,15 @@
 class tst_Attribute : public Qt3DCore::QBackendNodeTester
 {
     Q_OBJECT
+
 private Q_SLOTS:
 
     void checkPeerPropertyMirroring()
     {
         // GIVEN
+        TestRenderer renderer;
         Qt3DRender::Render::Attribute renderAttribute;
+        renderAttribute.setRenderer(&renderer);
 
         Qt3DRender::QAttribute attribute;
         attribute.setAttributeType(Qt3DRender::QAttribute::IndexAttribute);
@@ -59,7 +62,7 @@ private Q_SLOTS:
         attribute.setBuffer(&buffer);
 
         // WHEN
-        simulateInitialization(&attribute, &renderAttribute);
+        simulateInitializationSync(&attribute, &renderAttribute);
 
         // THEN
         QCOMPARE(renderAttribute.peerId(), attribute.id());
@@ -111,7 +114,7 @@ private Q_SLOTS:
         attribute.setBuffer(&buffer);
 
         // WHEN
-        simulateInitialization(&attribute, &renderAttribute);
+        simulateInitializationSync(&attribute, &renderAttribute);
         renderAttribute.cleanup();
 
         // THEN
@@ -130,17 +133,20 @@ private Q_SLOTS:
     void checkPropertyChanges()
     {
         // GIVEN
+        Qt3DRender::QAttribute attribute;
         TestRenderer renderer;
         Qt3DRender::Render::Attribute renderAttribute;
         renderAttribute.setRenderer(&renderer);
+        simulateInitializationSync(&attribute, &renderAttribute);
+        renderAttribute.cleanup();
+        renderer.resetDirty();
 
         QVERIFY(!renderAttribute.isDirty());
+        QVERIFY(!renderer.dirtyBits());
 
         // WHEN
-        Qt3DCore::QPropertyUpdatedChangePtr updateChange(new Qt3DCore::QPropertyUpdatedChange(Qt3DCore::QNodeId()));
-        updateChange->setValue(static_cast<int>(Qt3DRender::QAttribute::Int));
-        updateChange->setPropertyName("vertexBaseType");
-        renderAttribute.sceneChangeEvent(updateChange);
+        attribute.setVertexBaseType(Qt3DRender::QAttribute::Int);
+        renderAttribute.syncFromFrontEnd(&attribute, false);
 
         // THEN
         QCOMPARE(renderAttribute.vertexBaseType(), Qt3DRender::QAttribute::Int);
@@ -153,10 +159,8 @@ private Q_SLOTS:
         QVERIFY(!renderer.dirtyBits());
 
         // WHEN
-        updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId());
-        updateChange->setValue(3);
-        updateChange->setPropertyName("vertexSize");
-        renderAttribute.sceneChangeEvent(updateChange);
+        attribute.setVertexSize(3);
+        renderAttribute.syncFromFrontEnd(&attribute, false);
 
         // THEN
         QCOMPARE(renderAttribute.vertexSize(), 3U);
@@ -168,10 +172,8 @@ private Q_SLOTS:
         QVERIFY(!renderAttribute.isDirty());
 
         // WHEN
-        updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId());
-        updateChange->setValue(static_cast<int>(Qt3DRender::QAttribute::IndexAttribute));
-        updateChange->setPropertyName("attributeType");
-        renderAttribute.sceneChangeEvent(updateChange);
+        attribute.setAttributeType(Qt3DRender::QAttribute::IndexAttribute);
+        renderAttribute.syncFromFrontEnd(&attribute, false);
 
         // THEN
         QCOMPARE(renderAttribute.attributeType(), Qt3DRender::QAttribute::IndexAttribute);
@@ -183,10 +185,8 @@ private Q_SLOTS:
         QVERIFY(!renderAttribute.isDirty());
 
         // WHEN
-        updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId());
-        updateChange->setValue(static_cast<int>(Qt3DRender::QAttribute::DrawIndirectAttribute));
-        updateChange->setPropertyName("attributeType");
-        renderAttribute.sceneChangeEvent(updateChange);
+        attribute.setAttributeType(Qt3DRender::QAttribute::DrawIndirectAttribute);
+        renderAttribute.syncFromFrontEnd(&attribute, false);
 
         // THEN
         QCOMPARE(renderAttribute.attributeType(), Qt3DRender::QAttribute::DrawIndirectAttribute);
@@ -198,10 +198,8 @@ private Q_SLOTS:
         QVERIFY(!renderAttribute.isDirty());
 
         // WHEN
-        updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId());
-        updateChange->setValue(1340);
-        updateChange->setPropertyName("count");
-        renderAttribute.sceneChangeEvent(updateChange);
+        attribute.setCount(1340);
+        renderAttribute.syncFromFrontEnd(&attribute, false);
 
         // THEN
         QCOMPARE(renderAttribute.count(), 1340U);
@@ -213,10 +211,8 @@ private Q_SLOTS:
         QVERIFY(!renderAttribute.isDirty());
 
         // WHEN
-        updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId());
-        updateChange->setValue(QStringLiteral("L88"));
-        updateChange->setPropertyName("name");
-        renderAttribute.sceneChangeEvent(updateChange);
+        attribute.setName(QStringLiteral("L88"));
+        renderAttribute.syncFromFrontEnd(&attribute, false);
 
         // THEN
         QCOMPARE(renderAttribute.name(), QStringLiteral("L88"));
@@ -228,10 +224,8 @@ private Q_SLOTS:
         QVERIFY(!renderAttribute.isDirty());
 
         // WHEN
-        updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId());
-        updateChange->setValue(555);
-        updateChange->setPropertyName("byteOffset");
-        renderAttribute.sceneChangeEvent(updateChange);
+        attribute.setByteOffset(555U);
+        renderAttribute.syncFromFrontEnd(&attribute, false);
 
         // THEN
         QCOMPARE(renderAttribute.byteOffset(), 555U);
@@ -243,10 +237,8 @@ private Q_SLOTS:
         QVERIFY(!renderAttribute.isDirty());
 
         // WHEN
-        updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId());
-        updateChange->setValue(454);
-        updateChange->setPropertyName("byteStride");
-        renderAttribute.sceneChangeEvent(updateChange);
+        attribute.setByteStride(454);
+        renderAttribute.syncFromFrontEnd(&attribute, false);
 
         // THEN
         QCOMPARE(renderAttribute.byteStride(), 454U);
@@ -258,10 +250,8 @@ private Q_SLOTS:
         QVERIFY(!renderAttribute.isDirty());
 
         // WHEN
-        updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId());
-        updateChange->setValue(1450);
-        updateChange->setPropertyName("divisor");
-        renderAttribute.sceneChangeEvent(updateChange);
+        attribute.setDivisor(1450);
+        renderAttribute.syncFromFrontEnd(&attribute, false);
 
         // THEN
         QCOMPARE(renderAttribute.divisor(), 1450U);
@@ -273,14 +263,12 @@ private Q_SLOTS:
         QVERIFY(!renderAttribute.isDirty());
 
         // WHEN
-        updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId());
-        Qt3DCore::QNodeId bufferId = Qt3DCore::QNodeId::createId();
-        updateChange->setValue(QVariant::fromValue(bufferId));
-        updateChange->setPropertyName("buffer");
-        renderAttribute.sceneChangeEvent(updateChange);
+        auto buffer = new Qt3DRender::QBuffer();
+        attribute.setBuffer(buffer);
+        renderAttribute.syncFromFrontEnd(&attribute, false);
 
         // THEN
-        QCOMPARE(renderAttribute.bufferId(), bufferId);
+        QCOMPARE(renderAttribute.bufferId(), buffer->id());
         QVERIFY(renderAttribute.isDirty());
         QVERIFY(renderer.dirtyBits() != 0);
 
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 5f4f26d50..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>
@@ -96,6 +95,23 @@ QVector<Qt3DCore::QNode *> getNodesForCreation(Qt3DCore::QNode *root)
     return nodes;
 }
 
+QVector<Qt3DCore::NodeTreeChange> nodeTreeChangesForNodes(const QVector<Qt3DCore::QNode *> nodes)
+{
+    QVector<Qt3DCore::NodeTreeChange> nodeTreeChanges;
+    nodeTreeChanges.reserve(nodes.size());
+
+    for (Qt3DCore::QNode *n : nodes) {
+        nodeTreeChanges.push_back({
+                                      n->id(),
+                                      Qt3DCore::QNodePrivate::get(n)->m_typeInfo,
+                                      Qt3DCore::NodeTreeChange::Added,
+                                      n
+                                  });
+    }
+
+    return nodeTreeChanges;
+}
+
 class TestAspect : public Qt3DRender::QRenderAspect
 {
 public:
@@ -106,7 +122,8 @@ public:
         QRenderAspect::onRegistered();
 
         const QVector<Qt3DCore::QNode *> nodes = getNodesForCreation(root);
-        d_func()->setRootAndCreateNodes(qobject_cast<Qt3DCore::QEntity *>(root), nodes);
+        const QVector<Qt3DCore::NodeTreeChange> nodeTreeChanges = nodeTreeChangesForNodes(nodes);
+        d_func()->setRootAndCreateNodes(qobject_cast<Qt3DCore::QEntity *>(root), nodeTreeChanges);
 
         Render::Entity *rootEntity = nodeManagers()->lookupResource<Render::Entity, Render::EntityManager>(rootEntityId());
         Q_ASSERT(rootEntity);
@@ -139,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());
@@ -296,13 +309,13 @@ private Q_SLOTS:
         Qt3DRender::Render::Buffer *vbufferBackend = test->nodeManagers()->bufferManager()->getOrCreateResource(vbuffer->id());
         vbufferBackend->setRenderer(test->renderer());
         vbufferBackend->setManager(test->nodeManagers()->bufferManager());
-        simulateInitialization(vbuffer, vbufferBackend);
+        simulateInitializationSync(vbuffer, vbufferBackend);
 
         ibuffer->setData(idata);
         Qt3DRender::Render::Buffer *ibufferBackend = test->nodeManagers()->bufferManager()->getOrCreateResource(ibuffer->id());
         ibufferBackend->setRenderer(test->renderer());
         ibufferBackend->setManager(test->nodeManagers()->bufferManager());
-        simulateInitialization(ibuffer, ibufferBackend);
+        simulateInitializationSync(ibuffer, ibufferBackend);
 
         Qt3DRender::QGeometry *g = new Qt3DRender::QGeometry;
         for (int i = 0; i < 2; ++i)
@@ -336,23 +349,23 @@ private Q_SLOTS:
 
         Qt3DRender::Render::Attribute *attr0Backend = test->nodeManagers()->attributeManager()->getOrCreateResource(attrs[0]->id());
         attr0Backend->setRenderer(test->renderer());
-        simulateInitialization(attrs[0], attr0Backend);
+        simulateInitializationSync(attrs[0], attr0Backend);
         Qt3DRender::Render::Attribute *attr1Backend = test->nodeManagers()->attributeManager()->getOrCreateResource(attrs[1]->id());
         attr1Backend->setRenderer(test->renderer());
-        simulateInitialization(attrs[1], attr1Backend);
+        simulateInitializationSync(attrs[1], attr1Backend);
 
         Qt3DRender::Render::Geometry *gBackend = test->nodeManagers()->geometryManager()->getOrCreateResource(g->id());
         gBackend->setRenderer(test->renderer());
-        simulateInitialization(g, gBackend);
+        simulateInitializationSync(g, gBackend);
 
         Qt3DRender::Render::GeometryRenderer *grBackend = test->nodeManagers()->geometryRendererManager()->getOrCreateResource(gr->id());
         grBackend->setRenderer(test->renderer());
         grBackend->setManager(test->nodeManagers()->geometryRendererManager());
-        simulateInitialization(gr, grBackend);
+        simulateInitializationSync(gr, grBackend);
 
         Qt3DRender::Render::Entity *entityBackend = test->nodeManagers()->renderNodesManager()->getOrCreateResource(entity->id());
         entityBackend->setRenderer(test->renderer());
-        simulateInitialization(entity.data(), entityBackend);
+        simulateInitializationSync(entity.data(), entityBackend);
 
         Qt3DRender::Render::CalculateBoundingVolumeJob calcBVolume;
         calcBVolume.setManagers(test->nodeManagers());
@@ -364,10 +377,10 @@ private Q_SLOTS:
         qDebug() << radius << center;
 
         // truncate and compare integers only
-        QVERIFY(int(radius) == int(expectedRadius));
-        QVERIFY(int(center.x()) == int(expectedCenter.x()));
-        QVERIFY(int(center.y()) == int(expectedCenter.y()));
-        QVERIFY(int(center.z()) == int(expectedCenter.z()));
+        QCOMPARE(int(radius), int(expectedRadius));
+        QCOMPARE(int(center.x()), int(expectedCenter.x()));
+        QCOMPARE(int(center.y()), int(expectedCenter.y()));
+        QCOMPARE(int(center.z()), int(expectedCenter.z()));
     }
 
     void checkCustomPackedGeometry()
@@ -408,7 +421,7 @@ private Q_SLOTS:
         Qt3DRender::Render::Buffer *vbufferBackend = test->nodeManagers()->bufferManager()->getOrCreateResource(vbuffer->id());
         vbufferBackend->setRenderer(test->renderer());
         vbufferBackend->setManager(test->nodeManagers()->bufferManager());
-        simulateInitialization(vbuffer, vbufferBackend);
+        simulateInitializationSync(vbuffer, vbufferBackend);
 
         Qt3DRender::QGeometry *g = new Qt3DRender::QGeometry;
         g->addAttribute(new Qt3DRender::QAttribute);
@@ -430,20 +443,20 @@ private Q_SLOTS:
 
         Qt3DRender::Render::Attribute *attr0Backend = test->nodeManagers()->attributeManager()->getOrCreateResource(attrs[0]->id());
         attr0Backend->setRenderer(test->renderer());
-        simulateInitialization(attrs[0], attr0Backend);
+        simulateInitializationSync(attrs[0], attr0Backend);
 
         Qt3DRender::Render::Geometry *gBackend = test->nodeManagers()->geometryManager()->getOrCreateResource(g->id());
         gBackend->setRenderer(test->renderer());
-        simulateInitialization(g, gBackend);
+        simulateInitializationSync(g, gBackend);
 
         Qt3DRender::Render::GeometryRenderer *grBackend = test->nodeManagers()->geometryRendererManager()->getOrCreateResource(gr->id());
         grBackend->setRenderer(test->renderer());
         grBackend->setManager(test->nodeManagers()->geometryRendererManager());
-        simulateInitialization(gr, grBackend);
+        simulateInitializationSync(gr, grBackend);
 
         Qt3DRender::Render::Entity *entityBackend = test->nodeManagers()->renderNodesManager()->getOrCreateResource(entity->id());
         entityBackend->setRenderer(test->renderer());
-        simulateInitialization(entity.data(), entityBackend);
+        simulateInitializationSync(entity.data(), entityBackend);
 
         Qt3DRender::Render::CalculateBoundingVolumeJob calcBVolume;
         calcBVolume.setManagers(test->nodeManagers());
diff --git a/tests/auto/render/buffer/tst_buffer.cpp b/tests/auto/render/buffer/tst_buffer.cpp
index da853d4e9..1487d3728 100644
--- a/tests/auto/render/buffer/tst_buffer.cpp
+++ b/tests/auto/render/buffer/tst_buffer.cpp
@@ -65,6 +65,7 @@ private:
 class tst_RenderBuffer : public Qt3DCore::QBackendNodeTester
 {
     Q_OBJECT
+
 private Q_SLOTS:
 
     void checkPeerPropertyMirroring()
@@ -82,7 +83,7 @@ private Q_SLOTS:
         // WHEN
         renderBuffer.setRenderer(&renderer);
         renderBuffer.setManager(&bufferManager);
-        simulateInitialization(&buffer, &renderBuffer);
+        simulateInitializationSync(&buffer, &renderBuffer);
 
         // THEN
         QCOMPARE(renderBuffer.peerId(), buffer.id());
@@ -98,170 +99,154 @@ private Q_SLOTS:
     void checkInitialAndCleanedUpState()
     {
         // GIVEN
-        Qt3DRender::Render::Buffer renderBuffer;
+        Qt3DRender::Render::Buffer backendBuffer;
         Qt3DRender::Render::BufferManager bufferManager;
         TestRenderer renderer;
 
         // THEN
-        QCOMPARE(renderBuffer.isDirty(), false);
-        QCOMPARE(renderBuffer.usage(), Qt3DRender::QBuffer::StaticDraw);
-        QVERIFY(renderBuffer.data().isEmpty());
-        QVERIFY(renderBuffer.peerId().isNull());
-        QVERIFY(renderBuffer.dataGenerator().isNull());
-        QVERIFY(renderBuffer.pendingBufferUpdates().empty());
+        QCOMPARE(backendBuffer.isDirty(), false);
+        QCOMPARE(backendBuffer.usage(), Qt3DRender::QBuffer::StaticDraw);
+        QVERIFY(backendBuffer.data().isEmpty());
+        QVERIFY(backendBuffer.peerId().isNull());
+        QVERIFY(backendBuffer.dataGenerator().isNull());
+        QVERIFY(backendBuffer.pendingBufferUpdates().empty());
 
         // GIVEN
-        Qt3DRender::QBuffer buffer;
-        buffer.setUsage(Qt3DRender::QBuffer::DynamicCopy);
-        buffer.setData(QByteArrayLiteral("C7"));
-        buffer.setDataGenerator(Qt3DRender::QBufferDataGeneratorPtr(new TestFunctor(73)));
+        Qt3DRender::QBuffer frontendBuffer;
+        frontendBuffer.setUsage(Qt3DRender::QBuffer::DynamicCopy);
+        frontendBuffer.setData(QByteArrayLiteral("C7KR4"));
+        frontendBuffer.setDataGenerator(Qt3DRender::QBufferDataGeneratorPtr(new TestFunctor(73)));
 
         // WHEN
-        renderBuffer.setManager(&bufferManager);
-        renderBuffer.setRenderer(&renderer);
-        simulateInitialization(&buffer, &renderBuffer);
+        backendBuffer.setManager(&bufferManager);
+        backendBuffer.setRenderer(&renderer);
+        simulateInitializationSync(&frontendBuffer, &backendBuffer);
 
-        Qt3DCore::QPropertyUpdatedChangePtr updateChange(new Qt3DCore::QPropertyUpdatedChange(Qt3DCore::QNodeId()));
-        Qt3DRender::QBufferUpdate updateData;
-        updateData.offset = 2;
-        updateData.data = QByteArrayLiteral("LS5");
-        updateChange->setValue(QVariant::fromValue(updateData));
-        updateChange->setPropertyName("updateData");
-        renderBuffer.sceneChangeEvent(updateChange);
+        frontendBuffer.updateData(2, QByteArrayLiteral("LS5"));
+        backendBuffer.syncFromFrontEnd(&frontendBuffer, false);
 
         // THEN
-        QCOMPARE(renderBuffer.usage(), Qt3DRender::QBuffer::DynamicCopy);
-        QCOMPARE(renderBuffer.isDirty(), true);
-        QCOMPARE(renderBuffer.data(), QByteArrayLiteral("C7LS5"));
-        QVERIFY(!renderBuffer.dataGenerator().isNull());
-        QVERIFY(!renderBuffer.pendingBufferUpdates().empty());
+        QCOMPARE(backendBuffer.usage(), Qt3DRender::QBuffer::DynamicCopy);
+        QCOMPARE(backendBuffer.isDirty(), true);
+        QCOMPARE(backendBuffer.data(), QByteArrayLiteral("C7LS5"));
+        QVERIFY(!backendBuffer.dataGenerator().isNull());
+        QVERIFY(!backendBuffer.pendingBufferUpdates().empty());
 
         // WHEN
-        renderBuffer.cleanup();
+        backendBuffer.cleanup();
 
         // THEN
-        QCOMPARE(renderBuffer.isDirty(), false);
-        QCOMPARE(renderBuffer.usage(), Qt3DRender::QBuffer::StaticDraw);
-        QVERIFY(renderBuffer.data().isEmpty());
-        QVERIFY(renderBuffer.dataGenerator().isNull());
-        QVERIFY(renderBuffer.pendingBufferUpdates().empty());
+        QCOMPARE(backendBuffer.isDirty(), false);
+        QCOMPARE(backendBuffer.usage(), Qt3DRender::QBuffer::StaticDraw);
+        QVERIFY(backendBuffer.data().isEmpty());
+        QVERIFY(backendBuffer.dataGenerator().isNull());
+        QVERIFY(backendBuffer.pendingBufferUpdates().empty());
     }
 
     void checkPropertyChanges()
     {
         // GIVEN
         TestRenderer renderer;
-        Qt3DRender::Render::Buffer renderBuffer;
-        renderBuffer.setRenderer(&renderer);
+        Qt3DRender::QBuffer frontendBuffer;
+        Qt3DRender::Render::Buffer backendBuffer;
+        backendBuffer.setRenderer(&renderer);
+        simulateInitializationSync(&frontendBuffer, &backendBuffer);
 
         // THEN
-        QVERIFY(renderBuffer.data().isEmpty());
-        QVERIFY(renderBuffer.usage() != Qt3DRender::QBuffer::DynamicRead);
-        QVERIFY(!renderBuffer.isDirty());
-        QVERIFY(!(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::BuffersDirty));
+        QVERIFY(backendBuffer.data().isEmpty());
+        QVERIFY(backendBuffer.usage() != Qt3DRender::QBuffer::DynamicRead);
+        QVERIFY(!backendBuffer.isDirty());
+        QVERIFY(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::BuffersDirty);
         renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty);
 
         // WHEN
-        Qt3DCore::QPropertyUpdatedChangePtr updateChange(new Qt3DCore::QPropertyUpdatedChange(Qt3DCore::QNodeId()));
-        updateChange->setValue(static_cast<int>(Qt3DRender::QBuffer::DynamicRead));
-        updateChange->setPropertyName("usage");
-        renderBuffer.sceneChangeEvent(updateChange);
+        frontendBuffer.setUsage(Qt3DRender::QBuffer::DynamicRead);
+        backendBuffer.syncFromFrontEnd(&frontendBuffer, false);
 
         // THEN
-        QCOMPARE(renderBuffer.usage(), Qt3DRender::QBuffer::DynamicRead);
-        QVERIFY(renderBuffer.isDirty());
+        QCOMPARE(backendBuffer.usage(), Qt3DRender::QBuffer::DynamicRead);
+        QVERIFY(backendBuffer.isDirty());
 
         QVERIFY(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::BuffersDirty);
         renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty);
 
-        renderBuffer.unsetDirty();
-        QVERIFY(!renderBuffer.isDirty());
+        backendBuffer.unsetDirty();
+        QVERIFY(!backendBuffer.isDirty());
 
         // WHEN
-        updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId());
-        updateChange->setValue(QByteArrayLiteral("LS9"));
-        updateChange->setPropertyName("data");
-        renderBuffer.sceneChangeEvent(updateChange);
+        frontendBuffer.setData(QByteArrayLiteral("LS9SL"));
+        backendBuffer.syncFromFrontEnd(&frontendBuffer, false);
 
         // THEN
-        QCOMPARE(renderBuffer.data(), QByteArrayLiteral("LS9"));
-        QVERIFY(renderBuffer.isDirty());
-        QCOMPARE(renderBuffer.pendingBufferUpdates().size(), 1);
-        QCOMPARE(renderBuffer.pendingBufferUpdates().first().offset, -1);
+        QCOMPARE(backendBuffer.data(), QByteArrayLiteral("LS9SL"));
+        QVERIFY(backendBuffer.isDirty());
+        QCOMPARE(backendBuffer.pendingBufferUpdates().size(), 1);
+        QCOMPARE(backendBuffer.pendingBufferUpdates().first().offset, -1);
 
-        renderBuffer.pendingBufferUpdates().clear();
+        backendBuffer.pendingBufferUpdates().clear();
 
         QVERIFY(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::BuffersDirty);
         renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty);
 
-        renderBuffer.unsetDirty();
-        QVERIFY(!renderBuffer.isDirty());
+        backendBuffer.unsetDirty();
+        QVERIFY(!backendBuffer.isDirty());
 
         // WHEN
         Qt3DRender::QBufferDataGeneratorPtr functor(new TestFunctor(355));
-        updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId());
-        updateChange->setValue(QVariant::fromValue(functor));
-        updateChange->setPropertyName("dataGenerator");
-        renderBuffer.sceneChangeEvent(updateChange);
+        frontendBuffer.setDataGenerator(functor);
+        backendBuffer.syncFromFrontEnd(&frontendBuffer, false);
 
         // THEN
-        QCOMPARE(renderBuffer.dataGenerator(), functor);
-        QVERIFY(renderBuffer.isDirty());
+        QCOMPARE(backendBuffer.dataGenerator(), functor);
+        QVERIFY(backendBuffer.isDirty());
 
         QVERIFY(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::BuffersDirty);
         renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty);
 
-        renderBuffer.unsetDirty();
-        QVERIFY(!renderBuffer.isDirty());
+        backendBuffer.unsetDirty();
+        QVERIFY(!backendBuffer.isDirty());
 
         // WHEN
-        updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId());
-        updateChange->setValue(true);
-        updateChange->setPropertyName("syncData");
-        renderBuffer.sceneChangeEvent(updateChange);
+        frontendBuffer.setSyncData(true);
+        backendBuffer.syncFromFrontEnd(&frontendBuffer, false);
 
         // THEN
-        QCOMPARE(renderBuffer.isSyncData(), true);
-        QVERIFY(!renderBuffer.isDirty());
+        QCOMPARE(backendBuffer.isSyncData(), true);
+        QVERIFY(!backendBuffer.isDirty());
 
         QVERIFY(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::BuffersDirty);
         renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty);
 
         // WHEN
         TestArbiter arbiter;
-        Qt3DCore::QBackendNodePrivate::get(&renderBuffer)->setArbiter(&arbiter);
-        renderBuffer.executeFunctor();
+        Qt3DCore::QBackendNodePrivate::get(&backendBuffer)->setArbiter(&arbiter);
+        backendBuffer.executeFunctor();
 
         // THEN
         QCOMPARE(arbiter.events.count(), 1);
         Qt3DCore::QPropertyUpdatedChangePtr change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
         QCOMPARE(change->propertyName(), "data");
         QCOMPARE(change->value().toByteArray(), QByteArrayLiteral("454"));
-        QCOMPARE(renderBuffer.pendingBufferUpdates().size(), 1);
-        QCOMPARE(renderBuffer.pendingBufferUpdates().first().offset, -1);
+        QCOMPARE(backendBuffer.pendingBufferUpdates().size(), 1);
+        QCOMPARE(backendBuffer.pendingBufferUpdates().first().offset, -1);
 
         arbiter.events.clear();
-        renderBuffer.pendingBufferUpdates().clear();
+        backendBuffer.pendingBufferUpdates().clear();
 
         // WHEN
-        updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId());
-        Qt3DRender::QBufferUpdate updateData;
-        updateData.offset = 2;
-        updateData.data = QByteArrayLiteral("LS5");
-        updateChange->setValue(QVariant::fromValue(updateData));
-        updateChange->setPropertyName("updateData");
-        renderBuffer.sceneChangeEvent(updateChange);
+        frontendBuffer.updateData(2, QByteArrayLiteral("LS5"));
+        backendBuffer.syncFromFrontEnd(&frontendBuffer, false);
 
         // THEN
-        QVERIFY(!renderBuffer.pendingBufferUpdates().empty());
-        QCOMPARE(renderBuffer.pendingBufferUpdates().first().offset, 2);
-        QVERIFY(renderBuffer.isDirty());
+        QVERIFY(!backendBuffer.pendingBufferUpdates().empty());
+        QCOMPARE(backendBuffer.pendingBufferUpdates().first().offset, 2);
+        QVERIFY(backendBuffer.isDirty());
 
         QVERIFY(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::BuffersDirty);
         renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty);
 
-        renderBuffer.unsetDirty();
-        QVERIFY(!renderBuffer.isDirty());
+        backendBuffer.unsetDirty();
+        QVERIFY(!backendBuffer.isDirty());
     }
 
     void checkBufferManagerReferenceCount()
@@ -275,7 +260,7 @@ private Q_SLOTS:
         // WHEN
         renderBuffer.setRenderer(&renderer);
         renderBuffer.setManager(&bufferManager);
-        simulateInitialization(&buffer, &renderBuffer);
+        simulateInitializationSync(&buffer, &renderBuffer);
 
         // THEN
         QVERIFY(bufferManager.takeBuffersToRelease().empty());
@@ -305,7 +290,7 @@ private Q_SLOTS:
         QCOMPARE(renderer.dirtyBits(), 0);
 
         // WHEN
-        simulateInitialization(&buffer, &renderBuffer);
+        simulateInitializationSync(&buffer, &renderBuffer);
 
         // THEN
         QCOMPARE(renderer.dirtyBits(), Qt3DRender::Render::AbstractRenderer::BuffersDirty);
diff --git a/tests/auto/render/commons/testaspect.cpp b/tests/auto/render/commons/testaspect.cpp
index 8be6a7833..87ffc56d7 100644
--- a/tests/auto/render/commons/testaspect.cpp
+++ b/tests/auto/render/commons/testaspect.cpp
@@ -37,6 +37,7 @@
 #include "testaspect.h"
 #include <Qt3DCore/private/qnodevisitor_p.h>
 #include <Qt3DCore/private/qnode_p.h>
+#include <Qt3DCore/private/qaspectmanager_p.h>
 
 QT_BEGIN_NAMESPACE
 
@@ -76,7 +77,12 @@ TestAspect::TestAspect(Qt3DCore::QNode *root)
     const QVector<Qt3DCore::QNode *> nodes = getNodesForCreation(root);
 
     for (Qt3DCore::QNode *node : nodes)
-        d_func()->createBackendNode(node);
+        d_func()->createBackendNode({
+                                        node->id(),
+                                        Qt3DCore::QNodePrivate::get(node)->m_typeInfo,
+                                        Qt3DCore::NodeTreeChange::Added,
+                                        node
+                                    });
 }
 
 TestAspect::~TestAspect()
diff --git a/tests/auto/render/commons/testrenderer.h b/tests/auto/render/commons/testrenderer.h
index dbe69ace5..8d27998a0 100644
--- a/tests/auto/render/commons/testrenderer.h
+++ b/tests/auto/render/commons/testrenderer.h
@@ -63,7 +63,7 @@ public:
     Qt3DCore::QAspectJobPtr rayCastingJob() override { return Qt3DCore::QAspectJobPtr(); }
     Qt3DCore::QAspectJobPtr syncLoadingJobs() override { return Qt3DCore::QAspectJobPtr(); }
     Qt3DCore::QAspectJobPtr expandBoundingVolumeJob() override { return Qt3DCore::QAspectJobPtr(); }
-    void setSceneRoot(Qt3DCore::QBackendNodeFactory *factory, Qt3DRender::Render::Entity *root) override { Q_UNUSED(factory);  Q_UNUSED(root); }
+    void setSceneRoot(Qt3DRender::Render::Entity *root) override { Q_UNUSED(root); }
     Qt3DRender::Render::Entity *sceneRoot() const override { return nullptr; }
     Qt3DRender::Render::FrameGraphNode *frameGraphRoot() const override { return nullptr; }
     Qt3DCore::QAbstractFrameAdvanceService *frameAdvanceService() const override { return nullptr; }
diff --git a/tests/auto/render/coordinatereader/tst_coordinatereader.cpp b/tests/auto/render/coordinatereader/tst_coordinatereader.cpp
index afb18fe55..417684245 100644
--- a/tests/auto/render/coordinatereader/tst_coordinatereader.cpp
+++ b/tests/auto/render/coordinatereader/tst_coordinatereader.cpp
@@ -101,7 +101,7 @@ private Q_SLOTS:
                                             ->getOrCreateResource(geometryRenderer->id());
         backendRenderer->setRenderer(&renderer);
         backendRenderer->setManager(nodeManagers->geometryRendererManager());
-        simulateInitialization(geometryRenderer.data(), backendRenderer);
+        simulateInitializationSync(geometryRenderer.data(), backendRenderer);
 
         // WHEN
         bool ret = reader.setGeometry(backendRenderer, QString(""));
@@ -149,7 +149,7 @@ private Q_SLOTS:
         Buffer *backendBuffer = nodeManagers->bufferManager()->getOrCreateResource(dataBuffer->id());
         backendBuffer->setRenderer(&renderer);
         backendBuffer->setManager(nodeManagers->bufferManager());
-        simulateInitialization(dataBuffer.data(), backendBuffer);
+        simulateInitializationSync(dataBuffer.data(), backendBuffer);
 
         positionAttribute->setBuffer(dataBuffer.data());
         positionAttribute->setName(Qt3DRender::QAttribute::defaultPositionAttributeName());
@@ -167,18 +167,18 @@ private Q_SLOTS:
         Attribute *backendAttribute = nodeManagers->attributeManager()
                                       ->getOrCreateResource(positionAttribute->id());
         backendAttribute->setRenderer(&renderer);
-        simulateInitialization(positionAttribute.data(), backendAttribute);
+        simulateInitializationSync(positionAttribute.data(), backendAttribute);
 
         Geometry *backendGeometry = nodeManagers->geometryManager()
                                     ->getOrCreateResource(geometry->id());
         backendGeometry->setRenderer(&renderer);
-        simulateInitialization(geometry, backendGeometry);
+        simulateInitializationSync(geometry, backendGeometry);
 
         GeometryRenderer *backendRenderer = nodeManagers->geometryRendererManager()
                                             ->getOrCreateResource(geometryRenderer->id());
         backendRenderer->setRenderer(&renderer);
         backendRenderer->setManager(nodeManagers->geometryRendererManager());
-        simulateInitialization(geometryRenderer.data(), backendRenderer);
+        simulateInitializationSync(geometryRenderer.data(), backendRenderer);
 
         // WHEN
         bool ret = reader.setGeometry(backendRenderer,
@@ -232,7 +232,7 @@ private Q_SLOTS:
         Buffer *backendBuffer = nodeManagers->bufferManager()->getOrCreateResource(dataBuffer->id());
         backendBuffer->setRenderer(&renderer);
         backendBuffer->setManager(nodeManagers->bufferManager());
-        simulateInitialization(dataBuffer.data(), backendBuffer);
+        simulateInitializationSync(dataBuffer.data(), backendBuffer);
 
         positionAttribute->setBuffer(dataBuffer.data());
         positionAttribute->setName(Qt3DRender::QAttribute::defaultPositionAttributeName());
@@ -250,18 +250,18 @@ private Q_SLOTS:
         Attribute *backendAttribute = nodeManagers->attributeManager()
                                       ->getOrCreateResource(positionAttribute->id());
         backendAttribute->setRenderer(&renderer);
-        simulateInitialization(positionAttribute.data(), backendAttribute);
+        simulateInitializationSync(positionAttribute.data(), backendAttribute);
 
         Geometry *backendGeometry = nodeManagers->geometryManager()
                                     ->getOrCreateResource(geometry->id());
         backendGeometry->setRenderer(&renderer);
-        simulateInitialization(geometry, backendGeometry);
+        simulateInitializationSync(geometry, backendGeometry);
 
         GeometryRenderer *backendRenderer = nodeManagers->geometryRendererManager()
                                             ->getOrCreateResource(geometryRenderer->id());
         backendRenderer->setRenderer(&renderer);
         backendRenderer->setManager(nodeManagers->geometryRendererManager());
-        simulateInitialization(geometryRenderer.data(), backendRenderer);
+        simulateInitializationSync(geometryRenderer.data(), backendRenderer);
 
         // WHEN
         bool ret = reader.setGeometry(backendRenderer,
@@ -326,7 +326,7 @@ private Q_SLOTS:
         Buffer *backendBuffer = nodeManagers->bufferManager()->getOrCreateResource(dataBuffer->id());
         backendBuffer->setRenderer(&renderer);
         backendBuffer->setManager(nodeManagers->bufferManager());
-        simulateInitialization(dataBuffer.data(), backendBuffer);
+        simulateInitializationSync(dataBuffer.data(), backendBuffer);
 
         positionAttribute->setBuffer(dataBuffer.data());
         positionAttribute->setName(Qt3DRender::QAttribute::defaultPositionAttributeName());
@@ -344,18 +344,18 @@ private Q_SLOTS:
         Attribute *backendAttribute = nodeManagers->attributeManager()
                                       ->getOrCreateResource(positionAttribute->id());
         backendAttribute->setRenderer(&renderer);
-        simulateInitialization(positionAttribute.data(), backendAttribute);
+        simulateInitializationSync(positionAttribute.data(), backendAttribute);
 
         Geometry *backendGeometry = nodeManagers->geometryManager()
                                     ->getOrCreateResource(geometry->id());
         backendGeometry->setRenderer(&renderer);
-        simulateInitialization(geometry, backendGeometry);
+        simulateInitializationSync(geometry, backendGeometry);
 
         GeometryRenderer *backendRenderer = nodeManagers->geometryRendererManager()
                                             ->getOrCreateResource(geometryRenderer->id());
         backendRenderer->setRenderer(&renderer);
         backendRenderer->setManager(nodeManagers->geometryRendererManager());
-        simulateInitialization(geometryRenderer.data(), backendRenderer);
+        simulateInitializationSync(geometryRenderer.data(), backendRenderer);
 
         // WHEN
         bool ret = reader.setGeometry(backendRenderer,
@@ -415,7 +415,7 @@ private Q_SLOTS:
         Buffer *backendBuffer = nodeManagers->bufferManager()->getOrCreateResource(dataBuffer->id());
         backendBuffer->setRenderer(&renderer);
         backendBuffer->setManager(nodeManagers->bufferManager());
-        simulateInitialization(dataBuffer.data(), backendBuffer);
+        simulateInitializationSync(dataBuffer.data(), backendBuffer);
 
         positionAttribute->setBuffer(dataBuffer.data());
         positionAttribute->setName(Qt3DRender::QAttribute::defaultPositionAttributeName());
@@ -443,23 +443,23 @@ private Q_SLOTS:
         Attribute *backendAttribute = nodeManagers->attributeManager()->getOrCreateResource(
                                         positionAttribute->id());
         backendAttribute->setRenderer(&renderer);
-        simulateInitialization(positionAttribute.data(), backendAttribute);
+        simulateInitializationSync(positionAttribute.data(), backendAttribute);
 
         Attribute *backendTexcoordAttribute = nodeManagers->attributeManager()
                                               ->getOrCreateResource(texcoordAttribute->id());
         backendTexcoordAttribute->setRenderer(&renderer);
-        simulateInitialization(texcoordAttribute.data(), backendTexcoordAttribute);
+        simulateInitializationSync(texcoordAttribute.data(), backendTexcoordAttribute);
 
         Geometry *backendGeometry = nodeManagers->geometryManager()
                                     ->getOrCreateResource(geometry->id());
         backendGeometry->setRenderer(&renderer);
-        simulateInitialization(geometry, backendGeometry);
+        simulateInitializationSync(geometry, backendGeometry);
 
         GeometryRenderer *backendRenderer = nodeManagers->geometryRendererManager()
                                             ->getOrCreateResource(geometryRenderer->id());
         backendRenderer->setRenderer(&renderer);
         backendRenderer->setManager(nodeManagers->geometryRendererManager());
-        simulateInitialization(geometryRenderer.data(), backendRenderer);
+        simulateInitializationSync(geometryRenderer.data(), backendRenderer);
 
         // WHEN
         bool ret = reader.setGeometry(backendRenderer,
diff --git a/tests/auto/render/effect/tst_effect.cpp b/tests/auto/render/effect/tst_effect.cpp
index 30df242f4..cb2ca41e1 100644
--- a/tests/auto/render/effect/tst_effect.cpp
+++ b/tests/auto/render/effect/tst_effect.cpp
@@ -72,7 +72,7 @@ private Q_SLOTS:
             Qt3DRender::QParameter parameter;
             effect.addTechnique(&technique);
             effect.addParameter(&parameter);
-            simulateInitialization(&effect, &backendEffect);
+            simulateInitializationSync(&effect, &backendEffect);
         }
 
         backendEffect.cleanup();
@@ -95,7 +95,7 @@ private Q_SLOTS:
         {
             // WHEN
             Qt3DRender::Render::Effect backendEffect;
-            simulateInitialization(&effect, &backendEffect);
+            simulateInitializationSync(&effect, &backendEffect);
 
             // THEN
             QCOMPARE(backendEffect.isEnabled(), true);
@@ -109,7 +109,7 @@ private Q_SLOTS:
             // WHEN
             Qt3DRender::Render::Effect backendEffect;
             effect.setEnabled(false);
-            simulateInitialization(&effect, &backendEffect);
+            simulateInitializationSync(&effect, &backendEffect);
 
             // THEN
             QCOMPARE(backendEffect.peerId(), effect.id());
@@ -120,17 +120,17 @@ private Q_SLOTS:
     void checkSceneChangeEvents()
     {
         // GIVEN
+        Qt3DRender::QEffect effect;
         Qt3DRender::Render::Effect backendEffect;
         TestRenderer renderer;
         backendEffect.setRenderer(&renderer);
+        simulateInitializationSync(&effect, &backendEffect);
 
         {
             // WHEN
             const bool newValue = false;
-            const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-            change->setPropertyName("enabled");
-            change->setValue(newValue);
-            backendEffect.sceneChangeEvent(change);
+            effect.setEnabled(newValue);
+            backendEffect.syncFromFrontEnd(&effect, false);
 
             // THEN
             QCOMPARE(backendEffect.isEnabled(), newValue);
@@ -139,9 +139,8 @@ private Q_SLOTS:
             Qt3DRender::QTechnique technique;
             {
                 // WHEN
-                const auto change = Qt3DCore::QPropertyNodeAddedChangePtr::create(Qt3DCore::QNodeId(), &technique);
-                change->setPropertyName("technique");
-                backendEffect.sceneChangeEvent(change);
+                effect.addTechnique(&technique);
+                backendEffect.syncFromFrontEnd(&effect, false);
 
                 // THEN
                 QCOMPARE(backendEffect.techniques().size(), 1);
@@ -149,9 +148,8 @@ private Q_SLOTS:
             }
             {
                 // WHEN
-                const auto change = Qt3DCore::QPropertyNodeRemovedChangePtr::create(Qt3DCore::QNodeId(), &technique);
-                change->setPropertyName("technique");
-                backendEffect.sceneChangeEvent(change);
+                effect.removeTechnique(&technique);
+                backendEffect.syncFromFrontEnd(&effect, false);
 
                 // THEN
                 QCOMPARE(backendEffect.techniques().size(), 0);
@@ -162,9 +160,8 @@ private Q_SLOTS:
 
             {
                 // WHEN
-                const auto change = Qt3DCore::QPropertyNodeAddedChangePtr::create(Qt3DCore::QNodeId(), &parameter);
-                change->setPropertyName("parameter");
-                backendEffect.sceneChangeEvent(change);
+                effect.addParameter(&parameter);
+                backendEffect.syncFromFrontEnd(&effect, false);
 
                 // THEN
                 QCOMPARE(backendEffect.parameters().size(), 1);
@@ -172,9 +169,8 @@ private Q_SLOTS:
             }
             {
                 // WHEN
-                const auto change = Qt3DCore::QPropertyNodeRemovedChangePtr::create(Qt3DCore::QNodeId(), &parameter);
-                change->setPropertyName("parameter");
-                backendEffect.sceneChangeEvent(change);
+                effect.removeParameter(&parameter);
+                backendEffect.syncFromFrontEnd(&effect, false);
 
                 // THEN
                 QCOMPARE(backendEffect.parameters().size(), 0);
diff --git a/tests/auto/render/entity/tst_entity.cpp b/tests/auto/render/entity/tst_entity.cpp
index 08d08404c..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,17 +221,9 @@ private slots:
         QVERIFY(backendC->childrenHandles().isEmpty());
 
         // WHEN
-        renderer.clearDirtyBits(0);
-        QVERIFY(renderer.dirtyBits() == 0);
-
         auto sendParentChange = [&nodeManagers](const Qt3DCore::QEntity &entity) {
-            const auto parentChange = QPropertyUpdatedChangePtr::create(entity.id());
-            parentChange->setPropertyName("parentEntityUpdated");
-            auto parent = entity.parentEntity();
-            parentChange->setValue(QVariant::fromValue(parent ? parent->id() : Qt3DCore::QNodeId()));
-
             Entity *backendEntity = nodeManagers.renderNodesManager()->getOrCreateResource(entity.id());
-            backendEntity->sceneChangeEvent(parentChange);
+            backendEntity->syncFromFrontEnd(&entity, false);
         };
 
         // reparent B to A and C to B.
@@ -253,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();
 
-        QVERIFY(backendA->parentEntityId().isNull());
-        QVERIFY(backendB->parentEntityId().isNull());
-        QVERIFY(backendC->parentEntityId() == frontendEntityB.id());
+        // 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());
+
+        // 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()
@@ -446,27 +469,13 @@ 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);
-            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) {
-            const auto parentChange = QPropertyUpdatedChangePtr::create(entity.id());
-            parentChange->setPropertyName("parentEntityUpdated");
-            auto parent = entity.parentEntity();
-            parentChange->setValue(QVariant::fromValue(parent ? parent->id() : Qt3DCore::QNodeId()));
-
             Entity *backendEntity = nodeManagers.renderNodesManager()->getOrCreateResource(entity.id());
-            backendEntity->sceneChangeEvent(parentChange);
+            backendEntity->syncFromFrontEnd(&entity, false);
         };
 
         // reparent B to A and C to B.
@@ -475,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; };
@@ -499,27 +500,17 @@ 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);
-            return entity;
-        };
+        frontendEntityA.setEnabled(false);
+        frontendEntityB.setEnabled(false);
+        frontendEntityC.setEnabled(false);
 
-        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) {
-            const auto parentChange = QPropertyUpdatedChangePtr::create(entity.id());
-            parentChange->setPropertyName("parentEntityUpdated");
-            auto parent = entity.parentEntity();
-            parentChange->setValue(QVariant::fromValue(parent ? parent->id() : Qt3DCore::QNodeId()));
-
             Entity *backendEntity = nodeManagers.renderNodesManager()->getOrCreateResource(entity.id());
-            backendEntity->sceneChangeEvent(parentChange);
+            backendEntity->syncFromFrontEnd(&entity, false);
         };
 
         // reparent B to A and C to B.
@@ -528,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);
@@ -547,8 +530,8 @@ private slots:
 
        // THEN
        QCOMPARE(v1.count, 3);
-       QCOMPARE(v2.count, 1); // nodes disabled by default but the first one is still visited before visitation finds out it's disabled
-       QCOMPARE(v3.count, 0); // nodes disabled by default
+       QCOMPARE(v2.count, 1); // nodes disabled but the first one is still visited before visitation finds out it's disabled
+       QCOMPARE(v3.count, 0); // nodes disabled
     }
 
     void accumulator()
@@ -558,27 +541,17 @@ 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);
-            return entity;
-        };
+        frontendEntityA.setEnabled(false);
+        frontendEntityB.setEnabled(false);
+        frontendEntityC.setEnabled(false);
 
-        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) {
-            const auto parentChange = QPropertyUpdatedChangePtr::create(entity.id());
-            parentChange->setPropertyName("parentEntityUpdated");
-            auto parent = entity.parentEntity();
-            parentChange->setValue(QVariant::fromValue(parent ? parent->id() : Qt3DCore::QNodeId()));
-
             Entity *backendEntity = nodeManagers.renderNodesManager()->getOrCreateResource(entity.id());
-            backendEntity->sceneChangeEvent(parentChange);
+            backendEntity->syncFromFrontEnd(&entity, false);
         };
 
         // reparent B to A and C to B.
@@ -587,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);
@@ -605,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/filtercompatibletechniquejob/tst_filtercompatibletechniquejob.cpp b/tests/auto/render/filtercompatibletechniquejob/tst_filtercompatibletechniquejob.cpp
index 80a6ae519..25262a772 100644
--- a/tests/auto/render/filtercompatibletechniquejob/tst_filtercompatibletechniquejob.cpp
+++ b/tests/auto/render/filtercompatibletechniquejob/tst_filtercompatibletechniquejob.cpp
@@ -81,7 +81,12 @@ public:
         });
 
         for (const auto node: nodes)
-            d_func()->createBackendNode(node);
+            d_func()->createBackendNode({
+                                            node->id(),
+                                            Qt3DCore::QNodePrivate::get(node)->m_typeInfo,
+                                            Qt3DCore::NodeTreeChange::Added,
+                                            node
+                                        });
     }
 
     ~TestAspect()
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/geometry/tst_geometry.cpp b/tests/auto/render/geometry/tst_geometry.cpp
index 7e65d27aa..54a28e776 100644
--- a/tests/auto/render/geometry/tst_geometry.cpp
+++ b/tests/auto/render/geometry/tst_geometry.cpp
@@ -50,6 +50,7 @@ public:
 class tst_RenderGeometry : public Qt3DCore::QBackendNodeTester
 {
     Q_OBJECT
+
 private Q_SLOTS:
 
     void checkPeerPropertyMirroring()
@@ -72,7 +73,7 @@ private Q_SLOTS:
         renderGeometry.setRenderer(&renderer);
 
         // WHEN
-        simulateInitialization(&geometry, &renderGeometry);
+        simulateInitializationSync(&geometry, &renderGeometry);
 
         // THEN
         QCOMPARE(renderGeometry.peerId(), geometry.id());
@@ -80,8 +81,9 @@ private Q_SLOTS:
         QCOMPARE(renderGeometry.attributes().count(), 4);
         QCOMPARE(renderGeometry.boundingPositionAttribute(), attr1.id());
 
-        for (int i = 0; i < 4; ++i)
-            QCOMPARE(geometry.attributes().at(i)->id(), renderGeometry.attributes().at(i));
+        Qt3DCore::QNodeIdVector attribs = Qt3DCore::qIdsForNodes(geometry.attributes());
+        std::sort(std::begin(attribs), std::end(attribs));
+        QCOMPARE(attribs, renderGeometry.attributes());
     }
 
     void checkSetRendererDirtyOnInitialization()
@@ -97,7 +99,7 @@ private Q_SLOTS:
         QCOMPARE(renderer.dirtyBits(), 0);
 
         // WHEN
-        simulateInitialization(&geometry, &renderGeometry);
+        simulateInitializationSync(&geometry, &renderGeometry);
 
         // THEN
         QCOMPARE(renderer.dirtyBits(), Qt3DRender::Render::AbstractRenderer::GeometryDirty);
@@ -130,7 +132,7 @@ private Q_SLOTS:
         geometry.addAttribute(&attr4);
 
         // WHEN
-        simulateInitialization(&geometry, &renderGeometry);
+        simulateInitializationSync(&geometry, &renderGeometry);
         renderGeometry.cleanup();
 
         // THEN
@@ -145,13 +147,15 @@ private Q_SLOTS:
         TestRenderer renderer;
         Qt3DRender::Render::Geometry renderGeometry;
         renderGeometry.setRenderer(&renderer);
+        Qt3DRender::QGeometry geometry;
+
+        simulateInitializationSync(&geometry, &renderGeometry);
 
         DummyAttribute attribute;
 
         // WHEN
-        const auto nodeAddedChange = Qt3DCore::QPropertyNodeAddedChangePtr::create(Qt3DCore::QNodeId(), &attribute);
-        nodeAddedChange->setPropertyName("attribute");
-        renderGeometry.sceneChangeEvent(nodeAddedChange);
+        geometry.addAttribute(&attribute);
+        renderGeometry.syncFromFrontEnd(&geometry, false);
 
         // THEN
         QCOMPARE(renderGeometry.attributes().count(), 1);
@@ -163,9 +167,8 @@ private Q_SLOTS:
         QVERIFY(!renderGeometry.isDirty());
 
         // WHEN
-        const auto nodeRemovedChange = Qt3DCore::QPropertyNodeRemovedChangePtr::create(Qt3DCore::QNodeId(), &attribute);
-        nodeRemovedChange->setPropertyName("attribute");
-        renderGeometry.sceneChangeEvent(nodeRemovedChange);
+        geometry.removeAttribute(&attribute);
+        renderGeometry.syncFromFrontEnd(&geometry, false);
 
         // THEN
         QCOMPARE(renderGeometry.attributes().count(), 0);
@@ -177,14 +180,11 @@ private Q_SLOTS:
         QVERIFY(!renderGeometry.isDirty());
 
         // WHEN
-        const Qt3DCore::QNodeId boundingAttrId = Qt3DCore::QNodeId::createId();
-        Qt3DCore::QPropertyUpdatedChangePtr updateChange(new Qt3DCore::QPropertyUpdatedChange(Qt3DCore::QNodeId()));
-        updateChange->setValue(QVariant::fromValue(boundingAttrId));
-        updateChange->setPropertyName("boundingVolumePositionAttribute");
-        renderGeometry.sceneChangeEvent(updateChange);
+        geometry.setBoundingVolumePositionAttribute(&attribute);
+        renderGeometry.syncFromFrontEnd(&geometry, false);
 
         // THEN
-        QCOMPARE(renderGeometry.boundingPositionAttribute(), boundingAttrId);
+        QCOMPARE(renderGeometry.boundingPositionAttribute(), attribute.id());
         QVERIFY(!renderGeometry.isDirty());
         QVERIFY(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::GeometryDirty);
         renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty);
diff --git a/tests/auto/render/geometryrenderer/tst_geometryrenderer.cpp b/tests/auto/render/geometryrenderer/tst_geometryrenderer.cpp
index d07ec9914..db997a5e5 100644
--- a/tests/auto/render/geometryrenderer/tst_geometryrenderer.cpp
+++ b/tests/auto/render/geometryrenderer/tst_geometryrenderer.cpp
@@ -75,6 +75,7 @@ public:
 class tst_RenderGeometryRenderer : public Qt3DCore::QBackendNodeTester
 {
     Q_OBJECT
+
 private Q_SLOTS:
 
     void checkPeerPropertyMirroring()
@@ -102,7 +103,7 @@ private Q_SLOTS:
         // WHEN
         renderGeometryRenderer.setRenderer(&renderer);
         renderGeometryRenderer.setManager(&geometryRendererManager);
-        simulateInitialization(&geometryRenderer, &renderGeometryRenderer);
+        simulateInitializationSync(&geometryRenderer, &renderGeometryRenderer);
 
         // THEN
         QCOMPARE(renderGeometryRenderer.peerId(), geometryRenderer.id());
@@ -163,7 +164,7 @@ private Q_SLOTS:
         // WHEN
         renderGeometryRenderer.setRenderer(&renderer);
         renderGeometryRenderer.setManager(&geometryRendererManager);
-        simulateInitialization(&geometryRenderer, &renderGeometryRenderer);
+        simulateInitializationSync(&geometryRenderer, &renderGeometryRenderer);
         renderGeometryRenderer.cleanup();
 
         // THEN
@@ -184,210 +185,185 @@ private Q_SLOTS:
     void checkPropertyChanges()
     {
         // GIVEN
-        Qt3DRender::Render::GeometryRenderer renderGeometryRenderer;
+        Qt3DRender::QGeometryRenderer frontEndRenderer;
+        Qt3DRender::Render::GeometryRenderer backEndRenderer;
         TestRenderer renderer;
-        renderGeometryRenderer.setRenderer(&renderer);
+        backEndRenderer.setRenderer(&renderer);
 
-        QVERIFY(!renderGeometryRenderer.isDirty());
+        QVERIFY(!backEndRenderer.isDirty());
 
         // WHEN
-        Qt3DCore::QPropertyUpdatedChangePtr updateChange(new Qt3DCore::QPropertyUpdatedChange(Qt3DCore::QNodeId()));
-        updateChange->setPropertyName("instanceCount");
-        updateChange->setValue(2);
-        renderGeometryRenderer.sceneChangeEvent(updateChange);
+        frontEndRenderer.setInstanceCount(2);
+        backEndRenderer.syncFromFrontEnd(&frontEndRenderer, false);
 
         // THEN
-        QCOMPARE(renderGeometryRenderer.instanceCount(), 2);
-        QVERIFY(renderGeometryRenderer.isDirty());
+        QCOMPARE(backEndRenderer.instanceCount(), 2);
+        QVERIFY(backEndRenderer.isDirty());
         QVERIFY(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::GeometryDirty);
         renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty);
 
-        renderGeometryRenderer.unsetDirty();
-        QVERIFY(!renderGeometryRenderer.isDirty());
+        backEndRenderer.unsetDirty();
+        QVERIFY(!backEndRenderer.isDirty());
 
         // WHEN
-        updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId());
-        updateChange->setPropertyName("vertexCount");
-        updateChange->setValue(56);
-        renderGeometryRenderer.sceneChangeEvent(updateChange);
+        frontEndRenderer.setVertexCount(56);
+        backEndRenderer.syncFromFrontEnd(&frontEndRenderer, false);
 
         // THEN
-        QCOMPARE(renderGeometryRenderer.vertexCount(), 56);
-        QVERIFY(renderGeometryRenderer.isDirty());
+        QCOMPARE(backEndRenderer.vertexCount(), 56);
+        QVERIFY(backEndRenderer.isDirty());
 
         QVERIFY(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::GeometryDirty);
         renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty);
 
-        renderGeometryRenderer.unsetDirty();
-        QVERIFY(!renderGeometryRenderer.isDirty());
+        backEndRenderer.unsetDirty();
+        QVERIFY(!backEndRenderer.isDirty());
 
         // WHEN
-        updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId());
-        updateChange->setPropertyName("indexOffset");
-        updateChange->setValue(65);
-        renderGeometryRenderer.sceneChangeEvent(updateChange);
+        frontEndRenderer.setIndexOffset(65);
+        backEndRenderer.syncFromFrontEnd(&frontEndRenderer, false);
 
         // THEN
-        QCOMPARE(renderGeometryRenderer.indexOffset(), 65);
-        QVERIFY(renderGeometryRenderer.isDirty());
+        QCOMPARE(backEndRenderer.indexOffset(), 65);
+        QVERIFY(backEndRenderer.isDirty());
 
         QVERIFY(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::GeometryDirty);
         renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty);
 
-        renderGeometryRenderer.unsetDirty();
-        QVERIFY(!renderGeometryRenderer.isDirty());
+        backEndRenderer.unsetDirty();
+        QVERIFY(!backEndRenderer.isDirty());
 
         // WHEN
-        updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId());
-        updateChange->setPropertyName("firstInstance");
-        updateChange->setValue(82);
-        renderGeometryRenderer.sceneChangeEvent(updateChange);
+        frontEndRenderer.setFirstInstance(82);
+        backEndRenderer.syncFromFrontEnd(&frontEndRenderer, false);
 
         // THEN
-        QCOMPARE(renderGeometryRenderer.firstInstance(), 82);
-        QVERIFY(renderGeometryRenderer.isDirty());
+        QCOMPARE(backEndRenderer.firstInstance(), 82);
+        QVERIFY(backEndRenderer.isDirty());
 
         QVERIFY(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::GeometryDirty);
         renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty);
 
-        renderGeometryRenderer.unsetDirty();
-        QVERIFY(!renderGeometryRenderer.isDirty());
+        backEndRenderer.unsetDirty();
+        QVERIFY(!backEndRenderer.isDirty());
 
         // WHEN
-        updateChange.reset(new Qt3DCore::QPropertyUpdatedChange(Qt3DCore::QNodeId()));
-        updateChange->setPropertyName("indexBufferByteOffset");
-        updateChange->setValue(96);
-        renderGeometryRenderer.sceneChangeEvent(updateChange);
+        frontEndRenderer.setIndexBufferByteOffset(96);
+        backEndRenderer.syncFromFrontEnd(&frontEndRenderer, false);
 
         // THEN
-        QCOMPARE(renderGeometryRenderer.indexBufferByteOffset(), 96);
-        QVERIFY(renderGeometryRenderer.isDirty());
+        QCOMPARE(backEndRenderer.indexBufferByteOffset(), 96);
+        QVERIFY(backEndRenderer.isDirty());
 
         QVERIFY(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::GeometryDirty);
         renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty);
 
-        renderGeometryRenderer.unsetDirty();
-        QVERIFY(!renderGeometryRenderer.isDirty());
+        backEndRenderer.unsetDirty();
+        QVERIFY(!backEndRenderer.isDirty());
 
         // WHEN
-        updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId());
-        updateChange->setPropertyName("restartIndexValue");
-        updateChange->setValue(46);
-        renderGeometryRenderer.sceneChangeEvent(updateChange);
+        frontEndRenderer.setRestartIndexValue(46);
+        backEndRenderer.syncFromFrontEnd(&frontEndRenderer, false);
 
         // THEN
-        QCOMPARE(renderGeometryRenderer.restartIndexValue(), 46);
-        QVERIFY(renderGeometryRenderer.isDirty());
+        QCOMPARE(backEndRenderer.restartIndexValue(), 46);
+        QVERIFY(backEndRenderer.isDirty());
 
         QVERIFY(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::GeometryDirty);
         renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty);
 
-        renderGeometryRenderer.unsetDirty();
-        QVERIFY(!renderGeometryRenderer.isDirty());
+        backEndRenderer.unsetDirty();
+        QVERIFY(!backEndRenderer.isDirty());
 
         // WHEN
-        updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId());
-        updateChange->setPropertyName("primitiveRestartEnabled");
-        updateChange->setValue(true);
-        renderGeometryRenderer.sceneChangeEvent(updateChange);
+        frontEndRenderer.setPrimitiveRestartEnabled(true);
+        backEndRenderer.syncFromFrontEnd(&frontEndRenderer, false);
 
         // THEN
-        QCOMPARE(renderGeometryRenderer.primitiveRestartEnabled(), true);
-        QVERIFY(renderGeometryRenderer.isDirty());
+        QCOMPARE(backEndRenderer.primitiveRestartEnabled(), true);
+        QVERIFY(backEndRenderer.isDirty());
 
         QVERIFY(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::GeometryDirty);
         renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty);
 
-        renderGeometryRenderer.unsetDirty();
-        QVERIFY(!renderGeometryRenderer.isDirty());
+        backEndRenderer.unsetDirty();
+        QVERIFY(!backEndRenderer.isDirty());
 
         // WHEN
-        updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId());
-        updateChange->setPropertyName("primitiveType");
-        updateChange->setValue(static_cast<int>(Qt3DRender::QGeometryRenderer::LineLoop));
-        renderGeometryRenderer.sceneChangeEvent(updateChange);
+        frontEndRenderer.setPrimitiveType(Qt3DRender::QGeometryRenderer::LineLoop);
+        backEndRenderer.syncFromFrontEnd(&frontEndRenderer, false);
 
         // THEN
-        QCOMPARE(renderGeometryRenderer.primitiveType(), Qt3DRender::QGeometryRenderer::LineLoop);
-        QVERIFY(renderGeometryRenderer.isDirty());
+        QCOMPARE(backEndRenderer.primitiveType(), Qt3DRender::QGeometryRenderer::LineLoop);
+        QVERIFY(backEndRenderer.isDirty());
 
         QVERIFY(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::GeometryDirty);
         renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty);
 
-        renderGeometryRenderer.unsetDirty();
-        QVERIFY(!renderGeometryRenderer.isDirty());
+        backEndRenderer.unsetDirty();
+        QVERIFY(!backEndRenderer.isDirty());
 
         // WHEN
-        updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId());
-        updateChange->setPropertyName("geometryFactory");
         Qt3DRender::QGeometryFactoryPtr factory(new TestFactory(1450));
-        updateChange->setValue(QVariant::fromValue(factory));
-        renderGeometryRenderer.sceneChangeEvent(updateChange);
+        frontEndRenderer.setGeometryFactory(factory);
+        backEndRenderer.syncFromFrontEnd(&frontEndRenderer, false);
 
         // THEN
-        QCOMPARE(renderGeometryRenderer.geometryFactory(), factory);
-        QVERIFY(renderGeometryRenderer.isDirty());
+        QCOMPARE(backEndRenderer.geometryFactory(), factory);
+        QVERIFY(backEndRenderer.isDirty());
 
         QVERIFY(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::GeometryDirty);
         renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty);
 
-        renderGeometryRenderer.unsetDirty();
-        QVERIFY(!renderGeometryRenderer.isDirty());
+        backEndRenderer.unsetDirty();
+        QVERIFY(!backEndRenderer.isDirty());
 
         // WHEN we set an identical factory again
-        updateChange.reset(new Qt3DCore::QPropertyUpdatedChange(Qt3DCore::QNodeId()));
-        updateChange->setPropertyName("geometryFactory");
         Qt3DRender::QGeometryFactoryPtr factory2(new TestFactory(1450));
-        updateChange->setValue(QVariant::fromValue(factory2));
-        renderGeometryRenderer.sceneChangeEvent(updateChange);
+        frontEndRenderer.setGeometryFactory(factory2);
+        backEndRenderer.syncFromFrontEnd(&frontEndRenderer, false);
 
         // THEN not dirty and still uses original factory
-        QCOMPARE(renderGeometryRenderer.geometryFactory(), factory);
-        QVERIFY(!renderGeometryRenderer.isDirty());
+        QCOMPARE(backEndRenderer.geometryFactory(), factory);
+        QVERIFY(!backEndRenderer.isDirty());
 
         // WHEN
         DummyGeometry geometry;
         const Qt3DCore::QNodeId geometryId = geometry.id();
-        const auto nodeAddedChange = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-        nodeAddedChange->setPropertyName("geometry");
-        nodeAddedChange->setValue(QVariant::fromValue(geometryId));
-        renderGeometryRenderer.sceneChangeEvent(nodeAddedChange);
+        frontEndRenderer.setGeometry(&geometry);
+        backEndRenderer.syncFromFrontEnd(&frontEndRenderer, false);
 
         // THEN
-        QCOMPARE(renderGeometryRenderer.geometryId(), geometryId);
-        QVERIFY(renderGeometryRenderer.isDirty());
+        QCOMPARE(backEndRenderer.geometryId(), geometryId);
+        QVERIFY(backEndRenderer.isDirty());
 
         QVERIFY(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::GeometryDirty);
         renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty);
 
-        renderGeometryRenderer.unsetDirty();
-        QVERIFY(!renderGeometryRenderer.isDirty());
+        backEndRenderer.unsetDirty();
+        QVERIFY(!backEndRenderer.isDirty());
 
         // WHEN
-        const auto nodeRemovedChange = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-        nodeRemovedChange->setPropertyName("geometry");
-        nodeRemovedChange->setValue(QVariant::fromValue(Qt3DCore::QNodeId()));
-        renderGeometryRenderer.sceneChangeEvent(nodeRemovedChange);
+        frontEndRenderer.setGeometry(nullptr);
+        backEndRenderer.syncFromFrontEnd(&frontEndRenderer, false);
 
         // THEN
-        QCOMPARE(renderGeometryRenderer.geometryId(), Qt3DCore::QNodeId());
-        QVERIFY(renderGeometryRenderer.isDirty());
+        QCOMPARE(backEndRenderer.geometryId(), Qt3DCore::QNodeId());
+        QVERIFY(backEndRenderer.isDirty());
 
         QVERIFY(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::GeometryDirty);
         renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty);
 
-        renderGeometryRenderer.unsetDirty();
-        QVERIFY(!renderGeometryRenderer.isDirty());
+        backEndRenderer.unsetDirty();
+        QVERIFY(!backEndRenderer.isDirty());
 
         // WHEN
-        updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId());
-        updateChange->setValue(QVariant::fromValue(true));
-        updateChange->setPropertyName("enabled");
-        renderGeometryRenderer.sceneChangeEvent(updateChange);
+        frontEndRenderer.setEnabled(true);
+        backEndRenderer.syncFromFrontEnd(&frontEndRenderer, false);
 
         // THEN
-        QCOMPARE(renderGeometryRenderer.isEnabled(), true);
-        QVERIFY(!renderGeometryRenderer.isDirty());
+        QCOMPARE(backEndRenderer.isEnabled(), true);
+        QVERIFY(!backEndRenderer.isDirty());
     }
 
     void checkSetRendererDirtyOnInitialization()
@@ -405,7 +381,7 @@ private Q_SLOTS:
         QCOMPARE(renderer.dirtyBits(), 0);
 
         // WHEN
-        simulateInitialization(&geometryRenderer, &renderGeometryRenderer);
+        simulateInitializationSync(&geometryRenderer, &renderGeometryRenderer);
 
         // THEN
         QCOMPARE(renderer.dirtyBits(), Qt3DRender::Render::AbstractRenderer::GeometryDirty);
diff --git a/tests/auto/render/joint/tst_joint.cpp b/tests/auto/render/joint/tst_joint.cpp
index 13aa915d2..c08d36725 100644
--- a/tests/auto/render/joint/tst_joint.cpp
+++ b/tests/auto/render/joint/tst_joint.cpp
@@ -60,6 +60,7 @@ private Q_SLOTS:
         Joint backendJoint;
         backendJoint.setRenderer(&renderer);
         backendJoint.setJointManager(nodeManagers.jointManager());
+        backendJoint.setSkeletonManager(nodeManagers.skeletonManager());
         QJoint joint;
 
         joint.setTranslation(QVector3D(1.0f, 2.0f, 3.0f));
@@ -77,7 +78,7 @@ private Q_SLOTS:
         }
 
         // WHEN
-        simulateInitialization(&joint, &backendJoint);
+        simulateInitializationSync(&joint, &backendJoint);
 
         // THEN
         QCOMPARE(backendJoint.peerId(), joint.id());
@@ -100,6 +101,7 @@ private Q_SLOTS:
         Joint backendJoint;
         backendJoint.setRenderer(&renderer);
         backendJoint.setJointManager(nodeManagers.jointManager());
+        backendJoint.setSkeletonManager(nodeManagers.skeletonManager());
 
         // THEN
         QVERIFY(backendJoint.peerId().isNull());
@@ -128,7 +130,7 @@ private Q_SLOTS:
         }
 
         // WHEN
-        simulateInitialization(&joint, &backendJoint);
+        simulateInitializationSync(&joint, &backendJoint);
         backendJoint.cleanup();
 
         // THEN
@@ -235,6 +237,88 @@ private Q_SLOTS:
             }
         }
     }
+
+    void checkDirectPropertyChanges()
+    {
+        // GIVEN
+        TestRenderer renderer;
+        NodeManagers nodeManagers;
+        renderer.setNodeManagers(&nodeManagers);
+        Joint backendJoint;
+        backendJoint.setRenderer(&renderer);
+        backendJoint.setJointManager(nodeManagers.jointManager());
+        backendJoint.setSkeletonManager(nodeManagers.skeletonManager());
+
+        QJoint joint;
+        simulateInitializationSync(&joint, &backendJoint);
+
+        // WHEN
+        joint.setEnabled(false);
+        backendJoint.syncFromFrontEnd(&joint, false);
+
+        // THEN
+        QCOMPARE(backendJoint.isEnabled(), false);
+
+        // WHEN
+        const QVector3D newTranslation = QVector3D(1.0f, 2.0f, 3.0f);
+        joint.setTranslation(newTranslation);
+        backendJoint.syncFromFrontEnd(&joint, false);
+
+        // THEN
+        QCOMPARE(backendJoint.translation(), newTranslation);
+
+        // WHEN
+        const QQuaternion newRotation = QQuaternion::fromAxisAndAngle(1.0f, 0.0f, 0.0f, 45.0f);
+        joint.setRotation(newRotation);
+        backendJoint.syncFromFrontEnd(&joint, false);
+
+        // THEN
+        QCOMPARE(backendJoint.rotation(), newRotation);
+
+        // WHEN
+        const QVector3D newScale = QVector3D(1.5f, 2.5f, 3.5f);
+        joint.setScale(newScale);
+        backendJoint.syncFromFrontEnd(&joint, false);
+
+        // THEN
+        QCOMPARE(backendJoint.scale(), newScale);
+
+        // WHEN
+        QMatrix4x4 newInverseBind;
+        newInverseBind.scale(5.4f);
+        joint.setInverseBindMatrix(newInverseBind);
+        backendJoint.syncFromFrontEnd(&joint, false);
+
+        // THEN
+        QCOMPARE(backendJoint.inverseBindMatrix(), newInverseBind);
+
+        // WHEN
+        QVector<QJoint *> childJoints;
+        for (int i = 0; i < 10; ++i) {
+            const auto childJoint = new QJoint();
+            joint.addChildJoint(childJoint);
+            childJoints.push_back(childJoint);
+        }
+        backendJoint.syncFromFrontEnd(&joint, false);
+
+        // THEN
+        for (int i = 0; i < childJoints.size(); ++i) {
+            QCOMPARE(backendJoint.childJointIds()[i], childJoints[i]->id());
+        }
+
+        for (int i = 0; i < 10; ++i) {
+            // WHEN
+            const auto childJoint = childJoints.takeLast();
+
+            joint.removeChildJoint(childJoint);
+            backendJoint.syncFromFrontEnd(&joint, false);
+
+            // THEN
+            for (int i = 0; i < childJoints.size(); ++i) {
+                QCOMPARE(backendJoint.childJointIds()[i], childJoints[i]->id());
+            }
+        }
+    }
 };
 
 QTEST_APPLESS_MAIN(tst_Joint)
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/material/tst_material.cpp b/tests/auto/render/material/tst_material.cpp
index 9dfa0c246..e47eaea34 100644
--- a/tests/auto/render/material/tst_material.cpp
+++ b/tests/auto/render/material/tst_material.cpp
@@ -45,6 +45,7 @@ using namespace Qt3DRender::Render;
 class tst_RenderMaterial : public Qt3DCore::QBackendNodeTester
 {
     Q_OBJECT
+
 public:
     tst_RenderMaterial() {}
 
@@ -117,7 +118,7 @@ void tst_RenderMaterial::shouldHavePropertiesMirroringFromItsPeer()
 
     // GIVEN
     backend.setRenderer(&renderer);
-    simulateInitialization(frontendMaterial, &backend);
+    simulateInitializationSync(frontendMaterial, &backend);
 
     // THEN
     QVERIFY(backend.isEnabled() == frontendMaterial->isEnabled());
@@ -136,15 +137,17 @@ void tst_RenderMaterial::shouldHavePropertiesMirroringFromItsPeer()
 void tst_RenderMaterial::shouldHandleParametersPropertyChange()
 {
     // GIVEN
-    QScopedPointer<QParameter> parameter(new QParameter());
+    QParameter *parameter = new QParameter();
     Material backend;
     TestRenderer renderer;
     backend.setRenderer(&renderer);
 
+    QMaterial material;
+    simulateInitializationSync(&material, &backend);
+
     // WHEN
-    const auto addChange = Qt3DCore::QPropertyNodeAddedChangePtr::create(Qt3DCore::QNodeId(), parameter.data());
-    addChange->setPropertyName("parameter");
-    backend.sceneChangeEvent(addChange);
+    material.addParameter(parameter);
+    backend.syncFromFrontEnd(&material, false);
 
     // THEN
     QCOMPARE(backend.parameters().count(), 1);
@@ -152,9 +155,8 @@ void tst_RenderMaterial::shouldHandleParametersPropertyChange()
     QVERIFY(renderer.dirtyBits() != 0);
 
     // WHEN
-    const auto removeChange = Qt3DCore::QPropertyNodeRemovedChangePtr::create(Qt3DCore::QNodeId(), parameter.data());
-    removeChange->setPropertyName("parameter");
-    backend.sceneChangeEvent(removeChange);
+    material.removeParameter(parameter);
+    backend.syncFromFrontEnd(&material, false);
 
     // THEN
     QVERIFY(backend.parameters().isEmpty());
@@ -167,24 +169,23 @@ void tst_RenderMaterial::shouldHandleEnablePropertyChange()
     TestRenderer renderer;
     backend.setRenderer(&renderer);
 
+    QMaterial material;
+    simulateInitializationSync(&material, &backend);
+
     // WHEN
-    auto updateChange = QPropertyUpdatedChangePtr::create(QNodeId());
-    updateChange->setValue(true);
-    updateChange->setPropertyName("enabled");
-    backend.sceneChangeEvent(updateChange);
+    material.setEnabled(false);
+    backend.syncFromFrontEnd(&material, false);
 
     // THEN
-    QVERIFY(backend.isEnabled());
+    QVERIFY(!backend.isEnabled());
     QVERIFY(renderer.dirtyBits() != 0);
 
     // WHEN
-    auto secondUpdateChange = QPropertyUpdatedChangePtr::create(QNodeId());
-    secondUpdateChange->setValue(false);
-    secondUpdateChange->setPropertyName("enabled");
-    backend.sceneChangeEvent(secondUpdateChange);
+    material.setEnabled(true);
+    backend.syncFromFrontEnd(&material, false);
 
     // THEN
-    QVERIFY(!backend.isEnabled());
+    QVERIFY(backend.isEnabled());
 
 }
 
@@ -195,15 +196,16 @@ void tst_RenderMaterial::shouldHandleEffectPropertyChange()
     TestRenderer renderer;
     backend.setRenderer(&renderer);
 
+    QMaterial material;
+    simulateInitializationSync(&material, &backend);
+
     // WHEN
-    QPropertyUpdatedChangePtr updateChange(new Qt3DCore::QPropertyUpdatedChange(Qt3DCore::QNodeId()));
-    Qt3DCore::QNodeId effectId = Qt3DCore::QNodeId::createId();
-    updateChange->setValue(QVariant::fromValue(effectId));
-    updateChange->setPropertyName("effect");
-    backend.sceneChangeEvent(updateChange);
+    QEffect effect;
+    material.setEffect(&effect);
+    backend.syncFromFrontEnd(&material, false);
 
     // THEN
-    QCOMPARE(backend.effect(), effectId);
+    QCOMPARE(backend.effect(), effect.id());
     QVERIFY(renderer.dirtyBits() != 0);
 }
 
diff --git a/tests/auto/render/materialparametergathererjob/tst_materialparametergathererjob.cpp b/tests/auto/render/materialparametergathererjob/tst_materialparametergathererjob.cpp
index c088cb84f..236faa8f0 100644
--- a/tests/auto/render/materialparametergathererjob/tst_materialparametergathererjob.cpp
+++ b/tests/auto/render/materialparametergathererjob/tst_materialparametergathererjob.cpp
@@ -76,7 +76,12 @@ public:
         });
 
         for (const auto node: nodes)
-            d_func()->createBackendNode(node);
+            d_func()->createBackendNode({
+                                            node->id(),
+                                            Qt3DCore::QNodePrivate::get(node)->m_typeInfo,
+                                            Qt3DCore::NodeTreeChange::Added,
+                                            node
+                                        });
 
         const auto handles = nodeManagers()->techniqueManager()->activeHandles();
         for (const auto &handle: handles) {
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/parameter/tst_parameter.cpp b/tests/auto/render/parameter/tst_parameter.cpp
index 3b83c1c82..44e7b7020 100644
--- a/tests/auto/render/parameter/tst_parameter.cpp
+++ b/tests/auto/render/parameter/tst_parameter.cpp
@@ -66,7 +66,7 @@ private Q_SLOTS:
 
         // WHEN
         backendParameter.setRenderer(&renderer);
-        simulateInitialization(&parameter, &backendParameter);
+        simulateInitializationSync(&parameter, &backendParameter);
         backendParameter.cleanup();
 
         // THEN
@@ -89,7 +89,7 @@ private Q_SLOTS:
             // WHEN
             Qt3DRender::Render::Parameter backendParameter;
             backendParameter.setRenderer(&renderer);
-            simulateInitialization(&parameter, &backendParameter);
+            simulateInitializationSync(&parameter, &backendParameter);
 
             // THEN
             QCOMPARE(backendParameter.isEnabled(), true);
@@ -105,7 +105,7 @@ private Q_SLOTS:
             Qt3DRender::Render::Parameter backendParameter;
             backendParameter.setRenderer(&renderer);
             parameter.setEnabled(false);
-            simulateInitialization(&parameter, &backendParameter);
+            simulateInitializationSync(&parameter, &backendParameter);
 
             // THEN
             QCOMPARE(backendParameter.peerId(), parameter.id());
@@ -121,13 +121,14 @@ private Q_SLOTS:
         TestRenderer renderer;
         backendParameter.setRenderer(&renderer);
 
+        Qt3DRender::QParameter parameter;
+        simulateInitializationSync(&parameter, &backendParameter);
+
         {
             // WHEN
             const bool newValue = false;
-            const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-            change->setPropertyName("enabled");
-            change->setValue(newValue);
-            backendParameter.sceneChangeEvent(change);
+            parameter.setEnabled(newValue);
+            backendParameter.syncFromFrontEnd(&parameter, false);
 
             // THEN
             QCOMPARE(backendParameter.isEnabled(), newValue);
@@ -137,10 +138,8 @@ private Q_SLOTS:
         {
             // WHEN
             const QString newValue = QStringLiteral("C7");
-            const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-            change->setPropertyName("name");
-            change->setValue(QVariant::fromValue(newValue));
-            backendParameter.sceneChangeEvent(change);
+            parameter.setName(newValue);
+            backendParameter.syncFromFrontEnd(&parameter, false);
 
             // THEN
             QCOMPARE(backendParameter.name(), newValue);
@@ -152,10 +151,8 @@ private Q_SLOTS:
             // WHEN
             const QVariant value = QVariant::fromValue(QVector3D(350.0f, 427.0f, 454.0f));
             const Qt3DRender::Render::UniformValue newValue = Qt3DRender::Render::UniformValue::fromVariant(value);
-            const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-            change->setPropertyName("value");
-            change->setValue(value);
-            backendParameter.sceneChangeEvent(change);
+            parameter.setValue(value);
+            backendParameter.syncFromFrontEnd(&parameter, false);
 
             // THEN
             QCOMPARE(backendParameter.uniformValue(), newValue);
diff --git a/tests/auto/render/pickboundingvolumejob/tst_pickboundingvolumejob.cpp b/tests/auto/render/pickboundingvolumejob/tst_pickboundingvolumejob.cpp
index a6b09d179..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>
@@ -91,6 +90,23 @@ QVector<Qt3DCore::QNode *> getNodesForCreation(Qt3DCore::QNode *root)
     return nodes;
 }
 
+QVector<Qt3DCore::NodeTreeChange> nodeTreeChangesForNodes(const QVector<Qt3DCore::QNode *> nodes)
+{
+    QVector<Qt3DCore::NodeTreeChange> nodeTreeChanges;
+    nodeTreeChanges.reserve(nodes.size());
+
+    for (Qt3DCore::QNode *n : nodes) {
+        nodeTreeChanges.push_back({
+                                      n->id(),
+                                      Qt3DCore::QNodePrivate::get(n)->m_typeInfo,
+                                      Qt3DCore::NodeTreeChange::Added,
+                                      n
+                                  });
+    }
+
+    return nodeTreeChanges;
+}
+
 class TestAspect : public Qt3DRender::QRenderAspect
 {
 public:
@@ -101,7 +117,7 @@ public:
         QRenderAspect::onRegistered();
 
         const QVector<Qt3DCore::QNode *> nodes = getNodesForCreation(root);
-        d_func()->setRootAndCreateNodes(qobject_cast<Qt3DCore::QEntity *>(root), nodes);
+        d_func()->setRootAndCreateNodes(qobject_cast<Qt3DCore::QEntity *>(root), nodeTreeChangesForNodes(nodes));
 
         Render::Entity *rootEntity = nodeManagers()->lookupResource<Render::Entity, Render::EntityManager>(rootEntityId());
         Q_ASSERT(rootEntity);
@@ -133,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/qabstracttexture/tst_qabstracttexture.cpp b/tests/auto/render/qabstracttexture/tst_qabstracttexture.cpp
index 04364e2d9..6db8d20f5 100644
--- a/tests/auto/render/qabstracttexture/tst_qabstracttexture.cpp
+++ b/tests/auto/render/qabstracttexture/tst_qabstracttexture.cpp
@@ -37,6 +37,7 @@
 #include <Qt3DCore/qpropertynodeaddedchange.h>
 #include <Qt3DCore/qpropertynoderemovedchange.h>
 #include <Qt3DCore/private/qnodecreatedchangegenerator_p.h>
+#include <Qt3DCore/private/qnodevisitor_p.h>
 #include <Qt3DCore/qnodecreatedchange.h>
 #include "testpostmanarbiter.h"
 
@@ -1099,28 +1100,6 @@ private Q_SLOTS:
     {
         {
             // GIVEN
-            FakeTexture abstractTexture;
-            Qt3DRender::QTextureDataUpdate update;
-
-            // WHEN
-            abstractTexture.updateData(update);
-
-            // THEN (no arbiter -> should be stored in the initial changes)
-            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&abstractTexture);
-            const QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges = creationChangeGenerator.creationChanges();
-
-            QCOMPARE(creationChanges.size(), 1);
-            const auto typedChange = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DRender::QAbstractTextureData>>(creationChanges.first());
-
-            QVERIFY(typedChange);
-            const Qt3DRender::QAbstractTextureData data = typedChange->data;
-
-            QCOMPARE(data.initialDataUpdates.size(), 1);
-            QVERIFY(data.initialDataUpdates.contains(update));
-        }
-
-        {
-            // GIVEN
             TestArbiter arbiter;
             FakeTexture abstractTexture;
             Qt3DRender::QTextureDataUpdate update;
@@ -1131,23 +1110,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN (arbiter -> should not be stored in the initial changes but only send as a property change)
-            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&abstractTexture);
-            const QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges = creationChangeGenerator.creationChanges();
-
-            QCOMPARE(creationChanges.size(), 1);
-            const auto typedChange = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DRender::QAbstractTextureData>>(creationChanges.first());
-
-            QVERIFY(typedChange);
-            const Qt3DRender::QAbstractTextureData data = typedChange->data;
-
-            QCOMPARE(data.initialDataUpdates.size(), 0);
-
-            // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "updateData");
-            QCOMPARE(change->value().value<Qt3DRender::QTextureDataUpdate>(), update);
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            auto d = static_cast<Qt3DRender::QAbstractTexturePrivate*>(Qt3DRender::QAbstractTexturePrivate::get(&abstractTexture));
+            QCOMPARE(d->m_pendingDataUpdates.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &abstractTexture);
         }
     }
 
diff --git a/tests/auto/render/qbuffer/tst_qbuffer.cpp b/tests/auto/render/qbuffer/tst_qbuffer.cpp
index 8a9a25408..94c0a49cb 100644
--- a/tests/auto/render/qbuffer/tst_qbuffer.cpp
+++ b/tests/auto/render/qbuffer/tst_qbuffer.cpp
@@ -154,12 +154,10 @@ private Q_SLOTS:
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "dataGenerator");
-        QCOMPARE(change->value().value<Qt3DRender::QBufferDataGeneratorPtr>(), functor);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), buffer.data());
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
 
         // WHEN
         buffer->setSyncData(true);
@@ -176,13 +174,8 @@ private Q_SLOTS:
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        QCOMPARE(buffer->data(), QByteArrayLiteral("ZL1"));
-        change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "updateData");
-        Qt3DRender::QBufferUpdate updateData = change->value().value<Qt3DRender::QBufferUpdate>();
-        QCOMPARE(updateData.offset, 1);
-        QCOMPARE(updateData.data, QByteArrayLiteral("L1"));
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), buffer.data());
     }
 };
 
diff --git a/tests/auto/render/qcamera/tst_qcamera.cpp b/tests/auto/render/qcamera/tst_qcamera.cpp
index 214305e53..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>
@@ -80,6 +79,23 @@ QVector<Qt3DCore::QNode *> getNodesForCreation(Qt3DCore::QNode *root)
     return nodes;
 }
 
+QVector<Qt3DCore::NodeTreeChange> nodeTreeChangesForNodes(const QVector<Qt3DCore::QNode *> nodes)
+{
+    QVector<Qt3DCore::NodeTreeChange> nodeTreeChanges;
+    nodeTreeChanges.reserve(nodes.size());
+
+    for (Qt3DCore::QNode *n : nodes) {
+        nodeTreeChanges.push_back({
+                                      n->id(),
+                                      Qt3DCore::QNodePrivate::get(n)->m_typeInfo,
+                                      Qt3DCore::NodeTreeChange::Added,
+                                      n
+                                  });
+    }
+
+    return nodeTreeChanges;
+}
+
 class TestAspect : public Qt3DRender::QRenderAspect
 {
 public:
@@ -90,7 +106,7 @@ public:
         QRenderAspect::onRegistered();
 
         const QVector<Qt3DCore::QNode *> nodes = getNodesForCreation(root);
-        d_func()->setRootAndCreateNodes(qobject_cast<Qt3DCore::QEntity *>(root), nodes);
+        d_func()->setRootAndCreateNodes(qobject_cast<Qt3DCore::QEntity *>(root), nodeTreeChangesForNodes(nodes));
 
         Render::Entity *rootEntity = nodeManagers()->lookupResource<Render::Entity, Render::EntityManager>(rootEntityId());
         Q_ASSERT(rootEntity);
@@ -124,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/qeffect/tst_qeffect.cpp b/tests/auto/render/qeffect/tst_qeffect.cpp
index 7449fee2c..955b58a1e 100644
--- a/tests/auto/render/qeffect/tst_qeffect.cpp
+++ b/tests/auto/render/qeffect/tst_qeffect.cpp
@@ -217,13 +217,8 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyNodeAddedChange>();
-            QCOMPARE(change->propertyName(), "parameter");
-            QCOMPARE(change->addedNodeId(), parameter.id());
-            QCOMPARE(change->type(), Qt3DCore::PropertyValueAdded);
-
-            arbiter.events.clear();
+            QCOMPARE(arbiter.events.size(), 0);
+            QVERIFY(effect.parameters().contains(&parameter));
         }
 
         {
@@ -232,13 +227,8 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyNodeRemovedChange>();
-            QCOMPARE(change->propertyName(), "parameter");
-            QCOMPARE(change->removedNodeId(), parameter.id());
-            QCOMPARE(change->type(), Qt3DCore::PropertyValueRemoved);
-
-            arbiter.events.clear();
+            QCOMPARE(arbiter.events.size(), 0);
+            QVERIFY(!effect.parameters().contains(&parameter));
         }
 
     }
@@ -257,13 +247,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyNodeAddedChange>();
-            QCOMPARE(change->propertyName(), "technique");
-            QCOMPARE(change->addedNodeId(), technique.id());
-            QCOMPARE(change->type(), Qt3DCore::PropertyValueAdded);
-
-            arbiter.events.clear();
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &effect);
+            arbiter.dirtyNodes.clear();
         }
 
         {
@@ -272,13 +259,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyNodeRemovedChange>();
-            QCOMPARE(change->propertyName(), "technique");
-            QCOMPARE(change->removedNodeId(), technique.id());
-            QCOMPARE(change->type(), Qt3DCore::PropertyValueRemoved);
-
-            arbiter.events.clear();
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &effect);
+            arbiter.dirtyNodes.clear();
         }
 
     }
diff --git a/tests/auto/render/qgeometry/tst_qgeometry.cpp b/tests/auto/render/qgeometry/tst_qgeometry.cpp
index 55b7e752c..b82c53de1 100644
--- a/tests/auto/render/qgeometry/tst_qgeometry.cpp
+++ b/tests/auto/render/qgeometry/tst_qgeometry.cpp
@@ -130,13 +130,11 @@ private Q_SLOTS:
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        Qt3DCore::QPropertyNodeAddedChangePtr nodeAddedChange = arbiter.events.first().staticCast<Qt3DCore::QPropertyNodeAddedChange>();
-        QCOMPARE(nodeAddedChange->propertyName(), "attribute");
-        QCOMPARE(nodeAddedChange->addedNodeId(), attr.id());
-        QCOMPARE(nodeAddedChange->type(), Qt3DCore::PropertyValueAdded);
+        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), geometry.data());
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
 
         // WHEN
         geometry->addAttribute(&attr);
@@ -144,17 +142,16 @@ private Q_SLOTS:
 
         // THEN
         QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 0);
 
         // WHEN
         geometry->removeAttribute(&attr);
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        Qt3DCore::QPropertyNodeRemovedChangePtr nodeRemovedChange = arbiter.events.first().staticCast<Qt3DCore::QPropertyNodeRemovedChange>();
-        QCOMPARE(nodeRemovedChange->propertyName(), "attribute");
-        QCOMPARE(nodeRemovedChange->removedNodeId(), attr.id());
-        QCOMPARE(nodeRemovedChange->type(), Qt3DCore::PropertyValueRemoved);
+        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), geometry.data());
 
         arbiter.events.clear();
     }
diff --git a/tests/auto/render/qgeometryrenderer/tst_qgeometryrenderer.cpp b/tests/auto/render/qgeometryrenderer/tst_qgeometryrenderer.cpp
index 15cf98de0..b03d48663 100644
--- a/tests/auto/render/qgeometryrenderer/tst_qgeometryrenderer.cpp
+++ b/tests/auto/render/qgeometryrenderer/tst_qgeometryrenderer.cpp
@@ -262,13 +262,11 @@ private Q_SLOTS:
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "geometryFactory");
-        QCOMPARE(change->value().value<Qt3DRender::QGeometryFactoryPtr>(), factory);
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), geometryRenderer.data());
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
 
         // WHEN
         Qt3DRender::QGeometry geom;
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/qmaterial/tst_qmaterial.cpp b/tests/auto/render/qmaterial/tst_qmaterial.cpp
index 5b24c6127..501d50556 100644
--- a/tests/auto/render/qmaterial/tst_qmaterial.cpp
+++ b/tests/auto/render/qmaterial/tst_qmaterial.cpp
@@ -295,13 +295,9 @@ private Q_SLOTS:
         QCOMPARE(param->parent(), material);
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        Qt3DCore::QPropertyNodeAddedChangePtr change = arbiter.events.first().staticCast<Qt3DCore::QPropertyNodeAddedChange>();
-        QCOMPARE(change->propertyName(), "parameter");
-        QCOMPARE(change->addedNodeId(), param->id());
-        QCOMPARE(change->type(), Qt3DCore::PropertyValueAdded);
-
-        arbiter.events.clear();
+        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QVERIFY(material->parameters().contains(param));
 
         // WHEN (add parameter to effect)
         param = new Qt3DRender::QParameter("testParamEffect", QVariant::fromValue(383.0f));
@@ -309,13 +305,9 @@ private Q_SLOTS:
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        change = arbiter.events.first().staticCast<Qt3DCore::QPropertyNodeAddedChange>();
-        QCOMPARE(change->propertyName(), "parameter");
-        QCOMPARE(change->addedNodeId(), param->id());
-        QCOMPARE(change->type(), Qt3DCore::PropertyValueAdded);
-
-        arbiter.events.clear();
+        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 2);
+        QVERIFY(material->effect()->parameters().contains(param));
 
         // WHEN (add parameter to technique)
         param = new Qt3DRender::QParameter("testParamTechnique", QVariant::fromValue(383.0f));
@@ -323,13 +315,10 @@ private Q_SLOTS:
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        change = arbiter.events.first().staticCast<Qt3DCore::QPropertyNodeAddedChange>();
-        QCOMPARE(change->propertyName(), "parameter");
-        QCOMPARE(change->addedNodeId(), param->id());
-        QCOMPARE(change->type(), Qt3DCore::PropertyValueAdded);
+        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 3);
+        QVERIFY(material->m_technique->parameters().contains(param));
 
-        arbiter.events.clear();
 
         // WHEN (add parameter to renderpass)
         param = new Qt3DRender::QParameter("testParamRenderPass", QVariant::fromValue(383.0f));
@@ -337,13 +326,9 @@ private Q_SLOTS:
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        change = arbiter.events.first().staticCast<Qt3DCore::QPropertyNodeAddedChange>();
-        QCOMPARE(change->propertyName(), "parameter");
-        QCOMPARE(change->addedNodeId(), param->id());
-        QCOMPARE(change->type(), Qt3DCore::PropertyValueAdded);
-
-        arbiter.events.clear();
+        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 4);
+        QVERIFY(material->m_renderPass->parameters().contains(param));
     }
 
     void checkShaderProgramUpdates()
diff --git a/tests/auto/render/qmesh/tst_qmesh.cpp b/tests/auto/render/qmesh/tst_qmesh.cpp
index fbc566395..49679e29e 100644
--- a/tests/auto/render/qmesh/tst_qmesh.cpp
+++ b/tests/auto/render/qmesh/tst_qmesh.cpp
@@ -186,18 +186,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.last().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "geometryFactory");
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
-
-            Qt3DRender::QGeometryFactoryPtr factory = change->value().value<Qt3DRender::QGeometryFactoryPtr>();
-            QSharedPointer<Qt3DRender::MeshLoaderFunctor> meshFunctor = qSharedPointerCast<Qt3DRender::MeshLoaderFunctor>(factory);
-            QVERIFY(meshFunctor != nullptr);
-            QCOMPARE(meshFunctor->mesh(), mesh.id());
-            QCOMPARE(meshFunctor->sourcePath(), mesh.source());
-
-            arbiter.events.clear();
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &mesh);
+
+            arbiter.dirtyNodes.clear();
         }
 
         {
@@ -206,7 +198,7 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
     }
@@ -231,18 +223,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "geometryFactory");
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
-
-            Qt3DRender::QGeometryFactoryPtr factory = change->value().value<Qt3DRender::QGeometryFactoryPtr>();
-            QSharedPointer<Qt3DRender::MeshLoaderFunctor> meshFunctor = qSharedPointerCast<Qt3DRender::MeshLoaderFunctor>(factory);
-            QVERIFY(meshFunctor != nullptr);
-            QCOMPARE(meshFunctor->mesh(), mesh.id());
-            QCOMPARE(meshFunctor->meshName(), mesh.meshName());
-
-            arbiter.events.clear();
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &mesh);
+
+            arbiter.dirtyNodes.clear();
         }
 
         {
@@ -251,7 +235,7 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
     }
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/qrenderpass/tst_qrenderpass.cpp b/tests/auto/render/qrenderpass/tst_qrenderpass.cpp
index 38b66de94..ce9c6581b 100644
--- a/tests/auto/render/qrenderpass/tst_qrenderpass.cpp
+++ b/tests/auto/render/qrenderpass/tst_qrenderpass.cpp
@@ -338,11 +338,9 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyNodeAddedChange>();
-            QCOMPARE(change->propertyName(), "filterKeys");
-            QCOMPARE(change->addedNodeId(), filterKey.id());
-            QCOMPARE(change->type(), Qt3DCore::PropertyValueAdded);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &renderPass);
 
             arbiter.events.clear();
         }
@@ -353,11 +351,9 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyNodeRemovedChange>();
-            QCOMPARE(change->propertyName(), "filterKeys");
-            QCOMPARE(change->removedNodeId(), filterKey.id());
-            QCOMPARE(change->type(), Qt3DCore::PropertyValueRemoved);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &renderPass);
 
             arbiter.events.clear();
         }
@@ -378,11 +374,9 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyNodeAddedChange>();
-            QCOMPARE(change->propertyName(), "renderState");
-            QCOMPARE(change->addedNodeId(), renderState.id());
-            QCOMPARE(change->type(), Qt3DCore::PropertyValueAdded);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &renderPass);
 
             arbiter.events.clear();
         }
@@ -393,11 +387,9 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyNodeRemovedChange>();
-            QCOMPARE(change->propertyName(), "renderState");
-            QCOMPARE(change->removedNodeId(), renderState.id());
-            QCOMPARE(change->type(), Qt3DCore::PropertyValueRemoved);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &renderPass);
 
             arbiter.events.clear();
         }
@@ -418,11 +410,9 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyNodeAddedChange>();
-            QCOMPARE(change->propertyName(), "parameter");
-            QCOMPARE(change->addedNodeId(), parameter.id());
-            QCOMPARE(change->type(), Qt3DCore::PropertyValueAdded);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &renderPass);
 
             arbiter.events.clear();
         }
@@ -433,11 +423,9 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyNodeRemovedChange>();
-            QCOMPARE(change->propertyName(), "parameter");
-            QCOMPARE(change->removedNodeId(), parameter.id());
-            QCOMPARE(change->type(), Qt3DCore::PropertyValueRemoved);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &renderPass);
 
             arbiter.events.clear();
         }
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/qshaderprogram/tst_qshaderprogram.cpp b/tests/auto/render/qshaderprogram/tst_qshaderprogram.cpp
index 7865a5f65..a261d0860 100644
--- a/tests/auto/render/qshaderprogram/tst_qshaderprogram.cpp
+++ b/tests/auto/render/qshaderprogram/tst_qshaderprogram.cpp
@@ -470,6 +470,9 @@ private Q_SLOTS:
         QCOMPARE(spy.count(), 0);
         QCOMPARE(arbiter.events.size(), 0);
         QCOMPARE(log(), logValue);
+
+        // Cleanup
+        Qt3DCore::QNodePrivate::get(this)->setArbiter(nullptr);
     }
 
     void checkStatusPropertyUpdate()
@@ -503,6 +506,9 @@ private Q_SLOTS:
         QCOMPARE(spy.count(), 0);
         QCOMPARE(arbiter.events.size(), 0);
         QCOMPARE(status(), newStatus);
+
+        // Cleanup
+        Qt3DCore::QNodePrivate::get(this)->setArbiter(nullptr);
     }
 
     void checkIncludes()
diff --git a/tests/auto/render/qtechnique/tst_qtechnique.cpp b/tests/auto/render/qtechnique/tst_qtechnique.cpp
index 1026dddc0..1e7e4b440 100644
--- a/tests/auto/render/qtechnique/tst_qtechnique.cpp
+++ b/tests/auto/render/qtechnique/tst_qtechnique.cpp
@@ -329,28 +329,21 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyNodeAddedChange>();
-            QCOMPARE(change->propertyName(), "pass");
-            QCOMPARE(change->addedNodeId(), pass.id());
-            QCOMPARE(change->type(), Qt3DCore::PropertyValueAdded);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QVERIFY(arbiter.dirtyNodes.contains(&technique));
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
-
         {
             // WHEN
             technique.removeRenderPass(&pass);
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyNodeRemovedChange>();
-            QCOMPARE(change->propertyName(), "pass");
-            QCOMPARE(change->removedNodeId(), pass.id());
-            QCOMPARE(change->type(), Qt3DCore::PropertyValueRemoved);
-
-            arbiter.events.clear();
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QVERIFY(arbiter.dirtyNodes.contains(&technique));
         }
     }
 
@@ -368,13 +361,11 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyNodeAddedChange>();
-            QCOMPARE(change->propertyName(), "parameter");
-            QCOMPARE(change->addedNodeId(), parameter.id());
-            QCOMPARE(change->type(), Qt3DCore::PropertyValueAdded);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QVERIFY(arbiter.dirtyNodes.contains(&technique));
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
@@ -383,13 +374,11 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyNodeRemovedChange>();
-            QCOMPARE(change->propertyName(), "parameter");
-            QCOMPARE(change->removedNodeId(), parameter.id());
-            QCOMPARE(change->type(), Qt3DCore::PropertyValueRemoved);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QVERIFY(arbiter.dirtyNodes.contains(&technique));
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
     }
 
@@ -407,13 +396,11 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyNodeAddedChange>();
-            QCOMPARE(change->propertyName(), "filterKeys");
-            QCOMPARE(change->addedNodeId(), filterKey.id());
-            QCOMPARE(change->type(), Qt3DCore::PropertyValueAdded);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QVERIFY(arbiter.dirtyNodes.contains(&technique));
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
@@ -422,13 +409,11 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyNodeRemovedChange>();
-            QCOMPARE(change->propertyName(), "filterKeys");
-            QCOMPARE(change->removedNodeId(), filterKey.id());
-            QCOMPARE(change->type(), Qt3DCore::PropertyValueRemoved);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QVERIFY(arbiter.dirtyNodes.contains(&technique));
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
     }
 
@@ -445,14 +430,11 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "graphicsApiFilterData");
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
-            Qt3DRender::GraphicsApiFilterData data = change->value().value<Qt3DRender::GraphicsApiFilterData>();
-            QCOMPARE(data.m_major, 4);
-
-            arbiter.events.clear();
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QVERIFY(arbiter.dirtyNodes.contains(&technique));
+
+            arbiter.dirtyNodes.clear();
         }
         {
             // WHEN
@@ -460,14 +442,11 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "graphicsApiFilterData");
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
-            Qt3DRender::GraphicsApiFilterData data = change->value().value<Qt3DRender::GraphicsApiFilterData>();
-            QCOMPARE(data.m_minor, 5);
-
-            arbiter.events.clear();
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QVERIFY(arbiter.dirtyNodes.contains(&technique));
+
+            arbiter.dirtyNodes.clear();
         }
         {
             // WHEN
@@ -475,14 +454,11 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "graphicsApiFilterData");
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
-            Qt3DRender::GraphicsApiFilterData data = change->value().value<Qt3DRender::GraphicsApiFilterData>();
-            QCOMPARE(data.m_vendor, QStringLiteral("AMD"));
-
-            arbiter.events.clear();
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QVERIFY(arbiter.dirtyNodes.contains(&technique));
+
+            arbiter.dirtyNodes.clear();
         }
         {
             // WHEN
@@ -490,14 +466,11 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "graphicsApiFilterData");
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
-            Qt3DRender::GraphicsApiFilterData data = change->value().value<Qt3DRender::GraphicsApiFilterData>();
-            QCOMPARE(data.m_profile, Qt3DRender::QGraphicsApiFilter::CompatibilityProfile);
-
-            arbiter.events.clear();
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QVERIFY(arbiter.dirtyNodes.contains(&technique));
+
+            arbiter.dirtyNodes.clear();
         }
     }
 };
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/qtextureimage/tst_qtextureimage.cpp b/tests/auto/render/qtextureimage/tst_qtextureimage.cpp
index 224784011..8ea656c28 100644
--- a/tests/auto/render/qtextureimage/tst_qtextureimage.cpp
+++ b/tests/auto/render/qtextureimage/tst_qtextureimage.cpp
@@ -174,14 +174,8 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "dataGenerator");
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
-
-            const auto generator = qSharedPointerCast<Qt3DRender::QImageTextureDataFunctor>(change->value().value<Qt3DRender::QTextureImageDataGeneratorPtr>());
-            QVERIFY(generator);
-            QCOMPARE(generator->url(), textureImage.source());
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &textureImage);
 
             arbiter.events.clear();
         }
@@ -210,14 +204,8 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "dataGenerator");
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
-
-            const auto generator = qSharedPointerCast<Qt3DRender::QImageTextureDataFunctor>(change->value().value<Qt3DRender::QTextureImageDataGeneratorPtr>());
-            QVERIFY(generator);
-            QCOMPARE(generator->isMirrored(), textureImage.isMirrored());
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &textureImage);
 
             arbiter.events.clear();
         }
diff --git a/tests/auto/render/qtextureloader/tst_qtextureloader.cpp b/tests/auto/render/qtextureloader/tst_qtextureloader.cpp
index 56ad55adf..eebbf5d41 100644
--- a/tests/auto/render/qtextureloader/tst_qtextureloader.cpp
+++ b/tests/auto/render/qtextureloader/tst_qtextureloader.cpp
@@ -168,16 +168,14 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            const auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "generator");
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &textureLoader);
 
-            const auto generator = qSharedPointerCast<Qt3DRender::QTextureFromSourceGenerator>(change->value().value<Qt3DRender::QTextureGeneratorPtr>());
+            Qt3DRender::QAbstractTexturePrivate *d = dynamic_cast<Qt3DRender::QAbstractTexturePrivate *>(Qt3DRender::QAbstractTexturePrivate::get(&textureLoader));
+            const auto generator = qSharedPointerCast<Qt3DRender::QTextureFromSourceGenerator>(d->dataFunctor());
             QVERIFY(generator);
             QCOMPARE(generator->url(), QUrl(QStringLiteral("Gary")));
 
-
             arbiter.events.clear();
         }
 
@@ -205,16 +203,15 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            const auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "generator");
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &textureLoader);
 
-            const auto generator = qSharedPointerCast<Qt3DRender::QTextureFromSourceGenerator>(change->value().value<Qt3DRender::QTextureGeneratorPtr>());
+            Qt3DRender::QAbstractTexturePrivate *d = dynamic_cast<Qt3DRender::QAbstractTexturePrivate *>(Qt3DRender::QAbstractTexturePrivate::get(&textureLoader));
+            const auto generator = qSharedPointerCast<Qt3DRender::QTextureFromSourceGenerator>(d->dataFunctor());
             QVERIFY(generator);
             QCOMPARE(generator->isMirrored(), false);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
@@ -223,7 +220,7 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
     }
diff --git a/tests/auto/render/raycastingjob/tst_raycastingjob.cpp b/tests/auto/render/raycastingjob/tst_raycastingjob.cpp
index d44596abc..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>
@@ -88,6 +87,23 @@ QVector<Qt3DCore::QNode *> getNodesForCreation(Qt3DCore::QNode *root)
     return nodes;
 }
 
+QVector<Qt3DCore::NodeTreeChange> nodeTreeChangesForNodes(const QVector<Qt3DCore::QNode *> nodes)
+{
+    QVector<Qt3DCore::NodeTreeChange> nodeTreeChanges;
+    nodeTreeChanges.reserve(nodes.size());
+
+    for (Qt3DCore::QNode *n : nodes) {
+        nodeTreeChanges.push_back({
+                                      n->id(),
+                                      Qt3DCore::QNodePrivate::get(n)->m_typeInfo,
+                                      Qt3DCore::NodeTreeChange::Added,
+                                      n
+                                  });
+    }
+
+    return nodeTreeChanges;
+}
+
 class TestAspect : public Qt3DRender::QRenderAspect
 {
 public:
@@ -98,7 +114,7 @@ public:
         QRenderAspect::onRegistered();
 
         const QVector<Qt3DCore::QNode *> nodes = getNodesForCreation(root);
-        d_func()->setRootAndCreateNodes(qobject_cast<Qt3DCore::QEntity *>(root), nodes);
+        d_func()->setRootAndCreateNodes(qobject_cast<Qt3DCore::QEntity *>(root), nodeTreeChangesForNodes(nodes));
 
         Render::Entity *rootEntity = nodeManagers()->lookupResource<Render::Entity, Render::EntityManager>(rootEntityId());
         Q_ASSERT(rootEntity);
@@ -130,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/renderpass/tst_renderpass.cpp b/tests/auto/render/renderpass/tst_renderpass.cpp
index a4a2762ba..7be741936 100644
--- a/tests/auto/render/renderpass/tst_renderpass.cpp
+++ b/tests/auto/render/renderpass/tst_renderpass.cpp
@@ -70,6 +70,7 @@ using namespace Qt3DRender::Render;
 class tst_RenderRenderPass : public Qt3DCore::QBackendNodeTester
 {
     Q_OBJECT
+
 public:
     tst_RenderRenderPass()
         : m_renderStateManager(new RenderStateManager())
@@ -96,6 +97,8 @@ private slots:
     {
         // GIVEN
         RenderPass backend;
+        TestRenderer renderer;
+        backend.setRenderer(&renderer);
 
         // WHEN
         backend.setEnabled(true);
@@ -112,7 +115,7 @@ private slots:
             frontend.addRenderState(&state);
             frontend.setShaderProgram(&program);
 
-            simulateInitialization(&frontend, &backend);
+            simulateInitializationSync(&frontend, &backend);
         }
 
         backend.cleanup();
@@ -141,12 +144,14 @@ private slots:
         frontend.addRenderState(frontendState);
 
         RenderPass backend;
+        TestRenderer renderer;
+        backend.setRenderer(&renderer);
 
         RenderStateNode *backendState = m_renderStateManager->getOrCreateResource(frontendState->id());
-        simulateInitialization(frontendState, backendState);
+        simulateInitializationSync(frontendState, backendState);
 
         // WHEN
-        simulateInitialization(&frontend, &backend);
+        simulateInitializationSync(&frontend, &backend);
 
         // THEN
         QCOMPARE(backend.shaderProgram(), frontend.shaderProgram()->id());
@@ -165,25 +170,26 @@ private slots:
     void shouldHandleShaderPropertyChangeEvents()
     {
         // GIVEN
-        QScopedPointer<QShaderProgram> shader(new QShaderProgram);
+        QShaderProgram *shader = new QShaderProgram;
 
         RenderPass backend;
         TestRenderer renderer;
         backend.setRenderer(&renderer);
 
+        QRenderPass frontend;
+        simulateInitializationSync(&frontend, &backend);
+
         // WHEN
-        const auto addChange = Qt3DCore::QPropertyNodeAddedChangePtr::create(Qt3DCore::QNodeId(), shader.data());
-        addChange->setPropertyName("shaderProgram");
-        backend.sceneChangeEvent(addChange);
+        frontend.setShaderProgram(shader);
+        backend.syncFromFrontEnd(&frontend, false);
 
         // THEN
         QCOMPARE(backend.shaderProgram(), shader->id());
         QVERIFY(renderer.dirtyBits() != 0);
 
         // WHEN
-        const auto removeChange = Qt3DCore::QPropertyNodeRemovedChangePtr::create(Qt3DCore::QNodeId(), shader.data());
-        removeChange->setPropertyName("shaderProgram");
-        backend.sceneChangeEvent(removeChange);
+        frontend.setShaderProgram(nullptr);
+        backend.syncFromFrontEnd(&frontend, false);
 
         // THEN
         QVERIFY(backend.shaderProgram().isNull());
@@ -192,16 +198,18 @@ private slots:
     void shouldHandleAnnotationsPropertyChangeEvents()
     {
         // GIVEN
-        QScopedPointer<QFilterKey> annotation(new QFilterKey);
+        QFilterKey *annotation = new QFilterKey;
 
         RenderPass backend;
         TestRenderer renderer;
         backend.setRenderer(&renderer);
 
+        QRenderPass frontend;
+        simulateInitializationSync(&frontend, &backend);
+
         // WHEN
-        const auto addChange = Qt3DCore::QPropertyNodeAddedChangePtr::create(Qt3DCore::QNodeId(), annotation.data());
-        addChange->setPropertyName("filterKeys");
-        backend.sceneChangeEvent(addChange);
+        frontend.addFilterKey(annotation);
+        backend.syncFromFrontEnd(&frontend, false);
 
         // THEN
         QCOMPARE(backend.filterKeys().size(), 1);
@@ -209,9 +217,8 @@ private slots:
         QVERIFY(renderer.dirtyBits() != 0);
 
         // WHEN
-        const auto removeChange = Qt3DCore::QPropertyNodeRemovedChangePtr::create(Qt3DCore::QNodeId(), annotation.data());
-        removeChange->setPropertyName("filterKeys");
-        backend.sceneChangeEvent(removeChange);
+        frontend.removeFilterKey(annotation);
+        backend.syncFromFrontEnd(&frontend, false);
 
         // THEN
         QVERIFY(backend.filterKeys().isEmpty());
@@ -220,16 +227,18 @@ private slots:
     void shouldHandleParametersPropertyChangeEvents()
     {
         // GIVEN
-        QScopedPointer<QParameter> parameter(new QParameter);
+        QParameter *parameter = new QParameter;
 
         RenderPass backend;
         TestRenderer renderer;
         backend.setRenderer(&renderer);
 
+        QRenderPass frontend;
+        simulateInitializationSync(&frontend, &backend);
+
         // WHEN
-        const auto addChange = Qt3DCore::QPropertyNodeAddedChangePtr::create(Qt3DCore::QNodeId(), parameter.data());
-        addChange->setPropertyName("parameter");
-        backend.sceneChangeEvent(addChange);
+        frontend.addParameter(parameter);
+        backend.syncFromFrontEnd(&frontend, false);
 
         // THEN
         QCOMPARE(backend.parameters().size(), 1);
@@ -237,9 +246,8 @@ private slots:
         QVERIFY(renderer.dirtyBits() != 0);
 
         // WHEN
-        const auto removeChange = Qt3DCore::QPropertyNodeRemovedChangePtr::create(Qt3DCore::QNodeId(), parameter.data());
-        removeChange->setPropertyName("parameter");
-        backend.sceneChangeEvent(removeChange);
+        frontend.removeParameter(parameter);
+        backend.syncFromFrontEnd(&frontend, false);
 
         // THEN
         QVERIFY(backend.parameters().isEmpty());
@@ -254,12 +262,14 @@ private slots:
         backend.setRenderer(&renderer);
 
         RenderStateNode *backendState = m_renderStateManager->getOrCreateResource(frontendState->id());
-        simulateInitialization(frontendState, backendState);
+        simulateInitializationSync(frontendState, backendState);
+
+        QRenderPass frontend;
+        simulateInitializationSync(&frontend, &backend);
 
         // WHEN
-        const auto addChange = Qt3DCore::QPropertyNodeAddedChangePtr::create(Qt3DCore::QNodeId(), frontendState);
-        addChange->setPropertyName("renderState");
-        backend.sceneChangeEvent(addChange);
+        frontend.addRenderState(frontendState);
+        backend.syncFromFrontEnd(&frontend, false);
 
         // THEN
         QCOMPARE(backend.renderStates().size(), 1);
@@ -267,32 +277,13 @@ private slots:
         QVERIFY(renderer.dirtyBits() != 0);
 
         // WHEN
-        const auto removeChange = Qt3DCore::QPropertyNodeRemovedChangePtr::create(Qt3DCore::QNodeId(), frontendState);
-        removeChange->setPropertyName("renderState");
-        backend.sceneChangeEvent(removeChange);
+        frontend.removeRenderState(frontendState);
+        backend.syncFromFrontEnd(&frontend, false);
 
         // THEN
         QVERIFY(backend.renderStates().isEmpty());
     }
 
-    void shouldHandleShaderProgramPropertyChangeEvents()
-    {
-        // GIVEN
-        RenderPass backend;
-        TestRenderer renderer;
-        backend.setRenderer(&renderer);
-
-        // WHEN
-        Qt3DCore::QNodeId shaderId = Qt3DCore::QNodeId::createId();
-        const auto shaderChange = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-        shaderChange->setPropertyName("shaderProgram");
-        shaderChange->setValue(QVariant::fromValue(shaderId));
-        backend.sceneChangeEvent(shaderChange);
-
-        // THEN
-        QCOMPARE(backend.shaderProgram(), shaderId);
-    }
-
 private:
     RenderStateManager *m_renderStateManager;
 };
diff --git a/tests/auto/render/renderviewbuilder/tst_renderviewbuilder.cpp b/tests/auto/render/renderviewbuilder/tst_renderviewbuilder.cpp
index 18c3b3f36..22a461e4a 100644
--- a/tests/auto/render/renderviewbuilder/tst_renderviewbuilder.cpp
+++ b/tests/auto/render/renderviewbuilder/tst_renderviewbuilder.cpp
@@ -78,7 +78,12 @@ public:
         });
 
         for (const auto node: nodes)
-            d_func()->createBackendNode(node);
+            d_func()->createBackendNode({
+                                            node->id(),
+                                            Qt3DCore::QNodePrivate::get(node)->m_typeInfo,
+                                            Qt3DCore::NodeTreeChange::Added,
+                                            node
+                                        });
     }
 
     ~TestAspect()
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/scene2d/tst_scene2d.cpp b/tests/auto/render/scene2d/tst_scene2d.cpp
index c30400202..f620064ed 100644
--- a/tests/auto/render/scene2d/tst_scene2d.cpp
+++ b/tests/auto/render/scene2d/tst_scene2d.cpp
@@ -276,7 +276,7 @@ private Q_SLOTS:
         Buffer *backendBuffer = nodeManagers->bufferManager()->getOrCreateResource(dataBuffer->id());
         backendBuffer->setRenderer(&renderer);
         backendBuffer->setManager(nodeManagers->bufferManager());
-        simulateInitialization(dataBuffer, backendBuffer);
+        simulateInitializationSync(dataBuffer, backendBuffer);
 
         positionAttribute->setBuffer(dataBuffer);
         positionAttribute->setName(Qt3DRender::QAttribute::defaultPositionAttributeName());
@@ -304,28 +304,28 @@ private Q_SLOTS:
         Attribute *backendAttribute = nodeManagers->attributeManager()->getOrCreateResource(
                                         positionAttribute->id());
         backendAttribute->setRenderer(&renderer);
-        simulateInitialization(positionAttribute, backendAttribute);
+        simulateInitializationSync(positionAttribute, backendAttribute);
 
         Attribute *backendTexcoordAttribute = nodeManagers->attributeManager()
                                               ->getOrCreateResource(texcoordAttribute->id());
         backendTexcoordAttribute->setRenderer(&renderer);
-        simulateInitialization(texcoordAttribute, backendTexcoordAttribute);
+        simulateInitializationSync(texcoordAttribute, backendTexcoordAttribute);
 
         Geometry *backendGeometry = nodeManagers->geometryManager()
                                     ->getOrCreateResource(geometry->id());
         backendGeometry->setRenderer(&renderer);
-        simulateInitialization(geometry, backendGeometry);
+        simulateInitializationSync(geometry, backendGeometry);
 
         GeometryRenderer *backendRenderer = nodeManagers->geometryRendererManager()
                                             ->getOrCreateResource(geometryRenderer->id());
         backendRenderer->setRenderer(&renderer);
         backendRenderer->setManager(nodeManagers->geometryRendererManager());
-        simulateInitialization(geometryRenderer, backendRenderer);
+        simulateInitializationSync(geometryRenderer, backendRenderer);
 
         Entity *backendEntity = nodeManagers->renderNodesManager()->getOrCreateResource(entity->id());
         backendEntity->setRenderer(&renderer);
         backendEntity->setNodeManagers(nodeManagers.data());
-        simulateInitialization(entity.data(), backendEntity);
+        simulateInitializationSync(entity.data(), backendEntity);
 
 #define PICK_TRIANGLE(tri, v0, v1, v2, uvw)     \
     new Qt3DRender::QPickTriangleEvent(QPointF(), QVector3D(), QVector3D(), 0.0f,   \
diff --git a/tests/auto/render/segmentvisitor/tst_segmentvisitor.cpp b/tests/auto/render/segmentvisitor/tst_segmentvisitor.cpp
index da420e1ac..4db12136a 100644
--- a/tests/auto/render/segmentvisitor/tst_segmentvisitor.cpp
+++ b/tests/auto/render/segmentvisitor/tst_segmentvisitor.cpp
@@ -185,7 +185,7 @@ private Q_SLOTS:
         Buffer *backendBuffer = nodeManagers->bufferManager()->getOrCreateResource(dataBuffer->id());
         backendBuffer->setRenderer(&renderer);
         backendBuffer->setManager(nodeManagers->bufferManager());
-        simulateInitialization(dataBuffer.data(), backendBuffer);
+        simulateInitializationSync(dataBuffer.data(), backendBuffer);
 
         positionAttribute->setBuffer(dataBuffer.data());
         positionAttribute->setName(Qt3DRender::QAttribute::defaultPositionAttributeName());
@@ -202,16 +202,16 @@ private Q_SLOTS:
 
         Attribute *backendAttribute = nodeManagers->attributeManager()->getOrCreateResource(positionAttribute->id());
         backendAttribute->setRenderer(&renderer);
-        simulateInitialization(positionAttribute.data(), backendAttribute);
+        simulateInitializationSync(positionAttribute.data(), backendAttribute);
 
         Geometry *backendGeometry = nodeManagers->geometryManager()->getOrCreateResource(geometry->id());
         backendGeometry->setRenderer(&renderer);
-        simulateInitialization(geometry, backendGeometry);
+        simulateInitializationSync(geometry, backendGeometry);
 
         GeometryRenderer *backendRenderer = nodeManagers->geometryRendererManager()->getOrCreateResource(geometryRenderer->id());
         backendRenderer->setRenderer(&renderer);
         backendRenderer->setManager(nodeManagers->geometryRendererManager());
-        simulateInitialization(geometryRenderer.data(), backendRenderer);
+        simulateInitializationSync(geometryRenderer.data(), backendRenderer);
 
         // WHEN
         visitor.apply(backendRenderer, Qt3DCore::QNodeId());
@@ -254,7 +254,7 @@ private Q_SLOTS:
         Buffer *backendBuffer = nodeManagers->bufferManager()->getOrCreateResource(dataBuffer->id());
         backendBuffer->setRenderer(&renderer);
         backendBuffer->setManager(nodeManagers->bufferManager());
-        simulateInitialization(dataBuffer.data(), backendBuffer);
+        simulateInitializationSync(dataBuffer.data(), backendBuffer);
 
         QByteArray indexData;
         indexData.resize(sizeof(uint) * 2 * 5);
@@ -274,7 +274,7 @@ private Q_SLOTS:
         Buffer *backendIndexBuffer = nodeManagers->bufferManager()->getOrCreateResource(indexDataBuffer->id());
         backendIndexBuffer->setRenderer(&renderer);
         backendIndexBuffer->setManager(nodeManagers->bufferManager());
-        simulateInitialization(indexDataBuffer.data(), backendIndexBuffer);
+        simulateInitializationSync(indexDataBuffer.data(), backendIndexBuffer);
 
         positionAttribute->setBuffer(dataBuffer.data());
         positionAttribute->setName(Qt3DRender::QAttribute::defaultPositionAttributeName());
@@ -298,20 +298,20 @@ private Q_SLOTS:
 
         Attribute *backendAttribute = nodeManagers->attributeManager()->getOrCreateResource(positionAttribute->id());
         backendAttribute->setRenderer(&renderer);
-        simulateInitialization(positionAttribute.data(), backendAttribute);
+        simulateInitializationSync(positionAttribute.data(), backendAttribute);
 
         Attribute *backendIndexAttribute = nodeManagers->attributeManager()->getOrCreateResource(indexAttribute->id());
         backendIndexAttribute->setRenderer(&renderer);
-        simulateInitialization(indexAttribute.data(), backendIndexAttribute);
+        simulateInitializationSync(indexAttribute.data(), backendIndexAttribute);
 
         Geometry *backendGeometry = nodeManagers->geometryManager()->getOrCreateResource(geometry->id());
         backendGeometry->setRenderer(&renderer);
-        simulateInitialization(geometry, backendGeometry);
+        simulateInitializationSync(geometry, backendGeometry);
 
         GeometryRenderer *backendRenderer = nodeManagers->geometryRendererManager()->getOrCreateResource(geometryRenderer->id());
         backendRenderer->setRenderer(&renderer);
         backendRenderer->setManager(nodeManagers->geometryRendererManager());
-        simulateInitialization(geometryRenderer.data(), backendRenderer);
+        simulateInitializationSync(geometryRenderer.data(), backendRenderer);
 
         // WHEN
         visitor.apply(backendRenderer, Qt3DCore::QNodeId());
@@ -354,7 +354,7 @@ private Q_SLOTS:
         Buffer *backendBuffer = nodeManagers->bufferManager()->getOrCreateResource(dataBuffer->id());
         backendBuffer->setRenderer(&renderer);
         backendBuffer->setManager(nodeManagers->bufferManager());
-        simulateInitialization(dataBuffer.data(), backendBuffer);
+        simulateInitializationSync(dataBuffer.data(), backendBuffer);
 
         positionAttribute->setBuffer(dataBuffer.data());
         positionAttribute->setName(Qt3DRender::QAttribute::defaultPositionAttributeName());
@@ -371,16 +371,16 @@ private Q_SLOTS:
 
         Attribute *backendAttribute = nodeManagers->attributeManager()->getOrCreateResource(positionAttribute->id());
         backendAttribute->setRenderer(&renderer);
-        simulateInitialization(positionAttribute.data(), backendAttribute);
+        simulateInitializationSync(positionAttribute.data(), backendAttribute);
 
         Geometry *backendGeometry = nodeManagers->geometryManager()->getOrCreateResource(geometry->id());
         backendGeometry->setRenderer(&renderer);
-        simulateInitialization(geometry, backendGeometry);
+        simulateInitializationSync(geometry, backendGeometry);
 
         GeometryRenderer *backendRenderer = nodeManagers->geometryRendererManager()->getOrCreateResource(geometryRenderer->id());
         backendRenderer->setRenderer(&renderer);
         backendRenderer->setManager(nodeManagers->geometryRendererManager());
-        simulateInitialization(geometryRenderer.data(), backendRenderer);
+        simulateInitializationSync(geometryRenderer.data(), backendRenderer);
 
         // WHEN
         visitor.apply(backendRenderer, Qt3DCore::QNodeId());
@@ -423,7 +423,7 @@ private Q_SLOTS:
         Buffer *backendBuffer = nodeManagers->bufferManager()->getOrCreateResource(dataBuffer->id());
         backendBuffer->setRenderer(&renderer);
         backendBuffer->setManager(nodeManagers->bufferManager());
-        simulateInitialization(dataBuffer.data(), backendBuffer);
+        simulateInitializationSync(dataBuffer.data(), backendBuffer);
 
         QByteArray indexData;
         indexData.resize(sizeof(uint) * 2 * 4);
@@ -437,7 +437,7 @@ private Q_SLOTS:
         Buffer *backendIndexBuffer = nodeManagers->bufferManager()->getOrCreateResource(indexDataBuffer->id());
         backendIndexBuffer->setRenderer(&renderer);
         backendIndexBuffer->setManager(nodeManagers->bufferManager());
-        simulateInitialization(indexDataBuffer.data(), backendIndexBuffer);
+        simulateInitializationSync(indexDataBuffer.data(), backendIndexBuffer);
 
         positionAttribute->setBuffer(dataBuffer.data());
         positionAttribute->setName(Qt3DRender::QAttribute::defaultPositionAttributeName());
@@ -461,20 +461,20 @@ private Q_SLOTS:
 
         Attribute *backendAttribute = nodeManagers->attributeManager()->getOrCreateResource(positionAttribute->id());
         backendAttribute->setRenderer(&renderer);
-        simulateInitialization(positionAttribute.data(), backendAttribute);
+        simulateInitializationSync(positionAttribute.data(), backendAttribute);
 
         Attribute *backendIndexAttribute = nodeManagers->attributeManager()->getOrCreateResource(indexAttribute->id());
         backendIndexAttribute->setRenderer(&renderer);
-        simulateInitialization(indexAttribute.data(), backendIndexAttribute);
+        simulateInitializationSync(indexAttribute.data(), backendIndexAttribute);
 
         Geometry *backendGeometry = nodeManagers->geometryManager()->getOrCreateResource(geometry->id());
         backendGeometry->setRenderer(&renderer);
-        simulateInitialization(geometry, backendGeometry);
+        simulateInitializationSync(geometry, backendGeometry);
 
         GeometryRenderer *backendRenderer = nodeManagers->geometryRendererManager()->getOrCreateResource(geometryRenderer->id());
         backendRenderer->setRenderer(&renderer);
         backendRenderer->setManager(nodeManagers->geometryRendererManager());
-        simulateInitialization(geometryRenderer.data(), backendRenderer);
+        simulateInitializationSync(geometryRenderer.data(), backendRenderer);
 
         // WHEN
         visitor.apply(backendRenderer, Qt3DCore::QNodeId());
@@ -515,7 +515,7 @@ private Q_SLOTS:
         Buffer *backendBuffer = nodeManagers->bufferManager()->getOrCreateResource(dataBuffer->id());
         backendBuffer->setRenderer(&renderer);
         backendBuffer->setManager(nodeManagers->bufferManager());
-        simulateInitialization(dataBuffer.data(), backendBuffer);
+        simulateInitializationSync(dataBuffer.data(), backendBuffer);
 
         positionAttribute->setBuffer(dataBuffer.data());
         positionAttribute->setName(Qt3DRender::QAttribute::defaultPositionAttributeName());
@@ -532,16 +532,16 @@ private Q_SLOTS:
 
         Attribute *backendAttribute = nodeManagers->attributeManager()->getOrCreateResource(positionAttribute->id());
         backendAttribute->setRenderer(&renderer);
-        simulateInitialization(positionAttribute.data(), backendAttribute);
+        simulateInitializationSync(positionAttribute.data(), backendAttribute);
 
         Geometry *backendGeometry = nodeManagers->geometryManager()->getOrCreateResource(geometry->id());
         backendGeometry->setRenderer(&renderer);
-        simulateInitialization(geometry, backendGeometry);
+        simulateInitializationSync(geometry, backendGeometry);
 
         GeometryRenderer *backendRenderer = nodeManagers->geometryRendererManager()->getOrCreateResource(geometryRenderer->id());
         backendRenderer->setRenderer(&renderer);
         backendRenderer->setManager(nodeManagers->geometryRendererManager());
-        simulateInitialization(geometryRenderer.data(), backendRenderer);
+        simulateInitializationSync(geometryRenderer.data(), backendRenderer);
 
         // WHEN
         visitor.apply(backendRenderer, Qt3DCore::QNodeId());
@@ -585,7 +585,7 @@ private Q_SLOTS:
         Buffer *backendBuffer = nodeManagers->bufferManager()->getOrCreateResource(dataBuffer->id());
         backendBuffer->setRenderer(&renderer);
         backendBuffer->setManager(nodeManagers->bufferManager());
-        simulateInitialization(dataBuffer.data(), backendBuffer);
+        simulateInitializationSync(dataBuffer.data(), backendBuffer);
 
         QByteArray indexData;
         indexData.resize(sizeof(uint) * 2 * 4);
@@ -599,7 +599,7 @@ private Q_SLOTS:
         Buffer *backendIndexBuffer = nodeManagers->bufferManager()->getOrCreateResource(indexDataBuffer->id());
         backendIndexBuffer->setRenderer(&renderer);
         backendIndexBuffer->setManager(nodeManagers->bufferManager());
-        simulateInitialization(indexDataBuffer.data(), backendIndexBuffer);
+        simulateInitializationSync(indexDataBuffer.data(), backendIndexBuffer);
 
         positionAttribute->setBuffer(dataBuffer.data());
         positionAttribute->setName(Qt3DRender::QAttribute::defaultPositionAttributeName());
@@ -623,20 +623,20 @@ private Q_SLOTS:
 
         Attribute *backendAttribute = nodeManagers->attributeManager()->getOrCreateResource(positionAttribute->id());
         backendAttribute->setRenderer(&renderer);
-        simulateInitialization(positionAttribute.data(), backendAttribute);
+        simulateInitializationSync(positionAttribute.data(), backendAttribute);
 
         Attribute *backendIndexAttribute = nodeManagers->attributeManager()->getOrCreateResource(indexAttribute->id());
         backendIndexAttribute->setRenderer(&renderer);
-        simulateInitialization(indexAttribute.data(), backendIndexAttribute);
+        simulateInitializationSync(indexAttribute.data(), backendIndexAttribute);
 
         Geometry *backendGeometry = nodeManagers->geometryManager()->getOrCreateResource(geometry->id());
         backendGeometry->setRenderer(&renderer);
-        simulateInitialization(geometry, backendGeometry);
+        simulateInitializationSync(geometry, backendGeometry);
 
         GeometryRenderer *backendRenderer = nodeManagers->geometryRendererManager()->getOrCreateResource(geometryRenderer->id());
         backendRenderer->setRenderer(&renderer);
         backendRenderer->setManager(nodeManagers->geometryRendererManager());
-        simulateInitialization(geometryRenderer.data(), backendRenderer);
+        simulateInitializationSync(geometryRenderer.data(), backendRenderer);
 
         // WHEN
         visitor.apply(backendRenderer, Qt3DCore::QNodeId());
@@ -679,7 +679,7 @@ private Q_SLOTS:
         Buffer *backendBuffer = nodeManagers->bufferManager()->getOrCreateResource(dataBuffer->id());
         backendBuffer->setRenderer(&renderer);
         backendBuffer->setManager(nodeManagers->bufferManager());
-        simulateInitialization(dataBuffer.data(), backendBuffer);
+        simulateInitializationSync(dataBuffer.data(), backendBuffer);
 
         positionAttribute->setBuffer(dataBuffer.data());
         positionAttribute->setName(Qt3DRender::QAttribute::defaultPositionAttributeName());
@@ -696,16 +696,16 @@ private Q_SLOTS:
 
         Attribute *backendAttribute = nodeManagers->attributeManager()->getOrCreateResource(positionAttribute->id());
         backendAttribute->setRenderer(&renderer);
-        simulateInitialization(positionAttribute.data(), backendAttribute);
+        simulateInitializationSync(positionAttribute.data(), backendAttribute);
 
         Geometry *backendGeometry = nodeManagers->geometryManager()->getOrCreateResource(geometry->id());
         backendGeometry->setRenderer(&renderer);
-        simulateInitialization(geometry, backendGeometry);
+        simulateInitializationSync(geometry, backendGeometry);
 
         GeometryRenderer *backendRenderer = nodeManagers->geometryRendererManager()->getOrCreateResource(geometryRenderer->id());
         backendRenderer->setRenderer(&renderer);
         backendRenderer->setManager(nodeManagers->geometryRendererManager());
-        simulateInitialization(geometryRenderer.data(), backendRenderer);
+        simulateInitializationSync(geometryRenderer.data(), backendRenderer);
 
         // WHEN
         visitor.apply(backendRenderer, Qt3DCore::QNodeId());
@@ -747,7 +747,7 @@ private Q_SLOTS:
         Buffer *backendBuffer = nodeManagers->bufferManager()->getOrCreateResource(dataBuffer->id());
         backendBuffer->setRenderer(&renderer);
         backendBuffer->setManager(nodeManagers->bufferManager());
-        simulateInitialization(dataBuffer.data(), backendBuffer);
+        simulateInitializationSync(dataBuffer.data(), backendBuffer);
 
         QByteArray indexData;
         indexData.resize(sizeof(uint) * 4);
@@ -761,7 +761,7 @@ private Q_SLOTS:
         Buffer *backendIndexBuffer = nodeManagers->bufferManager()->getOrCreateResource(indexDataBuffer->id());
         backendIndexBuffer->setRenderer(&renderer);
         backendIndexBuffer->setManager(nodeManagers->bufferManager());
-        simulateInitialization(indexDataBuffer.data(), backendIndexBuffer);
+        simulateInitializationSync(indexDataBuffer.data(), backendIndexBuffer);
 
         positionAttribute->setBuffer(dataBuffer.data());
         positionAttribute->setName(Qt3DRender::QAttribute::defaultPositionAttributeName());
@@ -785,20 +785,20 @@ private Q_SLOTS:
 
         Attribute *backendAttribute = nodeManagers->attributeManager()->getOrCreateResource(positionAttribute->id());
         backendAttribute->setRenderer(&renderer);
-        simulateInitialization(positionAttribute.data(), backendAttribute);
+        simulateInitializationSync(positionAttribute.data(), backendAttribute);
 
         Attribute *backendIndexAttribute = nodeManagers->attributeManager()->getOrCreateResource(indexAttribute->id());
         backendIndexAttribute->setRenderer(&renderer);
-        simulateInitialization(indexAttribute.data(), backendIndexAttribute);
+        simulateInitializationSync(indexAttribute.data(), backendIndexAttribute);
 
         Geometry *backendGeometry = nodeManagers->geometryManager()->getOrCreateResource(geometry->id());
         backendGeometry->setRenderer(&renderer);
-        simulateInitialization(geometry, backendGeometry);
+        simulateInitializationSync(geometry, backendGeometry);
 
         GeometryRenderer *backendRenderer = nodeManagers->geometryRendererManager()->getOrCreateResource(geometryRenderer->id());
         backendRenderer->setRenderer(&renderer);
         backendRenderer->setManager(nodeManagers->geometryRendererManager());
-        simulateInitialization(geometryRenderer.data(), backendRenderer);
+        simulateInitializationSync(geometryRenderer.data(), backendRenderer);
 
         // WHEN
         visitor.apply(backendRenderer, Qt3DCore::QNodeId());
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/skeleton/tst_skeleton.cpp b/tests/auto/render/skeleton/tst_skeleton.cpp
index 499bb7cc7..17996470c 100644
--- a/tests/auto/render/skeleton/tst_skeleton.cpp
+++ b/tests/auto/render/skeleton/tst_skeleton.cpp
@@ -86,7 +86,7 @@ private Q_SLOTS:
         skeleton.setSource(QUrl::fromLocalFile("funnybones.json"));
 
         // WHEN
-        simulateInitialization(&skeleton, &backendSkeleton);
+        simulateInitializationSync(&skeleton, &backendSkeleton);
 
         // THEN
         QCOMPARE(backendSkeleton.peerId(), skeleton.id());
@@ -104,7 +104,7 @@ private Q_SLOTS:
         skeleton2.setRootJoint(joint);
 
         // WHEN
-        simulateInitialization(&skeleton2, &backendSkeleton2);
+        simulateInitializationSync(&skeleton2, &backendSkeleton2);
 
         // THEN
         QCOMPARE(backendSkeleton2.peerId(), skeleton2.id());
@@ -135,7 +135,7 @@ private Q_SLOTS:
         skeleton.setSource(QUrl::fromLocalFile("skeleton1.json"));
 
         // WHEN
-        simulateInitialization(&skeleton, &backendSkeleton);
+        simulateInitializationSync(&skeleton, &backendSkeleton);
         backendSkeleton.cleanup();
 
         // THEN
@@ -145,7 +145,7 @@ private Q_SLOTS:
         QCOMPARE(backendSkeleton.rootJointId(), QNodeId());
     }
 
-    void checkPropertyChanges()
+    void checkDirectPropertyChanges()
     {
         // GIVEN
         TestRenderer renderer;
@@ -160,36 +160,22 @@ private Q_SLOTS:
         // Initialize to ensure skeleton manager is set
         QSkeletonLoader skeleton;
         skeleton.setSource(QUrl::fromLocalFile("skeleton1.json"));
-        simulateInitialization(&skeleton, &backendSkeleton);
+        simulateInitializationSync(&skeleton, &backendSkeleton);
 
         // WHEN
-        updateChange.reset(new Qt3DCore::QPropertyUpdatedChange(Qt3DCore::QNodeId()));
-        updateChange->setPropertyName("enabled");
-        updateChange->setValue(true);
-        backendSkeleton.sceneChangeEvent(updateChange);
+        skeleton.setEnabled(false);
+        backendSkeleton.syncFromFrontEnd(&skeleton, false);
 
         // THEN
-        QCOMPARE(backendSkeleton.isEnabled(), true);
+        QCOMPARE(backendSkeleton.isEnabled(), false);
 
         // WHEN
         const QUrl newSource = QUrl::fromLocalFile("terminator.json");
-        updateChange.reset(new Qt3DCore::QPropertyUpdatedChange(Qt3DCore::QNodeId()));
-        updateChange->setPropertyName("source");
-        updateChange->setValue(newSource);
-        backendSkeleton.sceneChangeEvent(updateChange);
+        skeleton.setSource(newSource);
+        backendSkeleton.syncFromFrontEnd(&skeleton, false);
 
         // THEN
         QCOMPARE(backendSkeleton.source(), newSource);
-
-        // WHEN
-        const QNodeId newRootJointId = QNodeId::createId();
-        updateChange.reset(new Qt3DCore::QPropertyUpdatedChange(Qt3DCore::QNodeId()));
-        updateChange->setPropertyName("rootJoint");
-        updateChange->setValue(QVariant::fromValue(newRootJointId));
-        backendSkeleton.sceneChangeEvent(updateChange);
-
-        // THEN
-        QCOMPARE(backendSkeleton.rootJointId(), newRootJointId);
     }
 
     void checkStatusPropertyBackendNotification()
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/technique/tst_technique.cpp b/tests/auto/render/technique/tst_technique.cpp
index 7d7a0f8ca..64a66f0c8 100644
--- a/tests/auto/render/technique/tst_technique.cpp
+++ b/tests/auto/render/technique/tst_technique.cpp
@@ -96,7 +96,7 @@ private Q_SLOTS:
             technique.addParameter(&parameter);
             technique.addFilterKey(&filterKey);
 
-            simulateInitialization(&technique, &backendTechnique);
+            simulateInitializationSync(&technique, &backendTechnique);
         }
 
         backendTechnique.cleanup();
@@ -129,7 +129,7 @@ private Q_SLOTS:
 
             backendTechnique.setRenderer(&renderer);
             backendTechnique.setNodeManager(&nodeManagers);
-            simulateInitialization(&technique, &backendTechnique);
+            simulateInitializationSync(&technique, &backendTechnique);
 
             // THEN
             QCOMPARE(backendTechnique.isEnabled(), true);
@@ -157,7 +157,7 @@ private Q_SLOTS:
             backendTechnique.setNodeManager(&nodeManagers);
             backendTechnique.setRenderer(&renderer);
             technique.setEnabled(false);
-            simulateInitialization(&technique, &backendTechnique);
+            simulateInitializationSync(&technique, &backendTechnique);
 
             // THEN
             QCOMPARE(backendTechnique.peerId(), technique.id());
@@ -184,6 +184,7 @@ private Q_SLOTS:
     void checkSceneChangeEvents()
     {
         // GIVEN
+        Qt3DRender::QTechnique technique;
         Qt3DRender::Render::Technique backendTechnique;
         Qt3DRender::Render::NodeManagers nodeManagers;
 
@@ -193,34 +194,31 @@ private Q_SLOTS:
 
         {
             // WHEN
-            const bool newValue = false;
-            const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-            change->setPropertyName("enabled");
-            change->setValue(newValue);
-            backendTechnique.sceneChangeEvent(change);
+            const bool newValue = true;
+            technique.setEnabled(newValue);
+            backendTechnique.syncFromFrontEnd(&technique, false);
 
             // THEN
             QCOMPARE(backendTechnique.isEnabled(), newValue);
             QVERIFY(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::TechniquesDirty);
             renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty);
+            QCOMPARE(nodeManagers.techniqueManager()->takeDirtyTechniques().size(), 1);
         }
         {
             // WHEN
             backendTechnique.setCompatibleWithRenderer(true);
             QCOMPARE(nodeManagers.techniqueManager()->takeDirtyTechniques().size(), 0);
 
-            Qt3DRender::GraphicsApiFilterData newValue;
-            newValue.m_major = 4;
-            newValue.m_minor = 5;
-            newValue.m_vendor = QStringLiteral("ATI");
+            technique.graphicsApiFilter()->setMajorVersion(4);
+            technique.graphicsApiFilter()->setMinorVersion(5);
+            technique.graphicsApiFilter()->setVendor(QStringLiteral("ATI"));
 
-            const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-            change->setPropertyName("graphicsApiFilterData");
-            change->setValue(QVariant::fromValue(newValue));
-            backendTechnique.sceneChangeEvent(change);
+            backendTechnique.syncFromFrontEnd(&technique, false);
 
             // THEN
-            QCOMPARE(*backendTechnique.graphicsApiFilter(), newValue);
+            QCOMPARE(backendTechnique.graphicsApiFilter()->m_major, technique.graphicsApiFilter()->majorVersion());
+            QCOMPARE(backendTechnique.graphicsApiFilter()->m_minor, technique.graphicsApiFilter()->minorVersion());
+            QCOMPARE(backendTechnique.graphicsApiFilter()->m_vendor, technique.graphicsApiFilter()->vendor());
             QCOMPARE(backendTechnique.isCompatibleWithRenderer(), false);
 
             const QVector<Qt3DCore::QNodeId> dirtyTechniques = nodeManagers.techniqueManager()->takeDirtyTechniques();
@@ -235,9 +233,8 @@ private Q_SLOTS:
 
             {
                 // WHEN
-                const auto change = Qt3DCore::QPropertyNodeAddedChangePtr::create(Qt3DCore::QNodeId(), &parameter);
-                change->setPropertyName("parameter");
-                backendTechnique.sceneChangeEvent(change);
+                technique.addParameter(&parameter);
+                backendTechnique.syncFromFrontEnd(&technique, false);
 
                 // THEN
                 QCOMPARE(backendTechnique.parameters().size(), 1);
@@ -247,9 +244,8 @@ private Q_SLOTS:
             }
             {
                 // WHEN
-                const auto change = Qt3DCore::QPropertyNodeRemovedChangePtr::create(Qt3DCore::QNodeId(), &parameter);
-                change->setPropertyName("parameter");
-                backendTechnique.sceneChangeEvent(change);
+                technique.removeParameter(&parameter);
+                backendTechnique.syncFromFrontEnd(&technique, false);
 
                 // THEN
                 QCOMPARE(backendTechnique.parameters().size(), 0);
@@ -262,9 +258,8 @@ private Q_SLOTS:
 
             {
                 // WHEN
-                const auto change = Qt3DCore::QPropertyNodeAddedChangePtr::create(Qt3DCore::QNodeId(), &filterKey);
-                change->setPropertyName("filterKeys");
-                backendTechnique.sceneChangeEvent(change);
+                technique.addFilterKey(&filterKey);
+                backendTechnique.syncFromFrontEnd(&technique, false);
 
                 // THEN
                 QCOMPARE(backendTechnique.filterKeys().size(), 1);
@@ -274,9 +269,8 @@ private Q_SLOTS:
             }
             {
                 // WHEN
-                const auto change = Qt3DCore::QPropertyNodeRemovedChangePtr::create(Qt3DCore::QNodeId(), &filterKey);
-                change->setPropertyName("filterKeys");
-                backendTechnique.sceneChangeEvent(change);
+                technique.removeFilterKey(&filterKey);
+                backendTechnique.syncFromFrontEnd(&technique, false);
 
                 // THEN
                 QCOMPARE(backendTechnique.filterKeys().size(), 0);
@@ -289,9 +283,8 @@ private Q_SLOTS:
 
             {
                 // WHEN
-                const auto change = Qt3DCore::QPropertyNodeAddedChangePtr::create(Qt3DCore::QNodeId(), &pass);
-                change->setPropertyName("pass");
-                backendTechnique.sceneChangeEvent(change);
+                technique.addRenderPass(&pass);
+                backendTechnique.syncFromFrontEnd(&technique, false);
 
                 // THEN
                 QCOMPARE(backendTechnique.renderPasses().size(), 1);
@@ -301,9 +294,8 @@ private Q_SLOTS:
             }
             {
                 // WHEN
-                const auto change = Qt3DCore::QPropertyNodeRemovedChangePtr::create(Qt3DCore::QNodeId(), &pass);
-                change->setPropertyName("pass");
-                backendTechnique.sceneChangeEvent(change);
+                technique.removeRenderPass(&pass);
+                backendTechnique.syncFromFrontEnd(&technique, false);
 
                 // THEN
                 QCOMPARE(backendTechnique.renderPasses().size(), 0);
diff --git a/tests/auto/render/texture/tst_texture.cpp b/tests/auto/render/texture/tst_texture.cpp
index 1d69c54be..a51f082a7 100644
--- a/tests/auto/render/texture/tst_texture.cpp
+++ b/tests/auto/render/texture/tst_texture.cpp
@@ -244,7 +244,7 @@ void tst_RenderTexture::checkPropertyMirroring()
     frontend.setSamples(32);
 
     // WHEN
-    simulateInitialization(&frontend, &backend);
+    simulateInitializationSync(&frontend, &backend);
 
     // THEN
     QCOMPARE(backend.peerId(), frontend.id());
@@ -275,15 +275,14 @@ void tst_RenderTexture::checkPropertyChanges()
 {
     // GIVEN
     TestRenderer renderer;
+    Qt3DRender::QSharedGLTexture frontend;
     Qt3DRender::Render::Texture backend;
     backend.setRenderer(&renderer);
     backend.unsetDirty();
 
     // WHEN
-    Qt3DCore::QPropertyUpdatedChangePtr updateChange(new Qt3DCore::QPropertyUpdatedChange(Qt3DCore::QNodeId()));
-    updateChange->setValue(256);
-    updateChange->setPropertyName("width");
-    backend.sceneChangeEvent(updateChange);
+    frontend.setWidth(256);
+    backend.syncFromFrontEnd(&frontend, false);
 
     // THEN
     QCOMPARE(backend.properties().width, 256);
@@ -293,10 +292,8 @@ void tst_RenderTexture::checkPropertyChanges()
     backend.unsetDirty();
 
     // WHEN
-    updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId());
-    updateChange->setValue(128);
-    updateChange->setPropertyName("height");
-    backend.sceneChangeEvent(updateChange);
+    frontend.setHeight(128);
+    backend.syncFromFrontEnd(&frontend, false);
 
     // THEN
     QCOMPARE(backend.properties().height, 128);
@@ -306,10 +303,8 @@ void tst_RenderTexture::checkPropertyChanges()
     backend.unsetDirty();
 
     // WHEN
-    updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId());
-    updateChange->setValue(16);
-    updateChange->setPropertyName("depth");
-    backend.sceneChangeEvent(updateChange);
+    frontend.setDepth(16);
+    backend.syncFromFrontEnd(&frontend, false);
 
     // THEN
     QCOMPARE(backend.properties().depth, 16);
@@ -319,10 +314,8 @@ void tst_RenderTexture::checkPropertyChanges()
     backend.unsetDirty();
 
     // WHEN
-    updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId());
-    updateChange->setValue(QVariant::fromValue(Qt3DRender::QAbstractTexture::RGB16F));
-    updateChange->setPropertyName("format");
-    backend.sceneChangeEvent(updateChange);
+    frontend.setFormat(Qt3DRender::QAbstractTexture::RGB16F);
+    backend.syncFromFrontEnd(&frontend, false);
 
     // THEN
     QCOMPARE(backend.properties().format, Qt3DRender::QAbstractTexture::RGB16F);
@@ -332,23 +325,8 @@ void tst_RenderTexture::checkPropertyChanges()
     backend.unsetDirty();
 
     // WHEN
-    updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId());
-    updateChange->setValue(QVariant::fromValue(Qt3DRender::QAbstractTexture::Target1DArray));
-    updateChange->setPropertyName("target");
-    backend.sceneChangeEvent(updateChange);
-
-    // THEN
-    QCOMPARE(backend.properties().target, Qt3DRender::QAbstractTexture::Target1DArray);
-    QVERIFY(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::TexturesDirty);
-    QVERIFY(backend.dirtyFlags() == Qt3DRender::Render::Texture::DirtyProperties);
-    renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty);
-    backend.unsetDirty();
-
-    // WHEN
-    updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId());
-    updateChange->setValue(true);
-    updateChange->setPropertyName("mipmaps");
-    backend.sceneChangeEvent(updateChange);
+    frontend.setGenerateMipMaps(true);
+    backend.syncFromFrontEnd(&frontend, false);
 
     // THEN
     QCOMPARE(backend.properties().generateMipMaps, true);
@@ -358,10 +336,8 @@ void tst_RenderTexture::checkPropertyChanges()
     backend.unsetDirty();
 
     // WHEN
-    updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId());
-    updateChange->setValue(QVariant::fromValue(Qt3DRender::QAbstractTexture::LinearMipMapLinear));
-    updateChange->setPropertyName("minificationFilter");
-    backend.sceneChangeEvent(updateChange);
+    frontend.setMinificationFilter(Qt3DRender::QAbstractTexture::LinearMipMapLinear);
+    backend.syncFromFrontEnd(&frontend, false);
 
     // THEN
     QCOMPARE(backend.parameters().minificationFilter, Qt3DRender::QAbstractTexture::LinearMipMapLinear);
@@ -371,10 +347,8 @@ void tst_RenderTexture::checkPropertyChanges()
     backend.unsetDirty();
 
     // WHEN
-    updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId());
-    updateChange->setValue(QVariant::fromValue(Qt3DRender::QAbstractTexture::Linear));
-    updateChange->setPropertyName("magnificationFilter");
-    backend.sceneChangeEvent(updateChange);
+    frontend.setMagnificationFilter(Qt3DRender::QAbstractTexture::Linear);
+    backend.syncFromFrontEnd(&frontend, false);
 
     // THEN
     QCOMPARE(backend.parameters().magnificationFilter, Qt3DRender::QAbstractTexture::Linear);
@@ -384,10 +358,8 @@ void tst_RenderTexture::checkPropertyChanges()
     backend.unsetDirty();
 
     // WHEN
-    updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId());
-    updateChange->setValue(QVariant::fromValue(Qt3DRender::QTextureWrapMode::Repeat));
-    updateChange->setPropertyName("wrapModeX");
-    backend.sceneChangeEvent(updateChange);
+    frontend.wrapMode()->setX(Qt3DRender::QTextureWrapMode::Repeat);
+    backend.syncFromFrontEnd(&frontend, false);
 
     // THEN
     QCOMPARE(backend.parameters().wrapModeX, Qt3DRender::QTextureWrapMode::Repeat);
@@ -397,10 +369,8 @@ void tst_RenderTexture::checkPropertyChanges()
     backend.unsetDirty();
 
     // WHEN
-    updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId());
-    updateChange->setValue(QVariant::fromValue(Qt3DRender::QTextureWrapMode::Repeat));
-    updateChange->setPropertyName("wrapModeY");
-    backend.sceneChangeEvent(updateChange);
+    frontend.wrapMode()->setY(Qt3DRender::QTextureWrapMode::Repeat);
+    backend.syncFromFrontEnd(&frontend, false);
 
     // THEN
     QCOMPARE(backend.parameters().wrapModeY, Qt3DRender::QTextureWrapMode::Repeat);
@@ -410,10 +380,8 @@ void tst_RenderTexture::checkPropertyChanges()
     backend.unsetDirty();
 
     // WHEN
-    updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId());
-    updateChange->setValue(QVariant::fromValue(Qt3DRender::QTextureWrapMode::Repeat));
-    updateChange->setPropertyName("wrapModeZ");
-    backend.sceneChangeEvent(updateChange);
+    frontend.wrapMode()->setZ(Qt3DRender::QTextureWrapMode::Repeat);
+    backend.syncFromFrontEnd(&frontend, false);
 
     // THEN
     QCOMPARE(backend.parameters().wrapModeZ, Qt3DRender::QTextureWrapMode::Repeat);
@@ -423,10 +391,8 @@ void tst_RenderTexture::checkPropertyChanges()
     backend.unsetDirty();
 
     // WHEN
-    updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId());
-    updateChange->setValue(16.0f);
-    updateChange->setPropertyName("maximumAnisotropy");
-    backend.sceneChangeEvent(updateChange);
+    frontend.setMaximumAnisotropy(16.f);
+    backend.syncFromFrontEnd(&frontend, false);
 
     // THEN
     QCOMPARE(backend.parameters().maximumAnisotropy, 16.0f);
@@ -436,10 +402,8 @@ void tst_RenderTexture::checkPropertyChanges()
     backend.unsetDirty();
 
     // WHEN
-    updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId());
-    updateChange->setValue(QVariant::fromValue(Qt3DRender::QAbstractTexture::CompareEqual));
-    updateChange->setPropertyName("comparisonFunction");
-    backend.sceneChangeEvent(updateChange);
+    frontend.setComparisonFunction(Qt3DRender::QAbstractTexture::CompareEqual);
+    backend.syncFromFrontEnd(&frontend, false);
 
     // THEN
     QCOMPARE(backend.parameters().comparisonFunction, Qt3DRender::QAbstractTexture::CompareEqual);
@@ -449,10 +413,8 @@ void tst_RenderTexture::checkPropertyChanges()
     backend.unsetDirty();
 
     // WHEN
-    updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId());
-    updateChange->setValue(QVariant::fromValue(Qt3DRender::QAbstractTexture::CompareRefToTexture));
-    updateChange->setPropertyName("comparisonMode");
-    backend.sceneChangeEvent(updateChange);
+    frontend.setComparisonMode(Qt3DRender::QAbstractTexture::CompareRefToTexture);
+    backend.syncFromFrontEnd(&frontend, false);
 
     // THEN
     QCOMPARE(backend.parameters().comparisonMode, Qt3DRender::QAbstractTexture::CompareRefToTexture);
@@ -462,10 +424,8 @@ void tst_RenderTexture::checkPropertyChanges()
     backend.unsetDirty();
 
     // WHEN
-    updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId());
-    updateChange->setValue(32);
-    updateChange->setPropertyName("layers");
-    backend.sceneChangeEvent(updateChange);
+    frontend.setLayers(32);
+    backend.syncFromFrontEnd(&frontend, false);
 
     // THEN
     QCOMPARE(backend.properties().layers, 32);
@@ -475,10 +435,8 @@ void tst_RenderTexture::checkPropertyChanges()
     backend.unsetDirty();
 
     // WHEN
-    updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId());
-    updateChange->setValue(64);
-    updateChange->setPropertyName("samples");
-    backend.sceneChangeEvent(updateChange);
+    frontend.setSamples(64);
+    backend.syncFromFrontEnd(&frontend, false);
 
     // THEN
     QCOMPARE(backend.properties().samples, 64);
@@ -488,24 +446,8 @@ void tst_RenderTexture::checkPropertyChanges()
     backend.unsetDirty();
 
     // WHEN
-    updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId());
-    Qt3DRender::QTextureGeneratorPtr gen = QSharedPointer<FakeGenerator>::create();
-    updateChange->setValue(QVariant::fromValue(gen));
-    updateChange->setPropertyName("generator");
-    backend.sceneChangeEvent(updateChange);
-
-    // THEN
-    QCOMPARE(backend.dataGenerator(), gen);
-    QVERIFY(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::TexturesDirty);
-    QVERIFY(backend.dirtyFlags() == Qt3DRender::Render::Texture::DirtyDataGenerator);
-    renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty);
-    backend.unsetDirty();
-
-    // WHEN
-    updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId());
-    updateChange->setValue(883);
-    updateChange->setPropertyName("textureId");
-    backend.sceneChangeEvent(updateChange);
+    frontend.setTextureId(883);
+    backend.syncFromFrontEnd(&frontend, false);
 
     // THEN
     QCOMPARE(backend.sharedTextureId(), 883);
@@ -533,10 +475,8 @@ void tst_RenderTexture::checkPropertyChanges()
     updateData.setX(100);
     updateData.setY(100);
     updateData.setZ(100);
-    updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId());
-    updateChange->setPropertyName("updateData");
-    updateChange->setValue(QVariant::fromValue(updateData));
-    backend.sceneChangeEvent(updateChange);
+    frontend.updateData(updateData);
+    backend.syncFromFrontEnd(&frontend, false);
 
     // THEN
     const QVector<Qt3DRender::QTextureDataUpdate> pendingUpdates = backend.takePendingTextureDataUpdates();
@@ -589,7 +529,7 @@ void tst_RenderTexture::checkInitialUpdateData()
 
     // WHEN -> updateData with no backend/arbiter
     frontend.updateData(updateData);
-    simulateInitialization(&frontend, &backend);
+    simulateInitializationSync(&frontend, &backend);
 
     // THEN -> should have received the update as part of the initial data
     const QVector<Qt3DRender::QTextureDataUpdate> pendingUpdates = backend.takePendingTextureDataUpdates();
diff --git a/tests/auto/render/transform/tst_transform.cpp b/tests/auto/render/transform/tst_transform.cpp
index 8e4ab8ef0..3238da2fe 100644
--- a/tests/auto/render/transform/tst_transform.cpp
+++ b/tests/auto/render/transform/tst_transform.cpp
@@ -59,6 +59,7 @@ private Q_SLOTS:
         // GIVEN
         TestRenderer renderer;
         Qt3DRender::Render::Transform backendTransform;
+        backendTransform.setRenderer(&renderer);
 
         // WHEN
         {
@@ -67,7 +68,7 @@ private Q_SLOTS:
             transform.setTranslation(QVector3D(-1.0, 5.0f, -2.0f));
             transform.setRotation(QQuaternion::fromAxisAndAngle(QVector3D(1.0f, 0.0f, 0.0), 30.0f));
             backendTransform.setRenderer(&renderer);
-            simulateInitialization(&transform, &backendTransform);
+            simulateInitializationSync(&transform, &backendTransform);
         }
         backendTransform.setEnabled(true);
 
@@ -94,7 +95,9 @@ private Q_SLOTS:
             // WHEN
             Qt3DRender::Render::Transform backendTransform;
             backendTransform.setRenderer(&renderer);
-            simulateInitialization(&transform, &backendTransform);
+            TestRenderer renderer;
+            backendTransform.setRenderer(&renderer);
+            simulateInitializationSync(&transform, &backendTransform);
 
             // THEN
             QCOMPARE(backendTransform.isEnabled(), true);
@@ -109,9 +112,10 @@ private Q_SLOTS:
         {
             // WHEN
             Qt3DRender::Render::Transform backendTransform;
+            TestRenderer renderer;
             backendTransform.setRenderer(&renderer);
             transform.setEnabled(false);
-            simulateInitialization(&transform, &backendTransform);
+            simulateInitializationSync(&transform, &backendTransform);
 
             // THEN
             QCOMPARE(backendTransform.peerId(), transform.id());
@@ -123,17 +127,18 @@ private Q_SLOTS:
     void checkSceneChangeEvents()
     {
         // GIVEN
+        Qt3DCore::QTransform frontendTranform;
         Qt3DRender::Render::Transform backendTransform;
         TestRenderer renderer;
         backendTransform.setRenderer(&renderer);
+        backendTransform.syncFromFrontEnd(&frontendTranform, true);
+        renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty);
 
         {
             // WHEN
             const bool newValue = false;
-            const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-            change->setPropertyName("enabled");
-            change->setValue(newValue);
-            backendTransform.sceneChangeEvent(change);
+            frontendTranform.setEnabled(newValue);
+            backendTransform.syncFromFrontEnd(&frontendTranform, false);
 
             // THEN
             QCOMPARE(backendTransform.isEnabled(), newValue);
@@ -143,10 +148,8 @@ private Q_SLOTS:
         {
             // WHEN
             const QQuaternion newValue = QQuaternion::fromAxisAndAngle(QVector3D(0.0f, 1.0f, 0.0f), 45.0f);
-            const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-            change->setPropertyName("rotation");
-            change->setValue(QVariant::fromValue(newValue));
-            backendTransform.sceneChangeEvent(change);
+            frontendTranform.setRotation(newValue);
+            backendTransform.syncFromFrontEnd(&frontendTranform, false);
 
             // THEN
             QCOMPARE(backendTransform.rotation(), newValue);
@@ -156,10 +159,8 @@ private Q_SLOTS:
         {
             // WHEN
             const QVector3D newValue(454.0f, 355.0f, 0.0f);
-            const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-            change->setPropertyName("scale3D");
-            change->setValue(QVariant::fromValue(newValue));
-            backendTransform.sceneChangeEvent(change);
+            frontendTranform.setScale3D(newValue);
+            backendTransform.syncFromFrontEnd(&frontendTranform, false);
 
             // THEN
             QCOMPARE(backendTransform.scale(), newValue);
@@ -169,10 +170,8 @@ private Q_SLOTS:
         {
             // WHEN
             const QVector3D newValue(383.0f, 0.0f, 427.0f);
-            const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-            change->setPropertyName("translation");
-            change->setValue(QVariant::fromValue(newValue));
-            backendTransform.sceneChangeEvent(change);
+            frontendTranform.setTranslation(newValue);
+            backendTransform.syncFromFrontEnd(&frontendTranform, false);
 
             // THEN
             QCOMPARE(backendTransform.translation(), newValue);
diff --git a/tests/auto/render/trianglesextractor/tst_trianglesextractor.cpp b/tests/auto/render/trianglesextractor/tst_trianglesextractor.cpp
index 0c3b579de..287a17b84 100644
--- a/tests/auto/render/trianglesextractor/tst_trianglesextractor.cpp
+++ b/tests/auto/render/trianglesextractor/tst_trianglesextractor.cpp
@@ -320,16 +320,21 @@ public:
     TestAspect(Qt3DCore::QNode *root)
         : Qt3DRender::QRenderAspect()
     {
-        QVector<Qt3DCore::QNode *> nodes;
+        QVector<Qt3DCore::NodeTreeChange> nodes;
         Qt3DCore::QNodeVisitor v;
         v.traverse(root, [&nodes](Qt3DCore::QNode *node) {
             Qt3DCore::QNodePrivate *d = Qt3DCore::QNodePrivate::get(node);
             d->m_typeInfo = const_cast<QMetaObject*>(Qt3DCore::QNodePrivate::findStaticMetaObject(node->metaObject()));
             d->m_hasBackendNode = true;
-            nodes << node;
+            nodes.push_back({
+                node->id(),
+                Qt3DCore::QNodePrivate::get(node)->m_typeInfo,
+                Qt3DCore::NodeTreeChange::Added,
+                node
+            });
         });
 
-        for (const auto node: nodes)
+        for (const auto &node: nodes)
             d_func()->createBackendNode(node);
     }
 
diff --git a/tests/auto/render/trianglevisitor/tst_trianglevisitor.cpp b/tests/auto/render/trianglevisitor/tst_trianglevisitor.cpp
index 4205d598e..8dfda0eea 100644
--- a/tests/auto/render/trianglevisitor/tst_trianglevisitor.cpp
+++ b/tests/auto/render/trianglevisitor/tst_trianglevisitor.cpp
@@ -187,7 +187,7 @@ private Q_SLOTS:
         Buffer *backendBuffer = nodeManagers->bufferManager()->getOrCreateResource(dataBuffer->id());
         backendBuffer->setRenderer(&renderer);
         backendBuffer->setManager(nodeManagers->bufferManager());
-        simulateInitialization(dataBuffer.data(), backendBuffer);
+        simulateInitializationSync(dataBuffer.data(), backendBuffer);
 
         positionAttribute->setBuffer(dataBuffer.data());
         positionAttribute->setName(Qt3DRender::QAttribute::defaultPositionAttributeName());
@@ -204,16 +204,16 @@ private Q_SLOTS:
 
         Attribute *backendAttribute = nodeManagers->attributeManager()->getOrCreateResource(positionAttribute->id());
         backendAttribute->setRenderer(&renderer);
-        simulateInitialization(positionAttribute.data(), backendAttribute);
+        simulateInitializationSync(positionAttribute.data(), backendAttribute);
 
         Geometry *backendGeometry = nodeManagers->geometryManager()->getOrCreateResource(geometry->id());
         backendGeometry->setRenderer(&renderer);
-        simulateInitialization(geometry, backendGeometry);
+        simulateInitializationSync(geometry, backendGeometry);
 
         GeometryRenderer *backendRenderer = nodeManagers->geometryRendererManager()->getOrCreateResource(geometryRenderer->id());
         backendRenderer->setRenderer(&renderer);
         backendRenderer->setManager(nodeManagers->geometryRendererManager());
-        simulateInitialization(geometryRenderer.data(), backendRenderer);
+        simulateInitializationSync(geometryRenderer.data(), backendRenderer);
 
         // WHEN
         visitor.apply(backendRenderer, Qt3DCore::QNodeId());
@@ -262,7 +262,7 @@ private Q_SLOTS:
         Buffer *backendBuffer = nodeManagers->bufferManager()->getOrCreateResource(dataBuffer->id());
         backendBuffer->setRenderer(&renderer);
         backendBuffer->setManager(nodeManagers->bufferManager());
-        simulateInitialization(dataBuffer.data(), backendBuffer);
+        simulateInitializationSync(dataBuffer.data(), backendBuffer);
 
         QByteArray indexData;
         indexData.resize(sizeof(uint) * 3 * 5);
@@ -287,7 +287,7 @@ private Q_SLOTS:
         Buffer *backendIndexBuffer = nodeManagers->bufferManager()->getOrCreateResource(indexDataBuffer->id());
         backendIndexBuffer->setRenderer(&renderer);
         backendIndexBuffer->setManager(nodeManagers->bufferManager());
-        simulateInitialization(indexDataBuffer.data(), backendIndexBuffer);
+        simulateInitializationSync(indexDataBuffer.data(), backendIndexBuffer);
 
         positionAttribute->setBuffer(dataBuffer.data());
         positionAttribute->setName(Qt3DRender::QAttribute::defaultPositionAttributeName());
@@ -311,20 +311,20 @@ private Q_SLOTS:
 
         Attribute *backendAttribute = nodeManagers->attributeManager()->getOrCreateResource(positionAttribute->id());
         backendAttribute->setRenderer(&renderer);
-        simulateInitialization(positionAttribute.data(), backendAttribute);
+        simulateInitializationSync(positionAttribute.data(), backendAttribute);
 
         Attribute *backendIndexAttribute = nodeManagers->attributeManager()->getOrCreateResource(indexAttribute->id());
         backendIndexAttribute->setRenderer(&renderer);
-        simulateInitialization(indexAttribute.data(), backendIndexAttribute);
+        simulateInitializationSync(indexAttribute.data(), backendIndexAttribute);
 
         Geometry *backendGeometry = nodeManagers->geometryManager()->getOrCreateResource(geometry->id());
         backendGeometry->setRenderer(&renderer);
-        simulateInitialization(geometry, backendGeometry);
+        simulateInitializationSync(geometry, backendGeometry);
 
         GeometryRenderer *backendRenderer = nodeManagers->geometryRendererManager()->getOrCreateResource(geometryRenderer->id());
         backendRenderer->setRenderer(&renderer);
         backendRenderer->setManager(nodeManagers->geometryRendererManager());
-        simulateInitialization(geometryRenderer.data(), backendRenderer);
+        simulateInitializationSync(geometryRenderer.data(), backendRenderer);
 
         // WHEN
         visitor.apply(backendRenderer, Qt3DCore::QNodeId());
@@ -374,7 +374,7 @@ private Q_SLOTS:
         Buffer *backendBuffer = nodeManagers->bufferManager()->getOrCreateResource(dataBuffer->id());
         backendBuffer->setRenderer(&renderer);
         backendBuffer->setManager(nodeManagers->bufferManager());
-        simulateInitialization(dataBuffer.data(), backendBuffer);
+        simulateInitializationSync(dataBuffer.data(), backendBuffer);
 
         positionAttribute->setBuffer(dataBuffer.data());
         positionAttribute->setName(Qt3DRender::QAttribute::defaultPositionAttributeName());
@@ -391,16 +391,16 @@ private Q_SLOTS:
 
         Attribute *backendAttribute = nodeManagers->attributeManager()->getOrCreateResource(positionAttribute->id());
         backendAttribute->setRenderer(&renderer);
-        simulateInitialization(positionAttribute.data(), backendAttribute);
+        simulateInitializationSync(positionAttribute.data(), backendAttribute);
 
         Geometry *backendGeometry = nodeManagers->geometryManager()->getOrCreateResource(geometry->id());
         backendGeometry->setRenderer(&renderer);
-        simulateInitialization(geometry, backendGeometry);
+        simulateInitializationSync(geometry, backendGeometry);
 
         GeometryRenderer *backendRenderer = nodeManagers->geometryRendererManager()->getOrCreateResource(geometryRenderer->id());
         backendRenderer->setRenderer(&renderer);
         backendRenderer->setManager(nodeManagers->geometryRendererManager());
-        simulateInitialization(geometryRenderer.data(), backendRenderer);
+        simulateInitializationSync(geometryRenderer.data(), backendRenderer);
 
         // WHEN
         visitor.apply(backendRenderer, Qt3DCore::QNodeId());
@@ -451,7 +451,7 @@ private Q_SLOTS:
         Buffer *backendBuffer = nodeManagers->bufferManager()->getOrCreateResource(dataBuffer->id());
         backendBuffer->setRenderer(&renderer);
         backendBuffer->setManager(nodeManagers->bufferManager());
-        simulateInitialization(dataBuffer.data(), backendBuffer);
+        simulateInitializationSync(dataBuffer.data(), backendBuffer);
 
         QByteArray indexData;
         indexData.resize(sizeof(uint) * 3 * 4);
@@ -473,7 +473,7 @@ private Q_SLOTS:
         Buffer *backendIndexBuffer = nodeManagers->bufferManager()->getOrCreateResource(indexDataBuffer->id());
         backendIndexBuffer->setRenderer(&renderer);
         backendIndexBuffer->setManager(nodeManagers->bufferManager());
-        simulateInitialization(indexDataBuffer.data(), backendIndexBuffer);
+        simulateInitializationSync(indexDataBuffer.data(), backendIndexBuffer);
 
         positionAttribute->setBuffer(dataBuffer.data());
         positionAttribute->setName(Qt3DRender::QAttribute::defaultPositionAttributeName());
@@ -497,20 +497,20 @@ private Q_SLOTS:
 
         Attribute *backendAttribute = nodeManagers->attributeManager()->getOrCreateResource(positionAttribute->id());
         backendAttribute->setRenderer(&renderer);
-        simulateInitialization(positionAttribute.data(), backendAttribute);
+        simulateInitializationSync(positionAttribute.data(), backendAttribute);
 
         Attribute *backendIndexAttribute = nodeManagers->attributeManager()->getOrCreateResource(indexAttribute->id());
         backendIndexAttribute->setRenderer(&renderer);
-        simulateInitialization(indexAttribute.data(), backendIndexAttribute);
+        simulateInitializationSync(indexAttribute.data(), backendIndexAttribute);
 
         Geometry *backendGeometry = nodeManagers->geometryManager()->getOrCreateResource(geometry->id());
         backendGeometry->setRenderer(&renderer);
-        simulateInitialization(geometry, backendGeometry);
+        simulateInitializationSync(geometry, backendGeometry);
 
         GeometryRenderer *backendRenderer = nodeManagers->geometryRendererManager()->getOrCreateResource(geometryRenderer->id());
         backendRenderer->setRenderer(&renderer);
         backendRenderer->setManager(nodeManagers->geometryRendererManager());
-        simulateInitialization(geometryRenderer.data(), backendRenderer);
+        simulateInitializationSync(geometryRenderer.data(), backendRenderer);
 
         // WHEN
         visitor.apply(backendRenderer, Qt3DCore::QNodeId());
@@ -563,7 +563,7 @@ private Q_SLOTS:
         Buffer *backendBuffer = nodeManagers->bufferManager()->getOrCreateResource(dataBuffer->id());
         backendBuffer->setRenderer(&renderer);
         backendBuffer->setManager(nodeManagers->bufferManager());
-        simulateInitialization(dataBuffer.data(), backendBuffer);
+        simulateInitializationSync(dataBuffer.data(), backendBuffer);
 
         positionAttribute->setBuffer(dataBuffer.data());
         positionAttribute->setName(Qt3DRender::QAttribute::defaultPositionAttributeName());
@@ -580,16 +580,16 @@ private Q_SLOTS:
 
         Attribute *backendAttribute = nodeManagers->attributeManager()->getOrCreateResource(positionAttribute->id());
         backendAttribute->setRenderer(&renderer);
-        simulateInitialization(positionAttribute.data(), backendAttribute);
+        simulateInitializationSync(positionAttribute.data(), backendAttribute);
 
         Geometry *backendGeometry = nodeManagers->geometryManager()->getOrCreateResource(geometry->id());
         backendGeometry->setRenderer(&renderer);
-        simulateInitialization(geometry, backendGeometry);
+        simulateInitializationSync(geometry, backendGeometry);
 
         GeometryRenderer *backendRenderer = nodeManagers->geometryRendererManager()->getOrCreateResource(geometryRenderer->id());
         backendRenderer->setRenderer(&renderer);
         backendRenderer->setManager(nodeManagers->geometryRendererManager());
-        simulateInitialization(geometryRenderer.data(), backendRenderer);
+        simulateInitializationSync(geometryRenderer.data(), backendRenderer);
 
         // WHEN
         visitor.apply(backendRenderer, Qt3DCore::QNodeId());
@@ -640,7 +640,7 @@ private Q_SLOTS:
         Buffer *backendBuffer = nodeManagers->bufferManager()->getOrCreateResource(dataBuffer->id());
         backendBuffer->setRenderer(&renderer);
         backendBuffer->setManager(nodeManagers->bufferManager());
-        simulateInitialization(dataBuffer.data(), backendBuffer);
+        simulateInitializationSync(dataBuffer.data(), backendBuffer);
 
         QByteArray indexData;
         indexData.resize(sizeof(uint) * 3 * 2);
@@ -656,7 +656,7 @@ private Q_SLOTS:
         Buffer *backendIndexBuffer = nodeManagers->bufferManager()->getOrCreateResource(indexDataBuffer->id());
         backendIndexBuffer->setRenderer(&renderer);
         backendIndexBuffer->setManager(nodeManagers->bufferManager());
-        simulateInitialization(indexDataBuffer.data(), backendIndexBuffer);
+        simulateInitializationSync(indexDataBuffer.data(), backendIndexBuffer);
 
         positionAttribute->setBuffer(dataBuffer.data());
         positionAttribute->setName(Qt3DRender::QAttribute::defaultPositionAttributeName());
@@ -680,20 +680,20 @@ private Q_SLOTS:
 
         Attribute *backendAttribute = nodeManagers->attributeManager()->getOrCreateResource(positionAttribute->id());
         backendAttribute->setRenderer(&renderer);
-        simulateInitialization(positionAttribute.data(), backendAttribute);
+        simulateInitializationSync(positionAttribute.data(), backendAttribute);
 
         Attribute *backendIndexAttribute = nodeManagers->attributeManager()->getOrCreateResource(indexAttribute->id());
         backendIndexAttribute->setRenderer(&renderer);
-        simulateInitialization(indexAttribute.data(), backendIndexAttribute);
+        simulateInitializationSync(indexAttribute.data(), backendIndexAttribute);
 
         Geometry *backendGeometry = nodeManagers->geometryManager()->getOrCreateResource(geometry->id());
         backendGeometry->setRenderer(&renderer);
-        simulateInitialization(geometry, backendGeometry);
+        simulateInitializationSync(geometry, backendGeometry);
 
         GeometryRenderer *backendRenderer = nodeManagers->geometryRendererManager()->getOrCreateResource(geometryRenderer->id());
         backendRenderer->setRenderer(&renderer);
         backendRenderer->setManager(nodeManagers->geometryRendererManager());
-        simulateInitialization(geometryRenderer.data(), backendRenderer);
+        simulateInitializationSync(geometryRenderer.data(), backendRenderer);
 
         // WHEN
         visitor.apply(backendRenderer, Qt3DCore::QNodeId());
@@ -742,7 +742,7 @@ private Q_SLOTS:
         Buffer *backendBuffer = nodeManagers->bufferManager()->getOrCreateResource(dataBuffer->id());
         backendBuffer->setRenderer(&renderer);
         backendBuffer->setManager(nodeManagers->bufferManager());
-        simulateInitialization(dataBuffer.data(), backendBuffer);
+        simulateInitializationSync(dataBuffer.data(), backendBuffer);
 
         positionAttribute->setBuffer(dataBuffer.data());
         positionAttribute->setName(Qt3DRender::QAttribute::defaultPositionAttributeName());
@@ -759,16 +759,16 @@ private Q_SLOTS:
 
         Attribute *backendAttribute = nodeManagers->attributeManager()->getOrCreateResource(positionAttribute->id());
         backendAttribute->setRenderer(&renderer);
-        simulateInitialization(positionAttribute.data(), backendAttribute);
+        simulateInitializationSync(positionAttribute.data(), backendAttribute);
 
         Geometry *backendGeometry = nodeManagers->geometryManager()->getOrCreateResource(geometry->id());
         backendGeometry->setRenderer(&renderer);
-        simulateInitialization(geometry, backendGeometry);
+        simulateInitializationSync(geometry, backendGeometry);
 
         GeometryRenderer *backendRenderer = nodeManagers->geometryRendererManager()->getOrCreateResource(geometryRenderer->id());
         backendRenderer->setRenderer(&renderer);
         backendRenderer->setManager(nodeManagers->geometryRendererManager());
-        simulateInitialization(geometryRenderer.data(), backendRenderer);
+        simulateInitializationSync(geometryRenderer.data(), backendRenderer);
 
         // WHEN
         visitor.apply(backendRenderer, Qt3DCore::QNodeId());
@@ -816,7 +816,7 @@ private Q_SLOTS:
         Buffer *backendBuffer = nodeManagers->bufferManager()->getOrCreateResource(dataBuffer->id());
         backendBuffer->setRenderer(&renderer);
         backendBuffer->setManager(nodeManagers->bufferManager());
-        simulateInitialization(dataBuffer.data(), backendBuffer);
+        simulateInitializationSync(dataBuffer.data(), backendBuffer);
 
         QByteArray indexData;
         indexData.resize(sizeof(uint) * 3 * 4);
@@ -839,7 +839,7 @@ private Q_SLOTS:
         Buffer *backendIndexBuffer = nodeManagers->bufferManager()->getOrCreateResource(indexDataBuffer->id());
         backendIndexBuffer->setRenderer(&renderer);
         backendIndexBuffer->setManager(nodeManagers->bufferManager());
-        simulateInitialization(indexDataBuffer.data(), backendIndexBuffer);
+        simulateInitializationSync(indexDataBuffer.data(), backendIndexBuffer);
 
         positionAttribute->setBuffer(dataBuffer.data());
         positionAttribute->setName(Qt3DRender::QAttribute::defaultPositionAttributeName());
@@ -863,20 +863,20 @@ private Q_SLOTS:
 
         Attribute *backendAttribute = nodeManagers->attributeManager()->getOrCreateResource(positionAttribute->id());
         backendAttribute->setRenderer(&renderer);
-        simulateInitialization(positionAttribute.data(), backendAttribute);
+        simulateInitializationSync(positionAttribute.data(), backendAttribute);
 
         Attribute *backendIndexAttribute = nodeManagers->attributeManager()->getOrCreateResource(indexAttribute->id());
         backendIndexAttribute->setRenderer(&renderer);
-        simulateInitialization(indexAttribute.data(), backendIndexAttribute);
+        simulateInitializationSync(indexAttribute.data(), backendIndexAttribute);
 
         Geometry *backendGeometry = nodeManagers->geometryManager()->getOrCreateResource(geometry->id());
         backendGeometry->setRenderer(&renderer);
-        simulateInitialization(geometry, backendGeometry);
+        simulateInitializationSync(geometry, backendGeometry);
 
         GeometryRenderer *backendRenderer = nodeManagers->geometryRendererManager()->getOrCreateResource(geometryRenderer->id());
         backendRenderer->setRenderer(&renderer);
         backendRenderer->setManager(nodeManagers->geometryRendererManager());
-        simulateInitialization(geometryRenderer.data(), backendRenderer);
+        simulateInitializationSync(geometryRenderer.data(), backendRenderer);
 
         // WHEN
         visitor.apply(backendRenderer, Qt3DCore::QNodeId());
@@ -936,7 +936,7 @@ private Q_SLOTS:
         Buffer *backendBuffer = nodeManagers->bufferManager()->getOrCreateResource(dataBuffer->id());
         backendBuffer->setRenderer(&renderer);
         backendBuffer->setManager(nodeManagers->bufferManager());
-        simulateInitialization(dataBuffer.data(), backendBuffer);
+        simulateInitializationSync(dataBuffer.data(), backendBuffer);
 
         positionAttribute->setBuffer(dataBuffer.data());
         positionAttribute->setName(Qt3DRender::QAttribute::defaultPositionAttributeName());
@@ -953,16 +953,16 @@ private Q_SLOTS:
 
         Attribute *backendAttribute = nodeManagers->attributeManager()->getOrCreateResource(positionAttribute->id());
         backendAttribute->setRenderer(&renderer);
-        simulateInitialization(positionAttribute.data(), backendAttribute);
+        simulateInitializationSync(positionAttribute.data(), backendAttribute);
 
         Geometry *backendGeometry = nodeManagers->geometryManager()->getOrCreateResource(geometry->id());
         backendGeometry->setRenderer(&renderer);
-        simulateInitialization(geometry, backendGeometry);
+        simulateInitializationSync(geometry, backendGeometry);
 
         GeometryRenderer *backendRenderer = nodeManagers->geometryRendererManager()->getOrCreateResource(geometryRenderer->id());
         backendRenderer->setRenderer(&renderer);
         backendRenderer->setManager(nodeManagers->geometryRendererManager());
-        simulateInitialization(geometryRenderer.data(), backendRenderer);
+        simulateInitializationSync(geometryRenderer.data(), backendRenderer);
 
         // WHEN
         visitor.apply(backendRenderer, Qt3DCore::QNodeId());
@@ -1012,7 +1012,7 @@ private Q_SLOTS:
         Buffer *backendBuffer = nodeManagers->bufferManager()->getOrCreateResource(dataBuffer->id());
         backendBuffer->setRenderer(&renderer);
         backendBuffer->setManager(nodeManagers->bufferManager());
-        simulateInitialization(dataBuffer.data(), backendBuffer);
+        simulateInitializationSync(dataBuffer.data(), backendBuffer);
 
         QByteArray indexData;
         indexData.resize(sizeof(uint) * 8);
@@ -1030,7 +1030,7 @@ private Q_SLOTS:
         Buffer *backendIndexBuffer = nodeManagers->bufferManager()->getOrCreateResource(indexDataBuffer->id());
         backendIndexBuffer->setRenderer(&renderer);
         backendIndexBuffer->setManager(nodeManagers->bufferManager());
-        simulateInitialization(indexDataBuffer.data(), backendIndexBuffer);
+        simulateInitializationSync(indexDataBuffer.data(), backendIndexBuffer);
 
         positionAttribute->setBuffer(dataBuffer.data());
         positionAttribute->setName(Qt3DRender::QAttribute::defaultPositionAttributeName());
@@ -1054,20 +1054,20 @@ private Q_SLOTS:
 
         Attribute *backendAttribute = nodeManagers->attributeManager()->getOrCreateResource(positionAttribute->id());
         backendAttribute->setRenderer(&renderer);
-        simulateInitialization(positionAttribute.data(), backendAttribute);
+        simulateInitializationSync(positionAttribute.data(), backendAttribute);
 
         Attribute *backendIndexAttribute = nodeManagers->attributeManager()->getOrCreateResource(indexAttribute->id());
         backendIndexAttribute->setRenderer(&renderer);
-        simulateInitialization(indexAttribute.data(), backendIndexAttribute);
+        simulateInitializationSync(indexAttribute.data(), backendIndexAttribute);
 
         Geometry *backendGeometry = nodeManagers->geometryManager()->getOrCreateResource(geometry->id());
         backendGeometry->setRenderer(&renderer);
-        simulateInitialization(geometry, backendGeometry);
+        simulateInitializationSync(geometry, backendGeometry);
 
         GeometryRenderer *backendRenderer = nodeManagers->geometryRendererManager()->getOrCreateResource(geometryRenderer->id());
         backendRenderer->setRenderer(&renderer);
         backendRenderer->setManager(nodeManagers->geometryRendererManager());
-        simulateInitialization(geometryRenderer.data(), backendRenderer);
+        simulateInitializationSync(geometryRenderer.data(), backendRenderer);
 
         // WHEN
         visitor.apply(backendRenderer, Qt3DCore::QNodeId());
diff --git a/tests/auto/render/updatemeshtrianglelistjob/tst_updatemeshtrianglelistjob.cpp b/tests/auto/render/updatemeshtrianglelistjob/tst_updatemeshtrianglelistjob.cpp
index 71576d495..df24a5ca6 100644
--- a/tests/auto/render/updatemeshtrianglelistjob/tst_updatemeshtrianglelistjob.cpp
+++ b/tests/auto/render/updatemeshtrianglelistjob/tst_updatemeshtrianglelistjob.cpp
@@ -69,6 +69,23 @@ QVector<Qt3DCore::QNode *> getNodesForCreation(Qt3DCore::QNode *root)
     return nodes;
 }
 
+QVector<Qt3DCore::NodeTreeChange> nodeTreeChangesForNodes(const QVector<Qt3DCore::QNode *> nodes)
+{
+    QVector<Qt3DCore::NodeTreeChange> nodeTreeChanges;
+    nodeTreeChanges.reserve(nodes.size());
+
+    for (Qt3DCore::QNode *n : nodes) {
+        nodeTreeChanges.push_back({
+                                      n->id(),
+                                      Qt3DCore::QNodePrivate::get(n)->m_typeInfo,
+                                      Qt3DCore::NodeTreeChange::Added,
+                                      n
+                                  });
+    }
+
+    return nodeTreeChanges;
+}
+
 class TestAspect : public Qt3DRender::QRenderAspect
 {
 public:
@@ -79,7 +96,7 @@ public:
         Qt3DRender::QRenderAspect::onRegistered();
 
         const QVector<Qt3DCore::QNode *> nodes = getNodesForCreation(root);
-        d_func()->setRootAndCreateNodes(qobject_cast<Qt3DCore::QEntity *>(root), nodes);
+        d_func()->setRootAndCreateNodes(qobject_cast<Qt3DCore::QEntity *>(root), nodeTreeChangesForNodes(nodes));
 
         Qt3DRender::Render::Entity *rootEntity = nodeManagers()->lookupResource<Qt3DRender::Render::Entity, Render::EntityManager>(rootEntityId());
         Q_ASSERT(rootEntity);
diff --git a/tests/auto/render/updateshaderdatatransformjob/tst_updateshaderdatatransformjob.cpp b/tests/auto/render/updateshaderdatatransformjob/tst_updateshaderdatatransformjob.cpp
index 4fe1794dc..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>
@@ -70,6 +69,23 @@ QVector<Qt3DCore::QNode *> getNodesForCreation(Qt3DCore::QNode *root)
     return nodes;
 }
 
+QVector<Qt3DCore::NodeTreeChange> nodeTreeChangesForNodes(const QVector<Qt3DCore::QNode *> nodes)
+{
+    QVector<Qt3DCore::NodeTreeChange> nodeTreeChanges;
+    nodeTreeChanges.reserve(nodes.size());
+
+    for (Qt3DCore::QNode *n : nodes) {
+        nodeTreeChanges.push_back({
+                                      n->id(),
+                                      Qt3DCore::QNodePrivate::get(n)->m_typeInfo,
+                                      Qt3DCore::NodeTreeChange::Added,
+                                      n
+                                  });
+    }
+
+    return nodeTreeChanges;
+}
+
 class TestAspect : public Qt3DRender::QRenderAspect
 {
 public:
@@ -80,7 +96,7 @@ public:
         Qt3DRender::QRenderAspect::onRegistered();
 
         const QVector<Qt3DCore::QNode *> nodes = getNodesForCreation(root);
-        d_func()->setRootAndCreateNodes(qobject_cast<Qt3DCore::QEntity *>(root), nodes);
+        d_func()->setRootAndCreateNodes(qobject_cast<Qt3DCore::QEntity *>(root), nodeTreeChangesForNodes(nodes));
 
         Qt3DRender::Render::Entity *rootEntity = nodeManagers()->lookupResource<Qt3DRender::Render::Entity, Render::EntityManager>(rootEntityId());
         Q_ASSERT(rootEntity);
@@ -112,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));
diff --git a/tests/benchmarks/render/jobs/tst_bench_jobs.cpp b/tests/benchmarks/render/jobs/tst_bench_jobs.cpp
index 35b7e0184..b611f3cdc 100644
--- a/tests/benchmarks/render/jobs/tst_bench_jobs.cpp
+++ b/tests/benchmarks/render/jobs/tst_bench_jobs.cpp
@@ -123,16 +123,21 @@ namespace Qt3DRender {
         void onRootEntityChanged(Qt3DCore::QEntity *root)
         {
             if (!m_window) {
-                QVector<Qt3DCore::QNode *> nodes;
+                QVector<Qt3DCore::NodeTreeChange> nodes;
                 Qt3DCore::QNodeVisitor v;
                 v.traverse(root, [&nodes](Qt3DCore::QNode *node) {
                     Qt3DCore::QNodePrivate *d = Qt3DCore::QNodePrivate::get(node);
                     d->m_typeInfo = const_cast<QMetaObject*>(Qt3DCore::QNodePrivate::findStaticMetaObject(node->metaObject()));
                     d->m_hasBackendNode = true;
-                    nodes << node;
+                    nodes.push_back({
+                        node->id(),
+                        Qt3DCore::QNodePrivate::get(node)->m_typeInfo,
+                        Qt3DCore::NodeTreeChange::Added,
+                        node
+                    });
                 });
 
-                for (const auto node: nodes)
+                for (const auto &node: nodes)
                     d_func()->createBackendNode(node);
 
                 static_cast<Qt3DRender::Render::Renderer *>(d_func()->m_renderer)->m_renderSceneRoot =
diff --git a/tests/benchmarks/render/layerfiltering/tst_bench_layerfiltering.cpp b/tests/benchmarks/render/layerfiltering/tst_bench_layerfiltering.cpp
index 279655715..5523457be 100644
--- a/tests/benchmarks/render/layerfiltering/tst_bench_layerfiltering.cpp
+++ b/tests/benchmarks/render/layerfiltering/tst_bench_layerfiltering.cpp
@@ -55,16 +55,21 @@ public:
         Qt3DCore::QAbstractAspectPrivate::get(this)->m_jobManager = m_jobManager.data();
         QRenderAspect::onRegistered();
 
-        QVector<Qt3DCore::QNode *> nodes;
+        QVector<Qt3DCore::NodeTreeChange> nodes;
         Qt3DCore::QNodeVisitor v;
         v.traverse(root, [&nodes](Qt3DCore::QNode *node) {
             Qt3DCore::QNodePrivate *d = Qt3DCore::QNodePrivate::get(node);
             d->m_typeInfo = const_cast<QMetaObject*>(Qt3DCore::QNodePrivate::findStaticMetaObject(node->metaObject()));
             d->m_hasBackendNode = true;
-            nodes << node;
+            nodes.push_back({
+                node->id(),
+                Qt3DCore::QNodePrivate::get(node)->m_typeInfo,
+                Qt3DCore::NodeTreeChange::Added,
+                node
+            });
         });
 
-        for (const auto node: nodes)
+        for (const auto &node: nodes)
             d_func()->createBackendNode(node);
     }
 
diff --git a/tests/benchmarks/render/materialparametergathering/tst_bench_materialparametergathering.cpp b/tests/benchmarks/render/materialparametergathering/tst_bench_materialparametergathering.cpp
index 0bb1f6cf9..210d82dcf 100644
--- a/tests/benchmarks/render/materialparametergathering/tst_bench_materialparametergathering.cpp
+++ b/tests/benchmarks/render/materialparametergathering/tst_bench_materialparametergathering.cpp
@@ -56,16 +56,21 @@ public:
         Qt3DCore::QAbstractAspectPrivate::get(this)->m_jobManager = m_jobManager.data();
         QRenderAspect::onRegistered();
 
-        QVector<Qt3DCore::QNode *> nodes;
+        QVector<Qt3DCore::NodeTreeChange> nodes;
         Qt3DCore::QNodeVisitor v;
         v.traverse(root, [&nodes](Qt3DCore::QNode *node) {
             Qt3DCore::QNodePrivate *d = Qt3DCore::QNodePrivate::get(node);
             d->m_typeInfo = const_cast<QMetaObject*>(Qt3DCore::QNodePrivate::findStaticMetaObject(node->metaObject()));
             d->m_hasBackendNode = true;
-            nodes << node;
+            nodes.push_back({
+                node->id(),
+                Qt3DCore::QNodePrivate::get(node)->m_typeInfo,
+                Qt3DCore::NodeTreeChange::Added,
+                node
+            });
         });
 
-        for (const auto node: nodes)
+        for (const auto &node: nodes)
             d_func()->createBackendNode(node);
 
         const auto handles = nodeManagers()->techniqueManager()->activeHandles();
diff --git a/tests/manual/custom-mesh-update-data-cpp/main.cpp b/tests/manual/custom-mesh-update-data-cpp/main.cpp
index e9025c158..2b6b6b3cf 100644
--- a/tests/manual/custom-mesh-update-data-cpp/main.cpp
+++ b/tests/manual/custom-mesh-update-data-cpp/main.cpp
@@ -211,6 +211,7 @@ int main(int argc, char* argv[])
     Qt3DRender::QAttribute *positionAttribute = new Qt3DRender::QAttribute();
     positionAttribute->setAttributeType(Qt3DRender::QAttribute::VertexAttribute);
     positionAttribute->setBuffer(vertexDataBuffer);
+    positionAttribute->setVertexSize(3);
     positionAttribute->setByteOffset(0);
     positionAttribute->setByteStride(9 * sizeof(float));
     positionAttribute->setCount(4);
@@ -219,6 +220,7 @@ int main(int argc, char* argv[])
     Qt3DRender::QAttribute *normalAttribute = new Qt3DRender::QAttribute();
     normalAttribute->setAttributeType(Qt3DRender::QAttribute::VertexAttribute);
     normalAttribute->setBuffer(vertexDataBuffer);
+    normalAttribute->setVertexSize(3);
     normalAttribute->setByteOffset(3 * sizeof(float));
     normalAttribute->setByteStride(9 * sizeof(float));
     normalAttribute->setCount(4);
@@ -227,6 +229,7 @@ int main(int argc, char* argv[])
     Qt3DRender::QAttribute *colorAttribute = new Qt3DRender::QAttribute();
     colorAttribute->setAttributeType(Qt3DRender::QAttribute::VertexAttribute);
     colorAttribute->setBuffer(vertexDataBuffer);
+    colorAttribute->setVertexSize(3);
     colorAttribute->setByteOffset(6 * sizeof(float));
     colorAttribute->setByteStride(9 * sizeof(float));
     colorAttribute->setCount(4);
@@ -235,6 +238,8 @@ int main(int argc, char* argv[])
     Qt3DRender::QAttribute *indexAttribute = new Qt3DRender::QAttribute();
     indexAttribute->setAttributeType(Qt3DRender::QAttribute::IndexAttribute);
     indexAttribute->setBuffer(indexDataBuffer);
+    indexAttribute->setVertexBaseType(Qt3DRender::QAttribute::UnsignedShort);
+    indexAttribute->setVertexSize(1);
     indexAttribute->setByteOffset(0);
     indexAttribute->setByteStride(0);
     indexAttribute->setCount(12);