diff --git a/score/mw/com/impl/BUILD b/score/mw/com/impl/BUILD
index 29037f276..0f02b77c0 100644
--- a/score/mw/com/impl/BUILD
+++ b/score/mw/com/impl/BUILD
@@ -245,6 +245,7 @@ cc_library(
         "//score/mw/com/impl/mocking:i_skeleton_event",
         "//score/mw/com/impl/plumbing:event",
         "//score/mw/com/impl/plumbing:sample_allocatee_ptr",
+        "//score/mw/com/impl/plumbing:sample_ptr",
         "//score/mw/com/impl/tracing:skeleton_event_tracing",
         "@score_baselibs//score/mw/log",
         "@score_baselibs//score/result",
@@ -534,6 +535,7 @@ cc_library(
     deps = [
         ":binding_type",
         "//score/mw/com/impl/plumbing:sample_allocatee_ptr",
+        "//score/mw/com/impl/plumbing:sample_ptr",
         "//score/mw/com/impl/tracing:skeleton_event_tracing_data",
         "@score_baselibs//score/language/futurecpp",
         "@score_baselibs//score/result",
diff --git a/score/mw/com/impl/bindings/lola/BUILD b/score/mw/com/impl/bindings/lola/BUILD
index 9436dfbad..05a71038a 100644
--- a/score/mw/com/impl/bindings/lola/BUILD
+++ b/score/mw/com/impl/bindings/lola/BUILD
@@ -349,6 +349,7 @@ cc_library(
         "//score/mw/com/impl/configuration",
         "//score/mw/com/impl/methods:skeleton_method_binding",
         "//score/mw/com/impl/plumbing:sample_allocatee_ptr",
+        "//score/mw/com/impl/plumbing:sample_ptr",
         "//score/mw/com/impl/tracing:skeleton_event_tracing",
         "//score/mw/com/impl/util:arithmetic_utils",
         "@score_baselibs//score/filesystem",
diff --git a/score/mw/com/impl/bindings/lola/consumer_event_data_control_local_view.cpp b/score/mw/com/impl/bindings/lola/consumer_event_data_control_local_view.cpp
index 337eca77b..95af0da68 100644
--- a/score/mw/com/impl/bindings/lola/consumer_event_data_control_local_view.cpp
+++ b/score/mw/com/impl/bindings/lola/consumer_event_data_control_local_view.cpp
@@ -145,6 +145,59 @@ auto ConsumerEventDataControlLocalView<AtomicIndirectorType>::ReferenceNextEvent
     return {};
 }
 
+template <template <class> class AtomicIndirectorType>
+auto ConsumerEventDataControlLocalView<AtomicIndirectorType>::GetLatestSlot() noexcept -> std::optional<SlotIndexType>
+{
+    for (std::size_t retry_counter{0U}; retry_counter < MAX_REFERENCE_RETRIES; ++retry_counter)
+    {
+        EventSlotStatus::EventTimeStamp latest_time_stamp{EventSlotStatus::FIRST_VALID_TIMESTAMP};
+        std::optional<SlotIndexType> latest_slot_index{};
+        EventSlotStatus latest_slot_status{};
+
+        SlotIndexType current_index = 0U;
+        for (const auto& slot : state_slots_)
+        {
+            const EventSlotStatus slot_status{slot.load(std::memory_order_acquire)};
+            if (!slot_status.IsInvalid() && !slot_status.IsInWriting())
+            {
+                const auto slot_time_stamp = slot_status.GetTimeStamp();
+                if (latest_time_stamp < slot_time_stamp)
+                {
+                    latest_time_stamp = slot_time_stamp;
+                    latest_slot_index = current_index;
+                    latest_slot_status = slot_status;
+                }
+            }
+            ++current_index;
+        }
+
+        if (!latest_slot_index.has_value())
+        {
+            return {};
+        }
+
+        const auto slot_index = latest_slot_index.value();
+        SCORE_LANGUAGE_FUTURECPP_ASSERT_PRD(static_cast<std::size_t>(slot_index) < state_slots_.size());
+
+        auto expected = static_cast<EventSlotStatus::value_type>(latest_slot_status);
+        const auto new_refcount =
+            static_cast<EventSlotStatus::SubscriberCount>(latest_slot_status.GetReferenceCount() + 1U);
+        const EventSlotStatus updated_slot_status{latest_slot_status.GetTimeStamp(), new_refcount};
+        const auto desired = static_cast<EventSlotStatus::value_type>(updated_slot_status);
+
+        transaction_log_local_view_->ReferenceTransactionBegin(slot_index);
+        if (AtomicIndirectorType<EventSlotStatus::value_type>::compare_exchange_weak(
+                state_slots_[slot_index], expected, desired, std::memory_order_acq_rel))
+        {
+            transaction_log_local_view_->ReferenceTransactionCommit(slot_index);
+            return latest_slot_index;
+        }
+        transaction_log_local_view_->ReferenceTransactionAbort(slot_index);
+    }
+
+    return {};
+}
+
 template <template <class> class AtomicIndirectorType>
 // Suppress "AUTOSAR C++14 A15-5-3" rule findings. This rule states: "The std::terminate() function shall not be called
 // implicitly". std::terminate() is implicitly called from 'state_slots_[]' which might leds to a segmentation fault
diff --git a/score/mw/com/impl/bindings/lola/consumer_event_data_control_local_view.h b/score/mw/com/impl/bindings/lola/consumer_event_data_control_local_view.h
index 0a4d7aa65..62c2840d1 100644
--- a/score/mw/com/impl/bindings/lola/consumer_event_data_control_local_view.h
+++ b/score/mw/com/impl/bindings/lola/consumer_event_data_control_local_view.h
@@ -28,6 +28,8 @@
 
 namespace score::mw::com::impl::lola
 {
+template <typename SampleType>
+class SkeletonEventCommon;
 
 /// \brief View class which provides functionality for interacting with EventDataControl.
 ///
@@ -68,6 +70,13 @@ class ConsumerEventDataControlLocalView final
     ~ConsumerEventDataControlLocalView() noexcept = default;
 
     ConsumerEventDataControlLocalView(const ConsumerEventDataControlLocalView&) = delete;
+
+    // Suppress "AUTOSAR C++14 A11-3-1"
+    // SkeletonEventCommon needs controlled access to transaction-log view injection/cleanup for dual quality
+    // consumer setup.
+    // coverity[autosar_cpp14_a11_3_1_violation]
+    template <typename SampleType>
+    friend class SkeletonEventCommon;
     ConsumerEventDataControlLocalView& operator=(const ConsumerEventDataControlLocalView&) = delete;
     ConsumerEventDataControlLocalView(ConsumerEventDataControlLocalView&&) noexcept = delete;
     ConsumerEventDataControlLocalView& operator=(ConsumerEventDataControlLocalView&& other) noexcept = delete;
@@ -87,6 +96,15 @@ class ConsumerEventDataControlLocalView final
         const EventSlotStatus::EventTimeStamp last_search_time,
         const EventSlotStatus::EventTimeStamp upper_limit = EventSlotStatus::TIMESTAMP_MAX) noexcept;
 
+    /// \brief Returns the latest readable sample and marks it as referenced.
+    ///
+    /// \details This method performs bounded retries on data races while increasing the reference count for the
+    /// selected slot.
+    ///
+    /// \return Index of latest sample if available, empty optional otherwise.
+    /// \post DereferenceEvent() is invoked to withdraw read-ownership
+    std::optional<SlotIndexType> GetLatestSlot() noexcept;
+
     /// \brief Increments refcount of given slot by one (given it is in the correct state i.e. being accessible/
     ///        readable)
     /// \details This is a specific feature - not used by the standard proxy/consumer, which is using
diff --git a/score/mw/com/impl/bindings/lola/consumer_event_data_control_local_view_test.cpp b/score/mw/com/impl/bindings/lola/consumer_event_data_control_local_view_test.cpp
index 3bb8b72aa..b04c308a7 100644
--- a/score/mw/com/impl/bindings/lola/consumer_event_data_control_local_view_test.cpp
+++ b/score/mw/com/impl/bindings/lola/consumer_event_data_control_local_view_test.cpp
@@ -216,6 +216,38 @@ TEST_F(ConsumerEventDataControlLocalViewFixture, FailingToUpdateSlotValueCausesR
     // No event will be found
     ASSERT_FALSE(event.has_value());
 }
+
+TEST_F(ConsumerEventDataControlLocalViewFixture, GetLatestSlotReturnsNewestReadySlot)
+{
+    // Given an EventDataControl with multiple ready slots and increasing timestamps
+    GivenAConsumerEventDataControlLocalViewUsingRealAtomics(3);
+    score::cpp::ignore = WithAnAllocatedSlot(1);
+    score::cpp::ignore = WithAnAllocatedSlot(2);
+    score::cpp::ignore = WithAnAllocatedSlot(3);
+
+    // When requesting the latest slot
+    const auto latest_slot = unit_->GetLatestSlot();
+
+    // Then the newest sample is returned and referenced
+    ASSERT_TRUE(latest_slot.has_value());
+    EXPECT_EQ((*unit_)[latest_slot.value()].GetTimeStamp(), 3U);
+    EXPECT_EQ((*unit_)[latest_slot.value()].GetReferenceCount(), 1U);
+}
+
+TEST_F(ConsumerEventDataControlLocalViewFixture, GetLatestSlotReturnsNullIfNoReadySlotExists)
+{
+    // Given an EventDataControl with one slot in writing state (allocated but not marked ready)
+    GivenAConsumerEventDataControlLocalViewUsingRealAtomics(1);
+    const auto allocated_slot = provider_event_data_control_local_->AllocateNextSlot();
+    ASSERT_TRUE(allocated_slot.has_value());
+
+    // When requesting the latest slot
+    const auto latest_slot = unit_->GetLatestSlot();
+
+    // Then no slot is returned
+    EXPECT_FALSE(latest_slot.has_value());
+}
+
 using EventDataControlReferenceSpecificEventFixture = ConsumerEventDataControlLocalViewFixture;
 TEST_F(EventDataControlReferenceSpecificEventFixture, ReferenceSpecificEvents)
 {
diff --git a/score/mw/com/impl/bindings/lola/event_data_control_composite.cpp b/score/mw/com/impl/bindings/lola/event_data_control_composite.cpp
index 5dce0f2b3..e91386d48 100644
--- a/score/mw/com/impl/bindings/lola/event_data_control_composite.cpp
+++ b/score/mw/com/impl/bindings/lola/event_data_control_composite.cpp
@@ -236,7 +236,7 @@ template <template <class> class AtomicIndirectorType>
 // coverity[autosar_cpp14_a15_5_3_violation : FALSE]
 EventSlotStatus::EventTimeStamp EventDataControlComposite<AtomicIndirectorType>::GetLatestTimestamp() const noexcept
 {
-    EventSlotStatus::EventTimeStamp latest_time_stamp{1U};
+    EventSlotStatus::EventTimeStamp latest_time_stamp{EventSlotStatus{}.GetTimeStamp()};
     auto& control = (asil_b_control_local_ != nullptr) ? *asil_b_control_local_ : asil_qm_control_local_.get();
     for (SlotIndexType slot_index = 0U;
          // Suppress "AUTOSAR C++14 A4-7-1" rule finding. This rule states: "An integer expression shall not lead to
diff --git a/score/mw/com/impl/bindings/lola/event_data_control_composite_test.cpp b/score/mw/com/impl/bindings/lola/event_data_control_composite_test.cpp
index c3353cd90..167c9342f 100644
--- a/score/mw/com/impl/bindings/lola/event_data_control_composite_test.cpp
+++ b/score/mw/com/impl/bindings/lola/event_data_control_composite_test.cpp
@@ -284,9 +284,9 @@ TEST_F(EventDataControlCompositeFixture, GetLatestTimeStampReturnsDefaultValuesI
     unit_->Discard(allocation_result.allocated_slot_index.value());
     unit_->Discard(allocation_result_2.allocated_slot_index.value());
 
-    // Then the timestamp equal to 1
+    // Then the timestamp is invalid
     auto time_stamp = unit_->GetLatestTimestamp();
-    EventSlotStatus::EventTimeStamp expected_time_stamp{1};
+    EventSlotStatus::EventTimeStamp expected_time_stamp{EventSlotStatus{}.GetTimeStamp()};
     EXPECT_EQ(time_stamp, expected_time_stamp);
 }
 
@@ -295,9 +295,9 @@ TEST_F(EventDataControlCompositeFixture, GetLatestTimeStampReturnsDefaultValuesI
     // Given an EventDataControlComposite with zero used slots
     WithQmAndAsilBEventDataControlCompositeUsingRealAtomics();
 
-    // Then the timestamp equal to 1
+    // Then the timestamp is invalid
     auto time_stamp = unit_->GetLatestTimestamp();
-    EventSlotStatus::EventTimeStamp expected_time_stamp{1};
+    EventSlotStatus::EventTimeStamp expected_time_stamp{EventSlotStatus{}.GetTimeStamp()};
     EXPECT_EQ(time_stamp, expected_time_stamp);
 }
 
@@ -310,9 +310,9 @@ TEST_F(EventDataControlCompositeFixture,
     // When allocating 1 slot
     score::cpp::ignore = unit_->AllocateNextSlot();
 
-    // Then the timestamp equal to 1
+    // Then the timestamp is invalid
     auto time_stamp = unit_->GetLatestTimestamp();
-    EventSlotStatus::EventTimeStamp expected_time_stamp{1};
+    EventSlotStatus::EventTimeStamp expected_time_stamp{EventSlotStatus{}.GetTimeStamp()};
     EXPECT_EQ(time_stamp, expected_time_stamp);
 }
 
diff --git a/score/mw/com/impl/bindings/lola/event_slot_status.h b/score/mw/com/impl/bindings/lola/event_slot_status.h
index f3faee84f..d793cf84a 100644
--- a/score/mw/com/impl/bindings/lola/event_slot_status.h
+++ b/score/mw/com/impl/bindings/lola/event_slot_status.h
@@ -47,8 +47,10 @@ class EventSlotStatus final
     // coverity[autosar_cpp14_a0_1_1_violation : FALSE]
     static constexpr EventTimeStamp TIMESTAMP_MAX = std::numeric_limits<EventTimeStamp>::max();
 
-    /// \brief If default constructed, SlotStatus is invalid
-    EventSlotStatus() noexcept = default;
+    /// \brief First valid timestamp value that can appear in shared memory.
+    static constexpr EventTimeStamp FIRST_VALID_TIMESTAMP{1U};
+
+    EventSlotStatus() noexcept : EventSlotStatus{UNINITIALIZED_TIMESTAMP} {}
     explicit EventSlotStatus(const value_type init_val) noexcept;
     EventSlotStatus(const EventTimeStamp timestamp, const SubscriberCount refcount) noexcept;
     EventSlotStatus(const EventSlotStatus&) noexcept = default;
@@ -83,9 +85,13 @@ class EventSlotStatus final
     bool IsTimeStampBetween(const EventTimeStamp min_timestamp, const EventTimeStamp max_timestamp) const noexcept;
 
   private:
+    /// \brief Timestamp value indicating that a slot was never written.
+    static constexpr EventTimeStamp UNINITIALIZED_TIMESTAMP{0U};
+
     value_type data_;
 };
 
+static_assert(sizeof(EventSlotStatus) <= sizeof(std::uint64_t));
 }  // namespace score::mw::com::impl::lola
 
 #endif  // SCORE_MW_COM_IMPL_BINDINGS_LOLA_EVENT_SLOT_STATUS_H
diff --git a/score/mw/com/impl/bindings/lola/generic_skeleton_event.h b/score/mw/com/impl/bindings/lola/generic_skeleton_event.h
index 9e3854be1..742786852 100644
--- a/score/mw/com/impl/bindings/lola/generic_skeleton_event.h
+++ b/score/mw/com/impl/bindings/lola/generic_skeleton_event.h
@@ -56,6 +56,9 @@ class GenericSkeletonEvent : public GenericSkeletonEventBinding
         skeleton_event_common_.SetSkeletonEventTracingData(tracing_data);
     }
 
+    // GenericSkeletonEvent does not support getter functionality (void type); no-op.
+    void SetGetterEnabled(bool /*getter_enabled*/) noexcept override {}
+
     std::size_t GetMaxSize() const noexcept override
     {
         return size_info_.size;
diff --git a/score/mw/com/impl/bindings/lola/skeleton_event.h b/score/mw/com/impl/bindings/lola/skeleton_event.h
index 79c40a17d..54f9fc695 100644
--- a/score/mw/com/impl/bindings/lola/skeleton_event.h
+++ b/score/mw/com/impl/bindings/lola/skeleton_event.h
@@ -20,19 +20,25 @@
 #include "score/mw/com/impl/bindings/lola/i_runtime.h"
 #include "score/mw/com/impl/bindings/lola/provider_event_data_control_local_view.h"
 #include "score/mw/com/impl/bindings/lola/sample_allocatee_ptr.h"
+#include "score/mw/com/impl/bindings/lola/sample_ptr.h"
 #include "score/mw/com/impl/bindings/lola/skeleton.h"
 #include "score/mw/com/impl/bindings/lola/skeleton_event_common.h"
 #include "score/mw/com/impl/bindings/lola/skeleton_event_properties.h"
+#include "score/mw/com/impl/com_error.h"
+#include "score/mw/com/impl/configuration/quality_type.h"
 #include "score/mw/com/impl/plumbing/sample_allocatee_ptr.h"
+#include "score/mw/com/impl/plumbing/sample_ptr.h"
 #include "score/mw/com/impl/runtime.h"
 #include "score/mw/com/impl/skeleton_event_binding.h"
 #include "score/mw/com/impl/tracing/skeleton_event_tracing_data.h"
 
 #include "score/mw/log/logging.h"
 
+#include "score/result/result.h"
 #include <score/assert.hpp>
 #include <score/utility.hpp>
 
+#include <cstdint>
 #include <optional>
 #include <string_view>
 #include <utility>
@@ -87,6 +93,8 @@ class SkeletonEvent final : public SkeletonEventBinding<SampleType>
 
     Result<impl::SampleAllocateePtr<SampleType>> Allocate() noexcept override;
 
+    Result<impl::SamplePtr<SampleType>> GetLatestSample(const QualityType& quality_type) noexcept override;
+
     /// @requirement SWS_CM_00700
     Result<void> PrepareOffer() noexcept override;
 
@@ -102,6 +110,11 @@ class SkeletonEvent final : public SkeletonEventBinding<SampleType>
         skeleton_event_common_.SetSkeletonEventTracingData(tracing_data);
     }
 
+    void SetGetterEnabled(bool getter_enabled) noexcept override
+    {
+        skeleton_event_common_.SetGetterEnabled(getter_enabled);
+    }
+
   private:
     EventDataStorage<SampleType>* event_data_storage_;
     SkeletonEventCommon<SampleType> skeleton_event_common_;
@@ -179,6 +192,31 @@ Result<impl::SampleAllocateePtr<SampleType>> SkeletonEvent<SampleType>::Allocate
                                        slot_index));
 }
 
