diff --git a/FppTestProject/FppTest/state_machine/internal/harness/TestAbsType.hpp b/FppTestProject/FppTest/state_machine/internal/harness/TestAbsType.hpp
index f5e84069811..e5ef3d4cc3a 100644
--- a/FppTestProject/FppTest/state_machine/internal/harness/TestAbsType.hpp
+++ b/FppTestProject/FppTest/state_machine/internal/harness/TestAbsType.hpp
@@ -56,24 +56,10 @@ struct TestAbsType final : public Fw::Serializable {
     //! Deserialize method
     //! \return status
     Fw::SerializeStatus deserializeFrom(Fw::SerializeBufferBase& sbb  //!< The serialize buffer base
-                                    ) final {
+                                        ) final {
         return sbb.deserializeTo(this->m_data);
     }
 
-    // ----------------------------------------------------------------------
-    // Methods
-    // ----------------------------------------------------------------------
-
-    Fw::SerializeStatus serialize(Fw::SerializeBufferBase& sbb) const final
-    {
-        return this->serializeTo(sbb);
-    }
-
-    Fw::SerializeStatus deserialize(Fw::SerializeBufferBase& sbb) final
-    {
-        return this->deserializeFrom(sbb);
-    }
-
 #if FW_SERIALIZABLE_TO_STRING
     //! Convert TestAbsType to string
     void toString(Fw::StringBase& sb  //!< The StringBase object to hold the result
diff --git a/Fw/Buffer/Buffer.cpp b/Fw/Buffer/Buffer.cpp
index 111292bb72e..2f3ee2063ea 100644
--- a/Fw/Buffer/Buffer.cpp
+++ b/Fw/Buffer/Buffer.cpp
@@ -189,12 +189,4 @@ std::ostream& operator<<(std::ostream& os, const Buffer& obj) {
 }
 #endif
 
-Fw::SerializeStatus Buffer::serialize(Fw::SerializeBufferBase& serialBuffer) const {
-    return this->serializeTo(serialBuffer);
-}
-
-Fw::SerializeStatus Buffer::deserialize(Fw::SerializeBufferBase& buffer) {
-    return this->deserializeFrom(buffer);
-}
-
 }  // end namespace Fw
diff --git a/Fw/Buffer/Buffer.hpp b/Fw/Buffer/Buffer.hpp
index 8c9b849e521..e86901cb15f 100644
--- a/Fw/Buffer/Buffer.hpp
+++ b/Fw/Buffer/Buffer.hpp
@@ -137,14 +137,6 @@ class Buffer : public Fw::Serializable {
     //! \return: status of serialization
     Fw::SerializeStatus deserializeFrom(Fw::SerializeBufferBase& buffer);
 
-    // ----------------------------------------------------------------------
-    // Deprecated methods
-    // ----------------------------------------------------------------------
-
-    Fw::SerializeStatus serialize(Fw::SerializeBufferBase& serialBuffer) const;
-
-    Fw::SerializeStatus deserialize(Fw::SerializeBufferBase& buffer);
-
     // ----------------------------------------------------------------------
     // Accessor functions
     // ----------------------------------------------------------------------
diff --git a/Fw/Cmd/CmdPacket.cpp b/Fw/Cmd/CmdPacket.cpp
index 9a09a9c083a..d08e3bf1ef7 100644
--- a/Fw/Cmd/CmdPacket.cpp
+++ b/Fw/Cmd/CmdPacket.cpp
@@ -35,7 +35,7 @@ SerializeStatus CmdPacket::deserializeFrom(SerializeBufferBase& buffer) {
         return FW_DESERIALIZE_TYPE_MISMATCH;
     }
 
-    stat = buffer.deserialize(this->m_opcode);
+    stat = buffer.deserializeTo(this->m_opcode);
     if (stat != FW_SERIALIZE_OK) {
         return stat;
     }
@@ -49,15 +49,6 @@ SerializeStatus CmdPacket::deserializeFrom(SerializeBufferBase& buffer) {
     return stat;
 }
 
-// Deprecated methods for backward compatibility - these call the new interface
-SerializeStatus CmdPacket::serialize(SerializeBufferBase& buffer) const {
-    return this->serializeTo(buffer);
-}
-
-SerializeStatus CmdPacket::deserialize(SerializeBufferBase& buffer) {
-    return this->deserializeFrom(buffer);
-}
-
 FwOpcodeType CmdPacket::getOpCode() const {
     return this->m_opcode;
 }
diff --git a/Fw/Cmd/CmdPacket.hpp b/Fw/Cmd/CmdPacket.hpp
index 0c02432e347..4a9172d6a66 100644
--- a/Fw/Cmd/CmdPacket.hpp
+++ b/Fw/Cmd/CmdPacket.hpp
@@ -22,9 +22,6 @@ class CmdPacket : public ComPacket {
     SerializeStatus serializeTo(SerializeBufferBase& buffer) const;
     SerializeStatus deserializeFrom(SerializeBufferBase& buffer);
 
-    // Legacy serialization methods (backward compatibility)
-    SerializeStatus serialize(SerializeBufferBase& buffer) const;  //!< serialize contents
-    SerializeStatus deserialize(SerializeBufferBase& buffer);
     FwOpcodeType getOpCode() const;
     CmdArgBuffer& getArgBuffer();
 
diff --git a/Fw/Com/ComPacket.cpp b/Fw/Com/ComPacket.cpp
index 0ef469f37b6..ba694e1c51a 100644
--- a/Fw/Com/ComPacket.cpp
+++ b/Fw/Com/ComPacket.cpp
@@ -14,35 +14,16 @@ ComPacket::ComPacket() : m_type(ComPacketType::FW_PACKET_UNKNOWN) {}
 ComPacket::~ComPacket() {}
 
 SerializeStatus ComPacket::serializeBase(SerializeBufferBase& buffer) const {
-    return buffer.serialize(static_cast<FwPacketDescriptorType>(this->m_type));
+    return buffer.serializeFrom(static_cast<FwPacketDescriptorType>(this->m_type));
 }
 
 SerializeStatus ComPacket::deserializeBase(SerializeBufferBase& buffer) {
     FwPacketDescriptorType serVal;
-    SerializeStatus stat = buffer.deserialize(serVal);
+    SerializeStatus stat = buffer.deserializeTo(serVal);
     if (FW_SERIALIZE_OK == stat) {
         this->m_type = static_cast<ComPacketType>(serVal);
     }
     return stat;
 }
 
-SerializeStatus ComPacket::serializeTo(SerializeBufferBase& buffer) const {
-    // Default implementation for base class - derived classes should override this method
-    return FW_SERIALIZE_UNIMPLEMENTED;
-}
-
-SerializeStatus ComPacket::deserializeFrom(SerializeBufferBase& buffer) {
-    // Default implementation for base class - derived classes should override this method
-    return FW_DESERIALIZE_UNIMPLEMENTED;
-}
-
-// Deprecated methods for backward compatibility
-SerializeStatus ComPacket::serialize(SerializeBufferBase& buffer) const {
-    return this->serializeTo(buffer);
-}
-
-SerializeStatus ComPacket::deserialize(SerializeBufferBase& buffer) {
-    return this->deserializeFrom(buffer);
-}
-
 } /* namespace Fw */
diff --git a/Fw/Com/ComPacket.hpp b/Fw/Com/ComPacket.hpp
index ad45a1f19ab..a5be0c522c4 100644
--- a/Fw/Com/ComPacket.hpp
+++ b/Fw/Com/ComPacket.hpp
@@ -24,14 +24,6 @@ class ComPacket : public Serializable {
     ComPacket();
     virtual ~ComPacket();
 
-    // New serialization interface
-    SerializeStatus serializeTo(SerializeBufferBase& buffer) const override;
-    SerializeStatus deserializeFrom(SerializeBufferBase& buffer) override;
-
-    // Deprecated methods for backward compatibility
-    SerializeStatus serialize(SerializeBufferBase& buffer) const override;
-    SerializeStatus deserialize(SerializeBufferBase& buffer) override;
-
   protected:
     ComPacketType m_type;
     SerializeStatus serializeBase(
diff --git a/Fw/Log/AmpcsEvrLogPacket.cpp b/Fw/Log/AmpcsEvrLogPacket.cpp
index 25bfd6145ad..509e5149885 100644
--- a/Fw/Log/AmpcsEvrLogPacket.cpp
+++ b/Fw/Log/AmpcsEvrLogPacket.cpp
@@ -14,74 +14,64 @@ namespace Fw {
 AmpcsEvrLogPacket::AmpcsEvrLogPacket() : m_eventID(0), m_overSeqNum(0), m_catSeqNum(0) {
     this->m_type = FW_PACKET_LOG;
 }
-
 AmpcsEvrLogPacket::~AmpcsEvrLogPacket() {}
 
-SerializeStatus AmpcsEvrLogPacket::serialize(SerializeBufferBase& buffer) const {
-    // Deprecated method - calls new interface for backward compatibility
-    return this->serializeTo(buffer);
-}
-
-SerializeStatus AmpcsEvrLogPacket::deserialize(SerializeBufferBase& buffer) {
-    // Deprecated method - calls new interface for backward compatibility
-    return this->deserializeFrom(buffer);
-}
-
 SerializeStatus AmpcsEvrLogPacket::serializeTo(SerializeBufferBase& buffer) const {
     SerializeStatus stat;
 
-    stat = buffer.serialize(this->m_taskName, AMPCS_EVR_TASK_NAME_LEN, Fw::Serialization::OMIT_LENGTH);
+    stat = buffer.serializeFrom(this->m_taskName, AMPCS_EVR_TASK_NAME_LEN, Fw::Serialization::OMIT_LENGTH);
     if (stat != FW_SERIALIZE_OK) {
         return stat;
     }
 
-    stat = buffer.serialize(this->m_eventID);
+    stat = buffer.serializeFrom(this->m_eventID);
     if (stat != FW_SERIALIZE_OK) {
         return stat;
     }
 
-    stat = buffer.serialize(this->m_overSeqNum);
+    stat = buffer.serializeFrom(this->m_overSeqNum);
     if (stat != FW_SERIALIZE_OK) {
         return stat;
     }
 
-    stat = buffer.serialize(this->m_catSeqNum);
+    stat = buffer.serializeFrom(this->m_catSeqNum);
     if (stat != FW_SERIALIZE_OK) {
         return stat;
     }
 
-    return buffer.serialize(this->m_logBuffer.getBuffAddr(), m_logBuffer.getBuffLength(),
-                            Fw::Serialization::OMIT_LENGTH);
+    return buffer.serializeFrom(this->m_logBuffer.getBuffAddr(), m_logBuffer.getBuffLength(),
+                                Fw::Serialization::OMIT_LENGTH);
 }
 
 SerializeStatus AmpcsEvrLogPacket::deserializeFrom(SerializeBufferBase& buffer) {
     FwSizeType len;
 
+    SerializeStatus stat;
     SerializeStatus stat;
 
     len = AMPCS_EVR_TASK_NAME_LEN;
-    stat = buffer.deserialize(this->m_taskName, len, true);
+    stat = buffer.deserializeTo(this->m_taskName, len, true);
     if (stat != FW_SERIALIZE_OK) {
         return stat;
     }
 
-    stat = buffer.deserialize(this->m_eventID);
+    stat = buffer.deserializeTo(this->m_eventID);
     if (stat != FW_SERIALIZE_OK) {
         return stat;
     }
 
-    stat = buffer.deserialize(this->m_overSeqNum);
+    stat = buffer.deserializeTo(this->m_overSeqNum);
     if (stat != FW_SERIALIZE_OK) {
         return stat;
     }
 
-    stat = buffer.deserialize(this->m_catSeqNum);
+    stat = buffer.deserializeTo(this->m_catSeqNum);
     if (stat != FW_SERIALIZE_OK) {
         return stat;
     }
 
     FwSizeType size = buffer.getBuffLeft();
-    stat = buffer.deserialize(this->m_logBuffer.getBuffAddr(), size, true);
+    stat = buffer.deserializeTo(this->m_logBuffer.getBuffAddr(), size, true);
     if (stat == FW_SERIALIZE_OK) {
         // Shouldn't fail
         stat = this->m_logBuffer.setBuffLen(size);
diff --git a/Fw/Log/AmpcsEvrLogPacket.hpp b/Fw/Log/AmpcsEvrLogPacket.hpp
index 651ca6eb487..c1f18ee5f26 100644
--- a/Fw/Log/AmpcsEvrLogPacket.hpp
+++ b/Fw/Log/AmpcsEvrLogPacket.hpp
@@ -23,11 +23,8 @@ class AmpcsEvrLogPacket : public ComPacket {
     AmpcsEvrLogPacket();
     virtual ~AmpcsEvrLogPacket();
 
-    SerializeStatus serialize(SerializeBufferBase& buffer) const override;  //!< serialize contents
-    SerializeStatus deserialize(SerializeBufferBase& buffer) override;
-
-    SerializeStatus serializeTo(SerializeBufferBase& buffer) const override;  //!< serialize contents
-    SerializeStatus deserializeFrom(SerializeBufferBase& buffer) override;
+    SerializeStatus serializeTo(SerializeBufferBase& buffer) const;  //!< serialize contents
+    SerializeStatus deserializeFrom(SerializeBufferBase& buffer);
 
     void setTaskName(U8* taskName, U8 len);
     void setId(U32 eventID);
diff --git a/Fw/Log/LogPacket.cpp b/Fw/Log/LogPacket.cpp
index c584600defe..712be6e7a97 100644
--- a/Fw/Log/LogPacket.cpp
+++ b/Fw/Log/LogPacket.cpp
@@ -16,35 +16,25 @@ LogPacket::LogPacket() : m_id(0) {
 
 LogPacket::~LogPacket() {}
 
-SerializeStatus LogPacket::serialize(SerializeBufferBase& buffer) const {
-    // Deprecated method - calls new interface for backward compatibility
-    return this->serializeTo(buffer);
-}
-
-SerializeStatus LogPacket::deserialize(SerializeBufferBase& buffer) {
-    // Deprecated method - calls new interface for backward compatibility
-    return this->deserializeFrom(buffer);
-}
-
 SerializeStatus LogPacket::serializeTo(SerializeBufferBase& buffer) const {
     SerializeStatus stat = ComPacket::serializeBase(buffer);
     if (stat != FW_SERIALIZE_OK) {
         return stat;
     }
 
-    stat = buffer.serialize(this->m_id);
+    stat = buffer.serializeFrom(this->m_id);
     if (stat != FW_SERIALIZE_OK) {
         return stat;
     }
 
-    stat = buffer.serialize(this->m_timeTag);
+    stat = buffer.serializeFrom(this->m_timeTag);
     if (stat != FW_SERIALIZE_OK) {
         return stat;
     }
 
     // We want to add data but not size for the ground software
-    return buffer.serialize(this->m_logBuffer.getBuffAddr(), m_logBuffer.getBuffLength(),
-                            Fw::Serialization::OMIT_LENGTH);
+    return buffer.serializeFrom(this->m_logBuffer.getBuffAddr(), m_logBuffer.getBuffLength(),
+                                Fw::Serialization::OMIT_LENGTH);
 }
 
 SerializeStatus LogPacket::deserializeFrom(SerializeBufferBase& buffer) {
@@ -53,19 +43,19 @@ SerializeStatus LogPacket::deserializeFrom(SerializeBufferBase& buffer) {
         return stat;
     }
 
-    stat = buffer.deserialize(this->m_id);
+    stat = buffer.deserializeTo(this->m_id);
     if (stat != FW_SERIALIZE_OK) {
         return stat;
     }
 
-    stat = buffer.deserialize(this->m_timeTag);
+    stat = buffer.deserializeTo(this->m_timeTag);
     if (stat != FW_SERIALIZE_OK) {
         return stat;
     }
 
     // remainder of buffer must be telemetry value
     FwSizeType size = buffer.getBuffLeft();
-    stat = buffer.deserialize(this->m_logBuffer.getBuffAddr(), size, Fw::Serialization::OMIT_LENGTH);
+    stat = buffer.deserializeTo(this->m_logBuffer.getBuffAddr(), size, Fw::Serialization::OMIT_LENGTH);
     if (stat == FW_SERIALIZE_OK) {
         // Shouldn't fail
         stat = this->m_logBuffer.setBuffLen(size);
diff --git a/Fw/Log/LogPacket.hpp b/Fw/Log/LogPacket.hpp
index a613cf37309..9b8029b51ac 100644
--- a/Fw/Log/LogPacket.hpp
+++ b/Fw/Log/LogPacket.hpp
@@ -19,9 +19,6 @@ class LogPacket : public ComPacket {
     LogPacket();
     virtual ~LogPacket();
 
-    SerializeStatus serialize(SerializeBufferBase& buffer) const override;  //!< serialize contents
-    SerializeStatus deserialize(SerializeBufferBase& buffer) override;
-
     SerializeStatus serializeTo(SerializeBufferBase& buffer) const override;  //!< serialize contents
     SerializeStatus deserializeFrom(SerializeBufferBase& buffer) override;
 
diff --git a/Fw/Time/Time.cpp b/Fw/Time/Time.cpp
index 312427ae471..6d072fa7a89 100644
--- a/Fw/Time/Time.cpp
+++ b/Fw/Time/Time.cpp
@@ -76,37 +76,11 @@ bool Time::operator<=(const Time& other) const {
 }
 
 SerializeStatus Time::serializeTo(SerializeBufferBase& buffer) const {
-    // Fallback approach for backward compatibility:
-    // Try new interface first, but if it returns UNIMPLEMENTED (indicating default implementation),
-    // fall back to old interface. This bridges auto-generated enums/structs (old interface only)
-    // with new serialization infrastructure.
-    SerializeStatus status = this->m_val.serializeTo(buffer);
-    if (status == FW_SERIALIZE_UNIMPLEMENTED) {
-        // Fallback to old interface for backward compatibility
-        status = this->m_val.serialize(buffer);
-    }
-    return status;
+    return this->m_val.serializeTo(buffer);
 }
 
 SerializeStatus Time::deserializeFrom(SerializeBufferBase& buffer) {
-    // Fallback approach for backward compatibility:
-    // Try new interface first, but if it returns UNIMPLEMENTED (indicating default implementation),
-    // fall back to old interface.
-    SerializeStatus status = this->m_val.deserializeFrom(buffer);
-    if (status == FW_DESERIALIZE_UNIMPLEMENTED) {
-        // Fallback to old interface for backward compatibility
-        status = this->m_val.deserialize(buffer);
-    }
-    return status;
-}
-
-// Deprecated methods for backward compatibility - these call the new interface
-SerializeStatus Time::serialize(SerializeBufferBase& buffer) const {
-    return this->serializeTo(buffer);
-}
-
-SerializeStatus Time::deserialize(SerializeBufferBase& buffer) {
-    return this->deserializeFrom(buffer);
+    return this->m_val.deserializeFrom(buffer);
 }
 
 U32 Time::getSeconds() const {
diff --git a/Fw/Time/Time.hpp b/Fw/Time/Time.hpp
index 619d5d57f57..03d61bbfb19 100644
--- a/Fw/Time/Time.hpp
+++ b/Fw/Time/Time.hpp
@@ -38,8 +38,6 @@ class Time : public Serializable {
     FwTimeContextStoreType getContext() const;                                // !< get the context value
     SerializeStatus serializeTo(SerializeBufferBase& buffer) const override;  // !< Serialize method
     SerializeStatus deserializeFrom(SerializeBufferBase& buffer) override;    // !< Deserialize method
-    SerializeStatus serialize(SerializeBufferBase& buffer) const override;    // !< Serialize method (deprecated)
-    SerializeStatus deserialize(SerializeBufferBase& buffer) override;        // !< Deserialize method (deprecated)
     bool operator==(const Time& other) const;
     bool operator!=(const Time& other) const;
     bool operator>(const Time& other) const;
diff --git a/Fw/Time/TimeInterval.cpp b/Fw/Time/TimeInterval.cpp
index aa5b7b22862..d480acfe6ff 100644
--- a/Fw/Time/TimeInterval.cpp
+++ b/Fw/Time/TimeInterval.cpp
@@ -47,16 +47,6 @@ bool TimeInterval::operator<=(const TimeInterval& other) const {
     return ((LT == c) or (EQ == c));
 }
 
-SerializeStatus TimeInterval::serialize(SerializeBufferBase& buffer) const {
-    // Deprecated method - calls new interface for backward compatibility
-    return this->serializeTo(buffer);
-}
-
-SerializeStatus TimeInterval::deserialize(SerializeBufferBase& buffer) {
-    // Deprecated method - calls new interface for backward compatibility
-    return this->deserializeFrom(buffer);
-}
-
 SerializeStatus TimeInterval::serializeTo(SerializeBufferBase& buffer) const {
     // Use TimeIntervalValue's built-in serialization
     return this->m_val.serializeTo(buffer);
diff --git a/Fw/Time/TimeInterval.hpp b/Fw/Time/TimeInterval.hpp
index 1b74e35c652..67626f70879 100644
--- a/Fw/Time/TimeInterval.hpp
+++ b/Fw/Time/TimeInterval.hpp
@@ -27,8 +27,6 @@ class TimeInterval : public Serializable {
     void set(U32 seconds, U32 useconds);      // !< Sets value of time stored
     U32 getSeconds() const;                   // !< Gets seconds part of time
     U32 getUSeconds() const;                  // !< Gets microseconds part of time
-    SerializeStatus serialize(SerializeBufferBase& buffer) const override;  // !< Serialize method
-    SerializeStatus deserialize(SerializeBufferBase& buffer) override;      // !< Deserialize method
 
     SerializeStatus serializeTo(SerializeBufferBase& buffer) const override;  // !< Serialize method
     SerializeStatus deserializeFrom(SerializeBufferBase& buffer) override;    // !< Deserialize method
diff --git a/Fw/Tlm/TlmPacket.cpp b/Fw/Tlm/TlmPacket.cpp
index 974a092e367..61494f9b2a4 100644
--- a/Fw/Tlm/TlmPacket.cpp
+++ b/Fw/Tlm/TlmPacket.cpp
@@ -70,19 +70,20 @@ SerializeStatus TlmPacket::addValue(FwChanIdType id, Time& timeTag, TlmBuffer& b
     // serialize items into buffer
 
     // id
-    SerializeStatus stat = this->m_tlmBuffer.serialize(id);
+    SerializeStatus stat = this->m_tlmBuffer.serializeFrom(id);
     if (stat != Fw::FW_SERIALIZE_OK) {
         return stat;
     }
 
     // time tag
-    stat = this->m_tlmBuffer.serialize(timeTag);
+    stat = this->m_tlmBuffer.serializeFrom(timeTag);
     if (stat != Fw::FW_SERIALIZE_OK) {
         return stat;
     }
 
     // telemetry buffer
-    stat = this->m_tlmBuffer.serialize(buffer.getBuffAddr(), buffer.getBuffLength(), Fw::Serialization::OMIT_LENGTH);
+    stat =
+        this->m_tlmBuffer.serializeFrom(buffer.getBuffAddr(), buffer.getBuffLength(), Fw::Serialization::OMIT_LENGTH);
     if (stat != Fw::FW_SERIALIZE_OK) {
         return stat;
     }
@@ -98,19 +99,19 @@ SerializeStatus TlmPacket::extractValue(FwChanIdType& id, Time& timeTag, TlmBuff
     // deserialize items out of buffer
 
     // id
-    SerializeStatus stat = this->m_tlmBuffer.deserialize(id);
+    SerializeStatus stat = this->m_tlmBuffer.deserializeTo(id);
     if (stat != Fw::FW_SERIALIZE_OK) {
         return stat;
     }
 
     // time tag
-    stat = this->m_tlmBuffer.deserialize(timeTag);
+    stat = this->m_tlmBuffer.deserializeTo(timeTag);
     if (stat != Fw::FW_SERIALIZE_OK) {
         return stat;
     }
 
     // telemetry buffer
-    stat = this->m_tlmBuffer.deserialize(buffer.getBuffAddr(), bufferSize, Fw::Serialization::OMIT_LENGTH);
+    stat = this->m_tlmBuffer.deserializeTo(buffer.getBuffAddr(), bufferSize, Fw::Serialization::OMIT_LENGTH);
     if (stat != Fw::FW_SERIALIZE_OK) {
         return stat;
     }
@@ -124,36 +125,26 @@ SerializeStatus TlmPacket::extractValue(FwChanIdType& id, Time& timeTag, TlmBuff
     return Fw::FW_SERIALIZE_OK;
 }
 
-SerializeStatus TlmPacket::serialize(SerializeBufferBase& buffer) const {
-    // Deprecated method - calls new interface for backward compatibility
-    return this->serializeTo(buffer);
-}
-
-SerializeStatus TlmPacket::deserialize(SerializeBufferBase& buffer) {
-    // Deprecated method - calls new interface for backward compatibility
-    return this->deserializeFrom(buffer);
-}
-
 SerializeStatus TlmPacket::serializeTo(SerializeBufferBase& buffer) const {
     // serialize the number of packets
-    SerializeStatus stat = buffer.serialize(this->m_numEntries);
+    SerializeStatus stat = buffer.serializeFrom(this->m_numEntries);
     if (stat != Fw::FW_SERIALIZE_OK) {
         return stat;
     }
     // Serialize the ComBuffer
-    return buffer.serialize(this->m_tlmBuffer.getBuffAddr(), m_tlmBuffer.getBuffLength(),
-                            Fw::Serialization::OMIT_LENGTH);
+    return buffer.serializeFrom(this->m_tlmBuffer.getBuffAddr(), m_tlmBuffer.getBuffLength(),
+                                Fw::Serialization::OMIT_LENGTH);
 }
 
 SerializeStatus TlmPacket::deserializeFrom(SerializeBufferBase& buffer) {
     // deserialize the number of packets
-    SerializeStatus stat = buffer.deserialize(this->m_numEntries);
+    SerializeStatus stat = buffer.deserializeTo(this->m_numEntries);
     if (stat != Fw::FW_SERIALIZE_OK) {
         return stat;
     }
     // deserialize the channel value entry buffers
     FwSizeType size = buffer.getBuffLeft();
-    stat = buffer.deserialize(this->m_tlmBuffer.getBuffAddr(), size, Fw::Serialization::OMIT_LENGTH);
+    stat = buffer.deserializeTo(this->m_tlmBuffer.getBuffAddr(), size, Fw::Serialization::OMIT_LENGTH);
     if (stat == FW_SERIALIZE_OK) {
         // Shouldn't fail
         stat = this->m_tlmBuffer.setBuffLen(size);
diff --git a/Fw/Tlm/TlmPacket.hpp b/Fw/Tlm/TlmPacket.hpp
index f1b36f25036..bc581e32484 100644
--- a/Fw/Tlm/TlmPacket.hpp
+++ b/Fw/Tlm/TlmPacket.hpp
@@ -22,13 +22,6 @@ class TlmPacket : public ComPacket {
     //! Destructor
     virtual ~TlmPacket();
 
-    //! Serialize the packet before sending. For use internally in software. To send to the ground, use getBuffer()
-    //! below.
-    SerializeStatus serialize(SerializeBufferBase& buffer) const override;  //!< serialize contents
-    //! Deserialize the packet. For use internally in software. To extract channels, use setBuffer() and extractValue()
-    //! below. This is NOT typically used.
-    SerializeStatus deserialize(SerializeBufferBase& buffer) override;
-
     SerializeStatus serializeTo(SerializeBufferBase& buffer) const override;  //!< serialize contents
     SerializeStatus deserializeFrom(SerializeBufferBase& buffer) override;
     //! Add telemetry value to buffer.
diff --git a/Fw/Types/PolyType.cpp b/Fw/Types/PolyType.cpp
index de4009ee5ee..cd7f692e5a0 100644
--- a/Fw/Types/PolyType.cpp
+++ b/Fw/Types/PolyType.cpp
@@ -482,7 +482,7 @@ bool PolyType::operator<=(const PolyType& other) const {
 
 SerializeStatus PolyType::serializeTo(SerializeBufferBase& buffer) const {
     // store type
-    SerializeStatus stat = buffer.serialize(static_cast<FwEnumStoreType>(this->m_dataType));
+    SerializeStatus stat = buffer.serializeFrom(static_cast<FwEnumStoreType>(this->m_dataType));
     if (stat != FW_SERIALIZE_OK) {
         return stat;
     }
@@ -490,46 +490,46 @@ SerializeStatus PolyType::serializeTo(SerializeBufferBase& buffer) const {
     // switch on type
     switch (this->m_dataType) {
         case TYPE_U8:
-            stat = buffer.serialize(this->m_val.u8Val);
+            stat = buffer.serializeFrom(this->m_val.u8Val);
             break;
         case TYPE_I8:
-            stat = buffer.serialize(this->m_val.i8Val);
+            stat = buffer.serializeFrom(this->m_val.i8Val);
             break;
 #if FW_HAS_16_BIT
         case TYPE_U16:
-            stat = buffer.serialize(this->m_val.u16Val);
+            stat = buffer.serializeFrom(this->m_val.u16Val);
             break;
         case TYPE_I16:
-            stat = buffer.serialize(this->m_val.i16Val);
+            stat = buffer.serializeFrom(this->m_val.i16Val);
             break;
 #endif
 #if FW_HAS_32_BIT
         case TYPE_U32:
-            stat = buffer.serialize(this->m_val.u32Val);
+            stat = buffer.serializeFrom(this->m_val.u32Val);
             break;
         case TYPE_I32:
-            stat = buffer.serialize(this->m_val.i32Val);
+            stat = buffer.serializeFrom(this->m_val.i32Val);
             break;
 #endif
 #if FW_HAS_64_BIT
         case TYPE_U64:
-            stat = buffer.serialize(this->m_val.u64Val);
+            stat = buffer.serializeFrom(this->m_val.u64Val);
             break;
         case TYPE_I64:
-            stat = buffer.serialize(this->m_val.i64Val);
+            stat = buffer.serializeFrom(this->m_val.i64Val);
             break;
 #endif
         case TYPE_F64:
-            stat = buffer.serialize(this->m_val.f64Val);
+            stat = buffer.serializeFrom(this->m_val.f64Val);
             break;
         case TYPE_F32:
-            stat = buffer.serialize(this->m_val.f32Val);
+            stat = buffer.serializeFrom(this->m_val.f32Val);
             break;
         case TYPE_BOOL:
-            stat = buffer.serialize(this->m_val.boolVal);
+            stat = buffer.serializeFrom(this->m_val.boolVal);
             break;
         case TYPE_PTR:
-            stat = buffer.serialize(this->m_val.ptrVal);
+            stat = buffer.serializeFrom(this->m_val.ptrVal);
             break;
         default:
             stat = FW_SERIALIZE_FORMAT_ERROR;
@@ -539,15 +539,10 @@ SerializeStatus PolyType::serializeTo(SerializeBufferBase& buffer) const {
     return stat;
 }
 
-SerializeStatus PolyType::serialize(SerializeBufferBase& buffer) const {
-    // Deprecated method - calls new interface for backward compatibility
-    return this->serializeTo(buffer);
-}
-
 SerializeStatus PolyType::deserializeFrom(SerializeBufferBase& buffer) {
     // get type
     FwEnumStoreType des;
-    SerializeStatus stat = buffer.deserialize(des);
+    SerializeStatus stat = buffer.deserializeTo(des);
 
     if (stat != FW_SERIALIZE_OK) {
         return stat;
@@ -556,46 +551,41 @@ SerializeStatus PolyType::deserializeFrom(SerializeBufferBase& buffer) {
         // switch on type
         switch (this->m_dataType) {
             case TYPE_U8:
-                return buffer.deserialize(this->m_val.u8Val);
+                return buffer.deserializeTo(this->m_val.u8Val);
             case TYPE_I8:
-                return buffer.deserialize(this->m_val.i8Val);
+                return buffer.deserializeTo(this->m_val.i8Val);
 #if FW_HAS_16_BIT
             case TYPE_U16:
-                return buffer.deserialize(this->m_val.u16Val);
+                return buffer.deserializeTo(this->m_val.u16Val);
             case TYPE_I16:
-                return buffer.deserialize(this->m_val.i16Val);
+                return buffer.deserializeTo(this->m_val.i16Val);
 #endif
 #if FW_HAS_32_BIT
             case TYPE_U32:
-                return buffer.deserialize(this->m_val.u32Val);
+                return buffer.deserializeTo(this->m_val.u32Val);
             case TYPE_I32:
-                return buffer.deserialize(this->m_val.i32Val);
+                return buffer.deserializeTo(this->m_val.i32Val);
 #endif
 #if FW_HAS_64_BIT
             case TYPE_U64:
-                return buffer.deserialize(this->m_val.u64Val);
+                return buffer.deserializeTo(this->m_val.u64Val);
             case TYPE_I64:
-                return buffer.deserialize(this->m_val.i64Val);
+                return buffer.deserializeTo(this->m_val.i64Val);
 #endif
             case TYPE_F64:
-                return buffer.deserialize(this->m_val.f64Val);
+                return buffer.deserializeTo(this->m_val.f64Val);
             case TYPE_F32:
-                return buffer.deserialize(this->m_val.f32Val);
+                return buffer.deserializeTo(this->m_val.f32Val);
             case TYPE_BOOL:
-                return buffer.deserialize(this->m_val.boolVal);
+                return buffer.deserializeTo(this->m_val.boolVal);
             case TYPE_PTR:
-                return buffer.deserialize(this->m_val.ptrVal);
+                return buffer.deserializeTo(this->m_val.ptrVal);
             default:
                 return FW_DESERIALIZE_FORMAT_ERROR;
         }
     }
 }
 
-SerializeStatus PolyType::deserialize(SerializeBufferBase& buffer) {
-    // Deprecated method - calls new interface for backward compatibility
-    return this->deserializeFrom(buffer);
-}
-
 #if FW_SERIALIZABLE_TO_STRING || BUILD_UT
 
 void PolyType::toString(StringBase& dest) const {
diff --git a/Fw/Types/PolyType.hpp b/Fw/Types/PolyType.hpp
index 29e001ecba3..075eff11aaf 100644
--- a/Fw/Types/PolyType.hpp
+++ b/Fw/Types/PolyType.hpp
@@ -103,14 +103,9 @@ class PolyType : public Serializable {
     bool operator==(const PolyType& other) const;  //!< PolyType operator==
     bool operator!=(const PolyType& other) const;  //!< PolyType operator!=
 
-    // New serialization interface
     SerializeStatus serializeTo(SerializeBufferBase& buffer) const override;  //!< Serialize function
     SerializeStatus deserializeFrom(SerializeBufferBase& buffer) override;    //!< Deserialize function
 
-    // Deprecated methods for backward compatibility - these call the new interface
-    SerializeStatus serialize(SerializeBufferBase& buffer) const override;  //!< Serialize function (deprecated)
-    SerializeStatus deserialize(SerializeBufferBase& buffer) override;      //!< Deserialize function (deprecated)
-
   private:
     typedef enum {
         TYPE_NOTYPE,  // !< No type stored yet
diff --git a/Fw/Types/Serializable.cpp b/Fw/Types/Serializable.cpp
index fba7c89e497..b0bf5491fd9 100644
--- a/Fw/Types/Serializable.cpp
+++ b/Fw/Types/Serializable.cpp
@@ -17,23 +17,6 @@ Serializable::Serializable() {}
 
 Serializable::~Serializable() {}
 
-// ----------------------------------------------------------------------
-// Default implementations for new serialization methods
-//
-// These are provided for backward compatibility specifically for autocoding that
-// does not yet support the new serialization methods.
-// ----------------------------------------------------------------------
-
-SerializeStatus Serializable::serializeTo(SerializeBufferBase& buffer) const {
-    // Default implementation for base class - derived classes should override this method
-    return FW_SERIALIZE_UNIMPLEMENTED;
-}
-
-SerializeStatus Serializable::deserializeFrom(SerializeBufferBase& buffer) {
-    // Default implementation for base class - derived classes should override this method
-    return FW_DESERIALIZE_UNIMPLEMENTED;
-}
-
 // ----------------------------------------------------------------------
 #if FW_SERIALIZABLE_TO_STRING || FW_ENABLE_TEXT_LOGGING || BUILD_UT
 
@@ -267,16 +250,7 @@ SerializeStatus SerializeBufferBase::serializeFrom(const U8* buff, FwSizeType le
 }
 
 SerializeStatus SerializeBufferBase::serializeFrom(const Serializable& val) {
-    // Smart fallback approach for backward compatibility:
-    // Try new interface first, but if it returns UNIMPLEMENTED (indicating default implementation),
-    // fall back to old interface. This bridges auto-generated enums (old interface only)
-    // with new serialization infrastructure.
-    SerializeStatus status = val.serializeTo(*this);
-    if (status == FW_SERIALIZE_UNIMPLEMENTED) {
-        // Fallback to old interface for backward compatibility
-        status = val.serialize(*this);
-    }
-    return status;
+    return val.serializeTo(*this);
 }
 
 SerializeStatus SerializeBufferBase::serializeFrom(const SerializeBufferBase& val) {
@@ -560,15 +534,7 @@ SerializeStatus SerializeBufferBase::deserializeTo(U8* buff, Serializable::SizeT
 }
 
 SerializeStatus SerializeBufferBase::deserializeTo(Serializable& val) {
-    // Try new interface first, but if it returns UNIMPLEMENTED (indicating default implementation),
-    // fall back to old interface. This bridges auto-generated enums (old interface only)
-    // with new serialization infrastructure.
-    SerializeStatus status = val.deserializeFrom(*this);
-    if (status == FW_DESERIALIZE_UNIMPLEMENTED) {
-        // Fallback to old interface for backward compatibility
-        status = val.deserialize(*this);
-    }
-    return status;
+    return val.deserializeFrom(*this);
 }
 
 SerializeStatus SerializeBufferBase::deserializeTo(SerializeBufferBase& val) {
@@ -717,7 +683,8 @@ SerializeStatus SerializeBufferBase::copyRawOffset(SerializeBufferBase& dest, Se
     }
 
     // otherwise, serialize bytes to destination without writing length
-    SerializeStatus stat = dest.serialize(&this->getBuffAddr()[this->m_deserLoc], size, Fw::Serialization::OMIT_LENGTH);
+    SerializeStatus stat =
+        dest.serializeFrom(&this->getBuffAddr()[this->m_deserLoc], size, Fw::Serialization::OMIT_LENGTH);
     if (stat == FW_SERIALIZE_OK) {
         this->m_deserLoc += size;
     }
@@ -807,14 +774,6 @@ const U8* ExternalSerializeBuffer::getBuffAddr() const {
 // Deprecated method implementations for backward compatibility
 // ----------------------------------------------------------------------
 
-SerializeStatus Serializable::serialize(SerializeBufferBase& buffer) const {
-    return this->serializeTo(buffer);
-}
-
-SerializeStatus Serializable::deserialize(SerializeBufferBase& buffer) {
-    return this->deserializeFrom(buffer);
-}
-
 SerializeStatus SerializeBufferBase::serialize(U8 val) {
     return this->serializeFrom(val);
 }
diff --git a/Fw/Types/Serializable.hpp b/Fw/Types/Serializable.hpp
index 0c6f18ea2c6..19c4507fd4f 100644
--- a/Fw/Types/Serializable.hpp
+++ b/Fw/Types/Serializable.hpp
@@ -18,9 +18,7 @@ typedef enum {
     FW_DESERIALIZE_BUFFER_EMPTY,   //!< Deserialization buffer was empty when trying to read more data
     FW_DESERIALIZE_FORMAT_ERROR,   //!< Deserialization data had incorrect values (unexpected data types)
     FW_DESERIALIZE_SIZE_MISMATCH,  //!< Data was left in the buffer, but not enough to deserialize
-    FW_DESERIALIZE_TYPE_MISMATCH,  //!< Deserialized type ID didn't match
-    FW_SERIALIZE_UNIMPLEMENTED,    //!< Serialization function called is not implemented
-    FW_DESERIALIZE_UNIMPLEMENTED,  //!< Deserialization function called is not implemented
+    FW_DESERIALIZE_TYPE_MISMATCH   //!< Deserialized type ID didn't match
 } SerializeStatus;
 class SerializeBufferBase;  //!< forward declaration
 
@@ -30,17 +28,18 @@ class Serializable {
     using SizeType = FwSizeType;
 
   public:
-    virtual SerializeStatus serializeTo(SerializeBufferBase& buffer) const;  //!< serialize contents to buffer
+    virtual SerializeStatus serializeTo(SerializeBufferBase& buffer) const = 0;  //!< serialize contents to buffer
 
-    virtual SerializeStatus deserializeFrom(SerializeBufferBase& buffer);  //!< deserialize contents from buffer
+    virtual SerializeStatus deserializeFrom(SerializeBufferBase& buffer) = 0;  //!< deserialize contents from buffer
 
     // ----------------------------------------------------------------------
-    // Methods
+    // Legacy methods for backward compatibility
     // ----------------------------------------------------------------------
 
-    virtual SerializeStatus serialize(SerializeBufferBase& buffer) const;
+    SerializeStatus serialize(SerializeBufferBase& buffer) const { return this->serializeTo(buffer); }
+
+    SerializeStatus deserialize(SerializeBufferBase& buffer) { return this->deserializeFrom(buffer); }
 
-    virtual SerializeStatus deserialize(SerializeBufferBase& buffer);
 #if FW_SERIALIZABLE_TO_STRING || FW_ENABLE_TEXT_LOGGING || BUILD_UT
     virtual void toString(StringBase& text) const;  //!< generate text from serializable
 #endif
diff --git a/Fw/Types/StringBase.cpp b/Fw/Types/StringBase.cpp
index ded0234a15f..7cdffc0327c 100644
--- a/Fw/Types/StringBase.cpp
+++ b/Fw/Types/StringBase.cpp
@@ -139,10 +139,6 @@ StringBase::SizeType StringBase::serializedTruncatedSize(FwSizeType maxLength) c
     return static_cast<SizeType>(sizeof(FwSizeStoreType)) + static_cast<SizeType>(FW_MIN(this->length(), maxLength));
 }
 
-SerializeStatus StringBase::serialize(SerializeBufferBase& buffer) const {
-    return buffer.serializeFrom(reinterpret_cast<const U8*>(this->toChar()), this->length());
-}
-
 SerializeStatus StringBase::serializeTo(SerializeBufferBase& buffer) const {
     return buffer.serializeFrom(reinterpret_cast<const U8*>(this->toChar()), this->length());
 }
@@ -153,12 +149,14 @@ SerializeStatus StringBase::serializeTo(SerializeBufferBase& buffer, SizeType ma
     return buffer.serializeFrom(reinterpret_cast<const U8*>(this->toChar()), len, Serialization::INCLUDE_LENGTH);
 }
 
-SerializeStatus StringBase::serialize(SerializeBufferBase& buffer, SizeType maxLength) const {
-    return this->serializeTo(buffer, maxLength);
+// Deprecated method for backward compatibility
+SerializeStatus StringBase::serialize(SerializeBufferBase& buffer) const {
+    return this->serializeTo(buffer);
 }
 
-SerializeStatus StringBase::deserialize(SerializeBufferBase& buffer) {
-    return this->deserializeFrom(buffer);
+// Deprecated method for backward compatibility
+SerializeStatus StringBase::serialize(SerializeBufferBase& buffer, SizeType maxLength) const {
+    return this->serializeTo(buffer, maxLength);
 }
 
 SerializeStatus StringBase::deserializeFrom(SerializeBufferBase& buffer) {
diff --git a/Fw/Types/StringBase.hpp b/Fw/Types/StringBase.hpp
index 2b9d4c9f241..6a92a0f53d7 100644
--- a/Fw/Types/StringBase.hpp
+++ b/Fw/Types/StringBase.hpp
@@ -67,12 +67,11 @@ class StringBase : public Serializable {
     FormatStatus vformat(const CHAR* formatString, va_list args);  //!< write formatted string to buffer using va_list
 
     SerializeStatus serializeTo(SerializeBufferBase& buffer) const override;
-    SerializeStatus serializeTo(SerializeBufferBase& buffer, SizeType maxLen) const;
+    virtual SerializeStatus serializeTo(SerializeBufferBase& buffer, SizeType maxLen) const;
     SerializeStatus deserializeFrom(SerializeBufferBase& buffer) override;
 
-    SerializeStatus serialize(SerializeBufferBase& buffer) const override;
-    SerializeStatus serialize(SerializeBufferBase& buffer, SizeType maxLen) const;
-    SerializeStatus deserialize(SerializeBufferBase& buffer) override;
+    SerializeStatus serialize(SerializeBufferBase& buffer) const;
+    virtual SerializeStatus serialize(SerializeBufferBase& buffer, SizeType maxLen) const;
 
 #ifdef BUILD_UT
     // to support GoogleTest framework in unit tests
diff --git a/Fw/Types/test/ut/TypesTest.cpp b/Fw/Types/test/ut/TypesTest.cpp
index b8642c8e1d7..b2912efedcf 100644
--- a/Fw/Types/test/ut/TypesTest.cpp
+++ b/Fw/Types/test/ut/TypesTest.cpp
@@ -625,7 +625,7 @@ struct TestStruct {
 
 class MySerializable : public Fw::Serializable {
   public:
-    Fw::SerializeStatus serialize(Fw::SerializeBufferBase& buffer) const {
+    Fw::SerializeStatus serializeTo(Fw::SerializeBufferBase& buffer) const override {
         buffer.serialize(m_testStruct.m_u32);
         buffer.serialize(m_testStruct.m_u16);
         buffer.serialize(m_testStruct.m_u8);
@@ -634,7 +634,7 @@ class MySerializable : public Fw::Serializable {
         return Fw::FW_SERIALIZE_OK;
     }
 
-    Fw::SerializeStatus deserialize(Fw::SerializeBufferBase& buffer) {
+    Fw::SerializeStatus deserializeFrom(Fw::SerializeBufferBase& buffer) override {
         buffer.serialize(m_testStruct.m_buff, sizeof(m_testStruct.m_buff));
         buffer.serialize(m_testStruct.m_f32);
         buffer.serialize(m_testStruct.m_u8);
@@ -658,8 +658,8 @@ TEST(PerformanceTest, SerPerfTest) {
 
     I32 iterations = 1000000;
     for (I32 iter = 0; iter < iterations; iter++) {
-        in.serialize(buff);
-        out.deserialize(buff);
+        in.serializeTo(buff);
+        out.deserializeFrom(buff);
     }
 
     timer.stop();
diff --git a/Os/Posix/RawTime.cpp b/Os/Posix/RawTime.cpp
index e079bcee8f0..d863abd3169 100644
--- a/Os/Posix/RawTime.cpp
+++ b/Os/Posix/RawTime.cpp
@@ -75,14 +75,6 @@ RawTimeHandle* PosixRawTime::getHandle() {
     return &this->m_handle;
 }
 
-Fw::SerializeStatus PosixRawTime::serialize(Fw::SerializeBufferBase& buffer) const {
-    return this->serializeTo(buffer);
-}
-
-Fw::SerializeStatus PosixRawTime::deserialize(Fw::SerializeBufferBase& buffer) {
-    return this->deserializeFrom(buffer);
-}
-
 }  // namespace RawTime
 }  // namespace Posix
 }  // namespace Os
diff --git a/Os/Posix/RawTime.hpp b/Os/Posix/RawTime.hpp
index fa512395855..02aef28eb5b 100644
--- a/Os/Posix/RawTime.hpp
+++ b/Os/Posix/RawTime.hpp
@@ -81,14 +81,6 @@ class PosixRawTime : public RawTimeInterface {
     //! \return Fw::SerializeStatus indicating the result of the deserialization.
     Fw::SerializeStatus deserializeFrom(Fw::SerializeBufferBase& buffer) override;
 
-    // ----------------------------------------------------------------------
-    // Methods
-    // ----------------------------------------------------------------------
-
-    Fw::SerializeStatus serialize(Fw::SerializeBufferBase& buffer) const override;
-
-    Fw::SerializeStatus deserialize(Fw::SerializeBufferBase& buffer) override;
-
   private:
     //! Handle for PosixRawTime
     PosixRawTimeHandle m_handle;
diff --git a/Os/RawTime.cpp b/Os/RawTime.cpp
index f53a096b050..62a37b8dc67 100644
--- a/Os/RawTime.cpp
+++ b/Os/RawTime.cpp
@@ -77,14 +77,6 @@ RawTime::Status RawTime::getDiffUsec(const RawTime& other, U32& result) const {
     return status;
 }
 
-Fw::SerializeStatus RawTime::serialize(Fw::SerializeBufferBase& buffer) const {
-    return this->serializeTo(buffer);
-}
-
-Fw::SerializeStatus RawTime::deserialize(Fw::SerializeBufferBase& buffer) {
-    return this->deserializeFrom(buffer);
-}
-
 bool RawTime::operator==(const RawTime& other) const {
     Fw::TimeInterval interval;
     Status status = this->getTimeInterval(other, interval);
diff --git a/Os/RawTime.hpp b/Os/RawTime.hpp
index f508d5d870f..d2da52c69fa 100644
--- a/Os/RawTime.hpp
+++ b/Os/RawTime.hpp
@@ -77,7 +77,7 @@ class RawTimeInterface : public Fw::Serializable {
     //!
     //! \param buffer The buffer to serialize the contents into.
     //! \return Fw::SerializeStatus indicating the result of the serialization.
-    virtual Fw::SerializeStatus serializeTo(Fw::SerializeBufferBase& buffer) const { return this->serialize(buffer); }
+    virtual Fw::SerializeStatus serializeTo(Fw::SerializeBufferBase& buffer) const = 0;
 
     //! \brief Deserialize the contents of the RawTimeInterface object from a buffer.
     //!
@@ -91,7 +91,7 @@ class RawTimeInterface : public Fw::Serializable {
     //!
     //! \param buffer The buffer to deserialize the contents from.
     //! \return Fw::SerializeStatus indicating the result of the deserialization.
-    virtual Fw::SerializeStatus deserializeFrom(Fw::SerializeBufferBase& buffer) { return this->deserialize(buffer); }
+    virtual Fw::SerializeStatus deserializeFrom(Fw::SerializeBufferBase& buffer) = 0;
 };
 
 class RawTime final : public RawTimeInterface {
@@ -159,14 +159,6 @@ class RawTime final : public RawTimeInterface {
     //! \return Fw::SerializeStatus indicating the result of the deserialization.
     Fw::SerializeStatus deserializeFrom(Fw::SerializeBufferBase& buffer) override;
 
-    // ----------------------------------------------------------------------
-    // Methods
-    // ----------------------------------------------------------------------
-
-    Fw::SerializeStatus serialize(Fw::SerializeBufferBase& buffer) const override;
-
-    Fw::SerializeStatus deserialize(Fw::SerializeBufferBase& buffer) override;
-
     // ------------------------------------------------------------
     // Common functions built on top of OS-specific functions
     // ------------------------------------------------------------
diff --git a/Os/Stub/RawTime.cpp b/Os/Stub/RawTime.cpp
index f4971cd39b7..957269be8c3 100644
--- a/Os/Stub/RawTime.cpp
+++ b/Os/Stub/RawTime.cpp
@@ -29,14 +29,6 @@ Fw::SerializeStatus StubRawTime::deserializeFrom(Fw::SerializeBufferBase& buffer
     return Fw::FW_SERIALIZE_OK;
 }
 
-Fw::SerializeStatus StubRawTime::serialize(Fw::SerializeBufferBase& buffer) const {
-    return this->serializeTo(buffer);
-}
-
-Fw::SerializeStatus StubRawTime::deserialize(Fw::SerializeBufferBase& buffer) {
-    return this->deserializeFrom(buffer);
-}
-
 }  // namespace RawTime
 }  // namespace Stub
 }  // namespace Os
diff --git a/Os/Stub/RawTime.hpp b/Os/Stub/RawTime.hpp
index 837159b8cbc..8813c195eee 100644
--- a/Os/Stub/RawTime.hpp
+++ b/Os/Stub/RawTime.hpp
@@ -80,14 +80,6 @@ class StubRawTime : public RawTimeInterface {
     //! \return Fw::SerializeStatus indicating the result of the deserialization.
     Fw::SerializeStatus deserializeFrom(Fw::SerializeBufferBase& buffer) override;
 
-    // ----------------------------------------------------------------------
-    // Methods
-    // ----------------------------------------------------------------------
-
-    Fw::SerializeStatus serialize(Fw::SerializeBufferBase& buffer) const override;
-
-    Fw::SerializeStatus deserialize(Fw::SerializeBufferBase& buffer) override;
-
   private:
     //! Handle for StubRawTime
     StubRawTimeHandle m_handle;
diff --git a/Os/Stub/test/RawTime.hpp b/Os/Stub/test/RawTime.hpp
index 0e7cf3470da..96c699c2874 100644
--- a/Os/Stub/test/RawTime.hpp
+++ b/Os/Stub/test/RawTime.hpp
@@ -70,10 +70,6 @@ class TestRawTime : public RawTimeInterface {
     Fw::SerializeStatus serializeTo(Fw::SerializeBufferBase& buffer) const override;
     Fw::SerializeStatus deserializeFrom(Fw::SerializeBufferBase& buffer) override;
 
-    // Backward-compatibility wrappers
-    Fw::SerializeStatus serialize(Fw::SerializeBufferBase& buffer) const override { return this->serializeTo(buffer); }
-    Fw::SerializeStatus deserialize(Fw::SerializeBufferBase& buffer) override { return this->deserializeFrom(buffer); }
-
   private:
     //! Handle for TestRawTime
     TestRawTimeHandle m_handle;
diff --git a/Os/Stub/test/ut/StubRawTimeTests.cpp b/Os/Stub/test/ut/StubRawTimeTests.cpp
index d0ab0cf9031..a7c7a3440a4 100644
--- a/Os/Stub/test/ut/StubRawTimeTests.cpp
+++ b/Os/Stub/test/ut/StubRawTimeTests.cpp
@@ -57,7 +57,7 @@ TEST_F(Interface, GetTimeInterval) {
 }
 
 // Ensure that Os::RawTime properly calls the following delegate function
-TEST_F(Interface, SerializeTo) {
+TEST_F(Interface, Serialize) {
     Os::RawTime rawtime;
     Fw::Buffer buffer;
     auto esb = buffer.getSerializer();
@@ -66,7 +66,7 @@ TEST_F(Interface, SerializeTo) {
 }
 
 // Ensure that Os::RawTime properly calls the following delegate function
-TEST_F(Interface, DeserializeFrom) {
+TEST_F(Interface, Deserialize) {
     Os::RawTime rawtime;
     Fw::Buffer buffer;
     auto esb = buffer.getDeserializer();
diff --git a/Svc/OsTime/test/RawTimeTester/RawTimeTester.hpp b/Svc/OsTime/test/RawTimeTester/RawTimeTester.hpp
index 6d15c7dca18..5ba37499e91 100644
--- a/Svc/OsTime/test/RawTimeTester/RawTimeTester.hpp
+++ b/Svc/OsTime/test/RawTimeTester/RawTimeTester.hpp
@@ -56,10 +56,6 @@ class RawTimeTester : public Os::RawTimeInterface {
         return buffer.deserializeTo(m_handle.t);
     }
 
-    Fw::SerializeStatus serialize(Fw::SerializeBufferBase& buffer) const override { return this->serializeTo(buffer); }
-
-    Fw::SerializeStatus deserialize(Fw::SerializeBufferBase& buffer) override { return this->deserializeFrom(buffer); }
-
     static void setNowTime(const Fw::Time&& t) { s_now_time = t; }
 
   private: