diff --git a/score/mw/com/impl/BUILD b/score/mw/com/impl/BUILD
index 1f78b91aa..3bfce3095 100644
--- a/score/mw/com/impl/BUILD
+++ b/score/mw/com/impl/BUILD
@@ -147,6 +147,7 @@ cc_library(
     deps = [
         ":skeleton_event",
         ":skeleton_field_base",
+        "//score/mw/com/impl/methods:skeleton_method",
         "//score/mw/com/impl/mocking:i_skeleton_field",
         "//score/mw/com/impl/plumbing:field",
         "//score/mw/com/impl/plumbing:sample_allocatee_ptr",
@@ -246,6 +247,7 @@ cc_library(
     deps = [
         ":error",
         ":skeleton_event_base",
+        "//score/mw/com/impl/methods:skeleton_method_base",
         "@score_baselibs//score/language/futurecpp",
         "@score_baselibs//score/result",
         "@score_logging//score/mw/log",
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 f124db121..c894fe256 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
@@ -38,6 +38,54 @@ EventDataControlCompositeImpl<AtomicIndirectorType>::EventDataControlCompositeIm
     CheckForValidDataControls();
 }
 
+template <template <class> class AtomicIndirectorType>
+score::cpp::optional<SlotIndexType>
+EventDataControlCompositeImpl<AtomicIndirectorType>::FindLatestReadableSlotIndex(const EventDataControl& control) const noexcept
+{
+    EventSlotStatus::EventTimeStamp latest_time_stamp{1U};
+    score::cpp::optional<SlotIndexType> latest_slot_index{};
+
+    for (SlotIndexType slot_index = 0U;
+         // Suppress "AUTOSAR C++14 A4-7-1" rule finding. This rule states: "An integer expression shall not lead
+         // to loss.". As the maximum number of slots is std::uint16_t, so there is no case for a data loss here.
+         // coverity[autosar_cpp14_a4_7_1_violation]
+         slot_index < static_cast<SlotIndexType>(control.state_slots_.size());
+         ++slot_index)
+    {
+        SCORE_LANGUAGE_FUTURECPP_ASSERT_PRD(static_cast<std::size_t>(slot_index) < control.state_slots_.size());
+        const EventSlotStatus slot{control.state_slots_[slot_index].load(std::memory_order_acquire)};
+        if (!slot.IsInvalid() && !slot.IsInWriting())
+        {
+            const auto slot_time_stamp = slot.GetTimeStamp();
+            if (latest_time_stamp < slot_time_stamp)
+            {
+                latest_time_stamp = slot_time_stamp;
+                latest_slot_index = slot_index;
+            }
+        }
+    }
+
+    return latest_slot_index;
+}
+
+template <template <class> class AtomicIndirectorType>
+bool EventDataControlCompositeImpl<AtomicIndirectorType>::TryIncreaseReferenceCount(ControlSlotType& slot) const noexcept
+{
+    EventSlotStatus slot_old{slot.load(std::memory_order_acquire)};
+    if (slot_old.IsInvalid() || slot_old.IsInWriting())
+    {
+        return false;
+    }
+
+    const auto new_refcount = static_cast<EventSlotStatus::SubscriberCount>(slot_old.GetReferenceCount() + 1U);
+    EventSlotStatus slot_new{slot_old.GetTimeStamp(), new_refcount};
+
+    auto slot_old_value = static_cast<EventSlotStatus::value_type&>(slot_old);
+    auto slot_new_value = static_cast<EventSlotStatus::value_type&>(slot_new);
+    return AtomicIndirectorType<EventSlotStatus::value_type>::compare_exchange_weak(
+        slot, slot_old_value, slot_new_value, std::memory_order_acq_rel);
+}
+
 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". This is a false positive, all results which are accessed with '.value()' that could implicitly call
@@ -303,6 +351,53 @@ EventSlotStatus::EventTimeStamp EventDataControlCompositeImpl<AtomicIndirectorTy
     }
 }
 
+template <template <class> class AtomicIndirectorType>
+ControlSlotCompositeIndicator EventDataControlCompositeImpl<AtomicIndirectorType>::GetLatestSlot() const noexcept
+{
+    EventDataControl* control = (asil_b_control_ != nullptr) ? asil_b_control_ : asil_qm_control_;
+
+    for (std::size_t retry_counter{0U}; retry_counter < MAX_MULTI_ALLOCATE_RETRY_COUNT; ++retry_counter)
+    {
+        const auto latest_slot_index = FindLatestReadableSlotIndex(*control);
+
+        if (!latest_slot_index.has_value())
+        {
+            return {};
+        }
+
+        const auto slot_index = latest_slot_index.value();
+
+        if (asil_b_control_ != nullptr)
+        {
+            auto& slot_qm = asil_qm_control_->state_slots_[slot_index];
+            auto& slot_asil_b = asil_b_control_->state_slots_[slot_index];
+
+            if (!TryIncreaseReferenceCount(slot_qm))
+            {
+                continue;
+            }
+
+            if (!TryIncreaseReferenceCount(slot_asil_b))
+            {
+                score::cpp::ignore = slot_qm.fetch_sub(1U, std::memory_order_acq_rel);
+                continue;
+            }
+
+            return {slot_index, slot_qm, slot_asil_b};
+        }
+
+        auto& slot_qm = asil_qm_control_->state_slots_[slot_index];
+        if (!TryIncreaseReferenceCount(slot_qm))
+        {
+            continue;
+        }
+
+        return {slot_index, slot_qm, ControlSlotCompositeIndicator::CompositeSlotTagType::QM};
+    }
+
+    return {};
+}
+
 template <template <class> class AtomicIndirectorType>
 void EventDataControlCompositeImpl<AtomicIndirectorType>::CheckForValidDataControls() const noexcept
 {
diff --git a/score/mw/com/impl/bindings/lola/event_data_control_composite.h b/score/mw/com/impl/bindings/lola/event_data_control_composite.h
index c052bedf0..5efba2cf1 100644
--- a/score/mw/com/impl/bindings/lola/event_data_control_composite.h
+++ b/score/mw/com/impl/bindings/lola/event_data_control_composite.h
@@ -98,6 +98,8 @@ class EventDataControlCompositeImpl
     /// \brief Returns the timestamp of the provided slot index
     EventSlotStatus::EventTimeStamp GetEventSlotTimestamp(const SlotIndexType slot) const noexcept;
 
+    ControlSlotCompositeIndicator GetLatestSlot() const noexcept;
+
     EventSlotStatus::EventTimeStamp GetLatestTimestamp() const noexcept;
 
   private:
@@ -110,8 +112,10 @@ class EventDataControlCompositeImpl
 
     // Algorithms that operate on multiple control blocks
     ControlSlotCompositeIndicator GetNextFreeMultiSlot() const noexcept;
+    score::cpp::optional<SlotIndexType> FindLatestReadableSlotIndex(const EventDataControl& control) const noexcept;
 
     bool TryLockSlot(ControlSlotCompositeIndicator slot_indicator) noexcept;
+    bool TryIncreaseReferenceCount(ControlSlotType& slot) const noexcept;
     ControlSlotCompositeIndicator AllocateNextMultiSlot() noexcept;
     void CheckForValidDataControls() const noexcept;
 };
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 3f046d58f..7ca576cf3 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
@@ -202,6 +202,73 @@ TEST_F(EventDataControlCompositeFixture, GetLatestTimeStampReturnCorrectValue)
     EXPECT_EQ(time_stamp_obtained, time_stamp);
 }
 
