diff --git a/control/json/actions/action.hpp b/control/json/actions/action.hpp
index cfee7af..358e33a 100644
--- a/control/json/actions/action.hpp
+++ b/control/json/actions/action.hpp
@@ -15,7 +15,7 @@
  */
 #pragma once
 
-#include "types.hpp"
+#include "group.hpp"
 #include "zone.hpp"
 
 #include <fmt/format.h>
diff --git a/control/json/actions/default_floor.cpp b/control/json/actions/default_floor.cpp
index 5970ae2..1f95ffa 100644
--- a/control/json/actions/default_floor.cpp
+++ b/control/json/actions/default_floor.cpp
@@ -15,8 +15,9 @@
  */
 #include "default_floor.hpp"
 
-#include "types.hpp"
-#include "zone.hpp"
+#include "../manager.hpp"
+#include "../zone.hpp"
+#include "group.hpp"
 
 #include <nlohmann/json.hpp>
 
@@ -35,18 +36,18 @@
 
 void DefaultFloor::run(Zone& zone, const Group& group)
 {
-    // Set/update the services of the group
-    zone.setServices(&group);
-    auto services = zone.getGroupServices(&group);
-    auto defFloor =
-        std::any_of(services.begin(), services.end(),
-                    [](const auto& s) { return !std::get<hasOwnerPos>(s); });
-    if (defFloor)
+    const auto& members = group.getMembers();
+    auto isMissingOwner =
+        std::any_of(members.begin(), members.end(),
+                    [&intf = group.getInterface()](const auto& member) {
+                        return !Manager::hasOwner(member, intf);
+                    });
+    if (isMissingOwner)
     {
-        zone.setFloor(zone.getDefFloor());
+        zone.setFloor(zone.getDefaultFloor());
     }
     // Update fan control floor change allowed
-    zone.setFloorChangeAllow(&group, !defFloor);
+    zone.setFloorChangeAllow(group.getName(), !isMissingOwner);
 }
 
 } // namespace phosphor::fan::control::json
diff --git a/control/json/actions/default_floor.hpp b/control/json/actions/default_floor.hpp
index 5aa4182..3eeb13d 100644
--- a/control/json/actions/default_floor.hpp
+++ b/control/json/actions/default_floor.hpp
@@ -15,9 +15,9 @@
  */
 #pragma once
 
+#include "../zone.hpp"
 #include "action.hpp"
-#include "types.hpp"
-#include "zone.hpp"
+#include "group.hpp"
 
 #include <nlohmann/json.hpp>
 
diff --git a/control/json/group.hpp b/control/json/group.hpp
index e8d607f..e99687f 100644
--- a/control/json/group.hpp
+++ b/control/json/group.hpp
@@ -79,6 +79,38 @@
         return _service;
     }
 
+    /**
+     * @brief Set the dbus interface name for the group
+     */
+    inline void setInterface(std::string& intf)
+    {
+        _interface = intf;
+    }
+
+    /**
+     * @brief Get the group's dbus interface name
+     */
+    inline const auto& getInterface() const
+    {
+        return _interface;
+    }
+
+    /**
+     * @brief Set the dbus property name for the group
+     */
+    inline void setProperty(std::string& prop)
+    {
+        _property = prop;
+    }
+
+    /**
+     * @brief Get the group's dbus property name
+     */
+    inline const auto& getProperty() const
+    {
+        return _property;
+    }
+
   private:
     /* Members of the group */
     std::vector<std::string> _members;
@@ -86,6 +118,12 @@
     /* Service name serving all the members */
     std::string _service;
 
+    /* Dbus interface name for all the members */
+    std::string _interface;
+
+    /* Dbus property name for all the members */
+    std::string _property;
+
     /**
      * @brief Parse and set the members list
      *
diff --git a/control/json/manager.cpp b/control/json/manager.cpp
index 78aac29..cf8b070 100644
--- a/control/json/manager.cpp
+++ b/control/json/manager.cpp
@@ -34,6 +34,9 @@
 using json = nlohmann::json;
 
 std::vector<std::string> Manager::_activeProfiles;
+std::map<std::string,
+         std::map<std::pair<std::string, bool>, std::vector<std::string>>>
+    Manager::_servTree;
 
 Manager::Manager(sdbusplus::bus::bus& bus, const sdeventplus::Event& event) :
     _bus(bus), _event(event)
@@ -73,6 +76,29 @@
     return _activeProfiles;
 }
 
+bool Manager::hasOwner(const std::string& path, const std::string& intf)
+{
+    auto itServ = _servTree.find(path);
+    if (itServ == _servTree.end())
+    {
+        // Path not found in cache, therefore owner missing
+        return false;
+    }
+    for (const auto& serv : itServ->second)
+    {
+        auto itIntf = std::find_if(
+            serv.second.begin(), serv.second.end(),
+            [&intf](const auto& interface) { return intf == interface; });
+        if (itIntf != std::end(serv.second))
+        {
+            // Service found, return owner state
+            return serv.first.second;
+        }
+    }
+    // Interface not found in cache, therefore owner missing
+    return false;
+}
+
 unsigned int Manager::getPowerOnDelay()
 {
     auto powerOnDelay = 0;
diff --git a/control/json/manager.hpp b/control/json/manager.hpp
index 60cf2b7..8919b63 100644
--- a/control/json/manager.hpp
+++ b/control/json/manager.hpp
@@ -135,6 +135,17 @@
     }
 
     /**
+     * @brief Check if the given path and inteface is owned by a dbus service
+     *
+     * @param[in] path - Dbus object path
+     * @param[in] intf - Dbus object interface
+     *
+     * @return - Whether the service has an owner for the given object path and
+     * interface
+     */
+    static bool hasOwner(const std::string& path, const std::string& intf);
+
+    /**
      * @brief Get the configured power on delay(OPTIONAL)
      *
      * @return Power on delay in seconds
@@ -165,6 +176,11 @@
     /* List of active profiles */
     static std::vector<std::string> _activeProfiles;
 
