diff --git a/tools/power-utils/main.cpp b/tools/power-utils/main.cpp
index 5adbb1b..ca8a6fe 100644
--- a/tools/power-utils/main.cpp
+++ b/tools/power-utils/main.cpp
@@ -16,6 +16,7 @@
 #include "model.hpp"
 #include "updater.hpp"
 #include "utility.hpp"
+#include "validator.hpp"
 #include "version.hpp"
 
 #include <CLI/CLI.hpp>
@@ -31,6 +32,7 @@
 {
     std::string psuPathVersion, psuPathModel;
     std::vector<std::string> versions;
+    bool validateUpdate = false;
     bool rawOutput = false;
     std::vector<std::string> updateArguments;
 
@@ -42,11 +44,17 @@
                        "Get PSU model from inventory path");
     action->add_option("-c,--compare", versions,
                        "Compare and get the latest version");
-    action
-        ->add_option("-u,--update", updateArguments,
-                     "Update PSU firmware, expecting two arguments: "
-                     "<PSU inventory path> <image-dir>")
-        ->expected(2);
+    auto updateOpt =
+        action
+            ->add_option("-u,--update", updateArguments,
+                         "Update PSU firmware, expecting two arguments: "
+                         "<PSU inventory path> <image-dir>")
+            ->expected(2)
+            ->type_name("PSU_PATH IMAGE_DIR");
+    app.add_flag(
+           "--validate", validateUpdate,
+           "Validate number of present PSU vs number of required PSUs and all PSUs have same model  before updating firmware")
+        ->needs(updateOpt);
     action->require_option(1); // Only one option is supported
     app.add_flag("--raw", rawOutput, "Output raw text without linefeed");
     CLI11_PARSE(app, argc, argv);