+TEST_F(EventDataControlCompositeFixture, GetLatestSlotReturnsLatestReadySlotForQmOnly)
+{
+    // Given an EventDataControlComposite with QM-only control and two ready slots
+    WithQmOnlyEventDataControl().WithRealEventDataControlComposite();
+
+    auto first_slot = unit_->AllocateNextSlot();
+    auto second_slot = unit_->AllocateNextSlot();
+    unit_->EventReady(first_slot, 2U);
+    unit_->EventReady(second_slot, 3U);
+
+    // When acquiring the latest slot
+    const auto latest_slot = unit_->GetLatestSlot();
+
+    // Then the slot with the highest timestamp is returned
+    ASSERT_TRUE(latest_slot.IsValidQM());
+    EXPECT_EQ(latest_slot.GetIndex(), second_slot.GetIndex());
+}
+
+TEST_F(EventDataControlCompositeFixture, GetLatestSlotIncrementsReferenceCountForQmOnly)
+{
+    // Given an EventDataControlComposite with QM-only control and one ready slot
+    WithQmOnlyEventDataControl().WithRealEventDataControlComposite();
+
+    auto slot = unit_->AllocateNextSlot();
+    unit_->EventReady(slot, 2U);
+
+    // When acquiring the latest slot
+    const auto latest_slot = unit_->GetLatestSlot();
+
+    // Then the slot is referenced once
+    ASSERT_TRUE(latest_slot.IsValidQM());
+    const EventSlotStatus slot_status{latest_slot.GetSlotQM().load(std::memory_order_acquire)};
+    EXPECT_EQ(slot_status.GetReferenceCount(), 1U);
+}
+
+TEST_F(EventDataControlCompositeFixture, GetLatestSlotIncrementsReferenceCountForQmAndAsilB)
+{
+    // Given an EventDataControlComposite with QM and ASIL-B controls and one ready slot
+    WithQmAndAsilBEventDataControls().WithRealEventDataControlComposite();
+
+    auto slot = unit_->AllocateNextSlot();
+    unit_->EventReady(slot, 2U);
+
+    // When acquiring the latest slot
+    const auto latest_slot = unit_->GetLatestSlot();
+
+    // Then both control parts are referenced once
+    ASSERT_TRUE(latest_slot.IsValidQmAndAsilB());
+    const EventSlotStatus qm_slot_status{latest_slot.GetSlotQM().load(std::memory_order_acquire)};
+    const EventSlotStatus asil_b_slot_status{latest_slot.GetSlotAsilB().load(std::memory_order_acquire)};
+    EXPECT_EQ(qm_slot_status.GetReferenceCount(), 1U);
+    EXPECT_EQ(asil_b_slot_status.GetReferenceCount(), 1U);
+}
+
+TEST_F(EventDataControlCompositeFixture, GetLatestSlotReturnsInvalidIndicatorIfNoReadableSlotExists)
+{
+    // Given an EventDataControlComposite with no ready slot
+    WithQmAndAsilBEventDataControls().WithRealEventDataControlComposite();
+
+    // When acquiring the latest slot
+    const auto latest_slot = unit_->GetLatestSlot();
+
+    // Then no valid slot is returned
+    EXPECT_FALSE(latest_slot.IsValidQM());
+    EXPECT_FALSE(latest_slot.IsValidAsilB());
+}
+
 TEST_F(EventDataControlCompositeFixture, CanAllocateMultipleSlots)
 {
     // Given an EventDataControlComposite with zero used slots
diff --git a/score/mw/com/impl/bindings/lola/skeleton_event.h b/score/mw/com/impl/bindings/lola/skeleton_event.h
index c0bca4719..0a1ff08e6 100644
--- a/score/mw/com/impl/bindings/lola/skeleton_event.h
+++ b/score/mw/com/impl/bindings/lola/skeleton_event.h
@@ -91,6 +91,8 @@ class SkeletonEvent final : public SkeletonEventBinding<SampleType>
 
     Result<impl::SampleAllocateePtr<SampleType>> Allocate() noexcept override;
 
+    Result<SampleType> GetLatestSample() noexcept override;
+
     /// @requirement SWS_CM_00700
     ResultBlank PrepareOffer() noexcept override;
 
@@ -233,7 +235,7 @@ Result<impl::SampleAllocateePtr<SampleType>> SkeletonEvent<SampleType>::Allocate
 {
     if (event_data_control_composite_.has_value() == false)
     {
-        ::score::mw::log::LogError("lola") << "Tried to allocate event, but the EventDataControl does not exist!";
+        ::score::mw::log::LogError("lola") << "Tried to allocate event, but the EventDataControlComposite does not exist!";
         return MakeUnexpected(ComErrc::kBindingFailure);
     }
     const auto slot = event_data_control_composite_->AllocateNextSlot();
@@ -272,6 +274,37 @@ Result<impl::SampleAllocateePtr<SampleType>> SkeletonEvent<SampleType>::Allocate
     }
 }
 
