diff --git a/ibm_vpd_utils.cpp b/ibm_vpd_utils.cpp
index 4eb99cb..c7babf6 100644
--- a/ibm_vpd_utils.cpp
+++ b/ibm_vpd_utils.cpp
@@ -886,5 +886,28 @@
         map.emplace(interface, property);
     }
 }
+
+BIOSAttrValueType readBIOSAttribute(const std::string& attrName)
+{
+    std::tuple<std::string, BIOSAttrValueType, BIOSAttrValueType> attrVal;
+    auto bus = sdbusplus::bus::new_default();
+    auto method = bus.new_method_call(
+        "xyz.openbmc_project.BIOSConfigManager",
+        "/xyz/openbmc_project/bios_config/manager",
+        "xyz.openbmc_project.BIOSConfig.Manager", "GetAttribute");
+    method.append(attrName);
+    try
+    {
+        auto result = bus.call(method);
+        result.read(std::get<0>(attrVal), std::get<1>(attrVal),
+                    std::get<2>(attrVal));
+    }
+    catch (const sdbusplus::exception::SdBusError& e)
+    {
+        std::cerr << "Failed to read BIOS Attribute: " << attrName << std::endl;
+        std::cerr << e.what() << std::endl;
+    }
+    return std::get<1>(attrVal);
+}
 } // namespace vpd
 } // namespace openpower
diff --git a/ibm_vpd_utils.hpp b/ibm_vpd_utils.hpp
index 47bab17..3a7d13d 100644
--- a/ibm_vpd_utils.hpp
+++ b/ibm_vpd_utils.hpp
@@ -315,5 +315,50 @@
                    const inventory::Interface& interface,
                    inventory::PropertyMap&& property);
 
+/**
+ * @brief Utility API to set a D-Bus property
+ *
+ * This calls org.freedesktop.DBus.Properties;Set method with the supplied
+ * arguments
+ *
+ * @tparam T Template type of the D-Bus property
+ * @param service[in] - The D-Bus service name.
+ * @param object[in] - The D-Bus object on which the property is to be set.
+ * @param interface[in] - The D-Bus interface to which the property belongs.
+ * @param propertyName[in] - The name of the property to set.
+ * @param propertyValue[in] - The value of the property.
+ */
+template <typename T>
+void setBusProperty(const std::string& service, const std::string& object,
+                    const std::string& interface,
+                    const std::string& propertyName,
+                    const std::variant<T>& propertyValue)
+{
+    try
+    {
+        auto bus = sdbusplus::bus::new_default();
+        auto method =
+            bus.new_method_call(service.c_str(), object.c_str(),
+                                "org.freedesktop.DBus.Properties", "Set");
+        method.append(interface);
+        method.append(propertyName);
+        method.append(propertyValue);
+
+        bus.call(method);
+    }
+    catch (const sdbusplus::exception::SdBusError& e)
+    {
+        std::cerr << e.what() << std::endl;
+    }
+}
+
+/**
+ * @brief Reads BIOS Attribute by name.
+ *
+ * @param attrName[in] - The BIOS attribute name.
+ * @return std::variant<int64_t, std::string> - The BIOS attribute value.
+ */
+std::variant<int64_t, std::string>
+    readBIOSAttribute(const std::string& attrName);
 } // namespace vpd
-} // namespace openpower
+} // namespace openpower
\ No newline at end of file
diff --git a/types.hpp b/types.hpp
index f87b53c..99a1127 100644
--- a/types.hpp
+++ b/types.hpp
@@ -17,6 +17,10 @@
 static_assert((8 == CHAR_BIT), "A byte is not 8 bits!");
 using Byte = uint8_t;
 using Binary = std::vector<Byte>;
