diff --git a/CHANGELOG.md b/CHANGELOG.md
index b24470d267..0539d3fa2a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,7 @@
 # NEXT RELEASE
 
 ### Enhancements
+* Improve sync bootstrap performance by reducing the number of table selections in the replication logs for embedded objects. ([#7945](https://github.com/realm/realm-core/issues/7945))
 * <New feature description> (PR [#????](https://github.com/realm/realm-core/pull/????))
 * Client reset cycle detection now checks if the previous recovery attempt was made by the same core version, and if not attempts recovery again ([PR #7944](https://github.com/realm/realm-core/pull/7944)).
 
diff --git a/src/realm/replication.cpp b/src/realm/replication.cpp
index 350eb61fd0..26826fb499 100644
--- a/src/realm/replication.cpp
+++ b/src/realm/replication.cpp
@@ -140,19 +140,20 @@ void Replication::erase_column(const Table* t, ColKey col_key)
     m_encoder.erase_column(col_key); // Throws
 }
 
-void Replication::track_new_object(ObjKey key)
+void Replication::track_new_object(const Table* table, ObjKey key)
 {
-    m_selected_obj = key;
-    m_selected_collection = CollectionId();
-    m_newly_created_object = true;
+    if (table == m_selected_table) {
+        m_selected_obj = key;
+        m_selected_obj_is_newly_created = true;
+    }
 
-    auto table_index = m_selected_table->get_index_in_group();
+    auto table_index = table->get_index_in_group();
     if (table_index >= m_most_recently_created_object.size()) {
         if (table_index >= m_most_recently_created_object.capacity())
             m_most_recently_created_object.reserve(table_index * 2);
         m_most_recently_created_object.resize(table_index + 1);
     }
-    m_most_recently_created_object[table_index] = m_selected_obj;
+    m_most_recently_created_object[table_index] = key;
 }
 
 void Replication::create_object(const Table* t, GlobalKey id)
@@ -162,7 +163,7 @@ void Replication::create_object(const Table* t, GlobalKey id)
     }
     select_table(t);                              // Throws
     m_encoder.create_object(id.get_local_key(0)); // Throws
-    track_new_object(id.get_local_key(0));        // Throws
+    track_new_object(t, id.get_local_key(0));     // Throws
 }
 
 void Replication::create_object_with_primary_key(const Table* t, ObjKey key, Mixed pk)
@@ -173,13 +174,12 @@ void Replication::create_object_with_primary_key(const Table* t, ObjKey key, Mix
     }
     select_table(t);              // Throws
     m_encoder.create_object(key); // Throws
-    track_new_object(key);
+    track_new_object(t, key);
 }
 
 void Replication::create_linked_object(const Table* t, ObjKey key)
 {
-    select_table(t);       // Throws
-    track_new_object(key); // Throws
+    track_new_object(t, key); // Throws
     // Does not need to encode anything as embedded tables can't be observed
 }
 
@@ -207,30 +207,37 @@ void Replication::do_select_table(const Table* table)
     m_selected_table = table;
     m_selected_collection = CollectionId();
     m_selected_obj = ObjKey();
+    m_selected_obj_is_newly_created = false;
 }
 
-void Replication::do_select_obj(ObjKey key)
+bool Replication::check_for_newly_created_object(ObjKey key, const Table* table)
 {
-    m_selected_obj = key;
-    m_selected_collection = CollectionId();
-
-    auto table_index = m_selected_table->get_index_in_group();
+    auto table_index = table->get_index_in_group();
     if (table_index < m_most_recently_created_object.size()) {
-        m_newly_created_object = m_most_recently_created_object[table_index] == key;
+        return m_most_recently_created_object[table_index] == key;
     }
-    else {
-        m_newly_created_object = false;
+    return false;
+}
+
+bool Replication::do_select_obj(ObjKey key, const Table* table)
+{
+    bool newly_created = check_for_newly_created_object(key, table);
+    if (!newly_created) {
+        select_table(table);
+        m_selected_obj = key;
+        m_selected_obj_is_newly_created = false;
+        m_selected_collection = CollectionId();
     }
 
     if (auto logger = would_log(LogLevel::debug)) {
-        auto class_name = m_selected_table->get_class_name();
-        if (m_selected_table->get_primary_key_column()) {
-            auto pk = m_selected_table->get_primary_key(key);
+        auto class_name = table->get_class_name();
+        if (table->get_primary_key_column()) {
+            auto pk = table->get_primary_key(key);
             logger->log(LogCategory::object, LogLevel::debug, "Mutating object '%1' with primary key %2", class_name,
                         pk);
         }
-        else if (m_selected_table->is_embedded()) {
-            auto obj = m_selected_table->get_object(key);
+        else if (table->is_embedded()) {
+            auto obj = table->get_object(key);
             logger->log(LogCategory::object, LogLevel::debug, "Mutating object '%1' with path '%2'", class_name,
                         obj.get_id());
         }
@@ -238,26 +245,21 @@ void Replication::do_select_obj(ObjKey key)
             logger->log(LogCategory::object, LogLevel::debug, "Mutating anonymous object '%1'[%2]", class_name, key);
         }
     }
+    return newly_created;
 }
 
 void Replication::do_select_collection(const CollectionBase& coll)
 {
-    select_table(coll.get_table().unchecked_ptr());
-    ColKey col_key = coll.get_col_key();
-    ObjKey key = coll.get_owner_key();
-    auto path = coll.get_stable_path();
-
-    if (select_obj(key)) {
-        m_encoder.select_collection(col_key, key, path); // Throws
+    if (select_obj(coll.get_owner_key(), coll.get_table().unchecked_ptr())) {
+        m_encoder.select_collection(coll.get_col_key(), coll.get_owner_key(), coll.get_stable_path()); // Throws
+        m_selected_collection = CollectionId(coll);
     }
-    m_selected_collection = CollectionId(coll.get_table()->get_key(), key, std::move(path));
 }
 
 void Replication::do_set(const Table* t, ColKey col_key, ObjKey key, _impl::Instruction variant)
 {
     if (variant != _impl::Instruction::instr_SetDefault) {
-        select_table(t); // Throws
-        if (select_obj(key)) {
+        if (select_obj(key, t)) {                  // Throws
             m_encoder.modify_object(col_key, key); // Throws
         }
     }
@@ -294,8 +296,7 @@ void Replication::set(const Table* t, ColKey col_key, ObjKey key, Mixed value, _
 
 void Replication::nullify_link(const Table* t, ColKey col_key, ObjKey key)
 {
-    select_table(t); // Throws
-    if (select_obj(key)) {
+    if (select_obj(key, t)) {                  // Throws
         m_encoder.modify_object(col_key, key); // Throws
     }
     if (auto logger = would_log(LogLevel::trace)) {
@@ -311,10 +312,10 @@ void Replication::add_int(const Table* t, ColKey col_key, ObjKey key, int_fast64
     }
 }
 
-Path Replication::get_prop_name(Path&& path) const
+Path Replication::get_prop_name(ConstTableRef table, Path&& path) const
 {
     auto col_key = path[0].get_col_key();
-    auto prop_name = m_selected_table->get_column_name(col_key);
+    auto prop_name = table->get_column_name(col_key);
     path[0] = PathElement(prop_name);
     return std::move(path);
 }
@@ -328,14 +329,15 @@ void Replication::log_collection_operation(const char* operation, const Collecti
 
     auto path = collection.get_short_path();
     auto col_key = path[0].get_col_key();
-    auto prop_name = m_selected_table->get_column_name(col_key);
+    ConstTableRef table = collection.get_table();
+    auto prop_name = table->get_column_name(col_key);
     path[0] = PathElement(prop_name);
     std::string position;
     if (!index.is_null()) {
         position = util::format(" at position %1", index);
     }
     if (Table::is_link_type(col_key.get_type()) && value.is_type(type_Link)) {
-        auto target_table = m_selected_table->get_opposite_table(col_key);
+        auto target_table = table->get_opposite_table(col_key);
         if (target_table->is_embedded()) {
             logger->log(LogCategory::object, LogLevel::trace, "   %1 embedded object '%2' in %3%4 ", operation,
                         target_table->get_class_name(), path, position);
@@ -381,7 +383,7 @@ void Replication::list_erase(const CollectionBase& list, size_t link_ndx)
     }
     if (auto logger = would_log(LogLevel::trace)) {
         logger->log(LogCategory::object, LogLevel::trace, "   Erase '%1' at position %2",
-                    get_prop_name(list.get_short_path()), link_ndx);
+                    get_prop_name(list.get_table(), list.get_short_path()), link_ndx);
     }
 }
 
@@ -392,7 +394,7 @@ void Replication::list_move(const CollectionBase& list, size_t from_link_ndx, si
     }
     if (auto logger = would_log(LogLevel::trace)) {
         logger->log(LogCategory::object, LogLevel::trace, "   Move %1 to %2 in '%3'", from_link_ndx, to_link_ndx,
-                    get_prop_name(list.get_short_path()));
+                    get_prop_name(list.get_table(), list.get_short_path()));
     }
 }
 
@@ -417,7 +419,8 @@ void Replication::list_clear(const CollectionBase& list)
         m_encoder.collection_clear(list.size()); // Throws
     }
     if (auto logger = would_log(LogLevel::trace)) {
-        logger->log(LogCategory::object, LogLevel::trace, "   Clear '%1'", get_prop_name(list.get_short_path()));
+        logger->log(LogCategory::object, LogLevel::trace, "   Clear '%1'",
+                    get_prop_name(list.get_table(), list.get_short_path()));
     }
 }
 
@@ -428,7 +431,7 @@ void Replication::link_list_nullify(const Lst<ObjKey>& list, size_t link_ndx)
     }
     if (auto logger = would_log(LogLevel::trace)) {
         logger->log(LogCategory::object, LogLevel::trace, "   Nullify '%1' position %2",
-                    m_selected_table->get_column_name(list.get_col_key()), link_ndx);
+                    list.get_table()->get_column_name(list.get_col_key()), link_ndx);
     }
 }
 
@@ -455,7 +458,7 @@ void Replication::dictionary_erase(const CollectionBase& dict, size_t ndx, Mixed
     }
     if (auto logger = would_log(LogLevel::trace)) {
         logger->log(LogCategory::object, LogLevel::trace, "   Erase %1 from '%2'", key,
-                    get_prop_name(dict.get_short_path()));
+                    get_prop_name(dict.get_table(), dict.get_short_path()));
     }
 }
 
@@ -465,6 +468,7 @@ void Replication::dictionary_clear(const CollectionBase& dict)
         m_encoder.collection_clear(dict.size());
     }
     if (auto logger = would_log(LogLevel::trace)) {
-        logger->log(LogCategory::object, LogLevel::trace, "   Clear '%1'", get_prop_name(dict.get_short_path()));
+        logger->log(LogCategory::object, LogLevel::trace, "   Clear '%1'",
+                    get_prop_name(dict.get_table(), dict.get_short_path()));
     }
 }
diff --git a/src/realm/replication.hpp b/src/realm/replication.hpp
index 5bae6e7c6e..41d6ff28dd 100644
--- a/src/realm/replication.hpp
+++ b/src/realm/replication.hpp
@@ -392,33 +392,34 @@ class Replication {
     util::Logger* m_logger = nullptr;
     const Table* m_selected_table = nullptr;
     ObjKey m_selected_obj;
+    bool m_selected_obj_is_newly_created = false;
     CollectionId m_selected_collection;
     // The ObjKey of the most recently created object for each table (indexed
     // by the Table's index in the group). Most insertion patterns will only
     // ever update the most recently created object, so this is almost as
     // effective as tracking all newly created objects but much cheaper.
     std::vector<ObjKey> m_most_recently_created_object;
-    // When true, the currently selected object was created in this transaction
-    // and we don't need to emit instructions for mutations on it
-    bool m_newly_created_object = false;
 
     void unselect_all() noexcept;
     void select_table(const Table*); // unselects link list and obj
-    bool select_obj(ObjKey key);
-    bool select_collection(const CollectionBase&);
+    [[nodiscard]] bool select_obj(ObjKey key, const Table*);
+    [[nodiscard]] bool select_collection(const CollectionBase&);
 
     void do_select_table(const Table*);
-    void do_select_obj(ObjKey key);
-    void do_select_collection(const CollectionBase&);
+    [[nodiscard]] bool do_select_obj(ObjKey key, const Table*);
+    void do_select_collection(const CollectionBase& coll);
+    // When true, the currently selected object was created in this transaction
+    // and we don't need to emit instructions for mutations on it
+    bool check_for_newly_created_object(ObjKey key, const Table* table);
 
     // Mark this ObjKey as being a newly created object that should not emit
     // mutation instructions
-    void track_new_object(ObjKey);
+    void track_new_object(const Table*, ObjKey);
 
     void do_set(const Table*, ColKey col_key, ObjKey key, _impl::Instruction variant = _impl::instr_Set);
     void log_collection_operation(const char* operation, const CollectionBase& collection, Mixed value,
                                   Mixed index) const;
-    Path get_prop_name(Path&&) const;
+    Path get_prop_name(ConstTableRef, Path&&) const;
     size_t transact_log_size();
 };
 