+template <typename SampleType>
+Result<SampleType> SkeletonEvent<SampleType>::GetLatestSample() noexcept
+{
+    if (event_data_control_composite_.has_value() == false)
+    {
+        ::score::mw::log::LogError("lola") << "Tried to get the latest sample, but the EventDataControlComposite does not exist!";
+        return MakeUnexpected(ComErrc::kBindingFailure);
+    }
+    auto slot = event_data_control_composite_->GetLatestSlot();
+
+    if (slot.IsValidQM() || slot.IsValidAsilB())
+    {
+        const auto sample = event_data_storage_->at(static_cast<std::uint64_t>(slot.GetIndex()));
+
+        if (slot.IsValidQM())
+        {
+            score::cpp::ignore = slot.GetSlotQM().fetch_sub(1U, std::memory_order_acq_rel);
+        }
+        if (slot.IsValidAsilB())
+        {
+            score::cpp::ignore = slot.GetSlotAsilB().fetch_sub(1U, std::memory_order_acq_rel);
+        }
+
+        return sample;
+    }
+    else
+    {
+        return MakeUnexpected(ComErrc::kBindingFailure);
+    }
+}
+
 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_test.cpp b/score/mw/com/impl/bindings/lola/skeleton_event_test.cpp
index 8827bfa08..e07306e15 100644
--- a/score/mw/com/impl/bindings/lola/skeleton_event_test.cpp
+++ b/score/mw/com/impl/bindings/lola/skeleton_event_test.cpp
@@ -318,6 +318,56 @@ TEST_F(SkeletonEventPrepareStopOfferFixture, StopOfferSkeletonEvent)
     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();
