diff --git a/vpd-manager/include/listener.hpp b/vpd-manager/include/listener.hpp
index bd516cf..830a287 100644
--- a/vpd-manager/include/listener.hpp
+++ b/vpd-manager/include/listener.hpp
@@ -141,7 +141,11 @@
         const std::string& i_interface, const std::string& i_property) const;
 
     /**
-     * @brief API to update a given correlated property.
+     * @brief API to update a given correlated property
+     *
+     * This API updates a given correlated property on Dbus. For updates to
+     * properties on Phosphor Inventory Manager it uses Phosphor Inventory
+     * Manager's "Notify" API to update the given property.
      *
      * @param[in] i_serviceName - Service name.
      * @param[in] i_corrProperty - Details of correlated property to update
diff --git a/vpd-manager/include/utility/common_utility.hpp b/vpd-manager/include/utility/common_utility.hpp
index 79c54c8..b5ff13c 100644
--- a/vpd-manager/include/utility/common_utility.hpp
+++ b/vpd-manager/include/utility/common_utility.hpp
@@ -137,5 +137,103 @@
 
     return l_oss.str();
 }
+
+/**
+ * @brief An API to convert binary value into ascii/hex representation.
+ *
+ * If given data contains printable characters, ASCII formated string value of
+ * the input data will be returned. Otherwise if the data has any non-printable
+ * value, returns the hex represented value of the given data in string format.
+ *
+ * @param[in] i_keywordValue - Data in binary format.
+ *
+ * @throw - Throws std::bad_alloc or std::terminate in case of error.
+ *
+ * @return - Returns the converted string value.
+ */
+inline std::string getPrintableValue(const types::BinaryVector& i_keywordValue)
+{
+    bool l_allPrintable =
+        std::all_of(i_keywordValue.begin(), i_keywordValue.end(),
+                    [](const auto& l_byte) { return std::isprint(l_byte); });
+
+    std::ostringstream l_oss;
+    if (l_allPrintable)
+    {
+        l_oss << std::string(i_keywordValue.begin(), i_keywordValue.end());
+    }
+    else
+    {
+        l_oss << "0x";
+        for (const auto& l_byte : i_keywordValue)
+        {
+            l_oss << std::setfill('0') << std::setw(2) << std::hex
+                  << static_cast<int>(l_byte);
+        }
+    }
+
+    return l_oss.str();
+}
+
+/**
+ * @brief API to get data in binary format.
+ *
+ * This API converts given string value present in hexadecimal or decimal format
+ * into array of binary data.
+ *
+ * @param[in] i_value - Input data.
+ *
+ * @return - Array of binary data on success, throws as exception in case
+ * of any error.
+ *
+ * @throw std::runtime_error, std::out_of_range, std::bad_alloc,
+ * std::invalid_argument
+ */
+inline types::BinaryVector convertToBinary(const std::string& i_value)
+{
+    if (i_value.empty())
+    {
+        throw std::runtime_error("Empty input provided");
+    }
+
+    types::BinaryVector l_binaryValue{};
+
+    if (i_value.substr(0, 2).compare("0x") == constants::STR_CMP_SUCCESS)
+    {
+        if (i_value.length() % 2 != 0)
+        {
+            throw std::runtime_error(
+                "Write option accepts 2 digit hex numbers. (Ex. 0x1 "
+                "should be given as 0x01).");
+        }
+
+        auto l_value = i_value.substr(2);
+
+        if (l_value.empty())
+        {
+            throw std::runtime_error(
+                "Provide a valid hexadecimal input. (Ex. 0x30313233)");
+        }
+
+        if (l_value.find_first_not_of("0123456789abcdefABCDEF") !=
+            std::string::npos)
+        {
+            throw std::runtime_error("Provide a valid hexadecimal input.");
+        }
+
+        for (size_t l_pos = 0; l_pos < l_value.length(); l_pos += 2)
+        {
+            uint8_t l_byte = static_cast<uint8_t>(
+                std::stoi(l_value.substr(l_pos, 2), nullptr, 16));
+            l_binaryValue.push_back(l_byte);
+        }
+    }
+    else
+    {
+        l_binaryValue.assign(i_value.begin(), i_value.end());
+    }
+    return l_binaryValue;
+}
+
 } // namespace commonUtility
 } // namespace vpd