+template <typename SampleType>
+Result<impl::SamplePtr<SampleType>> SkeletonEvent<SampleType>::GetLatestSample(const QualityType& quality_type) noexcept
+{
+    if (event_data_storage_ == nullptr)
+    {
+        ::score::mw::log::LogError("lola")
+            << "Tried to get latest event sample, but the event has not been offered yet!";
+        return MakeUnexpected(ComErrc::kBindingFailure);
+    }
+
+    auto& consumer_event_data_control_local = skeleton_event_common_.GetConsumerEventDataControlLocalView(quality_type);
+    const auto slot_result = consumer_event_data_control_local.GetLatestSlot();
+    if (!slot_result.has_value())
+    {
+        ::score::mw::log::LogError("lola") << "GetLatestSlot did not return a slot index";
+        return MakeUnexpected(ComErrc::kBindingFailure);
+    }
+
+    return impl::SamplePtr<SampleType>{
+        lola::SamplePtr<SampleType>{&event_data_storage_->at(static_cast<std::uint64_t>(*slot_result)),
+                                    consumer_event_data_control_local,
+                                    slot_result.value()},
+        impl::SampleReferenceGuard{}};
+}
+
 template <typename SampleType>
 // Suppress "AUTOSAR C++14 A15-5-3" rule findings. This rule states: "The std::terminate() function shall not be called
 // implicitly". This is a false positive, all results which are accessed with '.value()' that could implicitly call
diff --git a/score/mw/com/impl/bindings/lola/skeleton_event_common.h b/score/mw/com/impl/bindings/lola/skeleton_event_common.h
index 042ad3cc0..88f1ab6ce 100644
--- a/score/mw/com/impl/bindings/lola/skeleton_event_common.h
+++ b/score/mw/com/impl/bindings/lola/skeleton_event_common.h
@@ -14,6 +14,7 @@
 #ifndef SCORE_MW_COM_IMPL_BINDINGS_LOLA_SKELETON_EVENT_COMMON_H_
 #define SCORE_MW_COM_IMPL_BINDINGS_LOLA_SKELETON_EVENT_COMMON_H_
 
+#include "score/mw/com/impl/bindings/lola/consumer_event_data_control_local_view.h"
 #include "score/mw/com/impl/bindings/lola/control_slot_types.h"
 #include "score/mw/com/impl/bindings/lola/element_fq_id.h"
 #include "score/mw/com/impl/bindings/lola/event_data_control_composite.h"
@@ -86,6 +87,11 @@ class SkeletonEventCommon
         tracing_data_ = tracing_data;
     }
 
+    void SetGetterEnabled(bool getter_enabled) noexcept
+    {
+        getter_enabled_ = getter_enabled;
+    }
+
     const ElementFqId& GetElementFQId() const
     {
         return element_fq_id_;
@@ -107,8 +113,15 @@ class SkeletonEventCommon
         return event_data_control_composite_.value();
     }
 
-    ConsumerEventDataControlLocalView<>& GetConsumerEventDataControlLocalView()
+    ConsumerEventDataControlLocalView<>& GetConsumerEventDataControlLocalView(
+        QualityType quality_type = QualityType::kASIL_QM)
     {
+        if (quality_type == QualityType::kASIL_B)
+        {
+            SCORE_LANGUAGE_FUTURECPP_ASSERT_PRD(consumer_control_local_view_asil_.has_value());
+            return consumer_control_local_view_asil_.value();
+        }
+
         SCORE_LANGUAGE_FUTURECPP_ASSERT_PRD(consumer_control_local_view_qm_.has_value());
         return consumer_control_local_view_qm_.value();
     }
@@ -122,11 +135,13 @@ class SkeletonEventCommon
     std::optional<ProviderEventDataControlLocalView<>> provider_control_local_view_qm_;
     std::optional<ProviderEventDataControlLocalView<>> provider_control_local_view_asil_b_;
     std::optional<ConsumerEventDataControlLocalView<>> consumer_control_local_view_qm_;
+    std::optional<ConsumerEventDataControlLocalView<>> consumer_control_local_view_asil_;
     std::optional<EventDataControlComposite<>> event_data_control_composite_;
 
     EventSlotStatus::EventTimeStamp current_timestamp_;
     impl::tracing::SkeletonEventTracingData tracing_data_;
     bool qm_disconnect_;
+    bool getter_enabled_{false};
 
     /// \brief Atomic flags indicating whether any receive handlers are currently registered for this event
     ///        at each quality level (QM and ASIL-B).
@@ -184,6 +199,7 @@ void SkeletonEventCommon<SampleType>::PrepareOfferCommon(EventControl& event_con
     {
         auto& provider_control_local_view_asil_b =
             provider_control_local_view_asil_b_.emplace(event_control_asil_b->data_control);
+        score::cpp::ignore = consumer_control_local_view_asil_.emplace(event_control_asil_b->data_control);
         provider_control_local_view_asil_b_ptr = &provider_control_local_view_asil_b;
     }
     score::cpp::ignore =
@@ -198,13 +214,16 @@ void SkeletonEventCommon<SampleType>::PrepareOfferCommon(EventControl& event_con
 
     const bool tracing_for_skeleton_event_enabled =
         tracing_data_.enable_send || tracing_data_.enable_send_with_allocate;
+    if (tracing_for_skeleton_event_enabled || getter_enabled_)
+    {
+        EmplaceTransactionLogRegistrationGuard(event_control_qm.transaction_log_set_);
+    }
     // LCOV_EXCL_BR_START (Tool incorrectly marks the decision as "Decision couldn't be analyzed" despite all lines in
     // both branches (true / false) being covered. "Decision couldn't be analyzed" only appeared after changing the code
     // within the if statement (without changing the condition / tests). Suppression can be removed when bug is fixed in
     // Ticket-188259).
     if (tracing_for_skeleton_event_enabled)
     {
-        EmplaceTransactionLogRegistrationGuard(event_control_qm.transaction_log_set_);
         EmplaceTypeErasedSamplePtrsGuard();
     }
 
@@ -256,6 +275,7 @@ void SkeletonEventCommon<SampleType>::PrepareStopOfferCommon() noexcept
     provider_control_local_view_qm_.reset();
     provider_control_local_view_asil_b_.reset();
     consumer_control_local_view_qm_.reset();
+    consumer_control_local_view_asil_.reset();
 }
 
 template <typename SampleType>
@@ -351,8 +371,28 @@ void SkeletonEventCommon<SampleType>::EmplaceTransactionLogRegistrationGuard(Tra
 {
     SCORE_LANGUAGE_FUTURECPP_ASSERT_PRD_MESSAGE(consumer_control_local_view_qm_.has_value(),
                                                 "ConsumerEventDataControlLocalView must be initialized.");
-    score::cpp::ignore = transaction_log_registration_guard_.emplace(
-        transaction_log_set.RegisterSkeletonTracingElement(consumer_control_local_view_qm_.value()));
+
+    if (transaction_log_registration_guard_.has_value())
+    {
+        if (consumer_control_local_view_asil_.has_value())
+        {
+            // Clear the manually injected ASIL cache before unregistering the old QM-owned log.
+            consumer_control_local_view_asil_.value().ClearTransactionLogLocalView();
+        }
+        transaction_log_registration_guard_.reset();
+    }
+
+    auto transaction_log_registration_guard =
+        transaction_log_set.RegisterSkeletonTracingElement(consumer_control_local_view_qm_.value());
+
+    if (getter_enabled_ && consumer_control_local_view_asil_.has_value())
+    {
+        auto& transaction_log =
+            transaction_log_set.GetTransactionLog(transaction_log_registration_guard.GetTransactionLogIndex());
+        consumer_control_local_view_asil_.value().SetTransactionLogLocalView(transaction_log);
+    }
+
+    score::cpp::ignore = transaction_log_registration_guard_.emplace(std::move(transaction_log_registration_guard));
 }
 
 template <typename SampleType>
@@ -387,6 +427,10 @@ void SkeletonEventCommon<SampleType>::ResetGuards() noexcept
     type_erased_sample_ptrs_guard_.reset();
     if (event_data_control_composite_.has_value())
     {
+        if (consumer_control_local_view_asil_.has_value())
+        {
+            consumer_control_local_view_asil_.value().ClearTransactionLogLocalView();
+        }
         transaction_log_registration_guard_.reset();
     }
 }
diff --git a/score/mw/com/impl/bindings/lola/skeleton_event_test.cpp b/score/mw/com/impl/bindings/lola/skeleton_event_test.cpp
index 821a746b0..d944c4262 100644
--- a/score/mw/com/impl/bindings/lola/skeleton_event_test.cpp
+++ b/score/mw/com/impl/bindings/lola/skeleton_event_test.cpp
@@ -17,6 +17,7 @@
 
 #include "score/filesystem/filesystem.h"
 
+#include "score/mw/com/impl/com_error.h"
 #include "score/mw/com/impl/configuration/quality_type.h"
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
@@ -396,6 +397,58 @@ TEST_F(SkeletonEventPrepareStopOfferFixture, UnregisterEventNotificationExistenc
     skeleton_event_->PrepareStopOffer();
 }
 
+using SkeletonEventGetLatestSampleFixture = SkeletonEventFixture;
+TEST_F(SkeletonEventGetLatestSampleFixture, GetLatestSampleFailsBeforePrepareOffer)
+{
+    const bool enforce_max_samples{true};
+    InitialiseSkeletonEvent(fake_element_fq_id_, fake_event_name_, max_samples_, max_subscribers_, enforce_max_samples);
+
+    const auto latest_sample = skeleton_event_->GetLatestSample(QualityType::kASIL_QM);
+
+    ASSERT_FALSE(latest_sample.has_value());
+    EXPECT_EQ(latest_sample.error(), ComErrc::kBindingFailure);
+}
+
+TEST_F(SkeletonEventGetLatestSampleFixture, GetLatestSampleFailsIfNoSampleWasSent)
+{
+    const bool enforce_max_samples{true};
+    InitialiseSkeletonEvent(fake_element_fq_id_, fake_event_name_, max_samples_, max_subscribers_, enforce_max_samples);
+    std::ignore = skeleton_event_->PrepareOffer();
+
+    const auto latest_sample = skeleton_event_->GetLatestSample(QualityType::kASIL_QM);
+
+    ASSERT_FALSE(latest_sample.has_value());
+    EXPECT_EQ(latest_sample.error(), ComErrc::kBindingFailure);
+}
+
+TEST_F(SkeletonEventGetLatestSampleFixture, GetLatestSampleReturnsMostRecentlySentSample)
+{
+    const bool enforce_max_samples{true};
+    InitialiseSkeletonEvent(fake_element_fq_id_, fake_event_name_, max_samples_, max_subscribers_, enforce_max_samples);
+    // Getter must be enabled so that the transaction log is set up in PrepareOffer
+    skeleton_event_->SetGetterEnabled(true);
+    std::ignore = skeleton_event_->PrepareOffer();
+
+    auto first_allocated_slot_result = skeleton_event_->Allocate();
+    ASSERT_TRUE(first_allocated_slot_result.has_value());
+    auto first_allocated_slot = std::move(first_allocated_slot_result).value();
+    *first_allocated_slot = static_cast<test::TestSampleType>(11U);
+    auto first_send_result = skeleton_event_->Send(std::move(first_allocated_slot), std::nullopt);
+    ASSERT_TRUE(first_send_result.has_value());
+
+    auto second_allocated_slot_result = skeleton_event_->Allocate();
+    ASSERT_TRUE(second_allocated_slot_result.has_value());
+    auto second_allocated_slot = std::move(second_allocated_slot_result).value();
+    *second_allocated_slot = static_cast<test::TestSampleType>(42U);
+    auto second_send_result = skeleton_event_->Send(std::move(second_allocated_slot), std::nullopt);
+    ASSERT_TRUE(second_send_result.has_value());
+
+    const auto latest_sample = skeleton_event_->GetLatestSample(QualityType::kASIL_QM);
+
+    ASSERT_TRUE(latest_sample.has_value());
+    EXPECT_EQ(*latest_sample.value(), static_cast<test::TestSampleType>(42U));
+}
+
 using SkeletonEventTimestampFixture = SkeletonEventFixture;
 TEST_F(SkeletonEventTimestampFixture, SendUpdatesTimestampInControlData)
 {
@@ -423,9 +476,9 @@ TEST_F(SkeletonEventTimestampFixture, SendUpdatesTimestampInControlData)
     auto* event_control = GetEventControl(fake_element_fq_id_, QualityType::kASIL_QM);
     ProviderEventDataControlLocalView<> provider_event_data_control_local{event_control->data_control};
     const EventSlotStatus first_final_slot_status{provider_event_data_control_local[first_slot_index]};
-    // AND the first timestamp should be 2, as it's the first one after initialization.
+    // AND the first timestamp should be the first valid timestamp.
     const auto first_timestamp = first_final_slot_status.GetTimeStamp();
-    EXPECT_EQ(first_timestamp, 2U);
+    EXPECT_EQ(first_timestamp, EventSlotStatus::FIRST_VALID_TIMESTAMP);
 
     // AND WHEN we allocate and send a second sample
     auto second_allocated_slot_result = skeleton_event_->Allocate();
diff --git a/score/mw/com/impl/bindings/lola/skeleton_event_tracing_test.cpp b/score/mw/com/impl/bindings/lola/skeleton_event_tracing_test.cpp
index c3a514f90..7665a6083 100644
--- a/score/mw/com/impl/bindings/lola/skeleton_event_tracing_test.cpp
+++ b/score/mw/com/impl/bindings/lola/skeleton_event_tracing_test.cpp
@@ -455,7 +455,7 @@ TEST_F(SkeletonEventTracingSendWithAllocateFixture, MultipleSendCallsUsesCorrect
 
 using SkeletonEventTracingPrepareOfferFixture = SkeletonEventTracingFixture;
 
-TEST_F(SkeletonEventTracingPrepareOfferFixture, DisablingTracingWillNotRegisterTransactionLog)
+TEST_F(SkeletonEventTracingPrepareOfferFixture, DisablingTracingWillRegisterTransactionLog)
 {
     const bool enforce_max_samples{true};
 
@@ -470,10 +470,33 @@ TEST_F(SkeletonEventTracingPrepareOfferFixture, DisablingTracingWillNotRegisterT
                             enforce_max_samples,
                             expected_enabled_trace_points);
 
+    // Getter must be enabled so that the transaction log is set up even when tracing is disabled
+    skeleton_event_->SetGetterEnabled(true);
+
     // Given an offered event in an offered service
     std::ignore = skeleton_event_->PrepareOffer();
 
-    // Then a TransactionLog is not registered
+    // Then a TransactionLog is registered even when tracing is disabled.
+    auto& transaction_log_set = GetTransactionLogSet();
+    const auto skeleton_transaction_log_result =
+        TransactionLogSetAttorney{transaction_log_set}.GetSkeletonTransactionLog();
+    ASSERT_TRUE(skeleton_transaction_log_result.has_value());
+}
+
+TEST_F(SkeletonEventTracingPrepareOfferFixture, DisablingTracingAndGetterWillNotRegisterTransactionLog)
+{
+    const bool enforce_max_samples{true};
+    impl::tracing::SkeletonEventTracingData expected_enabled_trace_points{};
+
+    InitialiseSkeletonEvent(fake_element_fq_id_,
+                            fake_event_name_,
+                            max_samples_,
+                            max_subscribers_,
+                            enforce_max_samples,
+                            expected_enabled_trace_points);
+
+    std::ignore = skeleton_event_->PrepareOffer();
+
     auto& transaction_log_set = GetTransactionLogSet();
     const auto skeleton_transaction_log_result =
         TransactionLogSetAttorney{transaction_log_set}.GetSkeletonTransactionLog();
@@ -563,7 +586,7 @@ TEST_F(SkeletonEventTracingPrepareStopOfferFixture, PrepareStopOfferWillRemoveRe
     ASSERT_FALSE(TransactionLogSetAttorney{transaction_log_set}.GetSkeletonTransactionLog().has_value());
 }
 
-TEST_F(SkeletonEventTracingPrepareStopOfferFixture, PrepareStopOfferWillNotRemoveTransactionLogThatWasNotRegistered)
+TEST_F(SkeletonEventTracingPrepareStopOfferFixture, PrepareStopOfferWillRemoveTransactionLogWhenTracingDisabled)
 {
     const bool enforce_max_samples{true};
 
@@ -578,18 +601,20 @@ TEST_F(SkeletonEventTracingPrepareStopOfferFixture, PrepareStopOfferWillNotRemov
                             enforce_max_samples,
                             expected_enabled_trace_points);
 
+    // Getter must be enabled so that the transaction log is set up even when tracing is disabled
+    skeleton_event_->SetGetterEnabled(true);
+
     // Given an offered event in an offered service
     std::ignore = skeleton_event_->PrepareOffer();
 
-    // Then a TransactionLog is not registered, because expected_enabled_trace_points has no corresponding trace points
-    // enabled
+    // Then a TransactionLog is registered even when tracing is disabled.
     auto& transaction_log_set = GetTransactionLogSet();
-    ASSERT_FALSE(TransactionLogSetAttorney{transaction_log_set}.GetSkeletonTransactionLog().has_value());
+    ASSERT_TRUE(TransactionLogSetAttorney{transaction_log_set}.GetSkeletonTransactionLog().has_value());
 
     // and when calling PrepareStopOffer
     skeleton_event_->PrepareStopOffer();
 
-    // Then the TransactionLog is still not registered
+    // Then the TransactionLog is unregistered
     ASSERT_FALSE(TransactionLogSetAttorney{transaction_log_set}.GetSkeletonTransactionLog().has_value());
 }
 
diff --git a/score/mw/com/impl/bindings/lola/test/skeleton_event_component_test.cpp b/score/mw/com/impl/bindings/lola/test/skeleton_event_component_test.cpp
index 9d3401418..8ccca4ad2 100644
--- a/score/mw/com/impl/bindings/lola/test/skeleton_event_component_test.cpp
+++ b/score/mw/com/impl/bindings/lola/test/skeleton_event_component_test.cpp
@@ -94,6 +94,7 @@ class SkeletonEventComponentTestTemplateFixture : public ::testing::Test
 
     void TearDown() override
     {
+        skeleton_event_.PrepareStopOffer();
         parent_skeleton_->PrepareStopOffer({});
         parent_skeleton_.reset();
         score::memory::shared::MemoryResourceRegistry::getInstance().clear();
diff --git a/score/mw/com/impl/bindings/mock_binding/generic_skeleton_event.h b/score/mw/com/impl/bindings/mock_binding/generic_skeleton_event.h
index e2f897564..9c0a3e942 100644
--- a/score/mw/com/impl/bindings/mock_binding/generic_skeleton_event.h
+++ b/score/mw/com/impl/bindings/mock_binding/generic_skeleton_event.h
@@ -39,6 +39,8 @@ class GenericSkeletonEvent : public GenericSkeletonEventBinding
     MOCK_METHOD(BindingType, GetBindingType, (), (const, noexcept, override));
     MOCK_METHOD(void, SetSkeletonEventTracingData, (impl::tracing::SkeletonEventTracingData), (noexcept, override));
     MOCK_METHOD(std::size_t, GetMaxSize, (), (const, noexcept, override));
+    // GenericSkeletonEvent does not support getter functionality; no-op.
+    void SetGetterEnabled(bool /*getter_enabled*/) noexcept override {}
 };
 
 }  // namespace score::mw::com::impl::mock_binding
diff --git a/score/mw/com/impl/bindings/mock_binding/skeleton_event.h b/score/mw/com/impl/bindings/mock_binding/skeleton_event.h
index af6bc9366..97ce5962b 100644
--- a/score/mw/com/impl/bindings/mock_binding/skeleton_event.h
+++ b/score/mw/com/impl/bindings/mock_binding/skeleton_event.h
@@ -14,6 +14,7 @@
 #define SCORE_MW_COM_IMPL_BINDINGS_MOCK_BINDING_SKELETON_EVENT_H
 
 #include "score/mw/com/impl/plumbing/sample_allocatee_ptr.h"
+#include "score/mw/com/impl/plumbing/sample_ptr.h"
 #include "score/mw/com/impl/skeleton_event_binding.h"
 
 #include <gmock/gmock.h>
@@ -31,6 +32,7 @@ class SkeletonEventBase : public SkeletonEventBindingBase
     MOCK_METHOD(std::size_t, GetMaxSize, (), (const, noexcept, override));
     MOCK_METHOD(BindingType, GetBindingType, (), (const, noexcept, override));
     MOCK_METHOD(void, SetSkeletonEventTracingData, (impl::tracing::SkeletonEventTracingData), (noexcept, override));
+    MOCK_METHOD(void, SetGetterEnabled, (bool), (noexcept, override));
 };
 
 template <typename SampleType>
@@ -47,11 +49,16 @@ class SkeletonEvent : public SkeletonEventBinding<SampleType>
                  std::optional<typename SkeletonEventBinding<SampleType>::SendTraceCallback>),
                 (noexcept, override));
     MOCK_METHOD(Result<score::mw::com::impl::SampleAllocateePtr<SampleType>>, Allocate, (), (noexcept, override));