+
+    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();
+
+    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);
+    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), score::cpp::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), score::cpp::nullopt);
+    ASSERT_TRUE(second_send_result.has_value());
+
+    const auto latest_sample = skeleton_event_->GetLatestSample();
+
+    ASSERT_TRUE(latest_sample.has_value());
+    EXPECT_EQ(latest_sample.value(), static_cast<test::TestSampleType>(42U));
+}
+
 using SkeletonEventTimestampFixture = SkeletonEventFixture;
 TEST_F(SkeletonEventTimestampFixture, SendUpdatesTimestampInControlData)
 {
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 c08e21d16..b6f089a74 100644
--- a/score/mw/com/impl/bindings/mock_binding/skeleton_event.h
+++ b/score/mw/com/impl/bindings/mock_binding/skeleton_event.h
@@ -48,6 +48,7 @@ class SkeletonEvent : public SkeletonEventBinding<SampleType>
                  score::cpp::optional<typename SkeletonEventBinding<SampleType>::SendTraceCallback>),
                 (noexcept, override));
     MOCK_METHOD(Result<SampleAllocateePtr<SampleType>>, Allocate, (), (noexcept, override));
+    MOCK_METHOD(Result<SampleType>, GetLatestSample, (), (noexcept, override));
     MOCK_METHOD(ResultBlank, PrepareOffer, (), (noexcept, override));
     MOCK_METHOD(void, PrepareStopOffer, (), (noexcept, override));
     MOCK_METHOD(std::size_t, GetMaxSize, (), (const, noexcept, override));
@@ -83,6 +84,10 @@ class SkeletonEventFacade : public SkeletonEventBinding<SampleType>
     {
         return skeleton_event_.Allocate();
     };
+    Result<SampleType> GetLatestSample() noexcept override
+    {
+        return skeleton_event_.GetLatestSample();
+    }
     ResultBlank PrepareOffer() noexcept override
     {
         return skeleton_event_.PrepareOffer();
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 8e776377b..c8a0c5795 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
@@ -29,6 +29,7 @@
 #include <score/overload.hpp>
 
 #include <chrono>
+#include <cstddef>
 #include <exception>
 #include <memory>
 #include <string>
@@ -44,7 +45,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())
     {
@@ -61,7 +63,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_};
 }
@@ -79,7 +85,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);
@@ -88,7 +95,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)
@@ -106,7 +113,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 218192c5b..bd4692ed3 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/skeleton_event.h b/score/mw/com/impl/skeleton_event.h
index 2face4332..1f8d0fa9a 100644
--- a/score/mw/com/impl/skeleton_event.h
+++ b/score/mw/com/impl/skeleton_event.h
@@ -36,7 +36,7 @@ namespace score::mw::com::impl
 
 // False Positive: this is a normal forward declaration.
 // coverity[autosar_cpp14_m3_2_3_violation]
-template <typename>
+template <typename SampleDataType, const bool EnableSet, const bool EnableNotifier, const bool EnableGet>
 class SkeletonField;
 
 template <typename SampleDataType>
@@ -51,7 +51,8 @@ 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]
-    friend class SkeletonField<SampleDataType>;
+    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
     // the latter is a friend).
@@ -313,6 +314,11 @@ class SkeletonEventView
         return skeleton_event_.GetTypedEventBinding();
     }
 
+    Result<SampleType> GetLatestSample() noexcept
+    {
+        return GetBinding()->GetLatestSample();
+    }
+
   private:
     SkeletonEvent<SampleType>& skeleton_event_;
 };
diff --git a/score/mw/com/impl/skeleton_event_binding.h b/score/mw/com/impl/skeleton_event_binding.h
index 7255ab8f1..198f7d153 100644
--- a/score/mw/com/impl/skeleton_event_binding.h
+++ b/score/mw/com/impl/skeleton_event_binding.h
@@ -89,6 +89,8 @@ class SkeletonEventBinding : public SkeletonEventBindingBase
     /// implementations.
     virtual Result<SampleAllocateePtr<SampleType>> Allocate() noexcept = 0;
 
+    virtual Result<SampleType> GetLatestSample() 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 cb32d56e1..5e0461eac 100644
--- a/score/mw/com/impl/skeleton_event_binding_test.cpp
+++ b/score/mw/com/impl/skeleton_event_binding_test.cpp
@@ -48,6 +48,10 @@ class MyEvent final : public SkeletonEventBinding<SampleType>
     {
         return MakeSampleAllocateePtr(std::make_unique<SampleType>());
     }
+    Result<SampleType> GetLatestSample() noexcept override
+    {
+        return SampleType{};
+    }
     BindingType GetBindingType() const noexcept override
     {
         return BindingType::kFake;
diff --git a/score/mw/com/impl/skeleton_event_test.cpp b/score/mw/com/impl/skeleton_event_test.cpp
index 1db0646b6..af4afdff1 100644
--- a/score/mw/com/impl/skeleton_event_test.cpp
+++ b/score/mw/com/impl/skeleton_event_test.cpp
@@ -653,5 +653,63 @@ 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())
+        .WillOnce(Return(ByMove(static_cast<TestSampleType>(42U))));
+
+    // 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();
+
+    // 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())
+        .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();
+
+    // 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 b364d93f2..a949788ed 100644
--- a/score/mw/com/impl/skeleton_field.h
+++ b/score/mw/com/impl/skeleton_field.h
@@ -13,6 +13,7 @@
 #ifndef SCORE_MW_COM_IMPL_SKELETON_FIELD_H
 #define SCORE_MW_COM_IMPL_SKELETON_FIELD_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"
 #include "score/mw/com/impl/skeleton_event.h"
