diff --git a/src/activation.cpp b/src/activation.cpp
index bfc3b39..5c90860 100644
--- a/src/activation.cpp
+++ b/src/activation.cpp
@@ -280,8 +280,7 @@
     auto psuManufacturer = utils::getProperty<std::string>(
         bus, service.c_str(), psuInventoryPath.c_str(), ASSET_IFACE,
         MANUFACTURER);
-    auto psuModel = utils::getProperty<std::string>(
-        bus, service.c_str(), psuInventoryPath.c_str(), ASSET_IFACE, MODEL);
+    auto psuModel = utils::getModel(psuInventoryPath);
     if (psuModel != model)
     {
         // The model shall match
diff --git a/src/item_updater.cpp b/src/item_updater.cpp
index a545bf3..44612b3 100644
--- a/src/item_updater.cpp
+++ b/src/item_updater.cpp
@@ -10,12 +10,13 @@
 
 #include <cassert>
 #include <filesystem>
+#include <format>
+#include <set>
 
 namespace
 {
 constexpr auto MANIFEST_VERSION = "version";
 constexpr auto MANIFEST_EXTENDED_VERSION = "extended_version";
-constexpr auto TIMEOUT = 10;
 } // namespace
 
 namespace phosphor
@@ -306,15 +307,38 @@
     {
         psuStatusMap[psuPath] = {false, ""};
 
-        // Add matches for PSU Inventory's property changes
+        // Add PropertiesChanged listener for Item interface so we are notified
+        // when Present property changes
         psuMatches.emplace_back(
             bus, MatchRules::propertiesChanged(psuPath, ITEM_IFACE),
             std::bind(&ItemUpdater::onPsuInventoryChangedMsg, this,
-                      std::placeholders::_1)); // For present
-        psuMatches.emplace_back(
-            bus, MatchRules::propertiesChanged(psuPath, ASSET_IFACE),
-            std::bind(&ItemUpdater::onPsuInventoryChangedMsg, this,
-                      std::placeholders::_1)); // For model
+                      std::placeholders::_1));
+    }
+}
+
+void ItemUpdater::handlePSUPresenceChanged(const std::string& psuPath)
+{
+    if (psuStatusMap.contains(psuPath))
+    {
+        if (psuStatusMap[psuPath].present)
+        {
+            // PSU is now present
+            psuStatusMap[psuPath].model = utils::getModel(psuPath);
+            auto version = utils::getVersion(psuPath);
+            if (!version.empty() && !psuPathActivationMap.contains(psuPath))
+            {
+                createPsuObject(psuPath, version);
+            }
+        }
+        else
+        {
+            // PSU is now missing
+            psuStatusMap[psuPath].model.clear();
+            if (psuPathActivationMap.contains(psuPath))
+            {
+                removePsuObject(psuPath);
+            }
+        }
     }
 }
 