+using BIOSAttrValueType = std::variant<int64_t, std::string>;
+using PendingBIOSAttrItemType =
+    std::pair<std::string, std::tuple<std::string, BIOSAttrValueType>>;
+using PendingBIOSAttrsType = std::vector<PendingBIOSAttrItemType>;
 
 namespace inventory
 {
diff --git a/vpd-manager/bios_handler.cpp b/vpd-manager/bios_handler.cpp
new file mode 100644
index 0000000..cb251a6
--- /dev/null
+++ b/vpd-manager/bios_handler.cpp
@@ -0,0 +1,338 @@
+#include "config.h"
+
+#include "bios_handler.hpp"
+
+#include "const.hpp"
+#include "ibm_vpd_utils.hpp"
+#include "manager.hpp"
+#include "types.hpp"
+
+#include <iostream>
+#include <memory>
+#include <sdbusplus/bus.hpp>
+#include <string>
+#include <tuple>
+#include <variant>
+
+using namespace openpower::vpd;
+using namespace openpower::vpd::constants;
+
+namespace openpower
+{
+namespace vpd
+{
+namespace manager
+{
+void BiosHandler::checkAndListenPLDMService()
+{
+    // Setup a match on NameOwnerChanged to determine when PLDM is up. In
+    // the signal handler, call restoreBIOSAttribs
+    static std::shared_ptr<sdbusplus::bus::match::match> nameOwnerMatch =
+        std::make_shared<sdbusplus::bus::match::match>(
+            bus,
+            sdbusplus::bus::match::rules::nameOwnerChanged(
+                "xyz.openbmc_project.PLDM"),
+            [this](sdbusplus::message::message& msg) {
+                if (msg.is_method_error())
+                {
+                    std::cerr << "Error in reading name owner signal "
+                              << std::endl;
+                    return;
+                }
+                std::string name;
+                std::string newOwner;
+                std::string oldOwner;
+
+                msg.read(name, oldOwner, newOwner);
+                if (newOwner != "" && name == "xyz.openbmc_project.PLDM")
+                {
+                    this->restoreBIOSAttribs();
+                    // We don't need the match anymore
+                    nameOwnerMatch.reset();
+                }
+            });
+    // Check if PLDM is already running, if it is, we can go ahead and attempt
+    // to sync BIOS attributes (since PLDM would have initialized them by the
+    // time it acquires a bus name).
+    bool isPLDMRunning = false;
+    try
+    {
+        auto bus = sdbusplus::bus::new_default();
+        auto method =
+            bus.new_method_call("org.freedesktop.DBus", "/org/freedesktop/DBus",
+                                "org.freedesktop.DBus", "NameHasOwner");
+        method.append("xyz.openbmc_project.PLDM");
+
+        auto result = bus.call(method);
+        result.read(isPLDMRunning);
+    }
+    catch (const sdbusplus::exception::SdBusError& e)
+    {
+        std::cerr << "Failed to check if PLDM is running, assume false"
+                  << std::endl;
+        std::cerr << e.what() << std::endl;
+    }
+
+    std::cout << "Is PLDM running: " << isPLDMRunning << std::endl;
+
+    if (isPLDMRunning)
+    {
+        nameOwnerMatch.reset();
+        restoreBIOSAttribs();
+    }
+}
+
+void BiosHandler::listenBiosAttribs()
+{
+    static std::shared_ptr<sdbusplus::bus::match::match> biosMatcher =
+        std::make_shared<sdbusplus::bus::match::match>(
+            bus,
+            sdbusplus::bus::match::rules::propertiesChanged(
+                "/xyz/openbmc_project/bios_config/manager",
+                "xyz.openbmc_project.BIOSConfig.Manager"),
+            [this](sdbusplus::message::message& msg) {
+                biosAttribsCallback(msg);
+            });
+}
+
+void BiosHandler::biosAttribsCallback(sdbusplus::message::message& msg)
+{
+    if (msg.is_method_error())
+    {
+        std::cerr << "Error in reading BIOS attribute signal " << std::endl;
+        return;
+    }
+    using BiosProperty = std::tuple<
+        std::string, bool, std::string, std::string, std::string,
+        std::variant<int64_t, std::string>, std::variant<int64_t, std::string>,
+        std::vector<
+            std::tuple<std::string, std::variant<int64_t, std::string>>>>;
+    using BiosBaseTable = std::variant<std::map<std::string, BiosProperty>>;
+    using BiosBaseTableType = std::map<std::string, BiosBaseTable>;
+
+    std::string object;
+    BiosBaseTableType propMap;
+    msg.read(object, propMap);
+    for (auto prop : propMap)
+    {
+        if (prop.first == "BaseBIOSTable")
+        {
+            auto list = std::get<0>(prop.second);
+            for (const auto& item : list)
+            {
+                std::string attributeName = std::get<0>(item);
+                if (attributeName == "hb_memory_mirror_mode")
+                {
+                    auto attrValue = std::get<5>(std::get<1>(item));
+                    auto val = std::get_if<std::string>(&attrValue);
+                    if (val)
+                    {
+                        saveAMMToVPD(*val);
+                    }
+                }
+                else if (attributeName == "hb_field_core_override")
+                {
+                    auto attrValue = std::get<5>(std::get<1>(item));
+                    auto val = std::get_if<int64_t>(&attrValue);
+                    if (val)
+                    {
+                        saveFCOToVPD(*val);
+                    }
+                }
+            }
+        }
+    }
+}
+
+void BiosHandler::saveFCOToVPD(int64_t fcoVal)
+{
+    if (fcoVal == -1)
+    {
+        std::cerr << "Invalid FCO value from BIOS: " << fcoVal << std::endl;
+        return;
+    }
+
+    Binary vpdVal = {0, 0, 0, static_cast<uint8_t>(fcoVal)};
+    auto valInVPD = readBusProperty(SYSTEM_OBJECT, "com.ibm.ipzvpd.VSYS", "RG");
+
+    if (valInVPD.size() != 4)
+    {
+        std::cerr << "Read bad size for VSYS/RG: " << valInVPD.size()
+                  << std::endl;
+        return;
+    }
+
+    if (valInVPD.at(3) != fcoVal)
+    {
+        std::cout << "Writing FCO to VPD: " << fcoVal << std::endl;
+        manager.writeKeyword(sdbusplus::message::object_path{SYSTEM_OBJECT},
+                             "VSYS", "RG", vpdVal);
+    }
+}
+
+void BiosHandler::saveAMMToVPD(const std::string& mirrorMode)
+{
+    Binary vpdVal;
+    auto valInVPD = readBusProperty(SYSTEM_OBJECT, "com.ibm.ipzvpd.UTIL", "D0");
+
+    if (valInVPD.size() != 1)
+    {
+        std::cerr << "Read bad size for UTIL/D0: " << valInVPD.size()
+                  << std::endl;
+        return;
+    }
+
+    if (mirrorMode != "Enabled" && mirrorMode != "Disabled")
+    {
+        std::cerr << "Bad value for Mirror mode BIOS arttribute: " << mirrorMode
+                  << std::endl;
+        return;
+    }
+
+    // Write to VPD only if the value is not already what we want to write.
+    if (mirrorMode == "Enabled" && valInVPD.at(0) != 2)
+    {
+        vpdVal.emplace_back(2);
+    }
+    else if (mirrorMode == "Disabled" && valInVPD.at(0) != 1)
+    {
+        vpdVal.emplace_back(1);
+    }
+
+    if (!vpdVal.empty())
+    {
+        std::cout << "Writing AMM to VPD: " << static_cast<int>(vpdVal.at(0))
+                  << std::endl;
+        manager.writeKeyword(sdbusplus::message::object_path{SYSTEM_OBJECT},
+                             "UTIL", "D0", vpdVal);
+    }
+}
+
+int64_t BiosHandler::readBIOSFCO()
+{
+    int64_t fcoVal = -1;
+    auto val = readBIOSAttribute("hb_field_core_override");
+
+    if (auto pVal = std::get_if<int64_t>(&val))
+    {
+        fcoVal = *pVal;
+    }
+    else
+    {
+        std::cerr << "FCO is not an int" << std::endl;
+    }
+    return fcoVal;
+}
+
+std::string BiosHandler::readBIOSAMM()
+{
+    std::string ammVal{};
+    auto val = readBIOSAttribute("hb_memory_mirror_mode");
+
+    if (auto pVal = std::get_if<std::string>(&val))
+    {
+        ammVal = *pVal;
+    }
+    else
+    {
+        std::cerr << "AMM is not a string" << std::endl;
+    }
+    return ammVal;
+}
+
+void BiosHandler::saveFCOToBIOS(const std::string& fcoVal)
+{
+    if (fcoVal.size() != 4)
+    {
+        std::cerr << "Bad size for FCO in VPD: " << fcoVal.size() << std::endl;
+        return;
+    }
+    PendingBIOSAttrsType biosAttrs;
+    biosAttrs.push_back(
+        std::make_pair("hb_field_core_override",
+                       std::make_tuple("xyz.openbmc_project.BIOSConfig.Manager."
+                                       "AttributeType.Integer",
+                                       fcoVal.at(3))));
+
+    std::cout << "Set hb_field_core_override to: "
+              << static_cast<int>(fcoVal.at(3)) << std::endl;
+
+    setBusProperty<PendingBIOSAttrsType>(
+        "xyz.openbmc_project.BIOSConfigManager",
+        "/xyz/openbmc_project/bios_config/manager",
+        "xyz.openbmc_project.BIOSConfig.Manager", "PendingAttributes",
+        biosAttrs);
+}
+
+void BiosHandler::saveAMMToBIOS(const std::string& ammVal)
+{
+    if (ammVal.size() != 1)
+    {
+        std::cerr << "Bad size for AMM in VPD: " << ammVal.size() << std::endl;
+        return;
+    }
+
+    // Make sure data in VPD is sane
+    if (ammVal.at(0) != 1 && ammVal.at(0) != 2)
+    {
+        std::cerr << "Bad value for AMM read from VPD: "
+                  << static_cast<int>(ammVal.at(0)) << std::endl;
+        return;
+    }
+    PendingBIOSAttrsType biosAttrs;
+    biosAttrs.push_back(std::make_pair(
+        "hb_memory_mirror_mode",
+        std::make_tuple("xyz.openbmc_project.BIOSConfig.Manager."
+                        "AttributeType.Enumeration",
+                        (ammVal.at(0) == 2) ? "Enabled" : "Disabled")));
+
+    std::cout << "Set hb_memory_mirror_mode to: "
+              << ((ammVal.at(0) == 2) ? "Enabled" : "Disabled") << std::endl;
+
+    setBusProperty<PendingBIOSAttrsType>(
+        "xyz.openbmc_project.BIOSConfigManager",
+        "/xyz/openbmc_project/bios_config/manager",
+        "xyz.openbmc_project.BIOSConfig.Manager", "PendingAttributes",
+        biosAttrs);
+}
+
+void BiosHandler::restoreBIOSAttribs()
+{
+    // TODO: We could make this slightly more scalable by defining a table of
+    // attributes and their corresponding VPD keywords. However, that needs much
+    // more thought.
+    std::cout << "Attempting BIOS attribute reset" << std::endl;
+    // Check if the VPD contains valid data for FCO and AMM *and* that it
+    // differs from the data already in the attributes. If so, set the BIOS
+    // attributes as per the value in the VPD.
+    // If the VPD contains default data, then initialize the VPD keywords with
+    // data taken from the BIOS.
+    auto fcoInVPD = readBusProperty(SYSTEM_OBJECT, "com.ibm.ipzvpd.VSYS", "RG");
+    auto ammInVPD = readBusProperty(SYSTEM_OBJECT, "com.ibm.ipzvpd.UTIL", "D0");
+    auto fcoInBIOS = readBIOSFCO();
+    auto ammInBIOS = readBIOSAMM();
+
+    if (fcoInVPD == "    ")
+    {
+        saveFCOToVPD(fcoInBIOS);
+    }
+    else
+    {
+        saveFCOToBIOS(fcoInVPD);
+    }
+
+    if (ammInVPD.at(0) == 0)
+    {
+        saveAMMToVPD(ammInBIOS);
+    }
+    else
+    {
+        saveAMMToBIOS(ammInVPD);
+    }
+
+    // Start listener now that we have done the restore
+    listenBiosAttribs();
+}
+} // namespace manager
+} // namespace vpd
+} // namespace openpower
\ No newline at end of file
diff --git a/vpd-manager/bios_handler.hpp b/vpd-manager/bios_handler.hpp
new file mode 100644
index 0000000..ad6f05e
--- /dev/null
+++ b/vpd-manager/bios_handler.hpp
@@ -0,0 +1,169 @@
+#pragma once
+
+#include "types.hpp"
+
+#include <stdint.h>
+
+#include <string>
+
+namespace sdbusplus
+{
+namespace bus
+{
+class bus;
+} // namespace bus
+} // namespace sdbusplus
+
+namespace sdbusplus
+{
+namespace message
+{
+class message;
+} // namespace message
+} // namespace sdbusplus
+
+namespace openpower
+{
+namespace vpd
+{
+namespace manager
+{
+
+class Manager;
+/**
+ * @brief A class that handles changes to BIOS attributes backed by VPD.
+ *
+ * This class has APIs that handle updates to BIOS attributes that need to
+ * be backed up to VPD. It mainly does the following:
+ * 1) Checks if the VPD keywords that BIOS attributes are backed to are
+ * uninitialized. If so, it initializes them.
+ * 2) Listens for changes to BIOS attributes and synchronizes them to the
+ * appropriate VPD keyword.
+ *
+ * Since on a factory reset like scenario, the BIOS attributes are initialized
+ * by PLDM, this code waits until PLDM has grabbed a bus name before attempting
+ * any syncs.
+ */
+class BiosHandler
+{
+  public:
+    // Some default and deleted constructors and assignments.
+    BiosHandler() = delete;
+    BiosHandler(const BiosHandler&) = delete;
+    BiosHandler& operator=(const BiosHandler&) = delete;
+    BiosHandler(Manager&&) = delete;
+    BiosHandler& operator=(BiosHandler&&) = delete;
+    ~BiosHandler() = default;
+
+    BiosHandler(sdbusplus::bus::bus& bus, Manager& manager) :
+        bus(bus), manager(manager)
+    {
+        checkAndListenPLDMService();
+    }
+
+  private:
+    /**
+     * @brief Check if PLDM service is running and run BIOS sync
+     *
+     * This API checks if the PLDM service is running and if yes it will start
+     * an immediate sync of BIOS attributes. If the service is not running, it
+     * registers a listener to be notified when the service starts so that a
+     * restore can be performed.
+     */
+    void checkAndListenPLDMService();
+
+    /**
+     * @brief Register listener for changes to BIOS Attributes.
+     *
+     * The VPD manager needs to listen to changes to certain BIOS attributes
+     * that are backed by VPD. When the attributes we are interested in
+     * change, the VPD manager will make sure that we write them back to the
+     * VPD keywords that back them up.
+     */
+    void listenBiosAttribs();
+
+    /**
+     * @brief Callback for BIOS Attribute changes
+     *
+     * Checks if the BIOS attribute(s) changed are those backed up by VPD. If
+     * yes, it will update the VPD with the new attribute value.
+     * @param[in] msg - The callback message.
+     */
+    void biosAttribsCallback(sdbusplus::message::message& msg);
+
+    /**
+     * @brief Persistently saves the Memory mirror mode
+     *
+     * Memory mirror mode setting is saved to the UTIL/D0 keyword in the
+     * motherboard VPD. If the mirror mode in BIOS is "Disabled", set D0 to 1,
+     * if "Enabled" set D0 to 2
+     *
+     * @param[in] mirrorMode - The mirror mode BIOS attribute.
+     */
+    void saveAMMToVPD(const std::string& mirrorMode);
+
+    /**
+     * @brief Persistently saves the Field Core Override setting
+     *
+     * Saves the field core override value (FCO) into the VSYS/RG keyword in
+     * the motherboard VPD.
+     *
+     * @param[in] fcoVal - The FCO value as an integer.
+     */
+    void saveFCOToVPD(int64_t fcoVal);
+
+    /**
+     * @brief Writes Memory mirror mode to BIOS
+     *
+     * Writes to the hb_memory_mirror_mode BIOS attribute.
+     *
+     * @param[in] ammVal - The mirror mode as read from VPD.
+     */
+    void saveAMMToBIOS(const std::string& ammVal);
+
+    /**
+     * @brief Writes Field Core Override to BIOS
+     *
+     * Writes to the hb_field_core_override BIOS attribute.
+     *
+     * @param[in] fcoVal - The FCO value as read from VPD.
+     */
+    void saveFCOToBIOS(const std::string& fcoVal);
+
+    /**
+     * @brief Reads the hb_memory_mirror_mode attribute
+     *
+     * @return int64_t - The AMM BIOS attribute. -1 on failure.
+     */
+    std::string readBIOSAMM();
+
+    /**
+     * @brief Reads the hb_field_core_override attribute
+     *
+     * @return std::string - The FCO BIOS attribute. Empty string on failure.
+     */
+    int64_t readBIOSFCO();
+
+    /**
+     * @brief Restore BIOS attributes
+     *
+     * This function checks if we are coming out of a factory reset. If yes,
+     * it checks the VPD cache for valid backed up copy of the FCO and AMM
+     * BIOS attributes. If valid values are found in the VPD, it will apply
+     * those to the BIOS attributes.
+     */
+    void restoreBIOSAttribs();
+
+    /**
+     * @brief Reference to the bus.
+     */
+    sdbusplus::bus::bus& bus;
+
+    /**
+     * @brief Reference to the manager.
+     */
+    Manager& manager;
+}; // class BiosHandler
+} // namespace manager
+} // namespace vpd
+} // namespace openpower
\ No newline at end of file
diff --git a/vpd-manager/manager.cpp b/vpd-manager/manager.cpp
index 932cc9d..de40edf 100644
--- a/vpd-manager/manager.cpp
+++ b/vpd-manager/manager.cpp
@@ -2,6 +2,7 @@
 
 #include "manager.hpp"
 
+#include "bios_handler.hpp"
 #include "common_utility.hpp"
 #include "editor_impl.hpp"
 #include "gpioMonitor.hpp"
@@ -45,6 +46,9 @@
         listenHostState();
         listenAssetTag();
 
+        // Create an instance of the BIOS handler
+        BiosHandler biosHandler{_bus, *this};
+
         auto event = sdeventplus::Event::get_default();
         GpioMonitor gpioMon1(jsonFile, event);
 
diff --git a/vpd-manager/meson.build b/vpd-manager/meson.build
index 604f2b6..9b5c5c9 100644
--- a/vpd-manager/meson.build
+++ b/vpd-manager/meson.build
@@ -11,6 +11,7 @@
                       'editor_impl.cpp',
                       'reader_impl.cpp',
                       'gpioMonitor.cpp',
+                      'bios_handler.cpp',
                       '../impl.cpp',
                       '../vpd-parser/ipz_parser.cpp',
                       '../ibm_vpd_utils.cpp',