@@ -26,19 +27,75 @@
 #include <score/assert.hpp>
 
 #include <memory>
+#include <mutex>
 #include <string_view>
+#include <type_traits>
 #include <utility>
 
 namespace score::mw::com::impl
 {
 
-template <typename SampleDataType>
+namespace detail
+{
+/// Tag types for constructor overload disambiguation based on EnableGet/EnableSet template parameters
+struct EnableBothTag
+{
+};
+struct EnableGetOnlyTag
+{
+};
+struct EnableSetOnlyTag
+{
+};
+struct EnableNeitherTag
+{
+};
+}  // namespace detail
+
+template <typename SampleDataType,
+          const bool EnableSet = false,
+          const bool EnableNotifier = false,
+          const bool EnableGet = false>
 class SkeletonField : public SkeletonFieldBase
 {
   public:
     using FieldType = SampleDataType;
 
-    SkeletonField(SkeletonBase& parent, const std::string_view field_name);
+    /// \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.
+    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 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, 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.
     ///
@@ -92,6 +149,36 @@ class SkeletonField : public SkeletonFieldBase
         skeleton_field_mock_ = &skeleton_field_mock;
     }
 
+    // Set handler registration
+    // SFINAE-gated: only exists when EnableSet == true
+    template <typename Callable, bool ES = EnableSet, typename std::enable_if<ES, int>::type = 0>
+    ResultBlank RegisterSetHandler(Callable&& callback)
+    {
+        // Wrap user callback to also call Update() after user validation
+        auto wrapped_callback = [this, user_callback = std::move(callback)](FieldType new_value) -> Result<FieldType> {
+            // 1. Call user's validation/modification handler
+            auto result = user_callback(new_value);
+
+            if (!result.has_value())
+            {
+                return result;  // User rejected the value, propagate the error
+            }
+
+            // 2. User accepted (possibly modified) - update the field
+            auto update_result = this->Update(result.value());
+            if (!update_result.has_value())
+            {
+                return MakeUnexpected(update_result.error());
+            }
+
+            // 3. Return the actual value that was set
+            return result;
+        };
+
+        // set_method_ is guaranteed to be unique_ptr here since RegisterSetHandler is SFINAE-gated on EnableSet=true.
+        return set_method_.get()->RegisterHandler(std::move(wrapped_callback));
+    }
+
   private:
     bool IsInitialValueSaved() const noexcept override
     {
@@ -105,42 +192,241 @@ class SkeletonField : public SkeletonFieldBase
 
     SkeletonEvent<FieldType>* GetTypedEvent() const noexcept;
 
+    // Get handler registration
+    // SFINAE-gated: only exists when EnableGet == true
+    template <bool EG = EnableGet, typename std::enable_if<EG, int>::type = 0>
+    void RegisterGetHandler()
+    {
+        // get_method_ is guaranteed to be unique_ptr here since RegisterGetHandler is SFINAE-gated on EnableGet=true.
+        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_;
+
+    // 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_{};
+
+    // Zero-cost storage: when EnableSet=false the member has type 'detail::EnableSetOnlyTag', which is a zero-size
+    // type, so it doesn't actually take up any space in the class. When EnableSet=true, the member has the actual
+    // type and stores the set method.
+    using SetMethodType = std::conditional_t<EnableSet,
+                                             std::unique_ptr<SkeletonMethod<Result<FieldType>(FieldType)>>,
+                                             detail::EnableSetOnlyTag>;
+    SetMethodType set_method_;
+
+    using GetMethodType =
+        std::conditional_t<EnableGet, std::unique_ptr<SkeletonMethod<Result<FieldType>()>>, detail::EnableGetOnlyTag>;
+    GetMethodType get_method_;
+
+    /// \brief Private delegating constructor: EnableSet=true, EnableGet=true.
+    template <bool ES = EnableSet, bool EG = EnableGet, typename = std::enable_if_t<ES && EG>>
+    SkeletonField(SkeletonBase& parent,
+                  std::unique_ptr<SkeletonEvent<FieldType>> skeleton_event_dispatch,
+                  std::unique_ptr<SkeletonMethod<Result<FieldType>(FieldType)>> set_method,
+                  std::unique_ptr<SkeletonMethod<Result<FieldType>()>> get_method,
+                  const std::string_view field_name);
+
+    /// \brief Private delegating constructor: EnableSet=false, EnableGet=true.
+    template <bool ES = EnableSet, bool EG = EnableGet, typename = std::enable_if_t<!ES && EG>>
+    SkeletonField(SkeletonBase& parent,
+                  std::unique_ptr<SkeletonEvent<FieldType>> skeleton_event_dispatch,
+                  std::unique_ptr<SkeletonMethod<Result<FieldType>()>> get_method,
+                  const std::string_view field_name);
+
+    /// \brief Private delegating constructor: EnableSet=true, EnableGet=false.
+    template <bool ES = EnableSet, bool EG = EnableGet, typename = std::enable_if_t<ES && !EG>>
+    SkeletonField(SkeletonBase& parent,
+                  std::unique_ptr<SkeletonEvent<FieldType>> skeleton_event_dispatch,
+                  std::unique_ptr<SkeletonMethod<Result<FieldType>(FieldType)>> set_method,
+                  const std::string_view field_name);
+
+    /// \brief Private delegating constructor: EnableSet=false, EnableGet=false.
+    template <bool ES = EnableSet, bool EG = EnableGet, typename = std::enable_if_t<!ES && !EG>>
+    SkeletonField(SkeletonBase& parent,
+                  std::unique_ptr<SkeletonEvent<FieldType>> skeleton_event_dispatch,
+                  const std::string_view field_name);
 };
 
-template <typename SampleDataType>
-SkeletonField<SampleDataType>::SkeletonField(SkeletonBase& parent, const std::string_view field_name)
-    : SkeletonFieldBase{parent,
-                        field_name,
-                        std::make_unique<SkeletonEvent<FieldType>>(
-                            parent,
-                            field_name,
-                            SkeletonFieldBindingFactory<SampleDataType>::CreateEventBinding(
-                                SkeletonBaseView{parent}.GetAssociatedInstanceIdentifier(),
-                                parent,
-                                field_name),
-                            typename SkeletonEvent<FieldType>::FieldOnlyConstructorEnabler{})},
+/// \brief Public ctor - EnableSet=true, EnableGet=true.
+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,
+                                                     field_name,
+                                                     SkeletonFieldBindingFactory<SampleDataType>::CreateEventBinding(
+                                                         SkeletonBaseView{parent}.GetAssociatedInstanceIdentifier(),
+                                                         parent,
+                                                         field_name,
+                                                         (EnableSet || EnableGet) ? 1U : 0U),
+                                                     typename SkeletonEvent<FieldType>::FieldOnlyConstructorEnabler{}),
+          std::make_unique<SkeletonMethod<Result<FieldType>(FieldType)>>(parent, std::string(field_name) + "_Set"),
+          std::make_unique<SkeletonMethod<Result<FieldType>()>>(parent, std::string(field_name) + "_Get"),
+          field_name}
+{
+}
+
+/// \brief Public ctor - EnableSet=false, EnableGet=true.
+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{}),
+          std::make_unique<SkeletonMethod<Result<FieldType>()>>(parent, std::string(field_name) + "_Get"),
+          field_name}
+{
+}
+
+/// \brief Public ctor - EnableSet=true, EnableGet=false.
+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,
+                                                     field_name,
+                                                     SkeletonFieldBindingFactory<SampleDataType>::CreateEventBinding(
+                                                         SkeletonBaseView{parent}.GetAssociatedInstanceIdentifier(),
+                                                         parent,
+                                                         field_name,
+                                                         (EnableSet || EnableGet) ? 1U : 0U),
+                                                     typename SkeletonEvent<FieldType>::FieldOnlyConstructorEnabler{}),
+          std::make_unique<SkeletonMethod<Result<FieldType>(FieldType)>>(parent, std::string(field_name) + "_Set"),
+          field_name}
+{
+}
+
+/// \brief Public ctor - EnableSet=false, EnableGet=false.
+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{}),
+          field_name}
+{
+}
+
+/// \brief Testing ctor: binding is provided directly (used with mock bindings in tests).
+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)
+    : SkeletonField{skeleton_base,
+                    std::make_unique<SkeletonEvent<FieldType>>(skeleton_base, field_name, std::move(binding)),
+                    field_name}
+{
+}
+
+/// \brief Private delegating ctor - EnableSet=true, EnableGet=true.
+template <typename SampleDataType, bool EnableSet, bool EnableNotifier, bool EnableGet>
+template <bool ES, bool EG, typename>
+SkeletonField<SampleDataType, EnableSet, EnableNotifier, EnableGet>::SkeletonField(
+    SkeletonBase& parent,
+    std::unique_ptr<SkeletonEvent<FieldType>> skeleton_event_dispatch,
+    std::unique_ptr<SkeletonMethod<Result<FieldType>(FieldType)>> set_method,
+    std::unique_ptr<SkeletonMethod<Result<FieldType>()>> get_method,
+    const std::string_view field_name)
+    : SkeletonFieldBase{parent, field_name, std::move(skeleton_event_dispatch)},
       initial_field_value_{nullptr},