@@ -345,94 +369,56 @@
 void ItemUpdater::onPsuInventoryChanged(const std::string& psuPath,
                                         const Properties& properties)
 {
-    std::optional<bool> present;
-    std::optional<std::string> model;
-
-    // The code was expecting to get callback on multiple properties changed.
-    // But in practice, the callback is received one-by-one for each property.
-    // So it has to handle Present and Version property separately.
-    auto p = properties.find(PRESENT);
-    if (p != properties.end())
+    try
     {
-        present = std::get<bool>(p->second);
-        psuStatusMap[psuPath].present = *present;
-    }
-    p = properties.find(MODEL);
-    if (p != properties.end())
-    {
-        model = std::get<std::string>(p->second);
-        psuStatusMap[psuPath].model = *model;
-    }
-
-    // If present or model is not changed, ignore
-    if (!present.has_value() && !model.has_value())
-    {
-        return;
-    }
-
-    if (psuStatusMap[psuPath].present)
-    {
-        // If model is not updated, let's wait for it
-        if (psuStatusMap[psuPath].model.empty())
+        if (psuStatusMap.contains(psuPath) && properties.contains(PRESENT))
         {
-            log<level::DEBUG>("Waiting for model to be updated");
-            return;
-        }
-
-        auto version = utils::getVersion(psuPath);
-        if (!version.empty())
-        {
-            if (psuPathActivationMap.find(psuPath) ==
-                psuPathActivationMap.end())
+            psuStatusMap[psuPath].present =
+                std::get<bool>(properties.at(PRESENT));
+            handlePSUPresenceChanged(psuPath);
+            if (psuStatusMap[psuPath].present)
             {
-                createPsuObject(psuPath, version);
+                // Check if there are new PSU images to update
+                processStoredImage();
+                syncToLatestImage();
             }
         }
-        else
-        {
-            // TODO: log an event
-            log<level::ERR>("Failed to get PSU version",
-                            entry("PSU=%s", psuPath.c_str()));
-        }
-        // Check if there are new PSU images to update
-        processStoredImage();
-        syncToLatestImage();
     }
-    else
+    catch (const std::exception& e)
     {
-        if (!present.has_value())
-        {
-            // If a PSU is plugged out, model property is update to empty as
-            // well, and we get callback here, but ignore that because it is
-            // handled by "Present" callback.
-            return;
-        }
-        psuStatusMap[psuPath].model = "";
-
-        // Remove object or association
-        removePsuObject(psuPath);
+        log<level::ERR>(
+            std::format(
+                "Unable to handle inventory PropertiesChanged event: {}",
+                e.what())
+                .c_str());
     }
 }
 
 void ItemUpdater::processPSUImage()
 {
-    auto paths = utils::getPSUInventoryPath(bus);
-    for (const auto& p : paths)
+    try
     {
-        addPsuToStatusMap(p);
-
-        auto service = utils::getService(bus, p.c_str(), ITEM_IFACE);
-        psuStatusMap[p].present = utils::getProperty<bool>(
-            bus, service.c_str(), p.c_str(), ITEM_IFACE, PRESENT);
-        psuStatusMap[p].model = utils::getProperty<std::string>(
-            bus, service.c_str(), p.c_str(), ASSET_IFACE, MODEL);
-        auto version = utils::getVersion(p);
-        if ((psuPathActivationMap.find(p) == psuPathActivationMap.end()) &&
-            psuStatusMap[p].present && !version.empty())
+        auto paths = utils::getPSUInventoryPath(bus);
+        for (const auto& p : paths)
         {
-            createPsuObject(p, version);
+            try
+            {
+                addPsuToStatusMap(p);
+                auto service = utils::getService(bus, p.c_str(), ITEM_IFACE);
+                psuStatusMap[p].present = utils::getProperty<bool>(
+                    bus, service.c_str(), p.c_str(), ITEM_IFACE, PRESENT);
+                handlePSUPresenceChanged(p);
+            }
+            catch (const std::exception& e)
+            {
+                // Ignore errors; the information might not be available yet
+            }
         }
     }
+    catch (const std::exception& e)
+    {
+        // Ignore errors; the information might not be available yet
+    }
 }
 
 void ItemUpdater::processStoredImage()
@@ -583,15 +569,19 @@
     auto paths = utils::getPSUInventoryPath(bus);
     for (const auto& p : paths)
     {
-        // As long as there is a PSU is not associated with the latest
+        // If there is a present PSU that is not associated with the latest
         // image, run the activation so that all PSUs are running the same
         // latest image.
-        if (!utils::isAssociated(p, assocs))
+        if (psuStatusMap.contains(p) && psuStatusMap[p].present)
         {
-            log<level::INFO>("Automatically update PSU",
-                             entry("VERSION_ID=%s", latestVersionId->c_str()));
-            invokeActivation(activation);
-            break;
+            if (!utils::isAssociated(p, assocs))
+            {
+                log<level::INFO>(
+                    "Automatically update PSU",
+                    entry("VERSION_ID=%s", latestVersionId->c_str()));
+                invokeActivation(activation);
+                break;
+            }
         }
     }
 }