@@ -69,7 +77,18 @@
     if (!updateArguments.empty())
     {
         assert(updateArguments.size() == 2);
-        if (updater::update(bus, updateArguments[0], updateArguments[1]))
+        bool updateStatus = false;
+        if (validateUpdate)
+        {
+            updateStatus = updater::validateAndUpdate(bus, updateArguments[0],
+                                                      updateArguments[1]);
+        }
+        else
+        {
+            updateStatus =
+                updater::update(bus, updateArguments[0], updateArguments[1]);
+        }
+        if (updateStatus)
         {
             ret = "Update successful";
             lg2::info("Successful update to PSU: {PSU}", "PSU",
diff --git a/tools/power-utils/meson.build b/tools/power-utils/meson.build
index 790e1d2..f7c491e 100644
--- a/tools/power-utils/meson.build
+++ b/tools/power-utils/meson.build
@@ -5,6 +5,7 @@
     'aei_updater.cpp',
     'utils.cpp',
     'model.cpp',
+    'validator.cpp',
     'main.cpp',
     dependencies: [
         cli11_dep,
diff --git a/tools/power-utils/test/meson.build b/tools/power-utils/test/meson.build
index 3ac7b5c..ae29078 100644
--- a/tools/power-utils/test/meson.build
+++ b/tools/power-utils/test/meson.build
@@ -7,6 +7,8 @@
         'test_version.cpp',
         '../updater.cpp',
         '../aei_updater.cpp',
+        '../validator.cpp',
+        '../model.cpp',
         '../utils.cpp',
         '../version.cpp',
         dependencies: [gtest, gmock, nlohmann_json_dep, phosphor_logging],
diff --git a/tools/power-utils/updater.cpp b/tools/power-utils/updater.cpp
index 16e225f..07e74e9 100644
--- a/tools/power-utils/updater.cpp
+++ b/tools/power-utils/updater.cpp
@@ -21,6 +21,7 @@
 #include "types.hpp"
 #include "utility.hpp"
 #include "utils.hpp"
+#include "validator.hpp"
 #include "version.hpp"
 
 #include <phosphor-logging/lg2.hpp>
@@ -210,6 +211,22 @@
     return ret == 0;
 }
 
+bool validateAndUpdate(sdbusplus::bus_t& bus,
+                       const std::string& psuInventoryPath,
+                       const std::string& imageDir)
+{
+    auto poweredOn = phosphor::power::util::isPoweredOn(bus, true);
+    validator::PSUUpdateValidator psuValidator(bus, psuInventoryPath);
+    if (!poweredOn && psuValidator.validToUpdate())
+    {
+        return updater::update(bus, psuInventoryPath, imageDir);
+    }
+    else
+    {
+        return false;
+    }
+}
+
 Updater::Updater(const std::string& psuInventoryPath,
                  const std::string& devPath, const std::string& imageDir) :
     bus(sdbusplus::bus::new_default()), psuInventoryPath(psuInventoryPath),
diff --git a/tools/power-utils/updater.hpp b/tools/power-utils/updater.hpp
index 21bc4cd..79ecc5b 100644
--- a/tools/power-utils/updater.hpp
+++ b/tools/power-utils/updater.hpp
@@ -53,6 +53,21 @@
 bool update(sdbusplus::bus_t& bus, const std::string& psuInventoryPath,
             const std::string& imageDir);
 
+/**
+ * Validate number of present PSUs vs number of required PSUs for this system,
+ * and validate all PSUs have same model before proceeding to Update PSU
+ * firmware
+ *
+ * @param[in] bus - The sdbusplus DBus bus connection
+ * @param[in] psuInventoryPath - The inventory path of the PSU
+ * @param[in] imageDir - The directory containing the PSU image
+ *
+ * @return true if successful, otherwise false
+ */
+bool validateAndUpdate(sdbusplus::bus_t& bus,
+                       const std::string& psuInventoryPath,
+                       const std::string& imageDir);
+
 class Updater
 {
   public:
diff --git a/tools/power-utils/validator.cpp b/tools/power-utils/validator.cpp
new file mode 100644
index 0000000..7942be9
--- /dev/null
+++ b/tools/power-utils/validator.cpp
@@ -0,0 +1,170 @@
+#include "validator.hpp"
+
+#include "model.hpp"
+
+#include <phosphor-logging/lg2.hpp>
+
+#include <iostream>
+
+namespace validator
+{
+using namespace phosphor::power::util;
+constexpr auto supportedConfIntf =
+    "xyz.openbmc_project.Configuration.SupportedConfiguration";
+const auto IBMCFFPSInterface =
+    "xyz.openbmc_project.Configuration.IBMCFFPSConnector";
+const auto objectPath = "/";
+
+bool PSUUpdateValidator::areAllPsuSameModel()
+{
+    try
+    {
+        targetPsuModel = model::getModel(bus, psuPath);
+        psuPaths = getPSUInventoryPaths(bus);
+        for (const auto& path : psuPaths)
+        {
+            auto thisPsuModel = model::getModel(bus, path);
+            // All PSUs must have same model
+            if (targetPsuModel != thisPsuModel)
+            {
+                lg2::error(
+                    "PSU models do not match, targetPsuModel= {TARGET}, thisPsuModel= {THISPSU}",
+                    "TARGET", targetPsuModel, "THISPSU", thisPsuModel);
+                return false;
+            }
+        }
+    }
+    catch (const std::exception& e)
+    {
+        lg2::error("Failed to get all PSUs from EM, error {ERROR}", "ERROR", e);
+        return false;
+    }
+    return true;
+}
+
+bool PSUUpdateValidator::countPresentPsus()
+{
+    auto psuPaths = getPSUInventoryPaths(bus);
+    for (const auto& path : psuPaths)
+    {
+        auto present = false;
+        try
+        {
+            getProperty(INVENTORY_IFACE, PRESENT_PROP, path,
+                        INVENTORY_MGR_IFACE, bus, present);
+            if (present)
+            {
+                if (!isItFunctional(path))
+                {
+                    lg2::error("PSU {PATH} is not functional", "PATH", path);
+                    return false;
+                }
+
+                presentPsuCount++;
+            }
+        }
+        catch (const std::exception& e)
+        {
+            lg2::error("Failed to get PSU present status, error {ERR} ", "ERR",
+                       e);
+            return false;
+        }
+    }
+    return true;
+}
+
+bool PSUUpdateValidator::getRequiredPsus()
+{
+    try
+    {
+        supportedObjects = getSubTree(bus, objectPath, supportedConfIntf, 0);
+    }
+    catch (std::exception& e)
+    {
+        lg2::error("Failed to retrieve supported configuration");
+        return false;
+    }
+    for (const auto& [objPath, services] : supportedObjects)
+    {
+        if (objPath.empty() || services.empty())
+        {
+            continue;
+        }
+
+        std::string service = services.begin()->first;
+        try
+        {
+            properties =
+                getAllProperties(bus, objPath, supportedConfIntf, service);
+        }
+        catch (const std::exception& e)
+        {
+            lg2::error(
+                "Failed to get all PSU {PSUPATH} properties error: {ERR}",
+                "PSUPATH", objPath, "ERR", e);
+            return false;
+        }
+        auto propertyModel = properties.find("SupportedModel");
+        if (propertyModel == properties.end())
+        {
+            continue;
+        }
+        try
+        {
+            auto supportedModel = std::get<std::string>(propertyModel->second);
+            if ((supportedModel.empty()) || (supportedModel != targetPsuModel))
+            {
+                continue;
+            }
+        }
+        catch (const std::bad_variant_access& e)
+        {
+            lg2::error("Failed to get supportedModel, error: {ERR}", "ERR", e);
+        }
+
+        try
+        {
+            auto redundantCountProp = properties.find("RedundantCount");
+            if (redundantCountProp != properties.end())
+            {
+                redundantCount = static_cast<int>(
+                    std::get<uint64_t>(redundantCountProp->second));
+                break;
+            }
+        }
+        catch (const std::bad_variant_access& e)
+        {
+            lg2::error("Redundant type mismatch, error: {ERR}", "ERR", e);
+        }
+    }
+    return true;
+}
+
+bool PSUUpdateValidator::isItFunctional(const std::string& path)
+{
+    try
+    {
+        bool isFunctional = false;
+        getProperty(OPERATIONAL_STATE_IFACE, FUNCTIONAL_PROP, path,
+                    INVENTORY_MGR_IFACE, bus, isFunctional);
+        return isFunctional;
+    }
+    catch (const std::exception& e)
+    {
+        lg2::error("Failed to get PSU fault status, error {ERR} ", "ERR", e);
+        return false;
+    }
+}
+
+bool PSUUpdateValidator::validToUpdate()
+{
+    if (areAllPsuSameModel() && countPresentPsus() && getRequiredPsus())
+    {
+        if (presentPsuCount >= redundantCount)
+        {
+            return true;
+        }
+    }
+    return false;
+}
+} // namespace validator
diff --git a/tools/power-utils/validator.hpp b/tools/power-utils/validator.hpp
new file mode 100644
index 0000000..3ce235e
--- /dev/null
+++ b/tools/power-utils/validator.hpp
@@ -0,0 +1,101 @@
+/**
+ * Copyright © 2025 IBM Corporation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "types.hpp"
+#include "utility.hpp"
+
+#include <sdbusplus/bus.hpp>
+
+#include <string>
+
+namespace validator
+{
+using namespace phosphor::power::util;
+/**
+ * @class PSUUpdateValidator
+ * @brief This class validates PSU configurations in OpenBMC.
+ */
+class PSUUpdateValidator
+{
+  public:
+    /**
+     * @brief Constructor - Initializes D-Bus connection.
+     *
+     * @param bus The sdbusplus DBus bus connection
+     * @param psuPath PSU inventory path
+     */
+    PSUUpdateValidator(sdbusplus::bus_t& bus, const std::string& psuPath) :
+        bus(bus), psuPath(psuPath)
+    {}
+
+    /**
+     * @brief Checks if all PSUs are of the same model.
+     *
+     * @return true if all PSUs have the same model.
+     * @return false if any PSU has a different model.
+     */
+    bool areAllPsuSameModel();
+
+    /**
+     * @brief Counts the number of PSUs that are physically present and
+     * operational
+     *
+     * @return true if successfully counted present PSUs.
+     * @return false on failure.
+     */
+    bool countPresentPsus();
+
+    /**
+     * @brief Retrieves the required number of PSUs for redundancy.
+     *
+     * @return true if successfully retrieved redundancy count.
+     * @return false on failure.
+     */
+    bool getRequiredPsus();
+
+    /**
+     * @brief Ensure all PSUs have same model, validate all PSUs present
+     * and functional meet or exceed the number of PSUs required for this
+     * system
+     *
+     * @return true if all configuration requirement are met.
+     * @return otherwise false
+     */
+    bool validToUpdate();
+
+    /**
+     * @brief Retrieves the operational PSU status.
+     *
+     * @return true if operational
+     * @return false on operational failure.
+     */
+    bool isItFunctional(const std::string& path);
+
+  private:
+    sdbusplus::bus::bus& bus;          // D-Bus connection instance
+    std::vector<std::string> psuPaths; // List of PSU object paths
+    std::string targetPsuModel;        // Model name of the reference PSU
+    std::string psuPath;               // Path  of the referenced PSU
+    DbusSubtree supportedObjects;      // D-Bus PSU supported objects
+    DbusPropertyMap properties;        // D-Bus PSU properties
+    int presentPsuCount = 0;           // Count of physically present PSUs
+    int redundantCount = 0;            // Total number of PSUs required to be
+                                       // in this system configuration.
+};
+
+} // namespace validator