diff --git a/extensions/openpower-pels/section.hpp b/extensions/openpower-pels/section.hpp
index 96a1aad..183268c 100644
--- a/extensions/openpower-pels/section.hpp
+++ b/extensions/openpower-pels/section.hpp
@@ -71,6 +71,25 @@
         return std::nullopt;
     }
 
+    /**
+     * @brief Shrinks a PEL section
+     *
+     * If this is even possible for a section depends on which section
+     * it is.  If a section cannot be shrunk, it doesn't need to implement
+     * shrink so it will just return false, meaning no shrinking was done.
+     *
+     * If a section can be shrunk, this function will be overridden in that
+     * class.
+     *
+     * @param[in] newSize - The new size, in bytes, to shrink to
+     *
+     * @return bool - true if successful, false else
+     */
+    virtual bool shrink(size_t newSize)
+    {
+        return false;
+    }
+
   protected:
     /**
      * @brief Returns the flattened size of the section header
diff --git a/extensions/openpower-pels/user_data.cpp b/extensions/openpower-pels/user_data.cpp
index 70acbbb..0ae227b 100644
--- a/extensions/openpower-pels/user_data.cpp
+++ b/extensions/openpower-pels/user_data.cpp
@@ -104,5 +104,22 @@
     return std::nullopt;
 }
 
+bool UserData::shrink(size_t newSize)
+{
+    // minimum size is 4 bytes plus the 8B header
+    if ((newSize < flattenedSize()) &&
+        (newSize >= (Section::flattenedSize() + 4)))
+    {
+        auto dataSize = newSize - Section::flattenedSize();
+
+        // Ensure it's 4B aligned
+        _data.resize((dataSize / 4) * 4);
+        _header.size = Section::flattenedSize() + _data.size();
+        return true;
+    }
+
+    return false;
+}
+
 } // namespace pels
 } // namespace openpower
diff --git a/extensions/openpower-pels/user_data.hpp b/extensions/openpower-pels/user_data.hpp
index 3594849..b1c9084 100644
--- a/extensions/openpower-pels/user_data.hpp
+++ b/extensions/openpower-pels/user_data.hpp
@@ -88,6 +88,19 @@
      */
     std::optional<std::string> getJSON() const override;
 
+    /**
+     * @brief Shrink the section
+     *
+     * The new size must be between the current size and the minimum
+     * size, which is 12 bytes.  If it isn't a 4 byte aligned value
+     * the code will do the aligning before the resize takes place.
+     *
+     * @param[in] newSize - The new size in bytes
+     *
+     * @return bool - true if successful, false else.
+     */
+    bool shrink(size_t newSize) override;
+
   private:
     /**
      * @brief Fills in the object from the stream data
diff --git a/test/openpower-pels/user_data_test.cpp b/test/openpower-pels/user_data_test.cpp
index a957a4d..863d36a 100644
--- a/test/openpower-pels/user_data_test.cpp
+++ b/test/openpower-pels/user_data_test.cpp
@@ -99,8 +99,47 @@
     EXPECT_EQ(ud.header().version, 0x01);
     EXPECT_EQ(ud.header().subType, 0x42);
     EXPECT_EQ(ud.header().componentID, 0x1112);
+    EXPECT_EQ(ud.flattenedSize(), 16);
 
     const auto& d = ud.data();
 
     EXPECT_EQ(d, data);
 }
+
+TEST(UserDataTest, ShrinkTest)
+{
+    std::vector<uint8_t> data(100, 0xFF);
+
+    UserData ud(0x1112, 0x42, 0x01, data);
+    EXPECT_TRUE(ud.valid());
+
+    // 4B aligned
+    EXPECT_TRUE(ud.shrink(88));
+    EXPECT_EQ(ud.flattenedSize(), 88);
+    EXPECT_EQ(ud.header().size, 88);
+
+    // rounded off
+    EXPECT_TRUE(ud.shrink(87));
+    EXPECT_EQ(ud.flattenedSize(), 84);
+    EXPECT_EQ(ud.header().size, 84);
+
+    // too big
+    EXPECT_FALSE(ud.shrink(200));
+    EXPECT_EQ(ud.flattenedSize(), 84);
+    EXPECT_EQ(ud.header().size, 84);
+
+    // way too small
+    EXPECT_FALSE(ud.shrink(3));
+    EXPECT_EQ(ud.flattenedSize(), 84);
+    EXPECT_EQ(ud.header().size, 84);
+
+    // the smallest it can go
+    EXPECT_TRUE(ud.shrink(12));
+    EXPECT_EQ(ud.flattenedSize(), 12);
+    EXPECT_EQ(ud.header().size, 12);
+
+    // one too small
+    EXPECT_FALSE(ud.shrink(11));
+    EXPECT_EQ(ud.flattenedSize(), 12);
+    EXPECT_EQ(ud.header().size, 12);
+}