@@ -604,74 +594,48 @@
 
 void ItemUpdater::onPSUInterfaceAdded(sdbusplus::message_t& msg)
 {
-    sdbusplus::message::object_path objPath;
-    std::map<std::string,
-             std::map<std::string, std::variant<bool, std::string>>>
-        interfaces;
-    msg.read(objPath, interfaces);
-    std::string path = objPath.str;
+    // Maintain static set of valid PSU paths. This is needed if PSU interface
+    // comes in a separate InterfacesAdded message from Item interface.
+    static std::set<std::string> psuPaths{};
 
-    if (interfaces.find(PSU_INVENTORY_IFACE) == interfaces.end())
+    try
     {
-        return;
-    }
+        sdbusplus::message::object_path objPath;
+        std::map<std::string,
+                 std::map<std::string, std::variant<bool, std::string>>>
+            interfaces;
+        msg.read(objPath, interfaces);
+        std::string path = objPath.str;
 
-    addPsuToStatusMap(path);
-
-    if (psuStatusMap[path].present && !psuStatusMap[path].model.empty())
-    {
-        return;
-    }
-
-    auto timeout = std::chrono::steady_clock::now() +
-                   std::chrono::seconds(TIMEOUT);
-
-    // Poll the inventory item until it gets the present property
-    // or the timeout is reached
-    while (std::chrono::steady_clock::now() < timeout)
-    {
-        try
+        if (interfaces.contains(PSU_INVENTORY_IFACE))
         {
-            psuStatusMap[path].present = utils::getProperty<bool>(
-                bus, msg.get_sender(), path.c_str(), ITEM_IFACE, PRESENT);
-            break;
+            psuPaths.insert(path);
         }
-        catch (const std::exception& e)
+
+        if (interfaces.contains(ITEM_IFACE) && psuPaths.contains(path) &&
+            !psuStatusMap.contains(path))
         {
-            auto err = errno;
-            log<level::INFO>(
-                std::format("Failed to get Inventory Item Present. errno={}",
-                            err)
-                    .c_str());
-            sleep(1);
+            auto interface = interfaces[ITEM_IFACE];
+            if (interface.contains(PRESENT))
+            {
+                addPsuToStatusMap(path);
+                psuStatusMap[path].present = std::get<bool>(interface[PRESENT]);
+                handlePSUPresenceChanged(path);
+                if (psuStatusMap[path].present)
+                {
+                    // Check if there are new PSU images to update
+                    processStoredImage();
+                    syncToLatestImage();
+                }
+            }
         }
     }
-
-    // Poll the inventory item until it retrieves model or the timeout is
-    // reached. The model is the path trail of the firmware's and manifest
-    // subdirectory. If the model not found the firmware and manifest
-    // cannot be located.
-    timeout = std::chrono::steady_clock::now() + std::chrono::seconds(TIMEOUT);
-    while (std::chrono::steady_clock::now() < timeout &&
-           psuStatusMap[path].present)
+    catch (const std::exception& e)
     {
-        try
-        {
-            psuStatusMap[path].model = utils::getProperty<std::string>(
-                bus, msg.get_sender(), path.c_str(), ASSET_IFACE, MODEL);
-            processPSUImageAndSyncToLatest();
-            break;
-        }
-        catch (const std::exception& e)
-        {
-            auto err = errno;
-            log<level::INFO>(
-                std::format(
-                    "Failed to get Inventory Decorator Asset model. errno={}",
-                    err)
-                    .c_str());
-            sleep(1);
-        }
+        log<level::ERR>(
+            std::format("Unable to handle inventory InterfacesAdded event: {}",
+                        e.what())
+                .c_str());
     }
 }
 