@@ -463,7 +464,7 @@ inline void Replication::unselect_all() noexcept
 {
     m_selected_table = nullptr;
     m_selected_collection = CollectionId();
-    m_newly_created_object = false;
+    m_selected_obj_is_newly_created = false;
 }
 
 inline void Replication::select_table(const Table* table)
@@ -474,18 +475,20 @@ inline void Replication::select_table(const Table* table)
 
 inline bool Replication::select_collection(const CollectionBase& coll)
 {
+    bool newly_created_object =
+        check_for_newly_created_object(coll.get_owner_key(), coll.get_table().unchecked_ptr());
     if (CollectionId(coll) != m_selected_collection) {
         do_select_collection(coll); // Throws
     }
-    return !m_newly_created_object;
+    return !newly_created_object;
 }
 
-inline bool Replication::select_obj(ObjKey key)
+inline bool Replication::select_obj(ObjKey key, const Table* table)
 {
-    if (key != m_selected_obj) {
-        do_select_obj(key);
+    if (key != m_selected_obj || table != m_selected_table) {
+        return !do_select_obj(key, table);
     }
-    return !m_newly_created_object;
+    return !m_selected_obj_is_newly_created;
 }
 
 inline void Replication::rename_class(TableKey table_key, StringData)
diff --git a/test/test_replication.cpp b/test/test_replication.cpp
index 5e0fe845db..2c9396af7b 100644
--- a/test/test_replication.cpp
+++ b/test/test_replication.cpp
@@ -25,6 +25,7 @@
 #include <realm.hpp>
 #include <realm/util/features.h>
 #include <realm/util/file.hpp>
+#include <realm/util/overload.hpp>
 #include <realm/replication.hpp>
 
 #include "test.hpp"
@@ -264,55 +265,204 @@ TEST(Replication_WriteWithoutHistory)
     }
 }
 