+    MOCK_METHOD(Result<score::mw::com::impl::SamplePtr<SampleType>>,
+                GetLatestSample,
+                (const QualityType&),
+                (noexcept, override));
     MOCK_METHOD(Result<void>, PrepareOffer, (), (noexcept, override));
     MOCK_METHOD(void, PrepareStopOffer, (), (noexcept, override));
     MOCK_METHOD(std::size_t, GetMaxSize, (), (const, noexcept, override));
     MOCK_METHOD(BindingType, GetBindingType, (), (const, noexcept, override));
     MOCK_METHOD(void, SetSkeletonEventTracingData, (impl::tracing::SkeletonEventTracingData), (noexcept, override));
+    MOCK_METHOD(void, SetGetterEnabled, (bool), (noexcept, override));
 };
 
 template <typename SampleType>
@@ -82,6 +89,11 @@ class SkeletonEventFacade : public SkeletonEventBinding<SampleType>
     {
         return skeleton_event_.Allocate();
     };
+    Result<score::mw::com::impl::SamplePtr<SampleType>> GetLatestSample(
+        const QualityType& quality_type) noexcept override
+    {
+        return skeleton_event_.GetLatestSample(quality_type);
+    }
     Result<void> PrepareOffer() noexcept override
     {
         return skeleton_event_.PrepareOffer();
@@ -102,6 +114,10 @@ class SkeletonEventFacade : public SkeletonEventBinding<SampleType>
     {
         return skeleton_event_.SetSkeletonEventTracingData(tracing_data);
     }
+    void SetGetterEnabled(bool getter_enabled) noexcept override
+    {
+        return skeleton_event_.SetGetterEnabled(getter_enabled);
+    }
 };
 }  // namespace score::mw::com::impl::mock_binding
 
diff --git a/score/mw/com/impl/methods/BUILD b/score/mw/com/impl/methods/BUILD
index 6a36ba878..efe71d32a 100644
--- a/score/mw/com/impl/methods/BUILD
+++ b/score/mw/com/impl/methods/BUILD
@@ -28,6 +28,17 @@ cc_library(
     ],
 )
 
+cc_library(
+    name = "method_handler_checker",
+    srcs = ["method_handler_checker.cpp"],
+    hdrs = ["method_handler_checker.h"],
+    features = COMPILER_WARNING_FEATURES,
+    tags = ["FFI"],
+    visibility = [
+        "//score/mw/com:__subpackages__",
+    ],
+)
+
 cc_library(
     name = "proxy_method_base",
     srcs = ["proxy_method_base.cpp"],
@@ -111,6 +122,15 @@ cc_unit_test(
     ],
 )
 