-      skeleton_field_mock_{nullptr}
+      skeleton_field_mock_{nullptr},
+      set_method_{std::move(set_method)},
+      get_method_{std::move(get_method)}
+{
+    SkeletonBaseView skeleton_base_view{parent};
+    skeleton_base_view.RegisterField(field_name, *this);
+    RegisterGetHandler();
+}
+
+/// \brief Private delegating ctor - EnableSet=false, EnableGet=true.
+template <typename SampleDataType, bool EnableSet, bool EnableNotifier, bool EnableGet>
+template <bool ES, bool EG, typename>
+SkeletonField<SampleDataType, EnableSet, EnableNotifier, EnableGet>::SkeletonField(
+    SkeletonBase& parent,
+    std::unique_ptr<SkeletonEvent<FieldType>> skeleton_event_dispatch,
+    std::unique_ptr<SkeletonMethod<Result<FieldType>()>> get_method,
+    const std::string_view field_name)
+    : SkeletonFieldBase{parent, field_name, std::move(skeleton_event_dispatch)},
+      initial_field_value_{nullptr},
+      skeleton_field_mock_{nullptr},
+      get_method_{std::move(get_method)}
 {
     SkeletonBaseView skeleton_base_view{parent};
     skeleton_base_view.RegisterField(field_name, *this);
+    RegisterGetHandler();
 }
 