+    /* Subtree map of paths to services (with ownership state) of interfaces */
+    static std::map<std::string, std::map<std::pair<std::string, bool>,
+                                          std::vector<std::string>>>
+        _servTree;
+
     /* List of zones configured */
     std::map<configKey, std::unique_ptr<Zone>> _zones;
 
diff --git a/control/json/zone.cpp b/control/json/zone.cpp
index 11b7814..243fade 100644
--- a/control/json/zone.cpp
+++ b/control/json/zone.cpp
@@ -43,7 +43,7 @@
                                  {currentProp, zone::property::current}}}};
 
 Zone::Zone(sdbusplus::bus::bus& bus, const json& jsonObj) :
-    ConfigBase(jsonObj), _incDelay(0)
+    ConfigBase(jsonObj), _incDelay(0), _floor(0), _target(0)
 {
     if (jsonObj.contains("profiles"))
     {
@@ -72,6 +72,26 @@
     _fans.emplace_back(std::move(fan));
 }
 
+void Zone::setFloor(uint64_t target)
+{
+    // Check all entries are set to allow floor to be set
+    auto pred = [](auto const& entry) { return entry.second; };
+    if (std::all_of(_floorChange.begin(), _floorChange.end(), pred))
+    {
+        _floor = target;
+        // Floor above target, update target to floor
+        if (_target < _floor)
+        {
+            requestIncrease(_floor - _target);
+        }
+    }
+}
+
+void Zone::requestIncrease(uint64_t targetDelta)
+{
+    // TODO Add from `requestSpeedIncrease` method in YAML zone object
+}
+
 void Zone::setFullSpeed(const json& jsonObj)
 {
     if (!jsonObj.contains("full_speed"))
@@ -81,6 +101,8 @@
         throw std::runtime_error("Missing required zone's full speed");
     }
     _fullSpeed = jsonObj["full_speed"].get<uint64_t>();
+    // Start with the current target set as the default
+    _target = _fullSpeed;
 }
 
 void Zone::setDefaultFloor(const json& jsonObj)
@@ -92,6 +114,8 @@
         throw std::runtime_error("Missing required zone's default floor speed");
     }
     _defaultFloor = jsonObj["default_floor"].get<uint64_t>();
+    // Start with the current floor set as the default
+    _floor = _defaultFloor;
 }
 
 void Zone::setDecInterval(const json& jsonObj)
diff --git a/control/json/zone.hpp b/control/json/zone.hpp
index 2ed3166..b91af2f 100644
--- a/control/json/zone.hpp
+++ b/control/json/zone.hpp
@@ -160,6 +160,33 @@
      */
     void addFan(std::unique_ptr<Fan> fan);
 
+    /**
+     * @brief Set the floor to the given target and increase target to the floor
+     * when the target is below the floor value when floor changes are allowed.
+     *
+     * @param[in] target - Target to set the floor to
+     */
+    void setFloor(uint64_t target);
+
+    /**
+     * @brief Sets the floor change allowed state
+     *
+     * @param[in] ident - An identifier that affects floor changes
+     * @param[in] isAllow - Allow state according to the identifier
+     */
+    inline void setFloorChangeAllow(const std::string& ident, bool isAllow)
+    {
+        _floorChange[ident] = isAllow;
+    }
+
+    /**
+     * @brief Calculate the requested target from the given delta and increases
+     * the fans, not going above the ceiling.
+     *
+     * @param[in] targetDelta - The delta to increase the target by
+     */
+    void requestIncrease(uint64_t targetDelta);
+
   private:
     /* The zone's full speed value for fans */
     uint64_t _fullSpeed;
@@ -173,6 +200,15 @@
     /* Zone's speed decrease interval(in seconds) */
     uint64_t _decInterval;
 
+    /* The floor target to not go below */
+    uint64_t _floor;
+
+    /* Target for this zone */
+    uint64_t _target;
+
+    /* Map of whether floor changes are allowed by a string identifier */
+    std::map<std::string, bool> _floorChange;
+
     /**
      * Zone interface handler functions for its
      * configured interfaces (OPTIONAL)