+cc_unit_test(
+    name = "method_handler_checker_test",
+    srcs = ["method_handler_checker_test.cpp"],
+    features = COMPILER_WARNING_FEATURES,
+    deps = [
+        ":method_handler_checker",
+    ],
+)
+
 cc_unit_test(
     name = "proxy_method_test",
     srcs = ["proxy_method_test.cpp"],
@@ -154,6 +174,7 @@ cc_library(
         "//score/mw/com/impl:__subpackages__",
     ],
     deps = [
+        ":method_handler_checker",
         ":skeleton_method_binding",
         "//score/mw/com/impl:instance_identifier",
         "//score/mw/com/impl:skeleton_base",
@@ -187,6 +208,7 @@ cc_unit_test(
         ":skeleton_method",
         "//score/mw/com/impl/bindings/mock_binding",
         "//score/mw/com/impl/plumbing:skeleton_method_binding_factory_mock",
+        "//score/mw/com/impl/test:binding_factory_resources",
         "@score_baselibs//score/language/futurecpp",
     ],
 )
diff --git a/score/mw/com/impl/methods/method_handler_checker.cpp b/score/mw/com/impl/methods/method_handler_checker.cpp
new file mode 100644
index 000000000..35391fb98
--- /dev/null
+++ b/score/mw/com/impl/methods/method_handler_checker.cpp
@@ -0,0 +1,13 @@
+/********************************************************************************
+ * Copyright (c) 2025 Contributors to the Eclipse Foundation
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information regarding copyright ownership.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Apache License Version 2.0 which is available at
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ ********************************************************************************/
+#include "score/mw/com/impl/methods/method_handler_checker.h"
diff --git a/score/mw/com/impl/methods/method_handler_checker.h b/score/mw/com/impl/methods/method_handler_checker.h
new file mode 100644
index 000000000..15f6e2ec0
--- /dev/null
+++ b/score/mw/com/impl/methods/method_handler_checker.h
@@ -0,0 +1,125 @@
+/********************************************************************************
+ * Copyright (c) 2025 Contributors to the Eclipse Foundation
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information regarding copyright ownership.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Apache License Version 2.0 which is available at
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ ********************************************************************************/
+#ifndef SCORE_MW_COM_IMPL_METHODS_METHOD_HANDLER_CHECKER_H
+#define SCORE_MW_COM_IMPL_METHODS_METHOD_HANDLER_CHECKER_H
+
+#include <tuple>
+#include <type_traits>
+
+namespace score::mw::com::impl
+{
+namespace detail
+{
+
+template <typename T>
+struct get_method_in_arg_and_return_types : public get_method_in_arg_and_return_types<decltype(&T::operator())>
+{
+};
+
+template <typename C, typename Ret, typename RetArg, typename... InArgs>
+struct get_method_in_arg_and_return_types<Ret (C::*)(RetArg, InArgs...) const>
+{
+    using return_type = RetArg;
+    using in_args = std::tuple<InArgs...>;
+};
+
+template <typename T>
+struct get_method_in_arg_types : public get_method_in_arg_types<decltype(&T::operator())>
+{
+};
+
+template <typename C, typename Ret, typename... InArgs>
+struct get_method_in_arg_types<Ret (C::*)(InArgs...) const>
+{
+    using type = std::tuple<InArgs...>;
+};
+
+template <typename T>
+struct get_method_return_type : public get_method_return_type<decltype(&T::operator())>
+{
+};
+
+template <typename C, typename Ret, typename RetArg>
+struct get_method_return_type<Ret (C::*)(RetArg) const>
+{
+    using type = RetArg;
+};
+
+template <typename T>
+struct get_callable_return_type : public get_callable_return_type<decltype(&T::operator())>
+{
+};
+
+template <typename C, typename Ret, typename... Args>
+struct get_callable_return_type<Ret (C::*)(Args...) const>
+{
+    using type = Ret;
+};
+
+}  // namespace detail
+
+template <typename Callable, typename ReturnType, typename... ArgTypes>
+constexpr void AssertCallableMatchesMethodSignature()
+{
+    using CallableReturnType = typename detail::get_callable_return_type<Callable>::type;
+    static_assert(std::is_same_v<CallableReturnType, void>,
+                  "Registered method callable must have void return type! The actual method return type is passed as "
+                  "first argument to the callable as non-const reference!");
+
+    constexpr bool has_in_args = (sizeof...(ArgTypes) != 0);
+    constexpr bool has_return_type = !std::is_same_v<ReturnType, void>;
+    if constexpr (has_in_args && has_return_type)
+    {
+        using MethodInArgTuple = typename detail::get_method_in_arg_and_return_types<Callable>::in_args;
+        using MethodReturnType = typename detail::get_method_in_arg_and_return_types<Callable>::return_type;
+
+        using ExpectedInArgTypeTuple = std::tuple<const ArgTypes&...>;
+        using ExpectedReturnType = ReturnType&;
+
+        static_assert(
+            std::is_same_v<MethodReturnType, ExpectedReturnType>,
+            "Registered method callable must have the method return type as first argument as non-const reference!");
+        static_assert(std::is_same_v<MethodInArgTuple, ExpectedInArgTypeTuple>,
+                      "Registered method callable must have the same in argument types as the method signature "
+                      "following the return type, but with const reference semantics!");
+    }
+    else if constexpr (!has_in_args && has_return_type)
+    {
+        using MethodCallableReturnType = typename detail::get_method_return_type<Callable>::type;
+        using ExpectedReturnType = ReturnType&;
+
+        static_assert(
+            std::is_same_v<MethodCallableReturnType, ExpectedReturnType>,
+            "Registered method callable must have the method return type as only argument as non-const reference!");
+    }
+    else if constexpr (has_in_args && !has_return_type)
+    {
+        using MethodCallableInArgTuple = typename detail::get_method_in_arg_types<Callable>::type;
+        using ExpectedInArgTypeTuple = std::tuple<const ArgTypes&...>;
+
+        static_assert(std::is_same_v<MethodCallableInArgTuple, ExpectedInArgTypeTuple>,
+                      "Registered method callable must have only the in argument types from the method signature, but "
+                      "with const reference semantics!");
+    }
+    else
+    {
+        using MethodCallableInArgTuple = typename detail::get_method_in_arg_types<Callable>::type;
+        static_assert(std::is_same_v<MethodCallableInArgTuple, std::tuple<>>,
+                      "Registered method callable must not have any arguments since the method signature does not "
+                      "specify any in arguments or return type!");
+    }
+}
+
+}  // namespace score::mw::com::impl
+
+#endif  // SCORE_MW_COM_IMPL_METHODS_METHOD_HANDLER_CHECKER_H
diff --git a/score/mw/com/impl/methods/method_handler_checker_test.cpp b/score/mw/com/impl/methods/method_handler_checker_test.cpp
new file mode 100644
index 000000000..63ff53877
--- /dev/null
+++ b/score/mw/com/impl/methods/method_handler_checker_test.cpp
@@ -0,0 +1,242 @@
+/********************************************************************************
+ * Copyright (c) 2025 Contributors to the Eclipse Foundation
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information regarding copyright ownership.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Apache License Version 2.0 which is available at
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ ********************************************************************************/
+#include "score/mw/com/impl/methods/method_handler_checker.h"
+
+#include <gtest/gtest.h>
+
+#include <functional>
+
+namespace score::mw::com::impl
+{
+namespace
+{
+
+TEST(MethodHandlerCheckerReturnAndInArgsTest, CallingAssertCallableWithValidCallableDoesNotTerminate)
+{
+    // Given a method with a return type and InArgs.
+    using MethodReturnType = int;
+    using FirstInArgType = int;
+    using SecondInArgType = double;
+
+    // and given a callable that accepts the return and InArgs.
+    using ValidCallable = std::function<void(MethodReturnType&, const FirstInArgType&, const SecondInArgType&)>;
+
+    // When calling AssertCallableMatchesMethodSignature
+    // Then the call does not terminate
+    AssertCallableMatchesMethodSignature<ValidCallable, MethodReturnType, FirstInArgType, SecondInArgType>();
+}
+
+// TODO: Tests for invalid callables that should cause static assertion failures. These tests are disabled since we
+// currently don't have infrastructure for compile time testing. To be enabled in SWP-46885.
+#if 0
+TEST(MethodHandlerCheckerReturnAndInArgsTest, CallingAssertCallableWithCallableWithMissingReturnTerminates)
+{
+    // Given a method with a return type and InArgs.
+    using MethodReturnType = int;
+    using FirstInArgType = int;
+    using SecondInArgType = double;
+
+    // and given a callable that accepts only the InArgs.
+    using ValidCallable = std::function<void(const FirstInArgType&, const SecondInArgType&)>;
+
+    // When calling AssertCallableMatchesMethodSignature
+    // Then the function should not compile
+    AssertCallableMatchesMethodSignature<ValidCallable, MethodReturnType, FirstInArgType, SecondInArgType>();
+}
+
+TEST(MethodHandlerCheckerReturnAndInArgsTest, CallingAssertCallableWithCallableWithMissingInArgTerminates)
+{
+    // Given a method with a return type and InArgs.
+    using MethodReturnType = int;
+    using FirstInArgType = int;
+    using SecondInArgType = double;
+
+    // and given a callable that accepts only the return and only one of the InArgs.
+    using ValidCallable = std::function<void(MethodReturnType&, const SecondInArgType&)>;
+
+    // When calling AssertCallableMatchesMethodSignature
+    // Then the function should not compile
+    AssertCallableMatchesMethodSignature<ValidCallable, MethodReturnType, FirstInArgType, SecondInArgType>();
+}
+
+TEST(MethodHandlerCheckerReturnAndInArgsTest, CallingAssertCallableWithCallableWithConstReturnTypeRefTerminates)
+{
+    // Given a method with a return type and InArgs.
+    using MethodReturnType = int;
+    using FirstInArgType = int;
+    using SecondInArgType = double;
+
+    // and given a callable that accepts the correct arguments but the return type is a const reference instead of
+    // non-const reference.
+    using ValidCallable = std::function<void(const MethodReturnType&, const FirstInArgType&, const SecondInArgType&)>;
+
+    // When calling AssertCallableMatchesMethodSignature
+    // Then the function should not compile
+    AssertCallableMatchesMethodSignature<ValidCallable, MethodReturnType, FirstInArgType, SecondInArgType>();
+}
+
+TEST(MethodHandlerCheckerReturnAndInArgsTest, CallingAssertCallableWithCallableWithNonConstInArgRefTerminates)
+{
+    // Given a method with a return type and InArgs.
+    using MethodReturnType = int;
+    using FirstInArgType = int;
+    using SecondInArgType = double;
+
+    // and given a callable that accepts the correct arguments but one of the InArgs is a non-const reference instead of
+    // a const reference.
+    using ValidCallable = std::function<void(const MethodReturnType&, FirstInArgType&, const SecondInArgType&)>;
+
+    // When calling AssertCallableMatchesMethodSignature
+    // Then the function should not compile
+    AssertCallableMatchesMethodSignature<ValidCallable, MethodReturnType, FirstInArgType, SecondInArgType>();
+}
+#endif
+
+TEST(MethodHandlerCheckerReturnOnlyTest, CallingAssertCallableWithValidCallableDoesNotTerminate)
+{
+    // Given a method with a return type and no InArgs.
+    using MethodReturnType = int;
+
+    // and given a callable that accepts the return and no InArgs.
+    using ValidCallable = std::function<void(MethodReturnType&)>;
+
+    // When calling AssertCallableMatchesMethodSignature
+    // Then the call does not terminate
+    AssertCallableMatchesMethodSignature<ValidCallable, MethodReturnType>();
+}
+
+// TODO: Tests for invalid callables that should cause static assertion failures. These tests are disabled since we
+// currently don't have infrastructure for compile time testing. To be enabled in SWP-46885.
+#if 0
+TEST(MethodHandlerCheckerReturnOnlyTest, CallingAssertCallableWithCallableWithMissingReturnTerminates)
+{
+    // Given a method with a return type and no InArgs.
+    using MethodReturnType = int;
+
+    // and given a callable that accepts no return and no InArgs.
+    using ValidCallable = std::function<void()>;
+
+    // When calling AssertCallableMatchesMethodSignature
+    // Then the function should not compile
+    AssertCallableMatchesMethodSignature<ValidCallable, MethodReturnType>();
+}
+
+TEST(MethodHandlerCheckerReturnOnlyTest, CallingAssertCallableWithCallableWithConstReturnTypeRefTerminates)
+{
+    // Given a method with a return type and no InArgs.
+    using MethodReturnType = int;
+
+    // and given a callable that accepts the return type as const reference instead of non-const reference.
+    using ValidCallable = std::function<void(const MethodReturnType&)>;
+
+    // When calling AssertCallableMatchesMethodSignature
+    // Then the function should not compile
+    AssertCallableMatchesMethodSignature<ValidCallable, MethodReturnType>();
+}
+#endif
+
+TEST(MethodHandlerCheckerInArgsOnlyTest, CallingAssertCallableWithValidCallableDoesNotTerminate)
+{
+    // Given a method with no return type and InArgs.
+    using MethodReturnType = void;
+    using FirstInArgType = int;
+    using SecondInArgType = double;
+
+    // and given a callable that accepts no return and InArgs.
+    using ValidCallable = std::function<void(const FirstInArgType&, const SecondInArgType&)>;
+
+    // When calling AssertCallableMatchesMethodSignature
+    // Then the call does not terminate
+    AssertCallableMatchesMethodSignature<ValidCallable, MethodReturnType, FirstInArgType, SecondInArgType>();
+}
+
+// TODO: Tests for invalid callables that should cause static assertion failures. These tests are disabled since we
+// currently don't have infrastructure for compile time testing. To be enabled in SWP-46885.
+#if 0
+TEST(MethodHandlerCheckerInArgsOnlyTest, CallingAssertCallableWithCallableWithMissingInArgTerminates)
+{
+    // Given a method with no return type and InArgs.
+    using MethodReturnType = void;
+    using FirstInArgType = int;
+    using SecondInArgType = double;
+
+    // and given a callable that accepts only one InArg.
+    using ValidCallable = std::function<void(const FirstInArgType&)>;
+
+    // When calling AssertCallableMatchesMethodSignature
+    // Then the function should not compile
+    AssertCallableMatchesMethodSignature<ValidCallable, MethodReturnType, FirstInArgType, SecondInArgType>();
+}
+
+TEST(MethodHandlerCheckerInArgsOnlyTest, CallingAssertCallableWithCallableWithNonConstInArgRefTerminates)
+{
+    // Given a method with no return type and InArgs.
+    using MethodReturnType = void;
+    using FirstInArgType = int;
+    using SecondInArgType = double;
+
+    // and given a callable that accepts one of the InArgs as non-const reference instead of const reference.
+    using ValidCallable = std::function<void(const FirstInArgType&, SecondInArgType&)>;
+
+    // When calling AssertCallableMatchesMethodSignature
+    // Then the function should not compile
+    AssertCallableMatchesMethodSignature<ValidCallable, MethodReturnType, FirstInArgType, SecondInArgType>();
+}
+#endif
+
+TEST(MethodHandlerCheckerNoReturnAndNoInArgsTest, CallingAssertCallableWithValidCallableDoesNotTerminate)
+{
+    // Given a method with no return type and no InArgs.
+    using MethodReturnType = void;
+
+    // and given a callable that accepts no return and no InArgs.
+    using ValidCallable = std::function<void()>;
+
+    // When calling AssertCallableMatchesMethodSignature
+    // Then the call does not terminate
+    AssertCallableMatchesMethodSignature<ValidCallable, MethodReturnType>();
+}
+
+// TODO: Tests for invalid callables that should cause static assertion failures. These tests are disabled since we
+// currently don't have infrastructure for compile time testing. To be enabled in SWP-46885.
+#if 0
+TEST(MethodHandlerCheckerNoReturnAndNoInArgsTest, CallingAssertCallableWithCallableWithInArgTerminates)
+{
+    // Given a method with no return type and no InArgs.
+    using MethodReturnType = void;
+
+    // and given a callable that accepts an InArg.
+    using ValidCallable = std::function<void(const int&)>;
+
+    // When calling AssertCallableMatchesMethodSignature
+    // Then the function should not compile
+    AssertCallableMatchesMethodSignature<ValidCallable, MethodReturnType>();
+}
+
+TEST(MethodHandlerCheckerNoReturnAndNoInArgsTest, CallingAssertCallableWithCallableWithReturnTypeTerminates)
+{
+    // Given a method with no return type and no InArgs.
+    using MethodReturnType = void;
+
+    // and given a callable that returns a non-void value.
+    using ValidCallable = std::function<int()>;
+
+    // When calling AssertCallableMatchesMethodSignature
+    // Then the function should not compile
+    AssertCallableMatchesMethodSignature<ValidCallable, MethodReturnType>();
+}
+#endif
+
+}  // namespace
+
+}  // namespace score::mw::com::impl
diff --git a/score/mw/com/impl/methods/skeleton_method.h b/score/mw/com/impl/methods/skeleton_method.h
index 8164f2761..f884c9292 100644
--- a/score/mw/com/impl/methods/skeleton_method.h
+++ b/score/mw/com/impl/methods/skeleton_method.h
@@ -12,7 +12,9 @@
  ********************************************************************************/
 #ifndef SCORE_MW_COM_IMPL_METHODS_SKELETON_METHOD_H
 #define SCORE_MW_COM_IMPL_METHODS_SKELETON_METHOD_H
+
 #include "score/mw/com/impl/method_type.h"
+#include "score/mw/com/impl/methods/method_handler_checker.h"
 #include "score/mw/com/impl/methods/skeleton_method_base.h"
 #include "score/mw/com/impl/methods/skeleton_method_binding.h"
 #include "score/mw/com/impl/plumbing/skeleton_method_binding_factory.h"
@@ -21,7 +23,6 @@
 #include "score/result/result.h"
 
 #include <functional>
-#include <iostream>
 #include <memory>
 #include <optional>
 #include <tuple>
@@ -31,7 +32,7 @@
 namespace score::mw::com::impl
 {
 
-template <typename, bool, bool>
+template <typename, bool, bool, bool>
 class SkeletonField;
 
 template <typename Signature>
@@ -53,7 +54,7 @@ class SkeletonMethod<ReturnType(ArgTypes...)> final : public SkeletonMethodBase
     static_assert(return_value_is_not_a_pointer,
                   "Return value can not be a pointer, since we can not put them in shared memory.");
 
-    template <typename, bool, bool>
+    template <typename, bool, bool, bool>
     // coverity[autosar_cpp14_a11_3_1_violation]
     friend class SkeletonField;
 
@@ -160,19 +161,11 @@ Result<void> SkeletonMethod<ReturnType(ArgTypes...)>::RegisterHandler(Callable&&
 {
     static_assert(std::is_rvalue_reference_v<decltype(callback)>,
                   "Callbeck provided to register has to be an rvalue reference");
-
-    // A move would only be problematic if the forwarding refference Callback&& evealuates to an LValue and and is moved
-    // from (which the caller of the function might not expect). We static assert that the callback is an RValue
-    // refference and can always be movef from.
-    // NOLINTNEXTLINE(bugprone-move-forwarding-reference) The callback is asserted to be an RValue reference
-    auto callable_invoker = [callable = std::move(callback)](auto&&... ptrs) -> decltype(auto) {
-        return std::invoke(callable, (*ptrs)...);
-    };
+    AssertCallableMatchesMethodSignature<Callable, ReturnType, ArgTypes...>();
 
     SkeletonMethodBinding::TypeErasedHandler type_erased_callable =
-        [callable_invoker = std::move(callable_invoker)](
-            std::optional<score::cpp::span<std::byte>> type_erased_in_args,
-            std::optional<score::cpp::span<std::byte>> type_erased_return) {
+        [callback = std::forward<Callable>(callback)](std::optional<score::cpp::span<std::byte>> type_erased_in_args,
+                                                      std::optional<score::cpp::span<std::byte>> type_erased_return) {
             using InArgPtrTuple = std::tuple<ArgTypes*...>;
             InArgPtrTuple typed_in_arg_ptrs{};
 
@@ -189,15 +182,29 @@ Result<void> SkeletonMethod<ReturnType(ArgTypes...)>::RegisterHandler(Callable&&
             constexpr bool is_return_type_not_void = !std::is_same_v<ReturnType, void>;
             if constexpr (is_return_type_not_void)
             {
+                const auto typed_return_ptr_tuple = Deserialize<ReturnType>(type_erased_return.value());
+                auto* const typed_return_ptr = std::get<0>(typed_return_ptr_tuple);
                 SCORE_LANGUAGE_FUTURECPP_ASSERT_PRD_MESSAGE(
                     type_erased_return.has_value(),
                     "ReturnType is non void. Thus, type_erased_result needs to have a value!");
-                ReturnType res = std::apply(callable_invoker, std::forward<InArgPtrTuple>(typed_in_arg_ptrs));
-                SerializeArgs<ReturnType>(type_erased_return.value(), res);
+
+                // Call the callable with the typed_return_ptr and the typed_in_arg_ptrs which are unpacked from the
+                // tuple into individual arguments.
+                std::apply(
+                    [&callback, typed_return_ptr](ArgTypes*... typed_in_arg_ptrs) {
+                        std::invoke(callback, *typed_return_ptr, *typed_in_arg_ptrs...);
+                    },
+                    typed_in_arg_ptrs);
             }
             else
             {
-                std::apply(callable_invoker, std::forward<InArgPtrTuple>(typed_in_arg_ptrs));
+                // Call the callable with the typed_in_arg_ptrs which are unpacked from the tuple into individual
+                // arguments.
+                std::apply(
+                    [&callback](ArgTypes*... typed_in_arg_ptrs) {
+                        std::invoke(callback, *typed_in_arg_ptrs...);
+                    },
+                    typed_in_arg_ptrs);
             }
         };
 
@@ -205,4 +212,5 @@ Result<void> SkeletonMethod<ReturnType(ArgTypes...)>::RegisterHandler(Callable&&
 }
 
 }  // namespace score::mw::com::impl
+
 #endif  // SCORE_MW_COM_IMPL_METHODS_SKELETON_METHOD_H
diff --git a/score/mw/com/impl/methods/skeleton_method_test.cpp b/score/mw/com/impl/methods/skeleton_method_test.cpp
index 5173ab4f8..9cd00b542 100644
--- a/score/mw/com/impl/methods/skeleton_method_test.cpp
+++ b/score/mw/com/impl/methods/skeleton_method_test.cpp
@@ -17,9 +17,8 @@
 #include "score/mw/com/impl/instance_identifier.h"
 #include "score/mw/com/impl/methods/skeleton_method.h"
 #include "score/mw/com/impl/methods/skeleton_method_base.h"
-#include "score/mw/com/impl/plumbing/skeleton_method_binding_factory.h"
-#include "score/mw/com/impl/plumbing/skeleton_method_binding_factory_mock.h"
 #include "score/mw/com/impl/skeleton_base.h"
+#include "score/mw/com/impl/test/binding_factory_resources.h"
 #include "score/result/result.h"
 
 #include <gmock/gmock.h>
@@ -40,12 +39,12 @@ using ::testing::Return;
 
 const auto kInstanceSpecifier = InstanceSpecifier::Create(std::string{"abc/abc/TirePressurePort"}).value();
 const auto kServiceIdentifier = make_ServiceIdentifierType("foo", 13, 37);
-std::uint16_t kInstanceId{23U};
+constexpr std::uint16_t kInstanceId{23U};
 const ServiceInstanceDeployment kDeploymentInfo{kServiceIdentifier,
                                                 LolaServiceInstanceDeployment{LolaServiceInstanceId{kInstanceId}},
                                                 QualityType::kASIL_QM,
                                                 kInstanceSpecifier};
-std::uint16_t kServiceId{34U};
+constexpr std::uint16_t kServiceId{34U};
 const ServiceTypeDeployment kTypeDeployment{LolaServiceTypeDeployment{kServiceId}};
 const auto kInstanceIdWithLolaBinding = make_InstanceIdentifier(kDeploymentInfo, kTypeDeployment);
 
@@ -56,22 +55,7 @@ class EmptySkeleton final : public SkeletonBase
 };
 
 using TestMethodType = bool(int, bool);
-
-class SkeletonMethodTestFixture : public ::testing::Test
-{
-  public:
-    void CreateSkeletonMethod()
-    {
-        EmptySkeleton empty_skeleton{std::make_unique<mock_binding::Skeleton>(), kInstanceIdWithLolaBinding};
-        auto mock_method_binding_ptr = std::make_unique<mock_binding::SkeletonMethodFacade>(mock_method_binding_);
-
-        method_ = std::make_unique<SkeletonMethod<TestMethodType>>(
-            empty_skeleton, "dummy_method", std::move(mock_method_binding_ptr));
-    }
-
-    std::unique_ptr<SkeletonMethod<TestMethodType>> method_{nullptr};
-    mock_binding::SkeletonMethod mock_method_binding_{};
-};
+using TestMethodHandlerType = void(bool&, const int&, const bool&);
 
 TEST(SkeletonMethodTests, NotCopyable)
 {
@@ -99,17 +83,39 @@ TEST(SkeletonMethodTest, ClassTypeDependsOnMethodType)
                   "Class type does not depend on event data type");
 }
 
-template <typename T>
+template <typename Types>
 class SkeletonMethodTypedTest : public ::testing::Test
 {
   public:
-    using Type = T;
+    using MethodType = typename Types::MethodType;
+    using HandlerType = typename Types::HandlerType;
 
     void SetUp() override
     {
-        ON_CALL(skeleton_method_binding_mock_, RegisterHandler(_)).WillByDefault(Return(Result<void>{}));
+        ON_CALL(mock_method_binding_, RegisterHandler(_)).WillByDefault(Return(Result<void>{}));
     }
-    mock_binding::SkeletonMethod skeleton_method_binding_mock_;
+
+    SkeletonMethodTypedTest& GivenASkeletonMethod()
+    {
+        auto mock_method_binding_ptr = std::make_unique<mock_binding::SkeletonMethodFacade>(mock_method_binding_);
+
+        method_ = std::make_unique<SkeletonMethod<MethodType>>(
+            empty_skeleton_, method_name_, std::move(mock_method_binding_ptr));
+        return *this;
+    }
+
+    SkeletonMethodTypedTest& WithAMockedMethodBindingfactory()
+    {
+        skeleton_method_binding_factory_mock_guard_ = std::make_unique<SkeletonMethodBindingFactoryMockGuard>();
+        return *this;
+    }
+
+    EmptySkeleton empty_skeleton_{std::make_unique<mock_binding::Skeleton>(), kInstanceIdWithLolaBinding};
+    std::string method_name_{"dummy_method"};
+    std::unique_ptr<SkeletonMethod<MethodType>> method_{nullptr};
+    mock_binding::SkeletonMethod mock_method_binding_{};
+
+    std::unique_ptr<SkeletonMethodBindingFactoryMockGuard> skeleton_method_binding_factory_mock_guard_{nullptr};
 };
 
 struct MyDataStruct
@@ -119,67 +125,60 @@ struct MyDataStruct
     double d;
     float f[4];
 };
-using RegisteredFunctionTypes = ::testing::Types<TestMethodType,
-                                                 void(int),
-                                                 void(const double, int),
-                                                 void(char, MyDataStruct),
-                                                 int(),
-                                                 void(),
-                                                 MyDataStruct(MyDataStruct, int, float)>;
+
+template <typename MethodTypeIn, typename HandlerTypeIn>
+struct MethodTypeAndHandlerType
+{
+    using MethodType = MethodTypeIn;
+    using HandlerType = HandlerTypeIn;
+};
+using RegisteredFunctionTypes =
+    ::testing::Types<MethodTypeAndHandlerType<TestMethodType, TestMethodHandlerType>,
+                     MethodTypeAndHandlerType<void(int), void(const int&)>,
+                     MethodTypeAndHandlerType<void(int, int), void(const int&, const int&)>,
+                     MethodTypeAndHandlerType<void(const double, int), void(const double&, const int&)>,
+                     MethodTypeAndHandlerType<void(int, int), void(const int&, const int&)>,
+                     MethodTypeAndHandlerType<void(char, MyDataStruct), void(const char&, const MyDataStruct&)>,
+                     MethodTypeAndHandlerType<int(), void(int&)>,
+                     MethodTypeAndHandlerType<void(), void()>,
+                     MethodTypeAndHandlerType<MyDataStruct(MyDataStruct, int, float),
+                                              void(MyDataStruct&, const MyDataStruct&, const int&, const float&)>>;
 TYPED_TEST_SUITE(SkeletonMethodTypedTest, RegisteredFunctionTypes, );
 
+using SkeletonMethodTestFixture =
+    SkeletonMethodTypedTest<MethodTypeAndHandlerType<TestMethodType, TestMethodHandlerType>>;
+
 TYPED_TEST(SkeletonMethodTypedTest, AnyCombinationOfReturnAndInputArgTypesCanBeRegistered)
 {
-
     // Given A skeleton Method with a mock method binding
-    EmptySkeleton empty_skeleton{std::make_unique<mock_binding::Skeleton>(), kInstanceIdWithLolaBinding};
-    auto mock_method_binding_ptr = std::make_unique<mock_binding::SkeletonMethod>();
-    auto& mock_method_binding = *mock_method_binding_ptr;
-
-    // And a method type that can be one of the four qualitatively different Types
-    //  void()          SomeType()
-    //  void(SomeTypes) SomeType(SomeTypes)
-    using FixtureMethodType = typename TestFixture::Type;
-    SkeletonMethod<FixtureMethodType> method{empty_skeleton, "dummy_method", std::move(mock_method_binding_ptr)};
+    this->GivenASkeletonMethod();
 
     // Expecting that the register call is dispatched to the binding without errors
-    EXPECT_CALL(mock_method_binding, RegisterHandler(_));
+    EXPECT_CALL(this->mock_method_binding_, RegisterHandler(_));
 
-    // When a Register call is issued at the binding independent level
-    score::cpp::callback<FixtureMethodType> test_callback{};
-
-    std::ignore = method.RegisterHandler(std::move(test_callback));
+    // // When a Register call is issued at the binding independent level
+    using HandlerType = typename TestFixture::HandlerType;
+    score::cpp::callback<HandlerType> test_callback{};
+    std::ignore = this->method_->RegisterHandler(std::move(test_callback));
 }
 
 TYPED_TEST(SkeletonMethodTypedTest, TwoParameterConstructorCorrectlyCallsBindingFactoryAndSkeletonMethodIsCreated)
 {
+    this->WithAMockedMethodBindingfactory();
 
-    auto skeleton_method_binding_factory_mock = SkeletonMethodBindingFactoryMock();
-    SkeletonMethodBindingFactory::InjectMockBinding(&skeleton_method_binding_factory_mock);
-
-    auto skeleton_method_binding =
-        std::make_unique<mock_binding::SkeletonMethodFacade>(this->skeleton_method_binding_mock_);
-
-    // Given A skeleton Method with a mock method binding
-
-    EmptySkeleton empty_skeleton{std::make_unique<mock_binding::Skeleton>(), kInstanceIdWithLolaBinding};
-
-    // And a method type that can be one of the four qualitatively different Types void()          SomeType()
-    //  void(SomeTypes) SomeType(SomeTypes)
-
-    // expecting that a binding factory cannot crete a binding
-    EXPECT_CALL(skeleton_method_binding_factory_mock,
-                Create(_ /*handle*/, _ /*parent binding*/, _ /*method_name*/, _ /*method_type*/))
-        .WillOnce(testing::Return(testing::ByMove(std::move(skeleton_method_binding))));
+    // Expecting that a binding factory can create a binding
+    EXPECT_CALL(this->skeleton_method_binding_factory_mock_guard_->factory_mock_,
+                Create(_ /*handle*/, _ /*parent binding*/, this->method_name_, _))
+        .WillOnce(testing::Return(
+            testing::ByMove(std::make_unique<mock_binding::SkeletonMethodFacade>(this->mock_method_binding_))));
 
     // When the 2-parameter constructor of the SkeletonMethod class is called
-    using FixtureMethodType = typename TestFixture::Type;
-    SkeletonMethod<FixtureMethodType> method{empty_skeleton, "dummy_method"};
-
-    EXPECT_CALL(this->skeleton_method_binding_mock_, RegisterHandler(_));
+    using FixtureMethodType = typename TestFixture::MethodType;
+    SkeletonMethod<FixtureMethodType> method{this->empty_skeleton_, this->method_name_};
 
     // Then a Binding can be created which is capable of registering a callback
-    score::cpp::callback<FixtureMethodType> test_callback{};
+    using HandlerType = typename TestFixture::HandlerType;
+    score::cpp::callback<HandlerType> test_callback{};
     EXPECT_TRUE(method.RegisterHandler(std::move(test_callback)));
 }
 
@@ -187,45 +186,31 @@ TYPED_TEST(
     SkeletonMethodTypedTest,
     TwoParameterConstructorCorrectlyCallsBindingFactoryButSkeletonMethodIsNotCreatedWhenTheBindingFactoryDoesNotReturnBinding)
 {
+    this->WithAMockedMethodBindingfactory();
 
-    auto skeleton_method_binding_factory_mock = SkeletonMethodBindingFactoryMock();
-    SkeletonMethodBindingFactory::InjectMockBinding(&skeleton_method_binding_factory_mock);
-
-    auto skeleton_method_binding =
-        std::make_unique<mock_binding::SkeletonMethodFacade>(this->skeleton_method_binding_mock_);
-
-    // Given A skeleton Method with a mock method binding
-
-    EmptySkeleton empty_skeleton{std::make_unique<mock_binding::Skeleton>(), kInstanceIdWithLolaBinding};
-
-    // And a method type that can be one of the four qualitatively different Types
-    //  void()          SomeType()
-    //  void(SomeTypes) SomeType(SomeTypes)
-
-    // expecting that a binding factory cannot crete a binding
-    EXPECT_CALL(skeleton_method_binding_factory_mock,
-                Create(_ /*handle*/, _ /*parent binding*/, _ /*method_name*/, _ /*method_type*/))
+    // Expecting that a binding factory cannot create a binding
+    EXPECT_CALL(this->skeleton_method_binding_factory_mock_guard_->factory_mock_,
+                Create(_ /*handle*/, _ /*parent binding*/, this->method_name_, _ /*method_type*/))
         .WillOnce(testing::Return(testing::ByMove(nullptr)));
 
     // When the 2-parameter constructor of the SkeletonMethod class is called
-    using FixtureMethodType = typename TestFixture::Type;
-    SkeletonMethod<FixtureMethodType> method{empty_skeleton, "dummy_method"};
+    using FixtureMethodType = typename TestFixture::MethodType;
+    SkeletonMethod<FixtureMethodType> method{this->empty_skeleton_, this->method_name_};
 
     // Then the binding cannot be created and calling AreBindingsValid returns false
-    EXPECT_FALSE(SkeletonBaseView{empty_skeleton}.AreBindingsValid());
+    EXPECT_FALSE(SkeletonBaseView{this->empty_skeleton_}.AreBindingsValid());
 }
 
 TEST_F(SkeletonMethodTestFixture, ACallbackWithAPointerAsStateCanBeRegistered)
 {
-    // Given A skeleton Method with a mock method binding
-    CreateSkeletonMethod();
+    GivenASkeletonMethod();
 
     // And a callback with a unique_ptr as a state
     auto test_struct_p = std::make_unique<MyDataStruct>();
-    score::cpp::callback<TestMethodType> test_callback_with_state = [state = std::move(test_struct_p)](
-                                                                        int, bool b) noexcept {
-        return state->b || b;
-    };
+    score::cpp::callback<TestMethodHandlerType> test_callback_with_state =
+        [state = std::move(test_struct_p)](bool& return_value, const int&, const bool& b) noexcept {
+            return_value = state->b || b;
+        };
 
     // Expecting that the register call is dispatched to the binding without an error
     EXPECT_CALL(mock_method_binding_, RegisterHandler(_));
@@ -237,34 +222,38 @@ TEST_F(SkeletonMethodTestFixture, ACallbackWithAPointerAsStateCanBeRegistered)
 using Thing = long;
 using InType1 = double;
 using InType2 = int;
-using VoidVoid = void();
-using ThingVoid = Thing();
-using VoidStuff = void(InType1, InType2);
-using ThingStuff = Thing(InType1, InType2);
-
-template <typename MethodType>
+using VoidVoid = MethodTypeAndHandlerType<void(), void()>;
+using ThingVoid = MethodTypeAndHandlerType<Thing(), void(Thing&)>;
+using VoidStuff =
+    MethodTypeAndHandlerType<void(InType1, InType2, InType2), void(const InType1&, const InType2&, const InType2&)>;
+using ThingStuff = MethodTypeAndHandlerType<Thing(InType1, InType2, InType2),
+                                            void(Thing&, const InType1&, const InType2&, const InType2&)>;
+
+template <typename Types>
 class SkeletonMethodGenericTestFixture : public ::testing::Test
 {
-
   public:
     void CreateSkeletonMethodWithMockedTypeErasedCallback()
     {
         EmptySkeleton empty_skeleton{std::make_unique<mock_binding::Skeleton>(), kInstanceIdWithLolaBinding};
 
         auto mock_method_binding_ptr = std::make_unique<mock_binding::SkeletonMethodFacade>(mock_method_binding_);
-        method_ = std::make_unique<SkeletonMethod<MethodType>>(
+        method_ = std::make_unique<SkeletonMethod<typename Types::MethodType>>(
             empty_skeleton, "dummy_method", std::move(mock_method_binding_ptr));
     }
 
     static constexpr std::size_t in_args_buffer_size = sizeof(InType1) + sizeof(InType2);
-    void SerializeBuffers(InType1 in_arg_1, InType2 in_arg_2)
+    void SerializeBuffers(InType1 in_arg_1, InType2 in_arg_2, InType2 in_arg_3)
     {
         constexpr std::size_t in_type_1_size = sizeof(InType1);
+        constexpr std::size_t in_type_2_size = sizeof(InType2);
 
         std::byte* write_head = in_args_buffer_.begin();
         new (write_head) InType1(in_arg_1);
         write_head += in_type_1_size;
         new (write_head) InType2(in_arg_2);
+        write_head += in_type_2_size;
+        new (write_head) InType2(in_arg_3);
     }
     Thing GetTypedResultFromOutArgBuffer()
     {
@@ -273,8 +262,8 @@ class SkeletonMethodGenericTestFixture : public ::testing::Test
     std::array<std::byte, sizeof(Thing)> out_arg_buffer_{};
     std::array<std::byte, in_args_buffer_size> in_args_buffer_{};
 
-    std::unique_ptr<SkeletonMethod<MethodType>> method_{nullptr};
-    ::testing::MockFunction<MethodType> typed_callback_mock_{};
+    std::unique_ptr<SkeletonMethod<typename Types::MethodType>> method_{nullptr};
+    ::testing::MockFunction<typename Types::HandlerType> typed_callback_mock_{};
     std::optional<SkeletonMethodBinding::TypeErasedHandler> typeerased_callback_{};
     mock_binding::SkeletonMethod mock_method_binding_{};
 };
@@ -295,11 +284,15 @@ TEST_F(SkeletonMethodThingStuffFixture, DataTransferBetweenTypedAndTypeErasedCal
     Thing ret_val{505};
     InType1 in_arg_1{6.12};
     InType2 in_arg_2{17};
+    InType2 in_arg_3{18};
 
-    // Expecting that a typed callable will be called with correctly deserialized inargs and will return a value
-    EXPECT_CALL(typed_callback_mock_, Call(in_arg_1, in_arg_2)).WillOnce(Return(ret_val));
+    // Expecting that a typed callable will be called with correctly deserialized inargs and return value
+    EXPECT_CALL(typed_callback_mock_, Call(_, in_arg_1, in_arg_2, in_arg_3))
+        .WillOnce(Invoke([ret_val](auto& return_arg, auto, auto, auto) {
+            return_arg = ret_val;
+        }));
 
-    SerializeBuffers(in_arg_1, in_arg_2);
+    SerializeBuffers(in_arg_1, in_arg_2, in_arg_3);
     EXPECT_TRUE(method_->RegisterHandler(typed_callback_mock_.AsStdFunction()));
     // When the type erased call is executed by the binding
     typeerased_callback_.value()(in_args_buffer_, out_arg_buffer_);
@@ -324,8 +317,10 @@ TEST_F(SkeletonMethodThingVoidFixture, DataTransferBetweenTypedAndTypeErasedCall
 
     Thing ret_val{50255};
 
-    // Expecting that a typed callable will be called without inargs and will return a value
-    EXPECT_CALL(typed_callback_mock_, Call()).WillOnce(Return(ret_val));
+    // Expecting that a typed callable will be called without inargs and return a value
+    EXPECT_CALL(typed_callback_mock_, Call(_)).WillOnce(Invoke([ret_val](auto& return_arg) {
+        return_arg = ret_val;
+    }));
 
     EXPECT_TRUE(method_->RegisterHandler(typed_callback_mock_.AsStdFunction()));
 
@@ -352,11 +347,12 @@ TEST_F(SkeletonMethodVoidStuffFixture, DataTransferBetweenTypedAndTypeErasedCall
 
     InType1 in_arg_1{0.6};
     InType2 in_arg_2{0x1700};
+    InType2 in_arg_3{0x1701};
 
-    // Expecting that a typed callable will be called with correctly deserialized inargs and will not return a value
-    EXPECT_CALL(typed_callback_mock_, Call(in_arg_1, in_arg_2)).WillOnce(Return());
+    // Expecting that a typed callable will be called with correctly deserialized inargs and no return value
+    EXPECT_CALL(typed_callback_mock_, Call(in_arg_1, in_arg_2, in_arg_3));
 
-    SerializeBuffers(in_arg_1, in_arg_2);
+    SerializeBuffers(in_arg_1, in_arg_2, in_arg_3);
     EXPECT_TRUE(method_->RegisterHandler(typed_callback_mock_.AsStdFunction()));
 
     // When the type erased call is executed by the binding
@@ -376,13 +372,14 @@ TEST_F(SkeletonMethodVoidVoidFixture, DataTransferBetweenTypedAndTypeErasedCallb
             return {};
         }));
 
-    // Expecting that a typed callable will be called without inargs and will not return a value
-    EXPECT_CALL(typed_callback_mock_, Call()).WillOnce(Return());
+    // Expecting that a typed callable will be called without inargs or return value
+    EXPECT_CALL(typed_callback_mock_, Call());
 
     EXPECT_TRUE(method_->RegisterHandler(typed_callback_mock_.AsStdFunction()));
     // When the type erased call is executed by the binding
     typeerased_callback_.value()({}, {});
 }
+
 }  // namespace
 
 }  // namespace score::mw::com::impl
diff --git a/score/mw/com/impl/plumbing/i_skeleton_field_binding_factory.h b/score/mw/com/impl/plumbing/i_skeleton_field_binding_factory.h
index 053898253..063ab2164 100644
--- a/score/mw/com/impl/plumbing/i_skeleton_field_binding_factory.h
+++ b/score/mw/com/impl/plumbing/i_skeleton_field_binding_factory.h
@@ -18,6 +18,7 @@
 #include "score/mw/com/impl/skeleton_base.h"
 #include "score/mw/com/impl/skeleton_event_binding.h"
 
+#include <cstddef>
 #include <memory>
 #include <string_view>
 
@@ -44,11 +45,13 @@ class ISkeletonFieldBindingFactory
     /// \param identifier The instance identifier containing the binding information.
     /// \param parent A reference to the Skeleton which owns this event.
     /// \param field_name The binding unspecific name of the field inside the skeleton denoted by instance identifier.
+    /// \param additional_slots_for_field_get_set Additional slots to reserve on top of configured sample slots.
     /// \return An instance of SkeletonEventBinding or nullptr in case of an error.
     virtual auto CreateEventBinding(const InstanceIdentifier& identifier,
-                                    SkeletonBase& parent,
-                                    const std::string_view field_name) noexcept
-        -> std::unique_ptr<SkeletonEventBinding<SampleType>> = 0;
+                    SkeletonBase& parent,
+                    const std::string_view field_name,
+                std::size_t additional_slots_for_field_get_set = 0U) noexcept
+      -> std::unique_ptr<SkeletonEventBinding<SampleType>> = 0;
 };
 
 }  // namespace score::mw::com::impl