-template <typename SampleDataType>
-SkeletonField<SampleDataType>::SkeletonField(SkeletonBase& skeleton_base,
-                                             const std::string_view field_name,
-                                             std::unique_ptr<SkeletonEventBinding<FieldType>> binding)
-    : SkeletonFieldBase{skeleton_base,
-                        field_name,
-                        std::make_unique<SkeletonEvent<FieldType>>(skeleton_base, field_name, std::move(binding))},
+/// \brief Private delegating ctor - EnableSet=true, EnableGet=false.
+template <typename SampleDataType, bool EnableSet, bool EnableNotifier, bool EnableGet>
+template <bool ES, bool EG, typename>
+SkeletonField<SampleDataType, EnableSet, EnableNotifier, EnableGet>::SkeletonField(
+    SkeletonBase& parent,
+    std::unique_ptr<SkeletonEvent<FieldType>> skeleton_event_dispatch,
+    std::unique_ptr<SkeletonMethod<Result<FieldType>(FieldType)>> set_method,
+    const std::string_view field_name)
+    : SkeletonFieldBase{parent, field_name, std::move(skeleton_event_dispatch)},
+      initial_field_value_{nullptr},
+      skeleton_field_mock_{nullptr},
+      set_method_{std::move(set_method)}
+{
+    SkeletonBaseView skeleton_base_view{parent};
+    skeleton_base_view.RegisterField(field_name, *this);
+}
+
+/// \brief Private delegating ctor - EnableSet=false, EnableGet=false.
+template <typename SampleDataType, bool EnableSet, bool EnableNotifier, bool EnableGet>
+template <bool ES, bool EG, typename>
+SkeletonField<SampleDataType, EnableSet, EnableNotifier, EnableGet>::SkeletonField(
+    SkeletonBase& parent,
+    std::unique_ptr<SkeletonEvent<FieldType>> skeleton_event_dispatch,
+    const std::string_view field_name)
+    : SkeletonFieldBase{parent, field_name, std::move(skeleton_event_dispatch)},
+      initial_field_value_{nullptr},
       skeleton_field_mock_{nullptr}
 {
+    SkeletonBaseView skeleton_base_view{parent};
+    skeleton_base_view.RegisterField(field_name, *this);
 }
 
-template <typename SampleDataType>
-SkeletonField<SampleDataType>::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.
@@ -148,15 +434,18 @@ SkeletonField<SampleDataType>::SkeletonField(SkeletonField&& other) noexcept
       // so it's still valid to access it here for moving into our own member.
       // coverity[autosar_cpp14_a12_8_3_violation] This is a false-positive.
       initial_field_value_{std::move(other.initial_field_value_)},
-      skeleton_field_mock_{other.skeleton_field_mock_}
+      skeleton_field_mock_{other.skeleton_field_mock_},
+      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);
 }
 
-template <typename SampleDataType>
-auto SkeletonField<SampleDataType>::operator=(SkeletonField&& other) & noexcept -> SkeletonField<SampleDataType>&
+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)
     {
@@ -164,6 +453,8 @@ auto SkeletonField<SampleDataType>::operator=(SkeletonField&& other) & noexcept
 
         initial_field_value_ = std::move(other.initial_field_value_);
         skeleton_field_mock_ = std::move(other.skeleton_field_mock_);
+        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()};
@@ -179,8 +470,9 @@ auto SkeletonField<SampleDataType>::operator=(SkeletonField&& other) & noexcept
 /// 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>