diff --git a/vpd-manager/src/listener.cpp b/vpd-manager/src/listener.cpp
index 534112b..6470a41 100644
--- a/vpd-manager/src/listener.cpp
+++ b/vpd-manager/src/listener.cpp
@@ -4,6 +4,7 @@
 #include "event_logger.hpp"
 #include "exceptions.hpp"
 #include "logger.hpp"
+#include "utility/common_utility.hpp"
 #include "utility/dbus_utility.hpp"
 #include "utility/json_utility.hpp"
 
@@ -471,16 +472,73 @@
 }
 
 bool Listener::updateCorrelatedProperty(
-    [[maybe_unused]] const std::string& i_serviceName,
-    [[maybe_unused]] const types::DbusPropertyEntry& i_corrProperty,
-    [[maybe_unused]] const types::DbusVariantType& i_value) const noexcept
+    const std::string& i_serviceName,
+    const types::DbusPropertyEntry& i_corrProperty,
+    const types::DbusVariantType& i_propertyValue) const noexcept
 {
-    /* TODO:
-        1. Check destination interface type
-        2. Convert value to required type
-        3. Read current property value on Dbus, and if needed update it.
-    */
-    return true;
+    const auto& l_destinationObjectPath{std::get<0>(i_corrProperty)};
+    const auto& l_destinationInterface{std::get<1>(i_corrProperty)};
+    const auto& l_destinationPropertyName{std::get<2>(i_corrProperty)};
+
+    try
+    {
+        types::DbusVariantType l_valueToUpdate;
+
+        // destination interface is ipz vpd
+        if (l_destinationInterface.find(constants::ipzVpdInf) !=
+            std::string::npos)
+        {
+            if (const auto l_val = std::get_if<std::string>(&i_propertyValue))
+            {
+                // convert value to binary vector before updating
+                l_valueToUpdate = commonUtility::convertToBinary(*l_val);
+            }
+            else if (const auto l_val =
+                         std::get_if<types::BinaryVector>(&i_propertyValue))
+            {
+                l_valueToUpdate = *l_val;
+            }
+        }
+        else
+        {
+            // destination interface is not ipz vpd, assume target
+            // property type is of string type
+            if (const auto l_val =
+                    std::get_if<types::BinaryVector>(&i_propertyValue))
+            {
+                // convert property value to string before updating
+
+                l_valueToUpdate = commonUtility::getPrintableValue(*l_val);
+            }
+            else if (const auto l_val =
+                         std::get_if<std::string>(&i_propertyValue))
+            {
+                l_valueToUpdate = *l_val;
+            }
+        }
+
+        if (i_serviceName == constants::pimServiceName)
+        {
+            return dbusUtility::callPIM(types::ObjectMap{
+                {l_destinationObjectPath,
+                 {{l_destinationInterface,
+                   {{l_destinationPropertyName, l_valueToUpdate}}}}}});
+        }
+        else
+        {
+            return dbusUtility::writeDbusProperty(
+                i_serviceName, l_destinationObjectPath, l_destinationInterface,
+                l_destinationPropertyName, l_valueToUpdate);
+        }
+    }
+    catch (const std::exception& l_ex)
+    {
+        logging::logMessage(
+            "Failed to update correlated property: " + i_serviceName + " : " +
+            l_destinationObjectPath + " : " + l_destinationInterface + " : " +
+            l_destinationPropertyName + ". Error: " + std::string(l_ex.what()));
+    }
+    return false;
 }
 
 } // namespace vpd