diff --git a/score/mw/com/impl/plumbing/skeleton_field_binding_factory.h b/score/mw/com/impl/plumbing/skeleton_field_binding_factory.h
index 1473748cd..d50aa06df 100644
--- a/score/mw/com/impl/plumbing/skeleton_field_binding_factory.h
+++ b/score/mw/com/impl/plumbing/skeleton_field_binding_factory.h
@@ -23,6 +23,7 @@
 #include "score/mw/com/impl/skeleton_event_binding.h"
 
 #include <functional>
+#include <cstddef>
 #include <memory>
 #include <string_view>
 #include <utility>
@@ -39,9 +40,10 @@ class SkeletonFieldBindingFactory final
     /// \brief See documentation in ISkeletonFieldBindingFactory.
     static std::unique_ptr<SkeletonEventBinding<SampleType>> CreateEventBinding(const InstanceIdentifier& identifier,
                                                                                 SkeletonBase& parent,
-                                                                                const std::string_view field_name)
+                                                                                const std::string_view field_name,
+                                                                                std::size_t additional_slots_for_field_get_set = 0U)
     {
-        return instance().CreateEventBinding(identifier, parent, field_name);
+        return instance().CreateEventBinding(identifier, parent, field_name, additional_slots_for_field_get_set);
     }
 
     /// \brief Inject a mock ISkeletonFieldBindingFactory. If a mock is injected, then all calls on
diff --git a/score/mw/com/impl/plumbing/skeleton_field_binding_factory_impl.h b/score/mw/com/impl/plumbing/skeleton_field_binding_factory_impl.h
index 34dd2b44a..4edc06c14 100644
--- a/score/mw/com/impl/plumbing/skeleton_field_binding_factory_impl.h
+++ b/score/mw/com/impl/plumbing/skeleton_field_binding_factory_impl.h
@@ -21,6 +21,7 @@
 #include "score/mw/com/impl/skeleton_base.h"
 #include "score/mw/com/impl/skeleton_event_binding.h"
 
+#include <cstddef>
 #include <memory>
 #include <string_view>
 
@@ -36,7 +37,8 @@ class SkeletonFieldBindingFactoryImpl : public ISkeletonFieldBindingFactory<Samp
     std::unique_ptr<SkeletonEventBinding<SampleType>> CreateEventBinding(
         const InstanceIdentifier& identifier,
         SkeletonBase& parent,
-        const std::string_view field_name) noexcept override;
+        const std::string_view field_name,
+      std::size_t additional_slots_for_field_get_set = 0U) noexcept override;
 };
 
 template <typename SampleType>
@@ -49,13 +51,17 @@ template <typename SampleType>
 // This suppression should be removed after fixing [Ticket-173043](broken_link_j/Ticket-173043)
 // coverity[autosar_cpp14_a15_5_3_violation : FALSE]
 auto SkeletonFieldBindingFactoryImpl<SampleType>::CreateEventBinding(const InstanceIdentifier& identifier,
-                                                                     SkeletonBase& parent,
-                                                                     const std::string_view field_name) noexcept
-    -> std::unique_ptr<SkeletonEventBinding<SampleType>>
+                                   SkeletonBase& parent,
+                                   const std::string_view field_name,
+                                   std::size_t additional_slots_for_field_get_set) noexcept
+  -> std::unique_ptr<SkeletonEventBinding<SampleType>>
 {
-    return CreateSkeletonServiceElement<SkeletonEventBinding<SampleType>,
-                                        lola::SkeletonEvent<SampleType>,
-                                        ServiceElementType::FIELD>(identifier, parent, field_name);
+  return CreateSkeletonServiceElement<SkeletonEventBinding<SampleType>,
+                    lola::SkeletonEvent<SampleType>,
+                    ServiceElementType::FIELD>(identifier,
+                                   parent,
+                                   field_name,
+                                   additional_slots_for_field_get_set);
 }
 
 }  // namespace score::mw::com::impl
diff --git a/score/mw/com/impl/plumbing/skeleton_field_binding_factory_mock.h b/score/mw/com/impl/plumbing/skeleton_field_binding_factory_mock.h
index 6e9197cb7..1ab93a8ca 100644
--- a/score/mw/com/impl/plumbing/skeleton_field_binding_factory_mock.h
+++ b/score/mw/com/impl/plumbing/skeleton_field_binding_factory_mock.h
@@ -17,6 +17,8 @@
 
 #include <gmock/gmock.h>
 
+#include <cstddef>
+
 namespace score::mw::com::impl
 {
 
@@ -27,7 +29,17 @@ class SkeletonFieldBindingFactoryMock : public ISkeletonFieldBindingFactory<Samp
     MOCK_METHOD(std::unique_ptr<SkeletonEventBinding<SampleType>>,
                 CreateEventBinding,
                 (const InstanceIdentifier&, SkeletonBase&, const std::string_view),
-                (noexcept, override));
+                (noexcept));
+
+    auto CreateEventBinding(const InstanceIdentifier& identifier,
+                            SkeletonBase& parent,
+                            const std::string_view field_name,
+                std::size_t additional_slots_for_field_get_set) noexcept
+        -> std::unique_ptr<SkeletonEventBinding<SampleType>> override
+    {
+      static_cast<void>(additional_slots_for_field_get_set);
+        return CreateEventBinding(identifier, parent, field_name);
+    }
 };
 
 }  // namespace score::mw::com::impl
diff --git a/score/mw/com/impl/plumbing/skeleton_service_element_binding_factory_impl.h b/score/mw/com/impl/plumbing/skeleton_service_element_binding_factory_impl.h
index f3bc69910..089124939 100644
--- a/score/mw/com/impl/plumbing/skeleton_service_element_binding_factory_impl.h
+++ b/score/mw/com/impl/plumbing/skeleton_service_element_binding_factory_impl.h
@@ -30,6 +30,7 @@
 #include <score/overload.hpp>
 
 #include <chrono>
+#include <cstddef>
 #include <exception>
 #include <memory>
 #include <string>
