diff --git a/vpd-manager/src/event_logger.cpp b/vpd-manager/src/event_logger.cpp
index 77de7c5..5eecc62 100644
--- a/vpd-manager/src/event_logger.cpp
+++ b/vpd-manager/src/event_logger.cpp
@@ -43,7 +43,11 @@
         {types::ErrorType::GpioError, "com.ibm.VPD.Error.GPIOError"},
         {types::ErrorType::InternalFailure,
          "xyz.openbmc_project.Common.Error.InternalFailure"},
-        {types::ErrorType::FruMissing, "com.ibm.VPD.Error.RequiredFRUMissing"}};
+        {types::ErrorType::FruMissing, "com.ibm.VPD.Error.RequiredFRUMissing"},
+        {types::ErrorType::SystemTypeMismatch,
+         "com.ibm.VPD.Error.SystemTypeMismatch"},
+        {types::ErrorType::UnknownSystemSettings,
+         "com.ibm.VPD.Error.UnknownSystemSettings"}};
 
 const std::unordered_map<types::CalloutPriority, std::string>
     EventLogger::m_priorityMap = {
diff --git a/vpd-manager/src/manager.cpp b/vpd-manager/src/manager.cpp
index 030f54e..be62094 100644
--- a/vpd-manager/src/manager.cpp
+++ b/vpd-manager/src/manager.cpp
@@ -9,6 +9,7 @@
 #include "parser.hpp"
 #include "parser_factory.hpp"
 #include "parser_interface.hpp"
+#include "single_fab.hpp"
 #include "types.hpp"
 #include "utility/dbus_utility.hpp"
 #include "utility/json_utility.hpp"
@@ -26,6 +27,21 @@
     const std::shared_ptr<sdbusplus::asio::connection>& asioConnection) :
     m_ioContext(ioCon), m_interface(iFace), m_asioConnection(asioConnection)
 {
+#ifdef IBM_SYSTEM
+    if (!dbusUtility::isChassisPowerOn())
+    {
+        SingleFab l_singleFab;
+        const int& l_rc = l_singleFab.singleFabImOverride();
+
+        if (l_rc == constants::FAILURE)
+        {
+            throw std::runtime_error(
+                std::string(__FUNCTION__) +
+                " : Found an invalid system configuration. Needs manual intervention. BMC is being quiesced.");
+        }
+    }
+#endif
+
     try
     {
 #ifdef IBM_SYSTEM
diff --git a/vpd-manager/src/single_fab.cpp b/vpd-manager/src/single_fab.cpp
index 12197f2..ca07a1a 100644
--- a/vpd-manager/src/single_fab.cpp
+++ b/vpd-manager/src/single_fab.cpp
@@ -3,12 +3,14 @@
 #include "single_fab.hpp"
 
 #include "constants.hpp"
+#include "event_logger.hpp"
 #include "parser.hpp"
 #include "types.hpp"
 
 #include <nlohmann/json.hpp>
 #include <utility/common_utility.hpp>
 #include <utility/json_utility.hpp>
+#include <utility/vpd_specific_utility.hpp>
 
 namespace vpd
 {
@@ -136,7 +138,7 @@
     return false;
 }
 
-bool SingleFab::updateSystemImValueInVpdToP11Series(
+void SingleFab::updateSystemImValueInVpdToP11Series(
     std::string i_currentImValuePlanar) const noexcept
 {
     bool l_retVal{false};
@@ -148,6 +150,144 @@
             constants::VALUE_0, constants::VALUE_1,
             std::to_string(constants::VALUE_6)));
     }
-    return l_retVal;
+
+    if (!l_retVal)
+    {
+        EventLogger::createSyncPel(
+            types::ErrorType::InternalFailure,
+            types::SeverityType::Informational, __FILE__, __FUNCTION__, 0,
+            std::string("Failed to update IM value to P11 series."),
+            std::nullopt, std::nullopt, std::nullopt, std::nullopt);
+    }
+}
+
+int SingleFab::singleFabImOverride() const noexcept
+{
+    const std::string& l_planarImValue = getImFromPlanar();
+    const std::string& l_eBmcImValue = getImFromPersistedLocation();
+    const bool& l_isFieldModeEnabled = isFieldModeEnabled();
+    const bool& l_isLabModeEnabled =
+        !l_isFieldModeEnabled;                       // used for understanding
+    const bool& l_isPowerVsImage = vpdSpecificUtility::isPowerVsImage();
+    const bool& l_isNormalImage = !l_isPowerVsImage; // used for understanding
+
+    if (!isValidImSeries(l_planarImValue))
+    {
+        // Create Errorlog for invalid IM series encountered
+        EventLogger::createSyncPel(
+            types::ErrorType::InvalidSystem, types::SeverityType::Error,
+            __FILE__, __FUNCTION__, 0,
+            std::string("Invalid IM found on the system planar, IM value : ") +
+                l_planarImValue,
+            std::nullopt, std::nullopt, std::nullopt, std::nullopt);
+
+        return constants::SUCCESS;
+    }
+
+    if (!l_eBmcImValue.empty())
+    {
+        if (isP10System(l_eBmcImValue))
+        {
+            if (isP10System(l_planarImValue))
+            {
+                if (l_isFieldModeEnabled && l_isNormalImage)
+                {
+                    EventLogger::createSyncPel(
+                        types::ErrorType::SystemTypeMismatch,
+                        types::SeverityType::Warning, __FILE__, __FUNCTION__, 0,
+                        std::string("Mismatch in IM value found eBMC IM [") +
+                            l_eBmcImValue + std::string("] planar IM [") +
+                            l_planarImValue +
+                            std::string("] Field mode enabled [") +
+                            ((l_isFieldModeEnabled) ? "true" : "false") +
+                            std::string("]"),
+                        std::nullopt, std::nullopt, std::nullopt, std::nullopt);
+
+                    return constants::FAILURE;
+                }
+            }
+            else if (isP11System(l_planarImValue))
+            {
+                if (!(l_isLabModeEnabled && l_isNormalImage))
+                {
+                    EventLogger::createSyncPel(
+                        types::ErrorType::SystemTypeMismatch,
+                        types::SeverityType::Warning, __FILE__, __FUNCTION__, 0,
+                        std::string("Mismatch in IM value found eBMC IM [") +
+                            l_eBmcImValue + std::string("] planar IM [") +
+                            l_planarImValue +
+                            std::string("] Field mode enabled [") +
+                            ((l_isFieldModeEnabled) ? "true" : "false") +
+                            std::string("]"),
+                        std::nullopt, std::nullopt, std::nullopt, std::nullopt);
+
+                    return constants::FAILURE;
+                }
+            }
+        }
+        else if (isP11System(l_eBmcImValue))
+        {
+            if (l_isPowerVsImage)
+            {
+                EventLogger::createSyncPel(
+                    types::ErrorType::SystemTypeMismatch,
+                    types::SeverityType::Warning, __FILE__, __FUNCTION__, 0,
+                    std::string("Mismatch in IM value found eBMC IM [") +
+                        l_eBmcImValue + std::string("] planar IM [") +
+                        l_planarImValue +
+                        std::string("] Field mode enabled [") +
+                        ((l_isFieldModeEnabled) ? "true" : "false") +
+                        std::string("]"),
+                    std::nullopt, std::nullopt, std::nullopt, std::nullopt);
+
+                return constants::FAILURE;
+            }
+            else
+            {
+                if (isP10System(l_planarImValue))
+                {
+                    updateSystemImValueInVpdToP11Series(l_planarImValue);
+                }
+            }
+        }
+    }
+    else
+    {
+        if (isP11System(l_planarImValue) && l_isPowerVsImage)
+        {
+            EventLogger::createSyncPel(
+                types::ErrorType::SystemTypeMismatch,
+                types::SeverityType::Warning, __FILE__, __FUNCTION__, 0,
+                std::string("Mismatch in IM value found eBMC IM [") +
+                    l_eBmcImValue + std::string("] planar IM [") +
+                    l_planarImValue + std::string("] Field mode enabled [") +
+                    ((l_isFieldModeEnabled) ? "true" : "false") +
+                    std::string("]"),
+                std::nullopt, std::nullopt, std::nullopt, std::nullopt);
+
+            return constants::FAILURE;
+        }
+        else if (isP10System(l_planarImValue) && l_isNormalImage)
+        {
+            if (l_isLabModeEnabled)
+            {
+                EventLogger::createSyncPel(
+                    types::ErrorType::UnknownSystemSettings,
+                    types::SeverityType::Warning, __FILE__, __FUNCTION__, 0,
+                    std::string("Mismatch in IM value found eBMC IM [") +
+                        l_eBmcImValue + std::string("] planar IM [") +
+                        l_planarImValue +
+                        std::string("] Field mode enabled [") +
+                        ((l_isFieldModeEnabled) ? "true" : "false") +
+                        std::string("]"),
+                    std::nullopt, std::nullopt, std::nullopt, std::nullopt);
+            }
+            else
+            {
+                updateSystemImValueInVpdToP11Series(l_planarImValue);
+            }
+        }
+    }
+    return constants::SUCCESS;
 }
 } // namespace vpd