-struct ObjectMutationObserver : _impl::NoOpTransactionLogParser {
+struct Select {
+    TableKey table_key;
+};
+
+struct Create {
+    int64_t obj_key;
+};
+
+struct Mutate {
+    int64_t obj_key;
+    ColKey col_key;
+};
+
+struct Remove {
+    int64_t obj_key;
+};
+
+struct SelectColl {
+    int64_t obj_key;
+    ColKey col_key;
+};
+
+struct CollInsert {
+    size_t ndx;
+};
+
+struct CollSet {
+    size_t ndx;
+};
+
+using InstructionVariant = mpark::variant<Select, Create, Mutate, Remove, SelectColl, CollInsert, CollSet>;
+
+std::ostream& print_instructions(std::ostream& os, const std::vector<InstructionVariant>& ivs,
+                                 size_t first_difference) noexcept
+{
+    size_t ndx = 0;
+    for (auto& element : ivs) {
+        if (first_difference == ndx) {
+            os << "==> ";
+        }
+        util::format(os, "[%1]: ", ndx++);
+        auto print = overload{
+            [&](Select st) {
+                util::format(os, "Select{%1}", st.table_key);
+            },
+            [&](Create co) {
+                util::format(os, "CreateObject{%1}", co.obj_key);
+            },
+            [&](Mutate mo) {
+                util::format(os, "Mutate{%1, %2}", mo.obj_key, mo.col_key);
+            },
+            [&](Remove rm) {
+                util::format(os, "RemoveObject{%1}", rm.obj_key);
+            },
+            [&](SelectColl sc) {
+                util::format(os, "SelectCollection{%1, %2}", sc.obj_key, sc.col_key);
+            },
+            [&](CollInsert ci) {
+                util::format(os, "CollectionInsert{%1}", ci.ndx);
+            },
+            [&](CollSet cs) {
+                util::format(os, "CollectionSet{%1}", cs.ndx);
+            },
+        };
+        mpark::visit(print, element);
+        os << '\n';
+    }
+    return os;
+}
+
+bool compare_instructions(const InstructionVariant& a, const InstructionVariant& b)
+{
+    bool equal = false;
+    auto comp = overload{
+        [&](Select a_val) {
+            if (const Select* b_val = mpark::get_if<Select>(&b)) {
+                equal = a_val.table_key == b_val->table_key;
+            }
+        },
+        [&](Create a_val) {
+            if (const Create* b_val = mpark::get_if<Create>(&b)) {
+                equal = a_val.obj_key == b_val->obj_key;
+            }
+        },
+        [&](Mutate a_val) {
+            if (const Mutate* b_val = mpark::get_if<Mutate>(&b)) {
+                equal = (a_val.obj_key == b_val->obj_key && a_val.col_key == b_val->col_key);
+            }
+        },
+        [&](Remove a_val) {
+            if (const Remove* b_val = mpark::get_if<Remove>(&b)) {
+                equal = a_val.obj_key == b_val->obj_key;
+            }
+        },
+        [&](SelectColl a_val) {
+            if (const SelectColl* b_val = mpark::get_if<SelectColl>(&b)) {
+                equal = a_val.obj_key == b_val->obj_key && a_val.col_key == b_val->col_key;
+            }
+        },
+        [&](CollInsert a_val) {
+            if (const CollInsert* b_val = mpark::get_if<CollInsert>(&b)) {
+                equal = a_val.ndx == b_val->ndx;
+            }
+        },
+        [&](CollSet a_val) {
+            if (const CollSet* b_val = mpark::get_if<CollSet>(&b)) {
+                equal = a_val.ndx == b_val->ndx;
+            }
+        },
+    };
+    mpark::visit(comp, a);
+    return equal;
+}
+
+struct RecordingObserver : _impl::NoOpTransactionLogParser {
     unit_test::TestContext& test_context;
-    std::set<std::pair<TableKey, ObjKey>> expected_creations;
-    std::set<std::tuple<TableKey, ObjKey, ColKey>> expected_modifications;
+    std::vector<InstructionVariant> m_expected_ops;
+    std::vector<InstructionVariant> m_observed_ops;
 
-    ObjectMutationObserver(unit_test::TestContext& test_context,
-                           std::initializer_list<std::pair<TableKey, int64_t>> creations,
-                           std::initializer_list<std::tuple<TableKey, int64_t, ColKey>> modifications)
+    RecordingObserver(unit_test::TestContext& test_context, std::initializer_list<InstructionVariant> ops)
         : test_context(test_context)
+        , m_expected_ops(ops.begin(), ops.end())
     {
-        for (auto [tk, ok] : creations) {
-            expected_creations.emplace(tk, ObjKey(ok));
-        }
-        for (auto [tk, ok, ck] : modifications) {
-            expected_modifications.emplace(tk, ObjKey(ok), ck);
-        }
     }
 
-    ObjectMutationObserver& operator=(ObjectMutationObserver&& obs) noexcept
+    RecordingObserver& operator=(RecordingObserver&& obs) noexcept
     {
-        expected_creations.swap(obs.expected_creations);
-        expected_modifications.swap(obs.expected_modifications);
+        m_observed_ops.swap(obs.m_observed_ops);
+        m_expected_ops.swap(obs.m_expected_ops);
         return *this;
     }
 
+    bool select_table(TableKey t)
+    {
+        _impl::NoOpTransactionLogParser::select_table(t);
+        m_observed_ops.push_back(Select{t});
+        return true;
+    }
+
     bool create_object(ObjKey obj_key)
     {
-        CHECK(expected_creations.erase(std::pair(get_current_table(), obj_key)));
+        m_observed_ops.push_back(Create{obj_key.value});
         return true;
     }
     bool modify_object(ColKey col, ObjKey obj)
     {
-        CHECK(expected_modifications.erase(std::tuple(get_current_table(), obj, col)));
+        m_observed_ops.push_back(Mutate{obj.value, col});
+        return true;
+    }
+    bool remove_object(ObjKey obj)
+    {
+        m_observed_ops.push_back(Remove{obj.value});
+        return true;
+    }
+    bool select_collection(ColKey col_key, ObjKey obj_key, const StablePath& path)
+    {
+        _impl::NoOpTransactionLogParser::select_collection(col_key, obj_key, path);
+        m_observed_ops.push_back(SelectColl{obj_key.value, col_key});
         return true;
     }
-    bool remove_object(ObjKey)
+    bool collection_insert(size_t ndx)
     {
+        m_observed_ops.push_back(CollInsert{ndx});
+        return true;
+    }
+    bool collection_set(size_t ndx)
+    {
+        m_observed_ops.push_back(CollSet{ndx});
         return true;
     }
 
     void check()
     {
-        CHECK(expected_creations.empty());
-        CHECK(expected_modifications.empty());
+        bool equality = m_observed_ops.size() == m_expected_ops.size();
+        size_t first_difference = -1;
+        if (equality) {
+            for (size_t i = 0; i < m_expected_ops.size(); ++i) {
+                if (!compare_instructions(m_observed_ops[i], m_expected_ops[i])) {
+                    first_difference = i;
+                    equality = false;
+                    break;
+                }
+            }
+        }
+
+        CHECK(equality);
+        if (!equality) {
+            std::cerr << "expected: \n";
+            print_instructions(std::cerr, m_expected_ops, first_difference);
+            std::cerr << "\nactual: \n";
+            print_instructions(std::cerr, m_observed_ops, first_difference);
+            std::cerr << std::endl;
+        }
     }
 };
 
 template <typename Fn>
-void expect(DBRef db, ObjectMutationObserver& observer, Fn&& write)
+void expect(DBRef db, RecordingObserver& observer, Fn&& write)
 {
     auto read = db->start_read();
     {
@@ -340,7 +490,7 @@ TEST(Replication_MutationsOnNewlyCreatedObject)
     }
 
     // Object creations with immediate mutations should report creations only
-    auto obs = ObjectMutationObserver(test_context, {{tk, 0}, {tk, 1}}, {});
+    auto obs = RecordingObserver(test_context, {Select{tk}, Create{0}, Create{1}});
     expect(db, obs, [](auto& tr) {
         auto table = tr.get_table("table");
         table->create_object().set_all(1);
@@ -348,7 +498,7 @@ TEST(Replication_MutationsOnNewlyCreatedObject)
     });
 
     // Mutating existing objects should report modifications
-    obs = ObjectMutationObserver(test_context, {}, {{tk, 0, col}, {tk, 1, col}});
+    obs = RecordingObserver(test_context, {Select{tk}, Mutate{0, col}, Mutate{1, col}});
     expect(db, obs, [](auto& tr) {
         auto table = tr.get_table("table");
         table->get_object(0).set_all(1);
@@ -358,7 +508,7 @@ TEST(Replication_MutationsOnNewlyCreatedObject)
     // Create two objects and then mutate them. We only track the most recently
     // created object, so this emits a mutation for the first object but not
     // the second.
-    obs = ObjectMutationObserver(test_context, {{tk, 2}, {tk, 3}}, {{tk, 2, col}});
+    obs = RecordingObserver(test_context, {Select{tk}, Create{2}, Create{3}, Mutate{2, col}});
     expect(db, obs, [](auto& tr) {
         auto table = tr.get_table("table");
         auto obj1 = table->create_object();
@@ -379,7 +529,7 @@ TEST(Replication_MutationsOnNewlyCreatedObject)
 
     // Creating an object in one table and then modifying the object with the
     // same ObjKey in a different table
-    obs = ObjectMutationObserver(test_context, {{tk2, 0}}, {{tk, 0, col}});
+    obs = RecordingObserver(test_context, {Select{tk2}, Create{0}, Select{tk}, Mutate{0, col}});
     expect(db, obs, [&](auto& tr) {
         auto table1 = tr.get_table(tk);
         auto table2 = tr.get_table(tk2);
@@ -393,7 +543,7 @@ TEST(Replication_MutationsOnNewlyCreatedObject)
     // Mutating an object whose Table has an index in group greater than the
     // higest of any created object after creating an object, which has to clear
     // the is-new-object flag
-    obs = ObjectMutationObserver(test_context, {{tk, 4}}, {{tk2, 0, col2}});
+    obs = RecordingObserver(test_context, {Select{tk}, Create{4}, Select{tk2}, Mutate{0, col2}});
     expect(db, obs, [&](auto& tr) {
         auto table1 = tr.get_table(tk);
         auto table2 = tr.get_table(tk2);
@@ -405,15 +555,15 @@ TEST(Replication_MutationsOnNewlyCreatedObject)
 
     // Splitting object creation and mutation over two different writes with the
     // same transaction object should produce mutation instructions
-    obs = ObjectMutationObserver(test_context, {{tk, 5}}, {{tk, 5, col}});
+    obs = RecordingObserver(test_context, {Select{tk}, Create{5}, Select{tk}, Mutate{5, col}});
     {
         auto read = db->start_read();
         auto tr = db->start_write();
         auto table = tr->get_table(tk);
-        auto obj = table->create_object();
+        auto obj = table->create_object(); // select tk
         tr->commit_and_continue_as_read();
         tr->promote_to_write();
-        obj.set_all(1);
+        obj.set_all(1); // select tk
         tr->commit_and_continue_as_read();
         read->advance_read(&obs);
         obs.check();
@@ -443,18 +593,18 @@ TEST(Replication_MutationsOnNewlyCreatedObject_Link)
     // Each top-level object creation is reported along with the mutation on
     // target_1 due to that both target objects are created before the mutations.
     // Nothing is reported for embedded objects
-    auto obs = ObjectMutationObserver(test_context, {{tk, 0}, {tk_target, 0}, {tk_target, 1}},
-                                      {{tk_target, 0, ck_target_value}});
+    auto obs = RecordingObserver(
+        test_context, {Select{tk}, Create{0}, Select{tk_target}, Create{0}, Create{1}, Mutate{0, ck_target_value}});
     expect(db, obs, [&](auto& tr) {
         auto table = tr.get_table(tk);
         auto target_table = tr.get_table(tk_target);
-        Obj obj = table->create_object();
-        Obj target_1 = target_table->create_object();
+        Obj obj = table->create_object();             // select tk
+        Obj target_1 = target_table->create_object(); // select tk_target
         Obj target_2 = target_table->create_object();
 
-        obj.set(ck_link_1, target_1.get_key());
+        obj.set(ck_link_1, target_1.get_key()); // select tk
         obj.set(ck_link_2, target_2.get_key());
-        target_1.set_all(1);
+        target_1.set_all(1); // select tk_target
         target_2.set_all(1);
 
         obj.create_and_set_linked_object(ck_embedded_1).set_all(1);
@@ -463,7 +613,8 @@ TEST(Replication_MutationsOnNewlyCreatedObject_Link)
 
     // Nullifying links via object deletions in both new and pre-existing objects
     // only reports the mutation in the pre-existing object
-    obs = ObjectMutationObserver(test_context, {{tk, 1}}, {{tk, 0, ck_link_1}});
+    obs =
+        RecordingObserver(test_context, {Select{tk}, Create{1}, Mutate{0, ck_link_1}, Select{tk_target}, Remove{0}});
     expect(db, obs, [&](auto& tr) {
         auto table = tr.get_table(tk);
         auto target_table = tr.get_table(tk_target);
@@ -502,7 +653,7 @@ TEST(Replication_MutationsOnNewlyCreatedObject_Collections)
 
     tr->commit();
 
-    auto obs = ObjectMutationObserver(test_context, {{tk, 0}, {tk_target, 0}}, {});
+    auto obs = RecordingObserver(test_context, {Select{tk}, Create{0}, Select{tk_target}, Create{0}});
     expect(db, obs, [&](auto& tr) {
         // Should report object creation but none of these mutations
         auto table = tr.get_table(tk);
@@ -527,6 +678,244 @@ TEST(Replication_MutationsOnNewlyCreatedObject_Collections)
         obj.get_linklist(ck_embedded_list).create_and_insert_linked_object(0).set(ck_embedded_value, 1);
         obj.get_dictionary(ck_embedded_dictionary).create_and_insert_linked_object("a").set(ck_embedded_value, 1);
     });
+
+    obs = RecordingObserver(test_context, {Select{tk},
+                                           SelectColl{0, ck_value_set},
+                                           CollInsert{1},
+                                           SelectColl{0, ck_value_list},
+                                           CollInsert{1},
+                                           CollInsert{2},
+                                           SelectColl{0, ck_value_dictionary},
+                                           CollSet{0},
+                                           CollInsert{1},
+                                           Select{tk_target},
+                                           Create{1},
+                                           Select{tk},
+                                           SelectColl{0, ck_obj_set},
+                                           CollInsert{1},
+                                           SelectColl{0, ck_obj_list},
+                                           CollInsert{1},
+                                           SelectColl{0, ck_obj_dictionary},
+                                           CollSet{0},
+                                           SelectColl{0, ck_embedded_list},
+                                           CollInsert{0},
+                                           SelectColl{0, ck_embedded_dictionary},
+                                           CollInsert{1}});
+    expect(db, obs, [&](auto& tr) {
+        // Should report mutations on this existing object
+        auto table = tr.get_table(tk);
+        Obj obj = table->get_object(0);
+        obj.get_set<int64_t>(ck_value_set).insert(5);
+        obj.get_list<int64_t>(ck_value_list).add(1);
+        obj.get_list<int64_t>(ck_value_list).add(2);
+        obj.get_dictionary(ck_value_dictionary).insert("a", 1);
+        obj.get_dictionary(ck_value_dictionary).insert("b", 2);
+
+        // Should report the object creation and the mutations on each collection
+        auto target_table = tr.get_table(tk_target);
+        Obj target_obj = target_table->create_object();
+        target_obj.set<int64_t>(ck_target_value, 2); // mutation skipped for this new object
+        obj.get_linkset(ck_obj_set).insert(target_obj.get_key());
+        obj.get_linklist(ck_obj_list).add(target_obj.get_key());
+        obj.get_dictionary(ck_obj_dictionary).insert("a", target_obj.get_key());
+
+        // Should not produce any instructions for the embedded objects created,
+        // just mutations on the obj which is not newly created.
+        obj.get_linklist(ck_embedded_list).create_and_insert_linked_object(0).set(ck_embedded_value, 1);
+        obj.get_dictionary(ck_embedded_dictionary).create_and_insert_linked_object("b").set(ck_embedded_value, 1);
+    });
+}
+
+TEST(Replication_NoSelectTableOnEmbeddedObjectMutations)
+{
+    SHARED_GROUP_TEST_PATH(path);
+    auto db = DB::create(make_in_realm_history(), path);
+    auto tr = db->start_write();
+
+    auto table = tr->add_table("table");
+    auto tk = table->get_key();
+    ColKey ck_value = table->add_column(type_Int, "value");
+
+    auto target_table = tr->add_table("target table");
+    auto tk_target = target_table->get_key();
+    auto ck_target_value = target_table->add_column(type_Int, "value");
+
+    auto embedded_table = tr->add_table("embedded table", Table::Type::Embedded);
+    auto tk_embedded = embedded_table->get_key();
+    auto ck_embedded_value = embedded_table->add_column(type_Int, "value");
+    auto embedded_table2 = tr->add_table("embedded_table2", Table::Type::Embedded);
+    auto tk_embedded2 = embedded_table2->get_key();
+    auto ck_embedded2_str = embedded_table2->add_column(type_String, "value_str");
+    auto ck_embedded_link = embedded_table->add_column(*embedded_table2, "embed");
+    ColKey ck_embedded_dictionary = table->add_column_dictionary(*embedded_table, "embedded dictionary");
+
+    tr->commit();
+
+    auto obs = RecordingObserver(test_context, {Select{tk}, Create{0}, Select{tk_target}, Create{0}, Create{1}});
+    expect(db, obs, [&](auto& tr) {
+        // Should report object creation but none of these mutations
+        auto table = tr.get_table(tk);
+        Obj obj = table->create_object();
+        obj.set<int64_t>(ck_value, 1);
+
+        // Should report the object creation but not the mutations on either object,
+        // as they're both the most recently created object in each table
+        auto target_table = tr.get_table(tk_target);
+        Obj target_obj = target_table->create_object(); // select tk_target
+        target_obj.set<int64_t>(ck_target_value, 1);
+
+        // Should not produce any instructions: embedded object creations aren't
+        // replicated (as you can't observe embedded tables directly), and the
+        // mutations are on the newest object for each table
+        Obj embedded_a = obj.get_dictionary(ck_embedded_dictionary).create_and_insert_linked_object("a");
+        embedded_a.set(ck_embedded_value, 1);
+        Obj embedded2_a = embedded_a.create_and_set_linked_object(ck_embedded_link);
+        embedded2_a.set(ck_embedded2_str, "test");
+
+        // target_table should still be selected, because there should have been
+        // no select table emitted for the embedded objects above
+        Obj target_obj2 = target_table->create_object();
+        target_obj2.set<int64_t>(ck_target_value, 2);
+    });
+
+    obs = RecordingObserver(test_context, {Select{tk}, Create{1}, Select{tk_embedded}, Mutate{1, ck_embedded_value},
+                                           Select{tk_embedded2}, Mutate{1, ck_embedded2_str}});
+    expect(db, obs, [&](auto& tr) {
+        // Should report object creation but none of these mutations
+        auto table = tr.get_table(tk);
+        Obj obj = table->create_object(); // select tk
+        obj.set<int64_t>(ck_value, 1);
+
+        // Should not produce any instructions: embedded object creations aren't
+        // replicated (as you can't observe embedded tables directly), and the
+        // mutations are on the newest object for each table
+        Obj embedded_a = obj.get_dictionary(ck_embedded_dictionary).create_and_insert_linked_object("a");
+        embedded_a.set(ck_embedded_value, 1);
+        Obj embedded2_a = embedded_a.create_and_set_linked_object(ck_embedded_link);
+        embedded2_a.set(ck_embedded2_str, "test a");
+
+        Obj embedded_b = obj.get_dictionary(ck_embedded_dictionary).create_and_insert_linked_object("b");
+        embedded_b.set(ck_embedded_value, 2);
+        Obj embedded2_b = embedded_b.create_and_set_linked_object(ck_embedded_link);
+        embedded2_b.set(ck_embedded2_str, "test b");
+
+        // setting a property on embeded_a means that it is no longer the newest object
+        // created, so we require a set_table, and modification for each modify:
+        // select "embedded table"
+        // modify embedded_a
+        // select "embedded table 2"
+        // modify embedded2_a
+        embedded_a.set(ck_embedded_value, 3);
+        embedded2_a.set(ck_embedded2_str, "test a 2");
+    });
+}
+
+TEST(Replication_EmbeddedListInsertions)
+{
+    SHARED_GROUP_TEST_PATH(path);
+    auto db = DB::create(make_in_realm_history(), path);
+    auto tr = db->start_write();
+
+    auto table = tr->add_table("table");
+    auto tk = table->get_key();
+    ColKey ck_value = table->add_column(type_Int, "value");
+
+    auto embedded_table = tr->add_table("embedded table", Table::Type::Embedded);
+    auto tk_embedded = embedded_table->get_key();
+    auto ck_embedded_value = embedded_table->add_column(type_Int, "value");
+    ColKey ck_embedded_list = table->add_column_list(*embedded_table, "embedded list");
+
+    // initial state
+    int64_t obj_key;
+    {
+        auto table = tr->get_table(tk);
+        Obj obj = table->create_object();
+        obj.set<int64_t>(ck_value, 1);
+        obj_key = obj.get_key().value;
+    }
+
+    tr->commit();
+
+    auto obs = RecordingObserver(test_context, {Select{tk}, SelectColl{obj_key, ck_embedded_list}, CollInsert{0},
+                                                CollInsert{1}, Select{tk_embedded}, Mutate{0, ck_embedded_value}});
+    expect(db, obs, [&](auto& tr) {
+        auto table = tr.get_table(tk);
+        Obj obj = table->get_object(0);
+        LnkLst list = obj.get_linklist(ck_embedded_list);
+        Obj link_0 = list.create_and_insert_linked_object(0);
+        Obj link_1 = list.create_and_insert_linked_object(1);
+
+        // both of these were just created, but only one is the "recently created"
+        // so we do record one unnecessary mutation
+        link_0.set<int64_t>(ck_embedded_value, 10);
+        link_1.set<int64_t>(ck_embedded_value, 11);
+    });
+}
+
+TEST(Replication_EmbeddedListInsertionsWithListMutations)
+{
+    SHARED_GROUP_TEST_PATH(path);
+    auto db = DB::create(make_in_realm_history(), path);
+    auto tr = db->start_write();
+
+    auto table = tr->add_table("table");
+    auto tk = table->get_key();
+    ColKey ck_value = table->add_column(type_Int, "value");
+
+    auto embedded_table = tr->add_table("embedded table", Table::Type::Embedded);
+    auto tk_embedded = embedded_table->get_key();
+    ColKey ck_embedded_list_of_ints = embedded_table->add_column_list(type_Int, "int list");
+    ColKey ck_list_of_embeddeds = table->add_column_list(*embedded_table, "embedded list");
+
+    // initial state
+    int64_t obj_key;
+    {
+        auto table = tr->get_table(tk);
+        Obj obj = table->create_object();
+        obj.set<int64_t>(ck_value, 1);
+        obj_key = obj.get_key().value;
+    }
+
+    tr->commit();
+
+    // there should be no extra select collection on ck_list_of_embeddeds between insertions,
+    // even though there are modifications to the embedded lists between insertions
+    auto obs = RecordingObserver(
+        test_context, {Select{tk}, SelectColl{obj_key, ck_list_of_embeddeds}, CollInsert{0}, CollInsert{1}});
+    expect(db, obs, [&](auto& tr) {
+        auto table = tr.get_table(tk);
+        Obj obj = table->get_object(0);
+        LnkLst list = obj.get_linklist(ck_list_of_embeddeds);
+        Obj link_0 = list.create_and_insert_linked_object(0);
+        link_0.get_list<Int>(ck_embedded_list_of_ints).insert(0, 0);
+        link_0.get_list<Int>(ck_embedded_list_of_ints).insert(1, 1);
+        Obj link_1 = list.create_and_insert_linked_object(1);
+        link_1.get_list<Int>(ck_embedded_list_of_ints).insert(0, 10);
+        link_1.get_list<Int>(ck_embedded_list_of_ints).insert(1, 11);
+    });
+
+    // modifications on an existing embedded object should make selections on the collection
+    obs = RecordingObserver(test_context,
+                            {Select{tk_embedded}, SelectColl{0, ck_embedded_list_of_ints}, CollInsert{0}, Select{tk},
+                             SelectColl{obj_key, ck_list_of_embeddeds}, CollInsert{2}, Select{tk_embedded},
+                             SelectColl{1, ck_embedded_list_of_ints}, CollInsert{0}});
+    expect(db, obs, [&](auto& tr) {
+        auto table = tr.get_table(tk);
+        Obj obj = table->get_object(0);
+        LnkLst list = obj.get_linklist(ck_list_of_embeddeds);
+        CHECK_EQUAL(list.size(), 2);
+        Obj link_0 = list.get_object(0);
+        // select embedded table, select embedded collection, collection insert
+        link_0.get_list<Int>(ck_embedded_list_of_ints).insert(0, 100);
+
+        // select top table, select top collection, collection insert
+        Obj link_2 = list.create_and_insert_linked_object(2);
+        link_2.get_list<Int>(ck_embedded_list_of_ints).insert(0, 0);
+
+        // select embedded table, select embedded collection, collection insert
+        Obj link_1 = list.get_object(1);
+        link_1.get_list<Int>(ck_embedded_list_of_ints).insert(0, 1000);
+    });
 }
 
 } // anonymous namespace