-ResultBlank SkeletonField<SampleDataType>::Update(const FieldType& sample_value) noexcept
+template <typename SampleDataType, bool EnableSet, bool EnableNotifier, bool EnableGet>
+ResultBlank SkeletonField<SampleDataType, EnableSet, EnableNotifier, EnableGet>::Update(
+    const FieldType& sample_value) noexcept
 {
     if (skeleton_field_mock_ != nullptr)
     {
@@ -197,8 +489,9 @@ ResultBlank SkeletonField<SampleDataType>::Update(const FieldType& sample_value)
 
 /// \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>
-ResultBlank SkeletonField<SampleDataType>::Update(SampleAllocateePtr<FieldType> sample) noexcept
+template <typename SampleDataType, bool EnableSet, bool EnableNotifier, bool EnableGet>
+ResultBlank SkeletonField<SampleDataType, EnableSet, EnableNotifier, EnableGet>::Update(
+    SampleAllocateePtr<FieldType> sample) noexcept
 {
     if (skeleton_field_mock_ != nullptr)
     {
@@ -213,8 +506,9 @@ ResultBlank SkeletonField<SampleDataType>::Update(SampleAllocateePtr<FieldType>
 ///
 /// 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>
-Result<SampleAllocateePtr<SampleDataType>> SkeletonField<SampleDataType>::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)
     {
@@ -232,12 +526,12 @@ Result<SampleAllocateePtr<SampleDataType>> SkeletonField<SampleDataType>::Alloca
     return GetTypedEvent()->Allocate();
 }
 
-template <typename SampleDataType>
+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]
-ResultBlank SkeletonField<SampleDataType>::DoDeferredUpdate() noexcept
+ResultBlank SkeletonField<SampleDataType, EnableSet, EnableNotifier, EnableGet>::DoDeferredUpdate() noexcept
 {
     SCORE_LANGUAGE_FUTURECPP_ASSERT_MESSAGE(
         initial_field_value_ != nullptr,
@@ -253,14 +547,16 @@ ResultBlank SkeletonField<SampleDataType>::DoDeferredUpdate() noexcept
     return ResultBlank{};
 }
 
-template <typename SampleDataType>
-ResultBlank SkeletonField<SampleDataType>::UpdateImpl(const FieldType& sample_value) noexcept
+template <typename SampleDataType, bool EnableSet, bool EnableNotifier, bool EnableGet>
+ResultBlank SkeletonField<SampleDataType, EnableSet, EnableNotifier, EnableGet>::UpdateImpl(
+    const FieldType& sample_value) noexcept
 {
     return GetTypedEvent()->Send(sample_value);
 }
 
-template <typename SampleDataType>
-auto SkeletonField<SampleDataType>::GetTypedEvent() const noexcept -> SkeletonEvent<SampleDataType>*
+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());
     SCORE_LANGUAGE_FUTURECPP_ASSERT_PRD_MESSAGE(typed_event != nullptr, "Downcast to SkeletonEvent<FieldType> failed!");
diff --git a/score/mw/com/impl/skeleton_field_base.h b/score/mw/com/impl/skeleton_field_base.h
index b38974f13..6ecff3fd2 100644
--- a/score/mw/com/impl/skeleton_field_base.h
+++ b/score/mw/com/impl/skeleton_field_base.h
@@ -15,6 +15,7 @@
 
 #include "score/mw/com/impl/com_error.h"
 #include "score/mw/com/impl/skeleton_event_base.h"
+#include "score/mw/com/impl/methods/skeleton_method_base.h"
 
 #include "score/mw/log/logging.h"
 #include "score/result/result.h"
diff --git a/score/mw/com/impl/skeleton_field_test.cpp b/score/mw/com/impl/skeleton_field_test.cpp
index 8510c500c..b084f36a6 100644
--- a/score/mw/com/impl/skeleton_field_test.cpp
+++ b/score/mw/com/impl/skeleton_field_test.cpp
@@ -12,6 +12,7 @@
  ********************************************************************************/
 #include "score/mw/com/impl/skeleton_field.h"
 
+#include "score/mw/com/impl/bindings/mock_binding/skeleton_method.h"
 #include "score/mw/com/impl/runtime.h"
 #include "score/mw/com/impl/runtime_mock.h"
 #include "score/mw/com/impl/test/binding_factory_resources.h"
@@ -19,6 +20,7 @@
 
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
+#include <array>
 #include <cstdint>
 #include <memory>
 #include <string_view>
@@ -64,6 +66,14 @@ class MyDummySkeleton : public SkeletonBase
     SkeletonField<TestSampleType> my_dummy_field_{*this, kFieldName};
 };
 
+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");
@@ -109,6 +119,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.
 TEST(SkeletonFieldCopyUpdateTest, CallingUpdateBeforeOfferServiceDefersCallToOfferService)
diff --git a/score/mw/com/impl/traits.h b/score/mw/com/impl/traits.h
index 5f2ce1b94..c3f570562 100644
--- a/score/mw/com/impl/traits.h
+++ b/score/mw/com/impl/traits.h
@@ -150,8 +150,8 @@ class SkeletonTrait
     template <typename SampleType>
     using Event = SkeletonEvent<SampleType>;
 
-    template <typename SampleType>
-    using Field = SkeletonField<SampleType>;
+    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>;