@@ -45,7 +46,8 @@ namespace detail
 
 template <typename LolaServiceElementInstanceDeployment>
 lola::SkeletonEventProperties GetSkeletonEventProperties(
-    const LolaServiceElementInstanceDeployment& lola_service_element_instance_deployment)
+    const LolaServiceElementInstanceDeployment& lola_service_element_instance_deployment,
+    std::size_t additional_slots_for_field_get_set = 0U)
 {
     if (!lola_service_element_instance_deployment.GetNumberOfSampleSlots().has_value())
     {
@@ -62,7 +64,11 @@ lola::SkeletonEventProperties GetSkeletonEventProperties(
                "not specified in the configuration. Terminating.";
         std::terminate();
     }
-    return lola::SkeletonEventProperties{lola_service_element_instance_deployment.GetNumberOfSampleSlots().value(),
+    const auto number_of_slots = static_cast<std::size_t>(
+        lola_service_element_instance_deployment.GetNumberOfSampleSlots().value()) +
+        additional_slots_for_field_get_set;
+
+    return lola::SkeletonEventProperties{number_of_slots,
                                          lola_service_element_instance_deployment.max_subscribers_.value(),
                                          lola_service_element_instance_deployment.enforce_max_samples_};
 }
@@ -80,7 +86,8 @@ template <typename SkeletonServiceElementBinding, typename SkeletonServiceElemen
 // coverity[autosar_cpp14_a15_5_3_violation : FALSE]
 auto CreateSkeletonServiceElement(const InstanceIdentifier& identifier,
                                   SkeletonBase& parent,
-                                  const std::string_view service_element_name) noexcept
+                                  const std::string_view service_element_name,
+                                  std::size_t additional_slots_for_field_get_set = 0U) noexcept
     -> std::unique_ptr<SkeletonServiceElementBinding>
 {
     static_assert(element_type != ServiceElementType::INVALID);
@@ -89,7 +96,7 @@ auto CreateSkeletonServiceElement(const InstanceIdentifier& identifier,
 
     using ReturnType = std::unique_ptr<SkeletonServiceElementBinding>;
     auto visitor = score::cpp::overload(
-        [identifier_view, &parent, &service_element_name](
+        [identifier_view, &parent, &service_element_name, additional_slots_for_field_get_set](
             const LolaServiceTypeDeployment& lola_service_type_deployment) -> ReturnType {
             auto* const lola_parent = dynamic_cast<lola::Skeleton*>(SkeletonBaseView{parent}.GetBinding());
             if (lola_parent == nullptr)
@@ -107,7 +114,8 @@ auto CreateSkeletonServiceElement(const InstanceIdentifier& identifier,
             const auto& lola_service_element_instance_deployment = GetServiceElementInstanceDeployment<element_type>(
                 lola_service_instance_deployment, service_element_name_str);
             const auto skeleton_event_properties =
-                detail::GetSkeletonEventProperties(lola_service_element_instance_deployment);
+                detail::GetSkeletonEventProperties(lola_service_element_instance_deployment,
+                                                   additional_slots_for_field_get_set);
 
             const auto lola_service_element_id =
                 GetServiceElementId<element_type>(lola_service_type_deployment, service_element_name_str);
diff --git a/score/mw/com/impl/plumbing/skeleton_service_element_binding_factory_test.cpp b/score/mw/com/impl/plumbing/skeleton_service_element_binding_factory_test.cpp
index 37207dd89..ace49bd78 100644
--- a/score/mw/com/impl/plumbing/skeleton_service_element_binding_factory_test.cpp
+++ b/score/mw/com/impl/plumbing/skeleton_service_element_binding_factory_test.cpp
@@ -138,6 +138,31 @@ INSTANTIATE_TEST_CASE_P(SkeletonServiceElementBindingFactoryParamaterisedDeathTe
 
 TEST_P(SkeletonServiceElementBindingFactoryParamaterisedFixture, CanConstructFixture) {}
 
+class SkeletonServiceElementBindingFactoryFixture : public ::testing::Test
+{
+  protected:
+    const LolaFieldInstanceDeployment field_deployment_{{2U}, {3U}, 1U, true, 0U};
+
+    auto GetSkeletonEventProperties(const std::size_t additional_slots_for_field_get_set = 0U) const
+    {
+        return detail::GetSkeletonEventProperties(field_deployment_, additional_slots_for_field_get_set);
+    }
+};
+
+TEST_F(SkeletonServiceElementBindingFactoryFixture, AdditionalSlotsAreAddedToConfiguredNumberOfSlots)
+{
+    const auto skeleton_event_properties = GetSkeletonEventProperties(1U);
+
+    EXPECT_EQ(skeleton_event_properties.number_of_slots, 3U);
+}
+
+TEST_F(SkeletonServiceElementBindingFactoryFixture, DefaultAdditionalSlotsKeepsConfiguredNumberOfSlots)
+{
+    const auto skeleton_event_properties = GetSkeletonEventProperties();
+
+    EXPECT_EQ(skeleton_event_properties.number_of_slots, 2U);
+}
+
 TEST_P(SkeletonServiceElementBindingFactoryParamaterisedFixture, CanConstructServiceElement)
 {
     RecordProperty("Verifies", "SCR-21803701, SCR-21803702, SCR-5898925");
diff --git a/score/mw/com/impl/proxy_field.h b/score/mw/com/impl/proxy_field.h
index 5e6598bdb..7c032d239 100644
--- a/score/mw/com/impl/proxy_field.h
+++ b/score/mw/com/impl/proxy_field.h
@@ -259,7 +259,7 @@ class ProxyField final : public ProxyFieldBase
     }
 
     template <typename T = SampleDataType, typename = std::enable_if_t<EnableSet && std::is_same_v<T, SampleDataType>>>
-    score::Result<MethodReturnTypePtr<T>> Set(SampleDataType& new_field_value) noexcept
+    score::Result<MethodReturnTypePtr<T>> Set(const SampleDataType& new_field_value) noexcept
     {
         return proxy_method_set_dispatch_->operator()(new_field_value);
     }
diff --git a/score/mw/com/impl/skeleton_event.h b/score/mw/com/impl/skeleton_event.h
index ac50d016a..0772d79d4 100644
--- a/score/mw/com/impl/skeleton_event.h
+++ b/score/mw/com/impl/skeleton_event.h
@@ -15,6 +15,7 @@
 
 #include "score/mw/com/impl/instance_identifier.h"
 #include "score/mw/com/impl/plumbing/sample_allocatee_ptr.h"
+#include "score/mw/com/impl/plumbing/sample_ptr.h"
 #include "score/mw/com/impl/plumbing/skeleton_event_binding_factory.h"
 #include "score/mw/com/impl/runtime.h"
 #include "score/mw/com/impl/skeleton_base.h"
@@ -36,7 +37,7 @@ namespace score::mw::com::impl
 
 // False Positive: this is a normal forward declaration.
 // coverity[autosar_cpp14_m3_2_3_violation]
-template <typename SampleDataType, const bool EnableSet, const bool EnableNotifier>
+template <typename SampleDataType, const bool EnableSet, const bool EnableNotifier, const bool EnableGet>
 class SkeletonField;
 
 template <typename SampleDataType>
@@ -51,7 +52,7 @@ class SkeletonEvent : public SkeletonEventBase
     // SkeletonField uses composition pattern to reuse code from SkeletonEvent. These two classes also have shared
     // private APIs which necessitates the use of the friend keyword.
     // coverity[autosar_cpp14_a11_3_1_violation]
-    template <typename T, bool ES, bool EN>
+    template <typename T, bool ES, bool EN, bool EG>
     friend class SkeletonField;
 
     // Empty struct that is used to make the second constructor only accessible to SkeletonEvent and SkeletonField (as
@@ -314,6 +315,11 @@ class SkeletonEventView
         return skeleton_event_.GetTypedEventBinding();
     }
 
+    Result<SamplePtr<SampleType>> GetLatestSample(const QualityType& quality_type) noexcept
+    {
+        return GetBinding()->GetLatestSample(quality_type);
+    }
+
   private:
     SkeletonEvent<SampleType>& skeleton_event_;
 };
diff --git a/score/mw/com/impl/skeleton_event_base.h b/score/mw/com/impl/skeleton_event_base.h
index b09dc0859..2cf355b79 100644
--- a/score/mw/com/impl/skeleton_event_base.h
+++ b/score/mw/com/impl/skeleton_event_base.h
@@ -60,6 +60,15 @@ class SkeletonEventBase
         skeleton_base_ = skeleton_base;
     }
 
+    /// \brief Informs the binding that getter functionality is enabled, triggering transaction log setup.
+    void SetGetterEnabled(bool getter_enabled) noexcept
+    {
+        if (binding_ != nullptr)
+        {
+            binding_->SetGetterEnabled(getter_enabled);
+        }
+    }
+
     /// \brief Used to indicate that the event shall be available to consumer
     /// Performs binding independent functionality and then dispatches to the binding
     score::Result<void> PrepareOffer() noexcept
diff --git a/score/mw/com/impl/skeleton_event_binding.h b/score/mw/com/impl/skeleton_event_binding.h
index a4a10f922..428f5045c 100644
--- a/score/mw/com/impl/skeleton_event_binding.h
+++ b/score/mw/com/impl/skeleton_event_binding.h
@@ -14,7 +14,9 @@
 #define SCORE_MW_COM_IMPL_SKELETON_EVENT_BINDING_H
 
 #include "score/mw/com/impl/binding_type.h"
+#include "score/mw/com/impl/configuration/quality_type.h"
 #include "score/mw/com/impl/plumbing/sample_allocatee_ptr.h"
+#include "score/mw/com/impl/plumbing/sample_ptr.h"
 #include "score/mw/com/impl/tracing/skeleton_event_tracing_data.h"
 
 #include "score/result/result.h"
@@ -66,6 +68,9 @@ class SkeletonEventBindingBase
 
     /// \todo To be removed in Ticket-134850
     virtual void SetSkeletonEventTracingData(impl::tracing::SkeletonEventTracingData tracing_data) noexcept = 0;
+
+    /// \brief Informs the binding that a getter is enabled for this field event, enabling transaction log setup.
+    virtual void SetGetterEnabled(bool getter_enabled) noexcept = 0;
 };
 
 /// \brief The SkeletonEventBinding represents the interface that _every_ binding has to provide, if it wants to support
@@ -89,6 +94,8 @@ class SkeletonEventBinding : public SkeletonEventBindingBase
     /// implementations.
     virtual Result<SampleAllocateePtr<SampleType>> Allocate() noexcept = 0;
 
+    virtual Result<SamplePtr<SampleType>> GetLatestSample(const QualityType& quality_type) noexcept = 0;
+
     std::size_t GetMaxSize() const noexcept override
     {
         return sizeof(SampleType);
diff --git a/score/mw/com/impl/skeleton_event_binding_test.cpp b/score/mw/com/impl/skeleton_event_binding_test.cpp
index 0176e2189..2061525c9 100644
--- a/score/mw/com/impl/skeleton_event_binding_test.cpp
+++ b/score/mw/com/impl/skeleton_event_binding_test.cpp
@@ -13,6 +13,7 @@
 #include "score/mw/com/impl/skeleton_event_binding.h"
 
 #include "score/mw/com/impl/plumbing/sample_allocatee_ptr.h"
+#include "score/mw/com/impl/plumbing/sample_ptr.h"
 
 #include <gtest/gtest.h>
 #include <memory>
@@ -46,11 +47,18 @@ class MyEvent final : public SkeletonEventBinding<SampleType>
     {
         return MakeSampleAllocateePtr(std::make_unique<SampleType>());
     }
+    Result<SamplePtr<SampleType>> GetLatestSample(const QualityType& quality_type) noexcept override
+    {
+        static_cast<void>(quality_type);
+        return SamplePtr<SampleType>{mock_binding::SamplePtr<SampleType>{std::make_unique<SampleType>()},
+                                     SampleReferenceGuard{}};
+    }
     BindingType GetBindingType() const noexcept override
     {
         return BindingType::kFake;
     }
     void SetSkeletonEventTracingData(impl::tracing::SkeletonEventTracingData) noexcept override {}
+    void SetGetterEnabled(bool) noexcept override {}
 };
 
 TEST(SkeletonEventBindingTest, CanGetMaxSizeOfLiteralType)
diff --git a/score/mw/com/impl/skeleton_event_test.cpp b/score/mw/com/impl/skeleton_event_test.cpp
index 45aa2f81c..80a5fbd4c 100644
--- a/score/mw/com/impl/skeleton_event_test.cpp
+++ b/score/mw/com/impl/skeleton_event_test.cpp
@@ -653,5 +653,64 @@ TEST(SkeletonEventTest, MovingAssigningSkeletonUpdatesEventMapReference)
     EXPECT_EQ(&event, &unit2.my_dummy_event_);
 }
 
+TEST(SkeletonEventGetLatestSampleTest, CallingGetLatestSampleDispatchesToBinding)
+{
+    RuntimeMockGuard runtime_mock_guard{};
+    ON_CALL(runtime_mock_guard.runtime_mock_, GetTracingFilterConfig()).WillByDefault(Return(nullptr));
+    SkeletonEventBindingFactoryMockGuard<TestSampleType> skeleton_event_binding_factory_mock_guard{};
+
+    // Expecting that a SkeletonEvent binding is created
+    auto skeleton_event_binding_mock_ptr = std::make_unique<mock_binding::SkeletonEvent<TestSampleType>>();
+    auto& skeleton_event_binding_mock = *skeleton_event_binding_mock_ptr;
+    EXPECT_CALL(skeleton_event_binding_factory_mock_guard.factory_mock_,
+                Create(kInstanceIdWithLolaBinding, _, kEventName))
+        .WillOnce(Return(ByMove(std::move(skeleton_event_binding_mock_ptr))));
+
+    // and that GetLatestSample() is called once on the event binding which returns a valid sample
+    EXPECT_CALL(skeleton_event_binding_mock, GetLatestSample(QualityType::kASIL_QM))
+        .WillOnce(Return(ByMove(SamplePtr<TestSampleType>{
+            mock_binding::SamplePtr<TestSampleType>{std::make_unique<TestSampleType>(42U)}, SampleReferenceGuard{}})));
+
+    // Given a skeleton which has a mock skeleton-binding
+    MyDummySkeleton unit{std::make_unique<mock_binding::Skeleton>(), kInstanceIdWithLolaBinding};
+
+    // When calling GetLatestSample on the event
+    const auto latest_sample_result =
+        SkeletonEventView<TestSampleType>{unit.my_dummy_event_}.GetLatestSample(QualityType::kASIL_QM);
+
+    // Then the result is valid and contains the sample from the binding
+    ASSERT_TRUE(latest_sample_result.has_value());
+    EXPECT_EQ(*latest_sample_result.value(), static_cast<TestSampleType>(42U));
+}
+
+TEST(SkeletonEventGetLatestSampleTest, CallingGetLatestSampleWhenBindingFailsReturnsError)
+{
+    RuntimeMockGuard runtime_mock_guard{};
+    ON_CALL(runtime_mock_guard.runtime_mock_, GetTracingFilterConfig()).WillByDefault(Return(nullptr));
+    SkeletonEventBindingFactoryMockGuard<TestSampleType> skeleton_event_binding_factory_mock_guard{};
+
+    // Expecting that a SkeletonEvent binding is created
+    auto skeleton_event_binding_mock_ptr = std::make_unique<mock_binding::SkeletonEvent<TestSampleType>>();
+    auto& skeleton_event_binding_mock = *skeleton_event_binding_mock_ptr;
+    EXPECT_CALL(skeleton_event_binding_factory_mock_guard.factory_mock_,
+                Create(kInstanceIdWithLolaBinding, _, kEventName))
+        .WillOnce(Return(ByMove(std::move(skeleton_event_binding_mock_ptr))));
+
+    // and that GetLatestSample() is called once on the event binding which returns an error
+    EXPECT_CALL(skeleton_event_binding_mock, GetLatestSample(QualityType::kASIL_QM))
+        .WillOnce(Return(ByMove(MakeUnexpected(ComErrc::kBindingFailure))));
+
+    // Given a skeleton which has a mock skeleton-binding
+    MyDummySkeleton unit{std::make_unique<mock_binding::Skeleton>(), kInstanceIdWithLolaBinding};
+
+    // When calling GetLatestSample on the event
+    const auto latest_sample_result =
+        SkeletonEventView<TestSampleType>{unit.my_dummy_event_}.GetLatestSample(QualityType::kASIL_QM);
+
+    // Then the result contains an error that the binding failed
+    ASSERT_FALSE(latest_sample_result.has_value());
+    EXPECT_EQ(latest_sample_result.error(), ComErrc::kBindingFailure);
+}
+
 }  // namespace
 }  // namespace score::mw::com::impl
diff --git a/score/mw/com/impl/skeleton_field.h b/score/mw/com/impl/skeleton_field.h
index f9cd07006..b6c440580 100644
--- a/score/mw/com/impl/skeleton_field.h
+++ b/score/mw/com/impl/skeleton_field.h
@@ -14,6 +14,7 @@
 #define SCORE_MW_COM_IMPL_SKELETON_FIELD_H
 
 #include "score/mw/com/impl/method_type.h"
+#include "score/mw/com/impl/methods/method_handler_checker.h"
 #include "score/mw/com/impl/methods/skeleton_method.h"
 #include "score/mw/com/impl/plumbing/sample_allocatee_ptr.h"
 #include "score/mw/com/impl/plumbing/skeleton_field_binding_factory.h"
@@ -28,6 +29,7 @@
 #include <score/assert.hpp>
 
 #include <memory>
+#include <mutex>
 #include <string_view>
 #include <type_traits>
 #include <utility>
@@ -35,29 +37,49 @@
 namespace score::mw::com::impl
 {
 
-template <typename SampleDataType, const bool EnableSet = false, const bool EnableNotifier = false>
+template <typename SampleDataType,
+          const bool EnableSet = false,
+          const bool EnableNotifier = false,
+          const bool EnableGet = false>
 class SkeletonField : public SkeletonFieldBase
 {
   public:
     using FieldType = SampleDataType;
 
-    /// \brief Constructs a SkeletonField with setter enabled. Normal ctor used in production code.
+    /// \brief Constructs a SkeletonField for EnableSet=true, EnableGet=true. Normal ctor used in production code.
+    ///
+    /// \param parent Skeleton that contains this field.
+    /// \param field_name Field name of the field.
+    /// \param detail::EnableBothTag This parameter is only used for constructor overload disambiguation and
+    /// has no semantic meaning.
+    template <bool ES = EnableSet, bool EG = EnableGet, typename = std::enable_if_t<ES && EG>>
+    SkeletonField(SkeletonBase& parent, const std::string_view field_name, detail::EnableBothTag = {});
+
+    /// \brief Constructs a SkeletonField for EnableSet=false, EnableGet=true. Normal ctor used in production code.
+    ///
+    /// \param parent Skeleton that contains this field.
+    /// \param field_name Field name of the field.
+    /// \param detail::EnableGetOnlyTag This parameter is only used for constructor overload disambiguation and
+    /// has no semantic meaning.
+    template <bool ES = EnableSet, bool EG = EnableGet, typename = std::enable_if_t<!ES && EG>>
+    SkeletonField(SkeletonBase& parent, const std::string_view field_name, detail::EnableGetOnlyTag = {});
+
+    /// \brief Constructs a SkeletonField for EnableSet=true, EnableGet=false. Normal ctor used in production code.
     ///
     /// \param parent Skeleton that contains this field.
     /// \param field_name Field name of the field.
     /// \param detail::EnableSetOnlyTag This parameter is only used for constructor overload disambiguation and
-    /// has no semantic meaning. The tag disambiguates the setter-enabled ctor from the no-setter ctor, as
-    /// otherwise both would have the same signature.
-    template <bool ES = EnableSet, typename = std::enable_if_t<ES>>
+    /// has no semantic meaning.
+    template <bool ES = EnableSet, bool EG = EnableGet, typename = std::enable_if_t<ES && !EG>>
     SkeletonField(SkeletonBase& parent, const std::string_view field_name, detail::EnableSetOnlyTag = {});
 
-    /// \brief Constructs a SkeletonField with no setter. Normal ctor used in production code.
+    /// \brief Constructs a SkeletonField for EnableSet=false, EnableGet=false. Normal ctor used in production code.
     ///
     /// \param parent Skeleton that contains this field.
     /// \param field_name Field name of the field.
     /// \param detail::EnableNeitherTag This parameter is only used for constructor overload disambiguation and
     /// has no semantic meaning.
-    template <bool ES = EnableSet, typename = std::enable_if_t<!ES>>
+    template <bool ES = EnableSet, bool EG = EnableGet, typename = std::enable_if_t<!ES && !EG>>
     SkeletonField(SkeletonBase& parent, const std::string_view field_name, detail::EnableNeitherTag = {});
 
     /// Constructor that allows to set the binding directly.
@@ -123,24 +145,27 @@ class SkeletonField : public SkeletonFieldBase
     template <bool ES = EnableSet, std::enable_if_t<ES, int> = 0, typename CallableType>
     Result<void> RegisterSetHandler(CallableType&& set_handler)
     {
-        static_assert(std::is_invocable_v<CallableType, FieldType&>,
+        static_assert(std::is_invocable_r_v<void, CallableType, FieldType&>,
                       "RegisterSetHandler: handler must be callable as void(FieldType& value). "
                       "The argument initially holds the proxy-requested value and may be modified in-place.");
 
-        auto wrapped_callback =
-            [this, set_handler = std::forward<CallableType>(set_handler)](FieldType& new_value) -> FieldType {
+        auto state =
+            std::make_unique<std::pair<SkeletonField*, CallableType>>(this, std::forward<CallableType>(set_handler));
+
+        auto wrapped_callback = [state = std::move(state)](FieldType& final_value, const FieldType& desired_value) {
+            // Copy desired_value (which is a method InArg) into final_value (which is the method return value).
+            // final_value can then be modified in place by set_handler.
+            final_value = desired_value;
+
             // Allow user to validate/modify the value in-place
-            set_handler(new_value);
+            state->second(final_value);
 
-            // Store the (possibly modified) value as the latest field value
-            auto update_result = this->Update(new_value);
+            // Copy the (possibly modified) value into the latest field value
+            auto update_result = state->first->Update(final_value);
             if (!update_result.has_value())
             {
                 score::mw::log::LogError("lola") << "Set handler: failed to update field value.";
             }
-
-            // Return the accepted value to the proxy
-            return new_value;
         };
 
         is_set_handler_registered_ = true;
@@ -200,22 +225,48 @@ class SkeletonField : public SkeletonFieldBase
         return !is_set_handler_registered_;
     }
 
+    // Get handler registration
+    // SFINAE-gated: only exists when EnableGet == true
+    template <bool EG = EnableGet, typename std::enable_if<EG, int>::type = 0>
+    void RegisterGetHandler()
+    {
+        if (get_method_ == nullptr)
+        {
+            return;
+        }
+        const auto result = get_method_.get()->RegisterHandler([this]() -> Result<FieldType> {
+            // need to serialize access to Get. In case of concurrent Get calls,
+            // we want to ensure that they are processed sequentially.
+            std::lock_guard<std::mutex> lock{get_handler_mutex_};
+            return SkeletonEventView<FieldType>{*GetTypedEvent()}.GetLatestSample();
+        });
+        if (!result.has_value())
+        {
+            score::mw::log::LogError("lola")
+                << "RegisterGetHandler: failed to register get handler: " << result.error();
+        }
+    }
+
     std::unique_ptr<FieldType> initial_field_value_;
     ISkeletonField<FieldType>* skeleton_field_mock_;
 
     // Tracks whether RegisterSetHandler() has been called.
     bool is_set_handler_registered_;
 
+    // Zero-cost storage: only a real mutex when EnableGet=true, otherwise an empty zero-size type.
+    using GetHandlerMutexType = std::conditional_t<EnableGet, std::mutex, detail::EnableNeitherTag>;
+    GetHandlerMutexType get_handler_mutex_{};
+
     std::unique_ptr<SkeletonMethod<SetMethodSignature>> set_method_;
     std::unique_ptr<SkeletonMethod<GetMethodSignature>> get_method_;
 };
 
-/// \brief Public ctor — EnableSet=true: delegates to the private ctor that also creates the set method.
-template <typename SampleDataType, bool EnableSet, bool EnableNotifier>
-template <bool ES, typename>
-SkeletonField<SampleDataType, EnableSet, EnableNotifier>::SkeletonField(SkeletonBase& parent,
-                                                                        const std::string_view field_name,
-                                                                        detail::EnableSetOnlyTag)
+/// \brief Public ctor — EnableSet=true, EnableGet=true: delegates to the private ctor.
+template <typename SampleDataType, bool EnableSet, bool EnableNotifier, bool EnableGet>
+template <bool ES, bool EG, typename>
+SkeletonField<SampleDataType, EnableSet, EnableNotifier, EnableGet>::SkeletonField(SkeletonBase& parent,
+                                                                                   const std::string_view field_name,
+                                                                                   detail::EnableBothTag)
     : SkeletonField{
           parent,
           std::make_unique<SkeletonEvent<FieldType>>(parent,
@@ -223,15 +274,14 @@ SkeletonField<SampleDataType, EnableSet, EnableNotifier>::SkeletonField(Skeleton
                                                      SkeletonFieldBindingFactory<SampleDataType>::CreateEventBinding(
                                                          SkeletonBaseView{parent}.GetAssociatedInstanceIdentifier(),
                                                          parent,
-                                                         field_name),
+                                                         field_name,
+                                                         (EnableSet || EnableGet) ? 1U : 0U),
                                                      typename SkeletonEvent<FieldType>::FieldOnlyConstructorEnabler{}),
           std::make_unique<SkeletonMethod<SetMethodSignature>>(
               parent,
               field_name,
               ::score::mw::com::impl::MethodType::kSet,
               typename SkeletonMethod<SetMethodSignature>::FieldOnlyConstructorEnabler{}),
-          // TODO: Move get_method_ initialization into the delegating constructors (like set_method_) once the
-          // Get handler is implemented.
           std::make_unique<SkeletonMethod<GetMethodSignature>>(
               parent,
               field_name,
@@ -241,12 +291,38 @@ SkeletonField<SampleDataType, EnableSet, EnableNotifier>::SkeletonField(Skeleton
 {
 }
 
-/// \brief Public ctor — EnableSet=false: delegates to the private ctor with no set method.
-template <typename SampleDataType, bool EnableSet, bool EnableNotifier>
-template <bool ES, typename>
-SkeletonField<SampleDataType, EnableSet, EnableNotifier>::SkeletonField(SkeletonBase& parent,
-                                                                        const std::string_view field_name,
-                                                                        detail::EnableNeitherTag)
+/// \brief Public ctor — EnableSet=false, EnableGet=true: delegates to the private ctor.
+template <typename SampleDataType, bool EnableSet, bool EnableNotifier, bool EnableGet>
+template <bool ES, bool EG, typename>
+SkeletonField<SampleDataType, EnableSet, EnableNotifier, EnableGet>::SkeletonField(SkeletonBase& parent,
+                                                                                   const std::string_view field_name,
+                                                                                   detail::EnableGetOnlyTag)
+    : SkeletonField{
+          parent,
+          std::make_unique<SkeletonEvent<FieldType>>(parent,
+                                                     field_name,
+                                                     SkeletonFieldBindingFactory<SampleDataType>::CreateEventBinding(
+                                                         SkeletonBaseView{parent}.GetAssociatedInstanceIdentifier(),
+                                                         parent,
+                                                         field_name,
+                                                         (EnableSet || EnableGet) ? 1U : 0U),
+                                                     typename SkeletonEvent<FieldType>::FieldOnlyConstructorEnabler{}),
+          nullptr,
+          std::make_unique<SkeletonMethod<GetMethodSignature>>(
+              parent,
+              field_name,
+              ::score::mw::com::impl::MethodType::kGet,
+              typename SkeletonMethod<GetMethodSignature>::FieldOnlyConstructorEnabler{}),
+          field_name}
+{
+}
+
+/// \brief Public ctor — EnableSet=true, EnableGet=false: delegates to the private ctor.
+template <typename SampleDataType, bool EnableSet, bool EnableNotifier, bool EnableGet>
+template <bool ES, bool EG, typename>
+SkeletonField<SampleDataType, EnableSet, EnableNotifier, EnableGet>::SkeletonField(SkeletonBase& parent,
+                                                                                   const std::string_view field_name,
+                                                                                   detail::EnableSetOnlyTag)
     : SkeletonField{
           parent,
           std::make_unique<SkeletonEvent<FieldType>>(parent,
@@ -254,7 +330,34 @@ SkeletonField<SampleDataType, EnableSet, EnableNotifier>::SkeletonField(Skeleton
                                                      SkeletonFieldBindingFactory<SampleDataType>::CreateEventBinding(
                                                          SkeletonBaseView{parent}.GetAssociatedInstanceIdentifier(),
                                                          parent,
-                                                         field_name),
+                                                         field_name,
+                                                         (EnableSet || EnableGet) ? 1U : 0U),
+                                                     typename SkeletonEvent<FieldType>::FieldOnlyConstructorEnabler{}),
+          std::make_unique<SkeletonMethod<SetMethodSignature>>(
+              parent,
+              field_name,
+              ::score::mw::com::impl::MethodType::kSet,
+              typename SkeletonMethod<SetMethodSignature>::FieldOnlyConstructorEnabler{}),
+          nullptr,
+          field_name}
+{
+}
+
+/// \brief Public ctor — EnableSet=false, EnableGet=false: delegates to the private ctor with no methods.
+template <typename SampleDataType, bool EnableSet, bool EnableNotifier, bool EnableGet>
+template <bool ES, bool EG, typename>
+SkeletonField<SampleDataType, EnableSet, EnableNotifier, EnableGet>::SkeletonField(SkeletonBase& parent,
+                                                                                   const std::string_view field_name,
+                                                                                   detail::EnableNeitherTag)
+    : SkeletonField{
+          parent,
+          std::make_unique<SkeletonEvent<FieldType>>(parent,
+                                                     field_name,
+                                                     SkeletonFieldBindingFactory<SampleDataType>::CreateEventBinding(
+                                                         SkeletonBaseView{parent}.GetAssociatedInstanceIdentifier(),
+                                                         parent,
+                                                         field_name,
+                                                         (EnableSet || EnableGet) ? 1U : 0U),
                                                      typename SkeletonEvent<FieldType>::FieldOnlyConstructorEnabler{}),
           nullptr,
           nullptr,
@@ -263,8 +366,8 @@ SkeletonField<SampleDataType, EnableSet, EnableNotifier>::SkeletonField(Skeleton
 }
 
 /// \brief Testing ctor: binding is provided directly (used with mock bindings in tests).
-template <typename SampleDataType, bool EnableSet, bool EnableNotifier>
-SkeletonField<SampleDataType, EnableSet, EnableNotifier>::SkeletonField(
+template <typename SampleDataType, bool EnableSet, bool EnableNotifier, bool EnableGet>
+SkeletonField<SampleDataType, EnableSet, EnableNotifier, EnableGet>::SkeletonField(
     SkeletonBase& skeleton_base,
     const std::string_view field_name,
     std::unique_ptr<SkeletonEventBinding<FieldType>> binding)
@@ -276,8 +379,8 @@ SkeletonField<SampleDataType, EnableSet, EnableNotifier>::SkeletonField(
 {
 }
 
-template <typename SampleDataType, bool EnableSet, bool EnableNotifier>
-SkeletonField<SampleDataType, EnableSet, EnableNotifier>::SkeletonField(
+template <typename SampleDataType, bool EnableSet, bool EnableNotifier, bool EnableGet>
+SkeletonField<SampleDataType, EnableSet, EnableNotifier, EnableGet>::SkeletonField(
     SkeletonBase& parent,
     std::unique_ptr<SkeletonEvent<FieldType>> skeleton_event_dispatch,
     std::unique_ptr<SkeletonMethod<SetMethodSignature>> skeleton_set_method_dispatch,
@@ -292,10 +395,14 @@ SkeletonField<SampleDataType, EnableSet, EnableNotifier>::SkeletonField(
 {
     SkeletonBaseView skeleton_base_view{parent};
     skeleton_base_view.RegisterField(field_name, *this);
+    if constexpr (EnableGet)
+    {
+        RegisterGetHandler();
+    }
 }
 
-template <typename SampleDataType, bool EnableSet, bool EnableNotifier>
-SkeletonField<SampleDataType, EnableSet, EnableNotifier>::SkeletonField(SkeletonField&& other) noexcept
+template <typename SampleDataType, bool EnableSet, bool EnableNotifier, bool EnableGet>
+SkeletonField<SampleDataType, EnableSet, EnableNotifier, EnableGet>::SkeletonField(SkeletonField&& other) noexcept
     : SkeletonFieldBase(static_cast<SkeletonFieldBase&&>(other)),
       // known llvm bug (https://github.com/llvm/llvm-project/issues/63202)
       // This usage is safe because the previous line only moves the base class portion via static_cast.
@@ -312,9 +419,9 @@ SkeletonField<SampleDataType, EnableSet, EnableNotifier>::SkeletonField(Skeleton
     skeleton_base_view.UpdateField(field_name_, *this);
 }
 
-template <typename SampleDataType, bool EnableSet, bool EnableNotifier>
-auto SkeletonField<SampleDataType, EnableSet, EnableNotifier>::operator=(SkeletonField&& other) & noexcept
-    -> SkeletonField<SampleDataType, EnableSet, EnableNotifier>&
+template <typename SampleDataType, bool EnableSet, bool EnableNotifier, bool EnableGet>
+auto SkeletonField<SampleDataType, EnableSet, EnableNotifier, EnableGet>::operator=(SkeletonField&& other) & noexcept
+    -> SkeletonField<SampleDataType, EnableSet, EnableNotifier, EnableGet>&
 {
     if (this != &other)
     {
@@ -325,6 +432,8 @@ auto SkeletonField<SampleDataType, EnableSet, EnableNotifier>::operator=(Skeleto
         is_set_handler_registered_ = other.is_set_handler_registered_;
         set_method_ = std::move(other.set_method_);
         get_method_ = std::move(other.get_method_);
+
+        // Since the address of this event has changed, we need update the address stored in the parent skeleton.
         SkeletonBaseView skeleton_base_view{skeleton_base_.get()};
         skeleton_base_view.UpdateField(field_name_, *this);
     }
@@ -338,8 +447,9 @@ auto SkeletonField<SampleDataType, EnableSet, EnableNotifier>::operator=(Skeleto
 /// field cannot be set until the Skeleton has been set up via Skeleton::OfferService(). Therefore, we create a
 /// callback that will update the field value with sample_value which will be called in the first call to
 /// SkeletonFieldBase::PrepareOffer().
-template <typename SampleDataType, bool EnableSet, bool EnableNotifier>
-Result<void> SkeletonField<SampleDataType, EnableSet, EnableNotifier>::Update(const FieldType& sample_value) noexcept
+template <typename SampleDataType, bool EnableSet, bool EnableNotifier, bool EnableGet>
+Result<void> SkeletonField<SampleDataType, EnableSet, EnableNotifier, EnableGet>::Update(
+    const FieldType& sample_value) noexcept
 {
     if (skeleton_field_mock_ != nullptr)
     {
@@ -356,8 +466,8 @@ Result<void> SkeletonField<SampleDataType, EnableSet, EnableNotifier>::Update(co
 
 /// \brief FieldType is previously allocated by middleware and provided by the user to indicate that he is finished
 /// filling the provided pointer with live data. Dispatches to SkeletonEvent::Send()
-template <typename SampleDataType, bool EnableSet, bool EnableNotifier>
-Result<void> SkeletonField<SampleDataType, EnableSet, EnableNotifier>::Update(
+template <typename SampleDataType, bool EnableSet, bool EnableNotifier, bool EnableGet>
+Result<void> SkeletonField<SampleDataType, EnableSet, EnableNotifier, EnableGet>::Update(
     SampleAllocateePtr<FieldType> sample) noexcept
 {
     if (skeleton_field_mock_ != nullptr)
@@ -373,8 +483,9 @@ Result<void> SkeletonField<SampleDataType, EnableSet, EnableNotifier>::Update(
 ///
 /// This function cannot be currently called to set the initial value of a field as the shared memory must be first
 /// set up in the Skeleton::PrepareOffer() before the user can obtain / use a SampleAllocateePtr.
-template <typename SampleDataType, bool EnableSet, bool EnableNotifier>
-Result<SampleAllocateePtr<SampleDataType>> SkeletonField<SampleDataType, EnableSet, EnableNotifier>::Allocate() noexcept
+template <typename SampleDataType, bool EnableSet, bool EnableNotifier, bool EnableGet>
+Result<SampleAllocateePtr<SampleDataType>>
+SkeletonField<SampleDataType, EnableSet, EnableNotifier, EnableGet>::Allocate() noexcept
 {
     if (skeleton_field_mock_ != nullptr)
     {
@@ -392,12 +503,12 @@ Result<SampleAllocateePtr<SampleDataType>> SkeletonField<SampleDataType, EnableS
     return GetTypedEvent()->Allocate();
 }
 
-template <typename SampleDataType, bool EnableSet, bool EnableNotifier>
+template <typename SampleDataType, bool EnableSet, bool EnableNotifier, bool EnableGet>
 // Suppress "AUTOSAR C++14 A0-1-3" rule finding. This rule states: "Every function defined in an anonymous
 // namespace, or static function with internal linkage, or private member function shall be used.".
 // False-positive, method is used in the base class in PrepareOffer().
 // coverity[autosar_cpp14_a0_1_3_violation : FALSE]
-Result<void> SkeletonField<SampleDataType, EnableSet, EnableNotifier>::DoDeferredUpdate() noexcept
+Result<void> SkeletonField<SampleDataType, EnableSet, EnableNotifier, EnableGet>::DoDeferredUpdate() noexcept
 {
     SCORE_LANGUAGE_FUTURECPP_ASSERT_MESSAGE(
         initial_field_value_ != nullptr,
@@ -413,15 +524,15 @@ Result<void> SkeletonField<SampleDataType, EnableSet, EnableNotifier>::DoDeferre
     return Result<void>{};
 }
 
-template <typename SampleDataType, bool EnableSet, bool EnableNotifier>
-Result<void> SkeletonField<SampleDataType, EnableSet, EnableNotifier>::UpdateImpl(
+template <typename SampleDataType, bool EnableSet, bool EnableNotifier, bool EnableGet>
+Result<void> SkeletonField<SampleDataType, EnableSet, EnableNotifier, EnableGet>::UpdateImpl(
     const FieldType& sample_value) noexcept
 {
     return GetTypedEvent()->Send(sample_value);
 }
 
-template <typename SampleDataType, bool EnableSet, bool EnableNotifier>
-auto SkeletonField<SampleDataType, EnableSet, EnableNotifier>::GetTypedEvent() const noexcept
+template <typename SampleDataType, bool EnableSet, bool EnableNotifier, bool EnableGet>
+auto SkeletonField<SampleDataType, EnableSet, EnableNotifier, EnableGet>::GetTypedEvent() const noexcept
     -> SkeletonEvent<SampleDataType>*
 {
     auto* const typed_event = dynamic_cast<SkeletonEvent<FieldType>*>(skeleton_event_dispatch_.get());
diff --git a/score/mw/com/impl/skeleton_field_test.cpp b/score/mw/com/impl/skeleton_field_test.cpp
index 1255f5e12..2e3ae798f 100644
--- a/score/mw/com/impl/skeleton_field_test.cpp
+++ b/score/mw/com/impl/skeleton_field_test.cpp
@@ -23,6 +23,7 @@
 
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
+#include <array>
 #include <cstdint>
 #include <memory>
 #include <string_view>
@@ -127,6 +128,14 @@ class SkeletonFieldTestFixture : public ::testing::Test
     std::optional<TestSampleType> return_storage_{};
 };
 
+class MyGetEnabledSkeleton : public SkeletonBase
+{
+  public:
+    using SkeletonBase::SkeletonBase;
+
+    SkeletonField<TestSampleType, false, false, true> my_get_field_{*this, kFieldName};
+};
+
 TEST(SkeletonFieldTest, NotCopyable)
 {
     RecordProperty("Verifies", "SCR-18221574");
@@ -172,6 +181,85 @@ TEST(SkeletonFieldTest, SkeletonFieldContainsPublicSampleType)
                   "Incorrect FieldType.");
 }
 
+TEST(SkeletonFieldTest, CtorBothEnabledAcceptsEnableBothTag)
+{
+    using FieldType = SkeletonField<TestSampleType, true, false, true>;
+    static_assert(std::is_constructible_v<FieldType, SkeletonBase&, std::string_view, detail::EnableBothTag>,
+                  "Constructor should accept EnableBothTag when ES=true and EG=true");
+}
+
+TEST(SkeletonFieldTest, CtorGetOnlyAcceptsEnableGetOnlyTag)
+{
+    using FieldType = SkeletonField<TestSampleType, false, false, true>;
+    static_assert(std::is_constructible_v<FieldType, SkeletonBase&, std::string_view, detail::EnableGetOnlyTag>,
+                  "Constructor should accept EnableGetOnlyTag when ES=false and EG=true");
+}
+
+TEST(SkeletonFieldTest, CtorSetOnlyAcceptsEnableSetOnlyTag)
+{
+    using FieldType = SkeletonField<TestSampleType, true, false, false>;
+    static_assert(std::is_constructible_v<FieldType, SkeletonBase&, std::string_view, detail::EnableSetOnlyTag>,
+                  "Constructor should accept EnableSetOnlyTag when ES=true and EG=false");
+}
+
+TEST(SkeletonFieldTest, CtorNeitherEnabledAcceptsEnableNeitherTag)
+{
+    using FieldType = SkeletonField<TestSampleType, false, false, false>;
+    static_assert(std::is_constructible_v<FieldType, SkeletonBase&, std::string_view, detail::EnableNeitherTag>,
+                  "Constructor should accept EnableNeitherTag when ES=false and EG=false");
+}
+
+TEST(SkeletonFieldTest, CtorBothEnabledRejectsEnableGetOnlyTag)
+{
+    using FieldType = SkeletonField<TestSampleType, true, false, true>;
+    static_assert(!std::is_constructible_v<FieldType, SkeletonBase&, std::string_view, detail::EnableGetOnlyTag>,
+                  "Constructor should reject EnableGetOnlyTag when ES=true and EG=true");
+}
+
+TEST(SkeletonFieldTest, CtorGetOnlyRejectsEnableSetOnlyTag)
+{
+    using FieldType = SkeletonField<TestSampleType, false, false, true>;
+    static_assert(!std::is_constructible_v<FieldType, SkeletonBase&, std::string_view, detail::EnableSetOnlyTag>,
+                  "Constructor should reject EnableSetOnlyTag when ES=false and EG=true");
+}
+
+TEST(SkeletonFieldTest, CtorSetOnlyRejectsEnableBothTag)
+{
+    using FieldType = SkeletonField<TestSampleType, true, false, false>;
+    static_assert(!std::is_constructible_v<FieldType, SkeletonBase&, std::string_view, detail::EnableBothTag>,
+                  "Constructor should reject EnableBothTag when ES=true and EG=false");
+}
+
+TEST(SkeletonFieldTest, CtorNeitherEnabledRejectsEnableBothTag)
+{
+    using FieldType = SkeletonField<TestSampleType, false, false, false>;
+    static_assert(!std::is_constructible_v<FieldType, SkeletonBase&, std::string_view, detail::EnableBothTag>,
+                  "Constructor should reject EnableBothTag when ES=false and EG=false");
+}
+
+TEST(SkeletonFieldGetHandlerTest, RegisterGetHandlerInvokesGetLatestSampleOnBinding)
+{
+    RuntimeMockGuard runtime_mock_guard{};
+    ON_CALL(runtime_mock_guard.runtime_mock_, GetTracingFilterConfig()).WillByDefault(Return(nullptr));
+
+    // Set up event binding mock
+    SkeletonFieldBindingFactoryMockGuard<TestSampleType> skeleton_field_binding_factory_mock_guard{};
+    auto skeleton_field_binding_mock_ptr = std::make_unique<mock_binding::SkeletonEvent<TestSampleType>>();
+    EXPECT_CALL(skeleton_field_binding_factory_mock_guard.factory_mock_,
+                CreateEventBinding(kInstanceIdWithLolaBinding, _, kFieldName))
+        .WillOnce(Return(ByMove(std::move(skeleton_field_binding_mock_ptr))));
+
+    // Set up method binding mock to verify RegisterHandler is called during construction
+    SkeletonMethodBindingFactoryMockGuard skeleton_method_binding_factory_mock_guard{};
+    mock_binding::SkeletonMethod skeleton_method_binding_mock{};
+    EXPECT_CALL(skeleton_method_binding_mock, RegisterHandler(_)).WillOnce(Return(ResultBlank{}));
+    EXPECT_CALL(skeleton_method_binding_factory_mock_guard.factory_mock_, Create(kInstanceIdWithLolaBinding, _, _, _))
+        .WillOnce(Return(ByMove(std::make_unique<mock_binding::SkeletonMethodFacade>(skeleton_method_binding_mock))));
+
+    // When a skeleton with EnableGet=true field is constructed, RegisterHandler is called automatically
+    MyGetEnabledSkeleton unit{std::make_unique<mock_binding::Skeleton>(), kInstanceIdWithLolaBinding};
+}
+
 // When Ticket-104261 is implemented, the Update call does not have to be deferred until OfferService is called. This
 // test can be reworked to remove the call to PrepareOffer() and simply test Update() before PrepareOffer() is called.
 using SkeletonFieldCopyUpdateTest = SkeletonFieldTestFixture;
@@ -944,25 +1032,30 @@ TEST_F(SkeletonFieldSetHandlerTest, PrepareOfferSucceedsWithoutHandlerWhenEnable
     EXPECT_TRUE(result.has_value());
 }
 
-TEST(SkeletonFieldSetHandlerTypeTraitsTest, RegisterSetHandlerAcceptsAnyCallable)
+TEST_F(SkeletonFieldSetHandlerTest, RegisterSetHandlerAcceptsStdFunction)
 {
-    RecordProperty("Description",
-                   "RegisterSetHandler() shall accept any callable (lambda, std::function, "
-                   "score::cpp::callback) with signature void(FieldType&). "
-                   "The public interface is not tied to a specific callable type.");
-    RecordProperty("TestType", "Requirements-based test");
-    RecordProperty("Priority", "1");
-    RecordProperty("DerivationTechnique", "Analysis of requirements");
+    // Given a skeleton containing a field with a setter enabled
+    MySetterSkeleton unit{std::make_unique<mock_binding::Skeleton>(), kInstanceIdWithLolaBinding};
+
+    // When registering a set handler using std::function
+    std::function<void(TestSampleType&)> std_function_handler = [](TestSampleType& /*value*/) noexcept {};
+    const auto result = unit.my_setter_field_.RegisterSetHandler(std_function_handler).has_value();
+
+    // Then the registration succeeds
+    EXPECT_TRUE(result);
+}
 
-    using HandlerSignature = void(TestSampleType&);
+TEST_F(SkeletonFieldSetHandlerTest, RegisterSetHandlerAcceptsCppCallback)
+{
+    // Given a skeleton containing a field with a setter enabled
+    MySetterSkeleton unit{std::make_unique<mock_binding::Skeleton>(), kInstanceIdWithLolaBinding};
 
-    // lambda
-    static_assert(std::is_invocable_v<std::function<HandlerSignature>, TestSampleType&>,
-                  "std::function with expected signature must be invocable");
+    // When registering a set handler using score::cpp::callback
+    score::cpp::callback<void(TestSampleType&)> cpp_callback_handler = [](TestSampleType& /*value*/) noexcept {};
+    const auto result = unit.my_setter_field_.RegisterSetHandler(std::move(cpp_callback_handler)).has_value();
 
-    // score::cpp::callback
-    static_assert(std::is_invocable_v<score::cpp::callback<HandlerSignature>, TestSampleType&>,
-                  "score::cpp::callback with expected signature must be invocable");
+    // Then the registration succeeds
+    EXPECT_TRUE(result);
 }
 
 // Handler wrapping: user callback is invoked and the field value is updated
@@ -999,11 +1092,6 @@ TEST_F(SkeletonFieldSetHandlerTest, UserCallbackIsInvokedByWrappedHandler)
     EXPECT_CALL(skeleton_method_binding_factory_mock_guard_.factory_mock_,
                 Create(kInstanceIdWithLolaBinding, _, _, MethodType::kSet))
         .WillOnce(Return(ByMove(std::move(capturing_binding))));
-    EXPECT_CALL(skeleton_method_binding_factory_mock_guard_.factory_mock_,
-                Create(kInstanceIdWithLolaBinding, _, _, MethodType::kGet))
-        .WillOnce(InvokeWithoutArgs([]() {
-            return std::unique_ptr<SkeletonMethodBinding>{};
-        }));
 
     MySetterSkeleton unit{std::make_unique<mock_binding::Skeleton>(), kInstanceIdWithLolaBinding};
 
@@ -1052,11 +1140,6 @@ TEST_F(SkeletonFieldSetHandlerTest, UserCallbackCanModifyValueInPlace)
     EXPECT_CALL(skeleton_method_binding_factory_mock_guard_.factory_mock_,
                 Create(kInstanceIdWithLolaBinding, _, _, MethodType::kSet))
         .WillOnce(Return(ByMove(std::move(capturing_binding))));
-    EXPECT_CALL(skeleton_method_binding_factory_mock_guard_.factory_mock_,
-                Create(kInstanceIdWithLolaBinding, _, _, MethodType::kGet))
-        .WillOnce(InvokeWithoutArgs([]() {
-            return std::unique_ptr<SkeletonMethodBinding>{};
-        }));
 
     MySetterSkeleton unit{std::make_unique<mock_binding::Skeleton>(), kInstanceIdWithLolaBinding};
 
@@ -1102,11 +1185,6 @@ TEST_F(SkeletonFieldSetHandlerTest, WrappedHandlerLogsWhenUpdateFails)
     EXPECT_CALL(skeleton_method_binding_factory_mock_guard_.factory_mock_,
                 Create(kInstanceIdWithLolaBinding, _, _, MethodType::kSet))
         .WillOnce(Return(ByMove(std::move(capturing_binding))));
-    EXPECT_CALL(skeleton_method_binding_factory_mock_guard_.factory_mock_,
-                Create(kInstanceIdWithLolaBinding, _, _, MethodType::kGet))
-        .WillOnce(InvokeWithoutArgs([]() {
-            return std::unique_ptr<SkeletonMethodBinding>{};
-        }));
 
     MySetterSkeleton unit{std::make_unique<mock_binding::Skeleton>(), kInstanceIdWithLolaBinding};
 
@@ -1186,9 +1264,6 @@ TEST_F(SkeletonFieldSetHandlerTest, SecondRegisterSetHandlerReplacesHandler)
     EXPECT_CALL(skeleton_method_binding_factory_mock_guard_.factory_mock_,
                 Create(kInstanceIdWithLolaBinding, _, _, MethodType::kSet))
         .WillOnce(Return(ByMove(std::move(capturing_binding))));
-    EXPECT_CALL(skeleton_method_binding_factory_mock_guard_.factory_mock_,
-                Create(kInstanceIdWithLolaBinding, _, _, MethodType::kGet))
-        .WillOnce(Return(ByMove(nullptr)));
 
     MySetterSkeleton unit{std::make_unique<mock_binding::Skeleton>(), kInstanceIdWithLolaBinding};
 
diff --git a/score/mw/com/impl/traits.h b/score/mw/com/impl/traits.h
index 1c51a0587..2578e2153 100644
--- a/score/mw/com/impl/traits.h
+++ b/score/mw/com/impl/traits.h
@@ -164,8 +164,8 @@ class SkeletonTrait
     template <typename SampleType>
     using Event = SkeletonEvent<SampleType>;
 
-    template <typename SampleType, bool EnableSet = false, bool EnableNotifier = false>
-    using Field = SkeletonField<SampleType, EnableSet, EnableNotifier>;
+    template <typename SampleType, bool EnableSet = false, bool EnableNotifier = false, bool EnableGet = false>
+    using Field = SkeletonField<SampleType, EnableSet, EnableNotifier, EnableGet>;
 
     template <typename MethodSignature>
     using Method = SkeletonMethod<MethodSignature>;
diff --git a/score/mw/com/impl/traits_test.cpp b/score/mw/com/impl/traits_test.cpp
index f99961ee5..c54481a4a 100644
--- a/score/mw/com/impl/traits_test.cpp
+++ b/score/mw/com/impl/traits_test.cpp
@@ -39,6 +39,7 @@ namespace
 using ::testing::_;
 using ::testing::ByMove;
 using ::testing::Invoke;
+using ::testing::NiceMock;
 using ::testing::Return;
 using ::testing::ReturnRef;
 
@@ -87,8 +88,8 @@ class RuntimeMockGuard
         Runtime::InjectMock(nullptr);
     }
 
-    RuntimeMock runtime_mock_;
-    ServiceDiscoveryMock service_discovery_mock_{};
+    NiceMock<RuntimeMock> runtime_mock_;
+    NiceMock<ServiceDiscoveryMock> service_discovery_mock_{};
 };
 
 class ProxyCreationFixture : public ::testing::Test
@@ -150,12 +151,12 @@ class ProxyCreationFixture : public ::testing::Test
     ProxyEventBindingFactoryMockGuard<TestSampleType> proxy_event_binding_factory_mock_guard_{};
     ProxyFieldBindingFactoryMockGuard<TestSampleType> proxy_field_binding_factory_mock_guard_{};
     ProxyMethodBindingFactoryMockGuard<TestMethodType> proxy_method_binding_factory_mock_guard_{};
-    mock_binding::Proxy proxy_binding_mock_{};
-    mock_binding::ProxyEvent<TestSampleType> proxy_event_binding_mock_{};
-    mock_binding::ProxyEvent<TestSampleType> proxy_field_binding_mock_{};
-    mock_binding::ProxyMethod proxy_method_binding_mock_{};
-    mock_binding::ProxyMethod proxy_field_set_binding_mock_{};
-    mock_binding::ProxyMethod proxy_field_get_binding_mock_{};
+    NiceMock<mock_binding::Proxy> proxy_binding_mock_{};
+    NiceMock<mock_binding::ProxyEvent<TestSampleType>> proxy_event_binding_mock_{};
+    NiceMock<mock_binding::ProxyEvent<TestSampleType>> proxy_field_binding_mock_{};
+    NiceMock<mock_binding::ProxyMethod> proxy_method_binding_mock_{};
+    NiceMock<mock_binding::ProxyMethod> proxy_field_set_binding_mock_{};
+    NiceMock<mock_binding::ProxyMethod> proxy_field_get_binding_mock_{};
 };
 
 TEST(GeneratedProxyTest, NotCopyable)
@@ -526,12 +527,12 @@ class SkeletonCreationFixture : public ::testing::Test
     SkeletonEventBindingFactoryMockGuard<TestSampleType> skeleton_event_binding_factory_mock_guard_{};
     SkeletonFieldBindingFactoryMockGuard<TestSampleType> skeleton_field_binding_factory_mock_guard_{};
     SkeletonMethodBindingFactoryMockGuard skeleton_method_binding_factory_mock_guard_{};
-    mock_binding::Skeleton skeleton_binding_mock_{};
-    mock_binding::SkeletonEvent<TestSampleType> skeleton_event_binding_mock_{};
-    mock_binding::SkeletonEvent<TestSampleType> skeleton_field_binding_mock_{};
-    mock_binding::SkeletonMethod skeleton_method_binding_mock_{};
-    mock_binding::SkeletonMethod skeleton_field_set_binding_mock_{};
-    mock_binding::SkeletonMethod skeleton_field_get_binding_mock_{};
+    NiceMock<mock_binding::Skeleton> skeleton_binding_mock_{};
+    NiceMock<mock_binding::SkeletonEvent<TestSampleType>> skeleton_event_binding_mock_{};
+    NiceMock<mock_binding::SkeletonEvent<TestSampleType>> skeleton_field_binding_mock_{};
+    NiceMock<mock_binding::SkeletonMethod> skeleton_method_binding_mock_{};
+    NiceMock<mock_binding::SkeletonMethod> skeleton_field_set_binding_mock_{};
+    NiceMock<mock_binding::SkeletonMethod> skeleton_field_get_binding_mock_{};
 };
 
 using GeneratedSkeletonCreationInstanceSpecifierTestFixture = SkeletonCreationFixture;
@@ -1016,12 +1017,12 @@ class GeneratedSkeletonStopOfferServiceRaiiFixture : public SkeletonCreationFixt
     bool skeleton_event_stop_offer_called_2_{false};
     bool skeleton_field_stop_offer_called_2_{false};
 
-    mock_binding::Skeleton skeleton_binding_mock_2_{};
-    mock_binding::SkeletonEvent<TestSampleType> skeleton_event_binding_mock_2_{};
-    mock_binding::SkeletonEvent<TestSampleType> skeleton_field_binding_mock_2_{};
-    mock_binding::SkeletonMethod skeleton_method_binding_mock_2_{};
-    mock_binding::SkeletonMethod skeleton_field_set_binding_mock_2_{};
-    mock_binding::SkeletonMethod skeleton_field_get_binding_mock_2_{};
+    NiceMock<mock_binding::Skeleton> skeleton_binding_mock_2_{};
+    NiceMock<mock_binding::SkeletonEvent<TestSampleType>> skeleton_event_binding_mock_2_{};
+    NiceMock<mock_binding::SkeletonEvent<TestSampleType>> skeleton_field_binding_mock_2_{};
+    NiceMock<mock_binding::SkeletonMethod> skeleton_method_binding_mock_2_{};
+    NiceMock<mock_binding::SkeletonMethod> skeleton_field_set_binding_mock_2_{};
+    NiceMock<mock_binding::SkeletonMethod> skeleton_field_get_binding_mock_2_{};
 
     std::optional<MySkeleton> skeleton_{};
     std::optional<MySkeleton> skeleton_2_{};
diff --git a/score/mw/com/test/methods/methods_test_resources/method_provider.h b/score/mw/com/test/methods/methods_test_resources/method_provider.h
index ff36eed65..134779503 100644
--- a/score/mw/com/test/methods/methods_test_resources/method_provider.h
+++ b/score/mw/com/test/methods/methods_test_resources/method_provider.h
@@ -109,10 +109,11 @@ bool MethodProvider<Skeleton>::RegisterMethodHandlerWithInArgsAndReturn()
 {
     SCORE_LANGUAGE_FUTURECPP_ASSERT_PRD(skeleton_ != nullptr);
 
-    auto handler_with_in_args_and_return = [](std::int32_t a, std::int32_t b) -> std::int32_t {
-        std::cout << "Provider: with_in_args_and_return called with " << a << " + " << b << std::endl;
-        return a + b;
-    };
+    auto handler_with_in_args_and_return =
+        [](std::int32_t& return_value, const std::int32_t& a, const std::int32_t& b) {
+            std::cout << "Provider: with_in_args_and_return called with " << a << " + " << b << std::endl;
+            return_value = a + b;
+        };
     const auto register_result =
         skeleton_->with_in_args_and_return.RegisterHandler(std::move(handler_with_in_args_and_return));
     if (!register_result)
@@ -129,8 +130,8 @@ template <typename Skeleton>
 bool MethodProvider<Skeleton>::RegisterMethodHandlerWithInArgsOnly(const std::int32_t expected_input_argument_a,
                                                                    const std::int32_t expected_input_argument_b)
 {
-    auto handler_with_in_args_only = [expected_input_argument_a, expected_input_argument_b](std::int32_t a,
-                                                                                            std::int32_t b) {
+    auto handler_with_in_args_only = [expected_input_argument_a, expected_input_argument_b](const std::int32_t& a,
+                                                                                            const std::int32_t& b) {
         std::cout << "Provider: with_in_args_only called with " << a << " + " << b << std::endl;
         SCORE_LANGUAGE_FUTURECPP_ASSERT_MESSAGE(a == expected_input_argument_a, "Unexpected first InArg received!");
         SCORE_LANGUAGE_FUTURECPP_ASSERT_MESSAGE(b == expected_input_argument_b, "Unexpected second InArg received!");
@@ -149,9 +150,9 @@ bool MethodProvider<Skeleton>::RegisterMethodHandlerWithInArgsOnly(const std::in
 template <typename Skeleton>
 bool MethodProvider<Skeleton>::RegisterMethodHandlerWithReturnOnly(const std::int32_t expected_return_value)
 {
-    auto handler_with_return_only = [expected_return_value]() -> std::int32_t {
+    auto handler_with_return_only = [expected_return_value](std::int32_t& return_value) {
         std::cout << "Provider: with_return_only called. Returning " << expected_return_value << std::endl;
-        return expected_return_value;
+        return_value = expected_return_value;
     };
     const auto register_result = skeleton_->with_return_only.RegisterHandler(std::move(handler_with_return_only));
     if (!register_result)
diff --git a/score/mw/com/test/methods/non_trivial_constructors/provider.cpp b/score/mw/com/test/methods/non_trivial_constructors/provider.cpp
index 5ee46c003..094794383 100644
--- a/score/mw/com/test/methods/non_trivial_constructors/provider.cpp
+++ b/score/mw/com/test/methods/non_trivial_constructors/provider.cpp
@@ -31,10 +31,11 @@ const std::string kInstanceSpecifier{"test/methods/non_trivial_constructors/Meth
 
 bool RegisterMethodHandlerWithInArgsAndReturn(NonTrivialConstructorSkeleton& skeleton)
 {
-    auto handler_with_in_args_and_return = [](NonTriviallyConstructibleType a,
-                                              NonTriviallyConstructibleType b) -> NonTriviallyConstructibleType {
+    auto handler_with_in_args_and_return = [](NonTriviallyConstructibleType& return_value,
+                                              const NonTriviallyConstructibleType& a,
+                                              const NonTriviallyConstructibleType& b) {
         std::cout << "Provider: with_in_args_and_return called with " << a << " + " << b << std::endl;
-        return a + b;
+        return_value = a + b;
     };
     const auto register_result =
         skeleton.with_in_args_and_return.RegisterHandler(std::move(handler_with_in_args_and_return));
@@ -50,7 +51,8 @@ bool RegisterMethodHandlerWithInArgsAndReturn(NonTrivialConstructorSkeleton& ske
 
 bool RegisterMethodHandlerWithInArgsOnly(NonTrivialConstructorSkeleton& skeleton)
 {
-    auto handler_with_in_args_only = [](NonTriviallyConstructibleType a, NonTriviallyConstructibleType b) {
+    auto handler_with_in_args_only = [](const NonTriviallyConstructibleType& a,
+                                        const NonTriviallyConstructibleType& b) {
         std::cout << "Provider: with_in_args_only called with " << a << " + " << b << std::endl;
         SCORE_LANGUAGE_FUTURECPP_ASSERT_MESSAGE(a == NonTriviallyConstructibleType{},
                                                 "Unexpected first InArg received!");
@@ -70,9 +72,9 @@ bool RegisterMethodHandlerWithInArgsOnly(NonTrivialConstructorSkeleton& skeleton
 
 bool RegisterMethodHandlerWithReturnOnly(NonTrivialConstructorSkeleton& skeleton)
 {
-    auto handler_with_return_only = []() -> NonTriviallyConstructibleType {
+    auto handler_with_return_only = [](NonTriviallyConstructibleType& return_value) {
         std::cout << "Provider: with_return_only called. Returning " << NonTriviallyConstructibleType{} << std::endl;
-        return NonTriviallyConstructibleType{};
+        return_value = NonTriviallyConstructibleType{};
     };
     const auto register_result = skeleton.with_return_only.RegisterHandler(std::move(handler_with_return_only));
     if (!register_result)