diff --git a/control/json/actions/timer_based_actions.cpp b/control/json/actions/timer_based_actions.cpp
new file mode 100644
index 0000000..52f35a2
--- /dev/null
+++ b/control/json/actions/timer_based_actions.cpp
@@ -0,0 +1,221 @@
+/**
+ * Copyright © 2021 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.
+ */
+#include "timer_based_actions.hpp"
+
+#include "../manager.hpp"
+#include "action.hpp"
+#include "event.hpp"
+#include "group.hpp"
+#include "sdbusplus.hpp"
+#include "sdeventplus.hpp"
+#include "zone.hpp"
+
+#include <fmt/format.h>
+
+#include <nlohmann/json.hpp>
+
+#include <algorithm>
+#include <chrono>
+
+namespace phosphor::fan::control::json
+{
+
+using json = nlohmann::json;
+
+TimerBasedActions::TimerBasedActions(const json& jsonObj,
+                                     const std::vector<Group>& groups) :
+    ActionBase(jsonObj, groups),
+    _timer(util::SDEventPlus::getEvent(),
+           std::bind(&TimerBasedActions::timerExpired, this))
+{
+    // If any of groups' value == nullopt(i.e. not configured), action is
+    // driven by the service owned state of the group members
+    _byOwner =
+        std::any_of(_groups.begin(), _groups.end(), [](const auto& group) {
+            return group.getValue() == std::nullopt;
+        });
+
+    setTimerConf(jsonObj);
+    setActions(jsonObj);
+}
+
+void TimerBasedActions::run(Zone& zone)
+{
+    if (_byOwner)
+    {
+        // If any service providing a group member is not owned, start
+        // timer and if all members' services are owned, stop timer.
+        if (std::any_of(_groups.begin(), _groups.end(), [](const auto& group) {
+                const auto& members = group.getMembers();
+                return std::any_of(members.begin(), members.end(),
+                                   [&group](const auto& member) {
+                                       return !Manager::hasOwner(
+                                           member, group.getInterface());
+                                   });
+            }))
+        {
+            startTimer();
+        }
+        else
+        {
+            stopTimer();
+        }
+    }
+    else
+    {
+        auto* mgr = zone.getManager();
+        // If all group members have a given value and it matches what's
+        // in the cache, start timer and if any do not match, stop
+        // timer.
+        if (std::all_of(
+                _groups.begin(), _groups.end(), [&mgr](const auto& group) {
+                    const auto& members = group.getMembers();
+                    return std::all_of(members.begin(), members.end(),
+                                       [&mgr, &group](const auto& member) {
+                                           return group.getValue() ==
+                                                  mgr->getProperty(
+                                                      member,
+                                                      group.getInterface(),
+                                                      group.getProperty());
+                                       });
+                }))
+        {
+            // Timer will be started(and never stopped) when _groups is empty
+            startTimer();
+        }
+        else
+        {
+            stopTimer();
+        }
+    }
+}
+
+void TimerBasedActions::startTimer()
+{
+    if (!_timer.isEnabled())
+    {
+        if (_type == TimerType::repeating)
+        {
+            _timer.restart(_interval);
+        }
+        else if (_type == TimerType::oneshot)
+        {
+            _timer.restartOnce(_interval);
+        }
+    }
+}
+
+void TimerBasedActions::stopTimer()
+{
+    if (_timer.isEnabled())
+    {
+        _timer.setEnabled(false);
+    }
+}
+
+void TimerBasedActions::timerExpired()
+{
+    // Perform the actions
+    std::for_each(_actions.begin(), _actions.end(),
+                  [](auto& action) { action->run(); });
+}
+
+void TimerBasedActions::setZones(
+    std::vector<std::reference_wrapper<Zone>>& zones)
+{
+    for (auto& zone : zones)
+    {
+        this->addZone(zone);
+        // Add zone to _actions
+        std::for_each(_actions.begin(), _actions.end(),
+                      [&zone](std::unique_ptr<ActionBase>& action) {
+                          action->addZone(zone);
+                      });
+    }
+}
+
+void TimerBasedActions::setTimerConf(const json& jsonObj)
+{
+    if (!jsonObj.contains("timer"))
+    {
+        throw ActionParseError{getName(), "Missing required timer entry"};
+    }
+    auto jsonTimer = jsonObj["timer"];
+    if (!jsonTimer.contains("interval") || !jsonTimer.contains("type"))
+    {
+        throw ActionParseError{
+            getName(), "Missing required timer parameters {interval, type}"};
+    }
+
+    // Interval provided in microseconds
+    _interval = static_cast<std::chrono::microseconds>(
+        jsonTimer["interval"].get<uint64_t>());
+
+    // Retrieve type of timer
+    auto type = jsonTimer["type"].get<std::string>();
+    if (type == "oneshot")
+    {
+        _type = TimerType::oneshot;
+    }
+    else if (type == "repeating")
+    {
+        _type = TimerType::repeating;
+    }
+    else
+    {
+        throw ActionParseError{
+            getName(), fmt::format("Timer type '{}' is not supported", type)};
+    }
+}
+
+void TimerBasedActions::setActions(const json& jsonObj)
+{
+    if (!jsonObj.contains("actions"))
+    {
+        throw ActionParseError{getName(), "Missing required actions entry"};
+    }
+    for (const auto& jsonAct : jsonObj["actions"])
+    {
+        if (!jsonAct.contains("name"))
+        {
+            throw ActionParseError{getName(), "Missing required action name"};
+        }
+
+        // Get any configured profile restrictions on the action
+        std::vector<std::string> profiles;
+        if (jsonAct.contains("profiles"))
+        {
+            for (const auto& profile : jsonAct["profiles"])
+            {
+                profiles.emplace_back(profile.get<std::string>());
+            }
+        }
+
+        // Set the groups configured for each action run when the timer expires
+        std::vector<Group> groups;
+        Event::setGroups(jsonAct, profiles, groups);
+
+        // List of zones is set on these actions by overriden setZones()
+        auto actObj = ActionFactory::getAction(
+            jsonAct["name"].get<std::string>(), jsonAct, std::move(groups), {});
+        if (actObj)
+        {
+            _actions.emplace_back(std::move(actObj));
+        }
+    }
+}
+
+} // namespace phosphor::fan::control::json
diff --git a/control/json/actions/timer_based_actions.hpp b/control/json/actions/timer_based_actions.hpp
new file mode 100644
index 0000000..c36ecf6
--- /dev/null
+++ b/control/json/actions/timer_based_actions.hpp
@@ -0,0 +1,152 @@
+/**
+ * Copyright © 2021 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 "../manager.hpp"
+#include "action.hpp"
+#include "group.hpp"
+#include "zone.hpp"
+
+#include <nlohmann/json.hpp>
+
+#include <chrono>
+#include <functional>
+#include <memory>
+#include <vector>
+
+namespace phosphor::fan::control::json
+{
+
+using json = nlohmann::json;
+
+/**
+ * @class TimerBasedActions - Action that wraps a list of actions with a timer
+ *
+ * Sets up a list of actions to be invoked when the defined timer expires.
+ * Once for a `oneshot` timer or at each expiration of a `repeating` timer.
+ */
+class TimerBasedActions :
+    public ActionBase,
+    public ActionRegister<TimerBasedActions>
+{
+  public:
+    /* Name of this action */
+    static constexpr auto name = "call_actions_based_on_timer";
+
+    TimerBasedActions() = delete;
+    TimerBasedActions(const TimerBasedActions&) = delete;
+    TimerBasedActions(TimerBasedActions&&) = delete;
+    TimerBasedActions& operator=(const TimerBasedActions&) = delete;
+    TimerBasedActions& operator=(TimerBasedActions&&) = delete;
+    ~TimerBasedActions() = default;
+
+    /**
+     * @brief Call actions when timer expires
+     *
+     * @param[in] jsonObj - JSON configuration of this action
+     * @param[in] groups - Groups of dbus objects the action uses
+     */
+    TimerBasedActions(const json& jsonObj, const std::vector<Group>& groups);
+
+    /**
+     * @brief Run the action
+     *
+     * Starts or stops a timer that runs a list of actions whenever the
+     * timer expires. The configured timer is set to callback the list of
+     * actions against the given zones and configured groups.
+     *
+     * Where any group does not have a configured value to be compared against,
+     * the groups' service owned state is used to start/stop the timer. When any
+     * service providing a group member is not owned, the timer is started and
+     * if all members' services are owned, the timer is stopped.
+     *
+     * Where all groups have a configured value to compare against, that will be
+     * compared against all members within each group to start/stop the timer.
+     * When all group members have a given value and it matches what's in the
+     * cache, the timer is started and if any do not match, the timer is
+     * stopped.
+     *
+     * @param[in] zone - Zone to run the action on
+     */
+    void run(Zone& zone) override;
+
+    /**
+     * @brief Start the timer
+     *
+     * Starts the configured timer of this action if not already running
+     */
+    void startTimer();
+
+    /**
+     * @brief Stop the timer
+     *
+     * Stops the configured timer of this action if running
+     */
+    void stopTimer();
+
+    /**
+     * @brief Timer expire's callback
+     *
+     * Called each time the timer expires, running the configured actions
+     */
+    void timerExpired();
+
+    /**
+     * @brief Set the zones on the action and the timer's actions
+     *
+     * @param[in] zones - Zones for the action and timer's actions
+     *
+     * Sets the zones on this action and the timer's actions to run against
+     */
+    virtual void
+        setZones(std::vector<std::reference_wrapper<Zone>>& zones) override;
+
+  private:
+    /* The timer for this action */
+    Timer _timer;
+
+    /* Whether timer triggered by groups' owner or property value states */
+    bool _byOwner;
+
+    /* Timer interval for this action's timer */
+    std::chrono::microseconds _interval;
+
+    /* Timer type for this action's timer */
+    TimerType _type;
+
+    /* List of actions to be called when the timer expires */
+    std::vector<std::unique_ptr<ActionBase>> _actions;
+
+    /**
+     * @brief Parse and set the timer configuration
+     *
+     * @param[in] jsonObj - JSON object for the action
+     *
+     * Sets the timer configuration used to run the list of actions
+     */
+    void setTimerConf(const json& jsonObj);
+
+    /**
+     * @brief Parse and set the list of actions
+     *
+     * @param[in] jsonObj - JSON object for the action
+     *
+     * Sets the list of actions that is run when the timer expires
+     */
+    void setActions(const json& jsonObj);
+};
+
+} // namespace phosphor::fan::control::json