diff --git a/activation.cpp b/activation.cpp
index 33b1e00..56ce157 100644
--- a/activation.cpp
+++ b/activation.cpp
@@ -357,6 +357,10 @@
 
 bool Activation::checkApplyTimeImmediate()
 {
+    if (parent.useUpdateDBusInterface)
+    {
+        return (applyTime == ApplyTimeIntf::RequestedApplyTimes::Immediate);
+    }
     auto service = utils::getService(bus, applyTimeObjPath, applyTimeIntf);
     if (service.empty())
     {
diff --git a/activation.hpp b/activation.hpp
index 22e0445..4ec621b 100644
--- a/activation.hpp
+++ b/activation.hpp
@@ -11,6 +11,7 @@
 #include <xyz/openbmc_project/Association/Definitions/server.hpp>
 #include <xyz/openbmc_project/Software/Activation/server.hpp>
 #include <xyz/openbmc_project/Software/ActivationBlocksTransition/server.hpp>
+#include <xyz/openbmc_project/Software/ApplyTime/common.hpp>
 
 #ifdef WANT_SIGNATURE_VERIFY
 #include <filesystem>
@@ -39,6 +40,8 @@
     sdbusplus::server::xyz::openbmc_project::software::RedundancyPriority>;
 using ActivationProgressInherit = sdbusplus::server::object_t<
     sdbusplus::server::xyz::openbmc_project::software::ActivationProgress>;
+using ApplyTimeIntf =
+    sdbusplus::common::xyz::openbmc_project::software::ApplyTime;
 
 constexpr auto applyTimeImmediate =
     "xyz.openbmc_project.Software.ApplyTime.RequestedApplyTimes.Immediate";
@@ -327,6 +330,9 @@
     /** @brief Persistent ActivationProgress dbus object */
     std::unique_ptr<ActivationProgress> activationProgress;
 
+    /** @brief Apply time */
+    ApplyTimeIntf::RequestedApplyTimes applyTime;
+
     /** @brief Used to subscribe to dbus systemd signals **/
     sdbusplus::bus::match_t systemdSignals;
 
diff --git a/item_updater.cpp b/item_updater.cpp
index e2282f7..247e1d3 100644
--- a/item_updater.cpp
+++ b/item_updater.cpp
@@ -43,7 +43,6 @@
 {
     using SVersion = server::Version;
     using VersionPurpose = SVersion::VersionPurpose;
-    using VersionClass = phosphor::software::manager::Version;
 
     sdbusplus::message::object_path objPath;
     auto purpose = VersionPurpose::Unknown;
@@ -133,46 +132,105 @@
 
     if (activations.find(versionId) == activations.end())
     {
-        // Determine the Activation state by processing the given image dir.
-        auto activationState = server::Activation::Activations::Invalid;
-        ItemUpdater::ActivationStatus result;
-        if (purpose == VersionPurpose::BMC || purpose == VersionPurpose::System)
-        {
-            result = ItemUpdater::validateSquashFSImage(filePath);
-        }
-        else
-        {
-            result = ItemUpdater::ActivationStatus::ready;
-        }
-        AssociationList associations;
-
-        if (result == ItemUpdater::ActivationStatus::ready)
-        {
-            activationState = server::Activation::Activations::Ready;
-            // Create an association to the BMC inventory item
-            associations.emplace_back(
-                std::make_tuple(ACTIVATION_FWD_ASSOCIATION,
-                                ACTIVATION_REV_ASSOCIATION, bmcInventoryPath));
-        }
-
-        auto versionPtr = std::make_unique<VersionClass>(
-            bus, path, version, purpose, extendedVersion, filePath,
-            compatibleNames,
-            std::bind(&ItemUpdater::erase, this, std::placeholders::_1),
-            versionId);
-        versionPtr->deleteObject =
-            std::make_unique<phosphor::software::manager::Delete>(
-                bus, path, *versionPtr);
-        versions.insert(std::make_pair(versionId, std::move(versionPtr)));
-
-        activations.insert(std::make_pair(
-            versionId,
-            std::make_unique<Activation>(bus, path, *this, versionId,
-                                         activationState, associations)));
+        verifyAndCreateObjects(versionId, path, version, purpose,
+                               extendedVersion, filePath, compatibleNames);
     }
     return;
 }
 
+void ItemUpdater::createActivationWithApplyTime(
+    std::string& id, std::string& path,
+    ApplyTimeIntf::RequestedApplyTimes applyTime)
+{
+    info("Creating Activation object for id: {ID}", "ID", id);
+    AssociationList associations = {};
+    // Create an association to the BMC inventory item
+    associations.emplace_back(
+        std::make_tuple(ACTIVATION_FWD_ASSOCIATION, ACTIVATION_REV_ASSOCIATION,
+                        bmcInventoryPath));
+    activations.insert(std::make_pair(
+        id, std::make_unique<Activation>(
+                bus, path, *this, id, server::Activation::Activations::NotReady,
+                associations)));
+    activations[id]->applyTime = applyTime;
+}
+
+ActivationIntf::Activations ItemUpdater::verifyAndCreateObjects(
+    std::string& id, std::string& path, std::string& version,
+    VersionClass::VersionPurpose purpose, std::string& extendedVersion,
+    std ::string& filePath, std::vector<std::string>& compatibleNames)
+{
+    // Determine the Activation state by processing the given image dir.
+    auto activationState = server::Activation::Activations::Invalid;
+    ItemUpdater::ActivationStatus result;
+    if (purpose == VersionPurpose::BMC || purpose == VersionPurpose::System)
+    {
+        result = ItemUpdater::validateSquashFSImage(filePath);
+    }
+    else
+    {
+        result = ItemUpdater::ActivationStatus::ready;
+    }
+
+    AssociationList associations = {};
+
+    if (result == ItemUpdater::ActivationStatus::ready)
+    {
+        activationState = server::Activation::Activations::Ready;
+        // Create an association to the BMC inventory item
+        associations.emplace_back(
+            std::make_tuple(ACTIVATION_FWD_ASSOCIATION,
+                            ACTIVATION_REV_ASSOCIATION, bmcInventoryPath));
+    }
+
+    auto versionPtr = std::make_unique<VersionClass>(
+        bus, path, version, purpose, extendedVersion, filePath, compatibleNames,
+        std::bind(&ItemUpdater::erase, this, std::placeholders::_1), id);
+    versionPtr->deleteObject =
+        std::make_unique<phosphor::software::manager::Delete>(
+            bus, path, *versionPtr);
+    versions.insert(std::make_pair(id, std::move(versionPtr)));
+
+    auto activation = activations.find(id);
+    if (activation == activations.end())
+    {
+        activations.insert(std::make_pair(
+            id, std::make_unique<Activation>(bus, path, *this, id,
+                                             activationState, associations)));
+    }
+    else
+    {
+        activation->second->activation(activationState);
+    }
+    return activationState;
+}
+
+bool ItemUpdater::requestActivation(std::string& id)
+{
+    auto activation = activations.find(id);
+    if (activation == activations.end())
+    {
+        error("Activation object not found for id: {ID}", "ID", id);
+        return false;
+    }
+    activation->second->requestedActivation(
+        server::Activation::RequestedActivations::Active);
+    return true;
+}
+
+bool ItemUpdater::updateActivationStatus(std::string& id,
+                                         ActivationIntf::Activations status)
+{
+    auto activation = activations.find(id);
+    if (activation == activations.end())
+    {
+        error("Activation object not found for id: {ID}", "ID", id);
+        return false;
+    }
+    activation->second->activation(status);
+    return true;
+}
+
 void ItemUpdater::processBMCImage()
 {
     using VersionClass = phosphor::software::manager::Version;
diff --git a/item_updater.hpp b/item_updater.hpp
index 9768627..1f3c0f1 100644
--- a/item_updater.hpp
+++ b/item_updater.hpp
@@ -6,6 +6,7 @@
 #include "version.hpp"
 #include "xyz/openbmc_project/Collection/DeleteAll/server.hpp"
 
+#include <sdbusplus/async.hpp>
 #include <sdbusplus/server.hpp>
 #include <xyz/openbmc_project/Association/Definitions/server.hpp>
 #include <xyz/openbmc_project/Common/FactoryReset/server.hpp>
@@ -22,6 +23,8 @@
 namespace updater
 {
 
+using ActivationIntf =
+    sdbusplus::xyz::openbmc_project::Software::server::Activation;
 using ItemUpdaterInherit = sdbusplus::server::object_t<
     sdbusplus::server::xyz::openbmc_project::common::FactoryReset,
     sdbusplus::server::xyz::openbmc_project::control::FieldMode,
@@ -73,16 +76,22 @@
      *
      * @param[in] bus    - The D-Bus bus object
      */
-    ItemUpdater(sdbusplus::bus_t& bus, const std::string& path) :
-        ItemUpdaterInherit(bus, path.c_str(),
+    ItemUpdater(sdbusplus::async::context& ctx, const std::string& path,
+                bool useUpdateDBusInterface = true) :
+        ItemUpdaterInherit(ctx.get_bus(), path.c_str(),
                            ItemUpdaterInherit::action::defer_emit),
-        bus(bus), helper(bus),
-        versionMatch(bus,
-                     MatchRules::interfacesAdded() +
-                         MatchRules::path("/xyz/openbmc_project/software"),
-                     std::bind(std::mem_fn(&ItemUpdater::createActivation),
-                               this, std::placeholders::_1))
+        useUpdateDBusInterface(useUpdateDBusInterface), bus(ctx.get_bus()),
+        helper(bus)
     {
+        if (!useUpdateDBusInterface)
+        {
+            versionMatch = std::make_unique<sdbusplus::bus::match_t>(
+                bus,
+                MatchRules::interfacesAdded() +
+                    MatchRules::path("/xyz/openbmc_project/software"),
+                std::bind(std::mem_fn(&ItemUpdater::createActivation), this,
+                          std::placeholders::_1));
+        }
         getRunningSlot();
         setBMCInventoryPath();
         processBMCImage();
@@ -118,6 +127,50 @@
     void processBMCImage();
 
     /**
+     * @brief Verifies the image at filepath and creates the version and
+     * activation object. In case activation object already exists for the
+     * specified id, update the activation status based on image verification.
+     * @param[in] id - The unique identifier for the update.
+     * @param[in] path - The object path for the relevant objects.
+     * @param[in] version - The version of the image.
+     * @param[in] purpose - The purpose of the image.
+     * @param[in] extendedVersion The extended version of the image.
+     * @param[in] filePath - The file path where the image is located.
+     * @param[in] compatibleNames - The compatible name for the image.
+     * @param[out] Activations - Whether the image is ready to activate or not.
+     */
+    ActivationIntf::Activations verifyAndCreateObjects(
+        std::string& id, std::string& path, std::string& version,
+        VersionClass::VersionPurpose purpose, std::string& extendedVersion,
+        std ::string& filePath, std::vector<std::string>& compatibleNames);
+
+    /**
+     * @brief Creates the activation object
+     * @param[in] id - The unique identifier for the update.
+     * @param[in] path - The object path for the activation object.
+     * @param[in] applyTime - The apply time for the image
+     */
+    void createActivationWithApplyTime(
+        std::string& id, std::string& path,
+        ApplyTimeIntf::RequestedApplyTimes applyTime);
+
+    /**
+     * @brief Request the activation for the specified update.
+     * @param[in] id - The unique identifier for the update.
+     * @param[out] bool - status for the action.
+     */
+    bool requestActivation(std::string& id);
+
+    /**
+     * @brief Change the activation status for the specified update.
+     * @param[in] id - The unique identifier for the update.
+     * @param[in] status - The activation status to set.
+     * @param[out] bool - status for the action.
+     */
+    bool updateActivationStatus(std::string& id,
+                                ActivationIntf::Activations status);
+
+    /**
      * @brief Erase specified entry D-Bus object
      *        if Action property is not set to Active
      *
@@ -196,6 +249,9 @@
     /** @brief The slot of running BMC image */
     uint32_t runningImageSlot = 0;
 
+    /** @brief Flag to indicate if the update interface is used or not */
+    bool useUpdateDBusInterface;
+
   private:
     /** @brief Callback function for Software.Version match.
      *  @details Creates an Activation D-Bus object.
@@ -257,7 +313,7 @@
     std::map<std::string, std::unique_ptr<Activation>> activations;
 
     /** @brief sdbusplus signal match for Software.Version */
-    sdbusplus::bus::match_t versionMatch;
+    std::unique_ptr<sdbusplus::bus::match_t> versionMatch;
 
     /** @brief This entry's associations */
     AssociationList assocs;
diff --git a/item_updater_main.cpp b/item_updater_main.cpp
index 790af60..e0c9c18 100644
--- a/item_updater_main.cpp
+++ b/item_updater_main.cpp
@@ -15,16 +15,17 @@
 
 int main()
 {
-    sdbusplus::asio::connection bus(getIOContext());
+    sdbusplus::async::context ctx;
 
     // Add sdbusplus ObjectManager.
-    sdbusplus::server::manager_t objManager(bus, SOFTWARE_OBJPATH);
+    sdbusplus::server::manager_t objManager(ctx, SOFTWARE_OBJPATH);
 
-    phosphor::software::updater::ItemUpdater updater(bus, SOFTWARE_OBJPATH);
+    phosphor::software::updater::ItemUpdater updater(ctx, SOFTWARE_OBJPATH,
+                                                     false);
 
-    bus.request_name(BUSNAME_UPDATER);
+    ctx.request_name(BUSNAME_UPDATER);
 
-    getIOContext().run();
+    ctx.run();
 
     return 0;
 }