diff --git a/inc/button_handler.hpp b/inc/button_handler.hpp
index e398a0a..1332a0f 100755
--- a/inc/button_handler.hpp
+++ b/inc/button_handler.hpp
@@ -1,4 +1,7 @@
 #pragma once
+
+#include "power_button_profile.hpp"
+
 #include <sdbusplus/bus.hpp>
 #include <sdbusplus/bus/match.hpp>
 
@@ -157,6 +160,11 @@
      * @brief Matches on the ocp debug host selector  button released signal
      */
     std::unique_ptr<sdbusplus::bus::match_t> debugHSButtonReleased;
+
+    /**
+     * @brief The custom power handler profile object.
+     */
+    std::unique_ptr<PowerButtonProfile> powerButtonProfile;
 };
 
 } // namespace button
diff --git a/inc/host_then_chassis_poweroff.hpp b/inc/host_then_chassis_poweroff.hpp
new file mode 100644
index 0000000..96d7aee
--- /dev/null
+++ b/inc/host_then_chassis_poweroff.hpp
@@ -0,0 +1,185 @@
+#pragma once
+#include "power_button_profile.hpp"
+
+#include <sdbusplus/bus/match.hpp>
+#include <sdeventplus/event.hpp>
+#include <sdeventplus/utility/timer.hpp>
+#include <xyz/openbmc_project/State/Host/server.hpp>
+
+#include <chrono>
+
+namespace phosphor::button
+{
+
+/**
+ * @class HostThenChassisPowerOff
+ *
+ * A custom power button handler that will do the following:
+ *
+ * If power is off:
+ *  - A button press will power on as long as the BMC is
+ *    in the ready state.
+ *
+ * If power is on:
+ *  - A button press less than 4s won't do anything.
+ *  - At 4s, issue a host power off and start a 10s timer.
+ *    - If the button is released within that 10s and not pressed
+ *      again, continue with the host power off.
+ *    - If the button is released within that 10s and also
+ *      pressed again in that 10s, do a hard power (chassis)
+ *      off.
+ *    - If the button is pressed throughout that 10s
+ *      issue a hard power off.
+ */
+class HostThenChassisPowerOff : public PowerButtonProfile
+{
+  public:
+    enum class PowerOpState
+    {
+        powerOnPress,
+        buttonNotPressed,
+        buttonPressed,
+        buttonPressedHostOffStarted,
+        buttonReleasedHostToChassisOffWindow,
+        chassisOffStarted
+    };
+
+    /**
+     * @brief Constructor
+     * @param[in] bus - The sdbusplus bus object
+     */
+    explicit HostThenChassisPowerOff(sdbusplus::bus_t& bus) :
+        PowerButtonProfile(bus), state(PowerOpState::buttonNotPressed),
+        timer(bus.get_event(),
+              std::bind(&HostThenChassisPowerOff::timerHandler, this),
+              pollInterval)
+    {
+        timer.setEnabled(false);
+    }
+
+    /**
+     * @brief Returns the name that matches the value in
+     *        meson_options.txt.
+     */
+    static constexpr std::string_view getName()
+    {
+        return "host_then_chassis_poweroff";
+    }
+
+    HostThenChassisPowerOff() = delete;
+    ~HostThenChassisPowerOff() = default;
+
+    /**
+     * @brief Called when the power button is pressed.
+     */
+    virtual void pressed() override;
+
+    /**
+     * @brief Called when the power button is released.
+     *
+     * @param[in] pressTimeMS - How long the button was pressed
+     *                          in milliseconds.
+     */
+    virtual void released(uint64_t pressTimeMS) override;
+
+  private:
+    /**
+     * @brief Determines if the BMC is in the ready state.
+     * @return bool If the BMC is in the ready state
+     */
+    bool isBmcReady() const;
+
+    /**
+     * @brief Determines if system (chassis) is powered on.
+     *
+     * @return bool - If power is on
+     */
+    bool isPoweredOn() const;
+
+    /**
+     * @brief Requests a host state transition
+     * @param[in] transition - The transition (like On or Off)
+     */
+    void hostTransition(
+        sdbusplus::xyz::openbmc_project::State::server::Host::Transition
+            transition);
+
+    /**
+     * @brief Powers on the system
+     */
+    void powerOn();
+
+    /**
+     * @brief Requests a host power off
+     */
+    void hostPowerOff();
+
+    /**
+     * @brief Requests a chassis power off
+     */
+    void chassisPowerOff();
+
+    /**
+     * @brief The handler for the 1s timer that runs when determining
+     *        how to power off.
+     *
+     * A 1 second timer is used so that there is the ability to emit
+     * a power off countdown if necessary.
+     */
+    void timerHandler();
+
+    /**
+     * @brief Sets the time the host will be powered off if the
+     *        button is still pressed - 4 seconds in the future.
+     */
+    inline void setHostOffTime()
+    {
+        hostOffTime = std::chrono::steady_clock::now() + hostOffInterval;
+    }
+
+    /**
+     * @brief Sets the time the chassis will be powered off if the
+     *        button is still pressed or pressed again - 10 seconds
+     *        in the future.
+     */
+    inline void setChassisOffTime()
+    {
+        chassisOffTime = std::chrono::steady_clock::now() + chassisOffInterval;
+    }
+
+    /**
+     * @brief The interval the timer handler is called at.
+     */
+    static constexpr std::chrono::milliseconds pollInterval{1000};
+
+    /**
+     * @brief Default button hold down interval constant
+     */
+    static constexpr std::chrono::milliseconds hostOffInterval{4000};
+
+    /**
+     * @brief The time between a host power off and chassis power off.
+     */
+    static constexpr std::chrono::milliseconds chassisOffInterval{10000};
+
+    /**
+     * @brief The current state of the handler.
+     */
+    PowerOpState state;
+
+    /**
+     * @brief When the host will be powered off.
+     */
+    std::chrono::time_point<std::chrono::steady_clock> hostOffTime;
+
+    /**
+     * @brief When the chassis will be powered off.
+     */
+    std::chrono::time_point<std::chrono::steady_clock> chassisOffTime;
+
+    /**
+     * @brief The timer object.
+     */
+    sdeventplus::utility::Timer<sdeventplus::ClockId::Monotonic> timer;
+};
+} // namespace phosphor::button
diff --git a/inc/power_button_profile.hpp b/inc/power_button_profile.hpp
new file mode 100644
index 0000000..37bfbe6
--- /dev/null
+++ b/inc/power_button_profile.hpp
@@ -0,0 +1,72 @@
+#pragma once
+
+#include "config.h"
+
+#include <sdbusplus/bus.hpp>
+#include <sdbusplus/bus/match.hpp>
+#include <sdbusplus/message.hpp>
+
+#include <string>
+
+namespace phosphor::button
+{
+
+constexpr auto powerButtonInterface =
+    "xyz.openbmc_project.Chassis.Buttons.Power";
+namespace sdbusRule = sdbusplus::bus::match::rules;
+
+/**
+ * @class PowerButtonProfile
+ *
+ * Abstract base class for custom power button profiles.
+ *
+ * Calls a derived class's pressed() and released()
+ * functions when the power button is pressed and
+ * released.
+ */
+class PowerButtonProfile
+{
+  public:
+    PowerButtonProfile(sdbusplus::bus_t& bus) :
+        bus(bus),
+        pressedMatch(bus,
+                     sdbusRule::type::signal() + sdbusRule::member("Pressed") +
+                         sdbusRule::path(POWER_DBUS_OBJECT_NAME) +
+                         sdbusRule::interface(powerButtonInterface),
+                     std::bind(&PowerButtonProfile::pressedHandler, this,
+                               std::placeholders::_1)),
+        releasedMatch(bus,
+                      sdbusRule::type::signal() +
+                          sdbusRule::member("Released") +
+                          sdbusRule::path(POWER_DBUS_OBJECT_NAME) +
+                          sdbusRule::interface(powerButtonInterface),
+                      std::bind(&PowerButtonProfile::releasedHandler, this,
+                                std::placeholders::_1))
+    {}
+
+    virtual ~PowerButtonProfile() = default;
+
+    void pressedHandler(sdbusplus::message_t /* msg*/)
+    {
+        pressed();
+    }
+
+    void releasedHandler(sdbusplus::message_t msg)
+    {
+        auto time = msg.unpack<uint64_t>();
+        released(time);
+    }
+
+    virtual void pressed() = 0;
+
+    virtual void released(uint64_t pressTimeMS) = 0;
+
+  protected:
+    sdbusplus::bus_t& bus;
+
+  private:
+    sdbusplus::bus::match_t pressedMatch;
+    sdbusplus::bus::match_t releasedMatch;
+};
+
+} // namespace phosphor::button
diff --git a/inc/power_button_profile_factory.hpp b/inc/power_button_profile_factory.hpp
new file mode 100644
index 0000000..de11e84
--- /dev/null
+++ b/inc/power_button_profile_factory.hpp
@@ -0,0 +1,79 @@
+#pragma once
+
+#include "config.h"
+
+#include "power_button_profile.hpp"
+
+#include <memory>
+#include <unordered_map>
+
+namespace phosphor::button
+{
+
+using powerButtonProfileCreator =
+    std::function<std::unique_ptr<PowerButtonProfile>(sdbusplus::bus_t& bus)>;
+
+/**
+ * @class PowerButtonProfileFactory
+ *
+ * Creates the custom power button profile class if one is set with
+ * the 'power-button-profile' meson option.
+ *
+ * The createProfile() method will return a nullptr if no custom
+ * profile is enabled.
+ */
+class PowerButtonProfileFactory
+{
+  public:
+    static PowerButtonProfileFactory& instance()
+    {
+        static PowerButtonProfileFactory factory;
+        return factory;
+    }
+
+    template <typename T>
+    void addToRegistry()
+    {
+        profileRegistry[std::string(T::getName())] = [](sdbusplus::bus_t& bus) {
+            return std::make_unique<T>(bus);
+        };
+    }
+
+    std::unique_ptr<PowerButtonProfile> createProfile(sdbusplus::bus_t& bus)
+    {
+        // Find the creator method named after the
+        // 'power-button-profile' option value.
+        auto objectIter = profileRegistry.find(POWER_BUTTON_PROFILE);
+        if (objectIter != profileRegistry.end())
+        {
+            return objectIter->second(bus);
+        }
+        else
+        {
+            return nullptr;
+        }
+    }
+
+  private:
+    PowerButtonProfileFactory() = default;
+
+    std::unordered_map<std::string, powerButtonProfileCreator> profileRegistry;
+};
+
+/**
+ * @brief Registers a power button profile with the factory.
+ *
+ * Declare a static instance of this at the top of the profile
+ * .cpp file like:
+ *    static PowerButtonProfileRegister<MyClass> register;
+ */
+template <class T>
+class PowerButtonProfileRegister
+{
+  public:
+    PowerButtonProfileRegister()
+    {
+        PowerButtonProfileFactory::instance().addToRegistry<T>();
+    }
+};
+} // namespace phosphor::button