diff --git a/ibm_vpd_utils.hpp b/ibm_vpd_utils.hpp
index 3924d39..d5fdc33 100644
--- a/ibm_vpd_utils.hpp
+++ b/ibm_vpd_utils.hpp
@@ -107,6 +107,37 @@
     return retVal;
 }
 
+/** @brief A templated method to get all D-Bus properties
+ *
+ * @param[in] service - Service path
+ * @param[in] object - Object path
+ * @param[in] inf - Interface
+ *
+ * @return All properties under the given interface.
+ */
+template <typename T>
+T getAllDBusProperty(const std::string& service, const std::string& object,
+                     const std::string& inf)
+{
+    T retVal{};
+    try
+    {
+        auto bus = sdbusplus::bus::new_default();
+        auto allProperties =
+            bus.new_method_call(service.c_str(), object.c_str(),
+                                "org.freedesktop.DBus.Properties", "GetAll");
+        allProperties.append(inf);
+
+        auto result = bus.call(allProperties);
+        result.read(retVal);
+    }
+    catch (const sdbusplus::exception::SdBusError& e)
+    {
+        std::cerr << e.what();
+    }
+    return retVal;
+}
+
 /**
  * @brief API to create PEL entry
  * @param[in] additionalData - Map holding the additional data
diff --git a/vpd_tool.cpp b/vpd_tool.cpp
index 740d5cd..a0699bb 100644
--- a/vpd_tool.cpp
+++ b/vpd_tool.cpp
@@ -80,6 +80,10 @@
         "User should provide valid hardware/eeprom path (and not dbus object "
         "path) in the -O/--object path. CAUTION: Developer Only Option");
 
+    auto fixSystemVPDFlag = app.add_flag(
+        "--fixSystemVPD", "Use this option to interactively fix critical "
+                          "system VPD keywords {vpd-tool-exe --fixSystemVPD}");
+
     CLI11_PARSE(app, argc, argv);
 
     ifstream inventoryJson(INVENTORY_JSON_SYM_LINK);
@@ -155,6 +159,11 @@
                                move(keyword));
             vpdToolObj.readKwFromHw(offset);
         }
+        else if (*fixSystemVPDFlag)
+        {
+            VpdTool vpdToolObj;
+            rc = vpdToolObj.fixSystemVPD();
+        }
         else
         {
             throw runtime_error("One of the valid options is required. Refer "
diff --git a/vpd_tool_impl.cpp b/vpd_tool_impl.cpp
index 0d57351..10eba2e 100644
--- a/vpd_tool_impl.cpp
+++ b/vpd_tool_impl.cpp
@@ -1,6 +1,7 @@
 #include "vpd_tool_impl.hpp"
 
 #include "impl.hpp"
+#include "parser_factory.hpp"
 #include "vpd_exceptions.hpp"
 
 #include <cstdlib>
@@ -18,6 +19,8 @@
 using json = nlohmann::json;
 using namespace openpower::vpd::exceptions;
 using namespace openpower::vpd::parser;
+using namespace openpower::vpd::parser::factory;
+using namespace openpower::vpd::parser::interface;
 
 Binary VpdTool::toBinary(const std::string& value)
 {
@@ -548,3 +551,420 @@
                   << fruPath << std::endl;
     }
 }
+
+void VpdTool::printFixSystemVPDOption(UserOption option)
+{
+    switch (option)
+    {
+        case VpdTool::EXIT:
+            cout << "\nEnter 0 => To exit successfully : ";
+            break;
+        case VpdTool::BMC_DATA_FOR_ALL:
+            cout << "\n\nEnter 1 => If you choose the data on BMC for all "
+                    "mismatching record-keyword pairs";
+            break;
+        case VpdTool::SYSTEM_BACKPLANE_DATA_FOR_ALL:
+            cout << "\nEnter 2 => If you choose the data on System "
+                    "Backplane for all mismatching record-keyword pairs";
+            break;
+        case VpdTool::MORE_OPTIONS:
+            cout << "\nEnter 3 => If you wish to explore more options";
+            break;
+        case VpdTool::BMC_DATA_FOR_CURRENT:
+            cout << "\nEnter 4 => If you choose the data on BMC as the "
+                    "right value";
+            break;
+        case VpdTool::SYSTEM_BACKPLANE_DATA_FOR_CURRENT:
+            cout << "\nEnter 5 => If you choose the data on System "
+                    "Backplane as the right value";
+            break;
+        case VpdTool::NEW_VALUE_ON_BOTH:
+            cout << "\nEnter 6 => If you wish to enter a new value to "
+                    "update both on BMC and System Backplane";
+            break;
+        case VpdTool::SKIP_CURRENT:
+            cout << "\nEnter 7 => If you wish to skip the above "
+                    "record-keyword pair";
+            break;
+    }
+}
+
+int VpdTool::fixSystemVPD()
+{
+    cout << "\nRestorable record-keyword pairs and their data on BMC & "
+            "System Backplane.\n ";
+
+    cout << "\n|==============================================================="
+            "=======================================|"
+         << endl;
+
+    cout << left << setw(6) << "S.No" << left << setw(8) << "Record" << left
+         << setw(9) << "Keyword" << left << setw(30) << "Data On BMC" << left
+         << setw(30) << "Data On System Backplane" << left << setw(14)
+         << "Data Mismatch";
+
+    cout << "\n|==============================================================="
+            "=======================================|"
+         << endl;
+
+    int num = 0;
+
+    // Get system VPD data in map
+    Binary vpdVector{};
+    json js{};
+
+    auto jsonToParse = INVENTORY_JSON_DEFAULT;
+    if (fs::exists(INVENTORY_JSON_SYM_LINK))
+    {
+        jsonToParse = INVENTORY_JSON_SYM_LINK;
+    }
+
+    ifstream inventoryJson(jsonToParse);
+    if (!inventoryJson)
+    {
+        throw runtime_error("VPD JSON file not found");
+    }
+    js = json::parse(inventoryJson);
+
+    vpdVector = getVpdDataInVector(js, constants::systemVpdFilePath);
+    ParserInterface* parser = ParserFactory::getParser(vpdVector);
+    auto parseResult = parser->parse();
+    ParserFactory::freeParser(parser);
+
+    unordered_map<string, DbusPropertyMap> vpdMap;
+
+    if (auto pVal = get_if<Store>(&parseResult))
+    {
+        vpdMap = pVal->getVpdMap();
+    }
+    else
+    {
+        std::cerr << "\n System backplane VPD is not of type IPZ. Unable to "
+                     "parse the VPD "
+                  << constants::systemVpdFilePath << " . Exit with error."
+                  << std::endl;
+        exit(1);
+    }
+
+    // Get system VPD D-Bus Data and store it in a map
+    using GetAllResultType =
+        std::vector<std::pair<std::string, std::variant<Binary>>>;
+    using IntfPropMap = std::map<std::string, GetAllResultType>;
+
+    IntfPropMap svpdBusData;
+
+    const auto vsys = getAllDBusProperty<GetAllResultType>(
+        constants::pimIntf,
+        "/xyz/openbmc_project/inventory/system/chassis/motherboard",
+        "com.ibm.ipzvpd.VSYS");
+    svpdBusData.emplace("VSYS", vsys);
+
+    const auto vcen = getAllDBusProperty<GetAllResultType>(
+        constants::pimIntf,
+        "/xyz/openbmc_project/inventory/system/chassis/motherboard",
+        "com.ibm.ipzvpd.VCEN");
+    svpdBusData.emplace("VCEN", vcen);
+
+    const auto lxr0 = getAllDBusProperty<GetAllResultType>(
+        constants::pimIntf,
+        "/xyz/openbmc_project/inventory/system/chassis/motherboard",
+        "com.ibm.ipzvpd.LXR0");
+    svpdBusData.emplace("LXR0", lxr0);
+
+    const auto util = getAllDBusProperty<GetAllResultType>(
+        constants::pimIntf,
+        "/xyz/openbmc_project/inventory/system/chassis/motherboard",
+        "com.ibm.ipzvpd.UTIL");
+    svpdBusData.emplace("UTIL", util);
+
+    for (const auto& recordKw : svpdKwdMap)
+    {
+        string record = recordKw.first;
+
+        // Extract specific record data from the svpdBusData map.
+        const auto& rec = svpdBusData.find(record);
+
+        if (rec == svpdBusData.end())
+        {
+            std::cerr << record << " not a part of critical system VPD records."
+                      << std::endl;
+            continue;
+        }
+
+        const auto& recData = svpdBusData.find(record)->second;
+
+        string busStr{}, hwValStr{};
+        string mismatch = "NO"; // no mismatch
+
+        for (const auto& keyword : recordKw.second)
+        {
+            string hardwareValue{};
+            auto recItr = vpdMap.find(record);
+
+            if (recItr != vpdMap.end())
+            {
+                DbusPropertyMap& kwValMap = recItr->second;
+                auto kwItr = kwValMap.find(keyword);
+                if (kwItr != kwValMap.end())
+                {
+                    hardwareValue = kwItr->second;
+                }
+            }
+
+            std::variant<Binary> kwValue;
+            for (auto& kwData : recData)
+            {
+                if (kwData.first == keyword)
+                {
+                    kwValue = kwData.second;
+                    break;
+                }
+            }
+
+            if (keyword != "SE")
+            {
+                ostringstream hwValStream;
+                hwValStream << "0x";
+                hwValStr = hwValStream.str();
+
+                for (uint16_t byte : hardwareValue)
+                {
+                    hwValStream << setfill('0') << setw(2) << hex << byte;
+                    hwValStr = hwValStream.str();
+                }
+
+                if (const auto value = get_if<Binary>(&kwValue))
+                {
+                    busStr = byteArrayToHexString(*value);
+                }
+                if (busStr != hwValStr)
+                {
+                    mismatch = "YES";
+                }
+            }
+            else
+            {
+                if (const auto value = get_if<Binary>(&kwValue))
+                {
+                    busStr = getPrintableValue(*value);
+                }
+                if (busStr != hardwareValue)
+                {
+                    mismatch = "YES";
+                }
+                hwValStr = hardwareValue;
+            }
+            recKwData.push_back(
+                make_tuple(++num, record, keyword, busStr, hwValStr, mismatch));
+            cout << left << setw(6) << num << left << setw(8) << record << left
+                 << setw(9) << keyword << left << setw(30) << setfill(' ')
+                 << busStr << left << setw(30) << setfill(' ') << hwValStr
+                 << left << setw(14) << mismatch;
+
+            cout << "\n|--------------------------------------------------"
+                    "----------------------------------------------------|"
+                 << endl;
+        }
+    }
+    parseSVPDOptions(js);
+    return 0;
+}
+
+void VpdTool::parseSVPDOptions(const nlohmann::json& json)
+{
+    do
+    {
+        printFixSystemVPDOption(VpdTool::BMC_DATA_FOR_ALL);
+        printFixSystemVPDOption(VpdTool::SYSTEM_BACKPLANE_DATA_FOR_ALL);
+        printFixSystemVPDOption(VpdTool::MORE_OPTIONS);
+        printFixSystemVPDOption(VpdTool::EXIT);
+
+        int option = 0;
+        cin >> option;
+        cout << "\n|==========================================================="
+                "===========================================|"
+             << endl;
+
+        if (json.find("frus") == json.end())
+        {
+            throw runtime_error("Frus not found in json");
+        }
+
+        bool mismatchFound = false;
+
+        if (option == VpdTool::BMC_DATA_FOR_ALL)
+        {
+            for (const auto& data : recKwData)
+            {
+                if (get<5>(data) == "YES")
+                {
+                    EditorImpl edit(constants::systemVpdFilePath, json,
+                                    get<1>(data), get<2>(data));
+                    edit.updateKeyword(toBinary(get<3>(data)), 0, true);
+                    mismatchFound = true;
+                }
+            }
+
+            if (mismatchFound)
+            {
+                cout << "\nData updated successfully for all mismatching "
+                        "record-keyword pairs by choosing their corresponding "
+                        "data on BMC. Exit successfully.\n"
+                     << endl;
+            }
+            else
+            {
+                cout << "\nNo mismatch found for any of the above mentioned "
+                        "record-keyword pair. Exit successfully.\n";
+            }
+
+            exit(0);
+        }
+        else if (option == VpdTool::SYSTEM_BACKPLANE_DATA_FOR_ALL)
+        {
+            for (const auto& data : recKwData)
+            {
+                if (get<5>(data) == "YES")
+                {
+                    EditorImpl edit(constants::systemVpdFilePath, json,
+                                    get<1>(data), get<2>(data));
+                    edit.updateKeyword(toBinary(get<4>(data)), 0, true);
+                    mismatchFound = true;
+                }
+            }
+
+            if (mismatchFound)
+            {
+                cout << "\nData updated successfully for all mismatching "
+                        "record-keyword pairs by choosing their corresponding "
+                        "data on System Backplane.\n"
+                     << endl;
+            }
+            else
+            {
+                cout << "\nNo mismatch found for any of the above mentioned "
+                        "record-keyword pair. Exit successfully.\n";
+            }
+
+            exit(0);
+        }
+        else if (option == VpdTool::MORE_OPTIONS)
+        {
+            cout << "\nIterate through all restorable record-keyword pairs\n";
+
+            for (const auto& data : recKwData)
+            {
+                do
+                {
+                    cout << "\n|==============================================="
+                            "=================================================="
+                            "=====|"
+                         << endl;
+
+                    cout << left << setw(6) << "S.No" << left << setw(8)
+                         << "Record" << left << setw(9) << "Keyword" << left
+                         << setw(30) << setfill(' ') << "Data On BMC" << left
+                         << setw(30) << setfill(' ')
+                         << "Data On System Backplane" << left << setw(14)
+                         << "Data Mismatch" << endl;
+
+                    cout << left << setw(6) << get<0>(data) << left << setw(8)
+                         << get<1>(data) << left << setw(9) << get<2>(data)
+                         << left << setw(30) << setfill(' ') << get<3>(data)
+                         << left << setw(30) << setfill(' ') << get<4>(data)
+                         << left << setw(14) << get<5>(data);
+
+                    cout << "\n|==============================================="
+                            "=================================================="
+                            "=====|"
+                         << endl;
+
+                    if (get<5>(data) == "NO")
+                    {
+                        cout << "\nNo mismatch found.\n";
+                        printFixSystemVPDOption(VpdTool::NEW_VALUE_ON_BOTH);
+                        printFixSystemVPDOption(VpdTool::SKIP_CURRENT);
+                        printFixSystemVPDOption(VpdTool::EXIT);
+                    }
+                    else
+                    {
+                        printFixSystemVPDOption(VpdTool::BMC_DATA_FOR_CURRENT);
+                        printFixSystemVPDOption(
+                            VpdTool::SYSTEM_BACKPLANE_DATA_FOR_CURRENT);
+                        printFixSystemVPDOption(VpdTool::NEW_VALUE_ON_BOTH);
+                        printFixSystemVPDOption(VpdTool::SKIP_CURRENT);
+                        printFixSystemVPDOption(VpdTool::EXIT);
+                    }
+
+                    cin >> option;
+
+                    cout << "\n|==============================================="
+                            "=================================================="
+                            "=====|"
+                         << endl;
+
+                    EditorImpl edit(constants::systemVpdFilePath, json,
+                                    get<1>(data), get<2>(data));
+
+                    if (option == VpdTool::BMC_DATA_FOR_CURRENT)
+                    {
+                        edit.updateKeyword(toBinary(get<3>(data)), 0, true);
+                        cout << "\nData updated successfully.\n";
+                        break;
+                    }
+                    else if (option ==
+                             VpdTool::SYSTEM_BACKPLANE_DATA_FOR_CURRENT)
+                    {
+                        edit.updateKeyword(toBinary(get<4>(data)), 0, true);
+                        cout << "\nData updated successfully.\n";
+                        break;
+                    }
+                    else if (option == VpdTool::NEW_VALUE_ON_BOTH)
+                    {
+                        string value;
+                        cout << "\nEnter the new value to update both on BMC & "
+                                "System Backplane (Value should be in ASCII or "
+                                "in HEX(prefixed with 0x)) : ";
+                        cin >> value;
+                        cout << "\n|==========================================="
+                                "=============================================="
+                                "=============|"
+                             << endl;
+
+                        edit.updateKeyword(toBinary(value), 0, true);
+                        cout << "\nData updated successfully.\n";
+                        break;
+                    }
+                    else if (option == VpdTool::SKIP_CURRENT)
+                    {
+                        cout << "\nSkipped the above record-keyword pair. "
+                                "Continue to the next available pair.\n";
+                        break;
+                    }
+                    else if (option == VpdTool::EXIT)
+                    {
+                        cout << "\nExit successfully\n";
+                        exit(0);
+                    }
+                    else
+                    {
+                        cout << "\nProvide a valid option. Retrying for the "
+                                "current record-keyword pair\n";
+                    }
+                } while (1);
+            }
+            exit(0);
+        }
+        else if (option == VpdTool::EXIT)
+        {
+            cout << "\nExit successfully";
+            exit(0);
+        }
+        else
+        {
+            cout << "\nProvide a valid option. Retry.";
+            continue;
+        }
+
+    } while (true);
+}
diff --git a/vpd_tool_impl.hpp b/vpd_tool_impl.hpp
index 3de98f9..8938fce 100644
--- a/vpd_tool_impl.hpp
+++ b/vpd_tool_impl.hpp
@@ -9,6 +9,11 @@
 
 using json = nlohmann::json;
 
+// <S.no, Record, Keyword, D-Bus value, HW value, Data mismatch>
+using SystemCriticalData =
+    std::vector<std::tuple<int, std::string, std::string, std::string,
+                           std::string, std::string>>;
+
 class VpdTool
 {
   private:
@@ -17,6 +22,7 @@
     const std::string keyword;
     const std::string value;
     bool objFound = true;
+    SystemCriticalData recKwData;
 
     // Store Type of FRU
     std::string fruType;
@@ -132,6 +138,34 @@
     json getPresentPropJson(const std::string& invPath,
                             std::string& parentPresence);
 
+    /**
+     * @brief Parse through the options to fix system VPD
+     *
+     * @param[in] json - Inventory JSON
+     */
+    void parseSVPDOptions(const nlohmann::json& json);
+
+    /**
+     * @brief List of user options that can be used to fix system VPD keywords.
+     */
+    enum UserOption
+    {
+        EXIT = 0,
+        BMC_DATA_FOR_ALL = 1,
+        SYSTEM_BACKPLANE_DATA_FOR_ALL = 2,
+        MORE_OPTIONS = 3,
+        BMC_DATA_FOR_CURRENT = 4,
+        SYSTEM_BACKPLANE_DATA_FOR_CURRENT = 5,
+        NEW_VALUE_ON_BOTH = 6,
+        SKIP_CURRENT = 7
+    };
+
+    /**
+     * @brief Print options to fix system VPD.
+     * @param[in] option - Option to use.
+     */
+    void printFixSystemVPDOption(UserOption option);
+
   public:
     /**
      * @brief Dump the complete inventory in JSON format
@@ -199,6 +233,16 @@
     void readKwFromHw(const uint32_t& startOffset);
 
     /**
+     * @brief Fix System VPD keyword.
+     * This API provides an interactive way to fix system VPD keywords that are
+     * part of restorable record-keyword pairs. The user can use this option to
+     * restore the restorable keywords in cache or in hardware or in both cache
+     * and hardware.
+     * @return returncode (success/failure).
+     */
+    int fixSystemVPD();
+
+    /**
      * @brief Constructor
      * Constructor is called during the
      * object instantiation for dumpInventory option and