diff --git a/src/item_updater.hpp b/src/item_updater.hpp
index 885847a..e8a489c 100644
--- a/src/item_updater.hpp
+++ b/src/item_updater.hpp
@@ -164,14 +164,20 @@
     void removePsuObject(const std::string& psuInventoryPath);
 
     /** @brief Add PSU inventory path to the PSU status map
-     *  @details Also adds PropertiesChanged listeners for the inventory path so
-     *           we are notified when the present or model properties change.
+     *  @details Also adds a PropertiesChanged listener for the inventory path
+     *           so we are notified when the Present property changes.
      *           Does nothing if the inventory path already exists in the map.
      *
      * @param[in]  psuPath - The PSU inventory path
      */
     void addPsuToStatusMap(const std::string& psuPath);
 
+    /** @brief Handle a change in presence for a PSU.
+     *
+     * @param[in]  psuPath - The PSU inventory path
+     */
+    void handlePSUPresenceChanged(const std::string& psuPath);
+
     /**
      * @brief Create and populate the active PSU Version.
      */
diff --git a/src/utils.cpp b/src/utils.cpp
index 3b611d7..316ef31 100644
--- a/src/utils.cpp
+++ b/src/utils.cpp
@@ -157,13 +157,22 @@
 
 std::string Utils::getVersion(const std::string& inventoryPath) const
 {
-    // Invoke vendor-specify tool to get the version string, e.g.
-    //   psutils get-version
+    // Invoke vendor-specific tool to get the version string, e.g.
+    //   psutils --get-version
     //   /xyz/openbmc_project/inventory/system/chassis/motherboard/powersupply0
     auto [rc, r] = internal::exec(PSU_VERSION_UTIL, inventoryPath);
     return (rc == 0) ? r : "";
 }
 
+std::string Utils::getModel(const std::string& inventoryPath) const
+{
+    // Invoke vendor-specific tool to get the model string, e.g.
+    //   psutils --get-model
+    //   /xyz/openbmc_project/inventory/system/chassis/motherboard/powersupply0
+    auto [rc, r] = internal::exec(PSU_MODEL_UTIL, inventoryPath);
+    return (rc == 0) ? r : "";
+}
+
 std::string Utils::getLatestVersion(const std::set<std::string>& versions) const
 {
     if (versions.empty())
diff --git a/src/utils.hpp b/src/utils.hpp
index be85494..3b033fc 100644
--- a/src/utils.hpp
+++ b/src/utils.hpp
@@ -80,10 +80,18 @@
  *
  * @param[in] inventoryPath - The PSU inventory object path
  *
- * @return The version string, or empry string if it fails to get the version
+ * @return The version string, or empty string if it fails to get the version
  */
 std::string getVersion(const std::string& inventoryPath);
 
+/** @brief Get model of PSU specified by the inventory path
+ *
+ * @param[in] inventoryPath - The PSU inventory object path
+ *
+ * @return The model string, or empty string if it fails to get the model
+ */
+std::string getModel(const std::string& inventoryPath);
+
 /** @brief Get latest version from the PSU versions
  *
  * @param[in] versions - The list of the versions
@@ -133,6 +141,8 @@
 
     virtual std::string getVersion(const std::string& inventoryPath) const = 0;
 
+    virtual std::string getModel(const std::string& inventoryPath) const = 0;
+
     virtual std::string
         getLatestVersion(const std::set<std::string>& versions) const = 0;
 
@@ -171,6 +181,8 @@
 
     std::string getVersion(const std::string& inventoryPath) const override;
 
+    std::string getModel(const std::string& inventoryPath) const override;
+
     std::string
         getLatestVersion(const std::set<std::string>& versions) const override;
 
@@ -209,6 +221,11 @@
     return getUtils().getVersion(inventoryPath);
 }
 
+inline std::string getModel(const std::string& inventoryPath)
+{
+    return getUtils().getModel(inventoryPath);
+}
+
 inline std::string getLatestVersion(const std::set<std::string>& versions)
 {
     return getUtils().getLatestVersion(versions);