diff --git a/phosphor-power-sequencer/src/power_interface.cpp b/phosphor-power-sequencer/src/power_interface.cpp
new file mode 100644
index 0000000..ed537db
--- /dev/null
+++ b/phosphor-power-sequencer/src/power_interface.cpp
@@ -0,0 +1,292 @@
+/**
+ * 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 "power_interface.hpp"
+
+#include "types.hpp"
+
+#include <fmt/format.h>
+
+#include <phosphor-logging/log.hpp>
+#include <sdbusplus/exception.hpp>
+#include <sdbusplus/sdbus.hpp>
+#include <sdbusplus/server.hpp>
+
+#include <string>
+#include <tuple>
+
+using namespace phosphor::logging;
+
+namespace phosphor::power::sequencer
+{
+
+PowerInterface::PowerInterface(sdbusplus::bus::bus& bus, const char* path) :
+    _serverInterface(bus, path, POWER_IFACE, _vtable, this)
+{
+}
+
+int PowerInterface::callbackGetPgood(sd_bus* /*bus*/, const char* /*path*/,
+                                     const char* /*interface*/,
+                                     const char* /*property*/,
+                                     sd_bus_message* msg, void* context,
+                                     sd_bus_error* error)
+{
+    if (msg != nullptr && context != nullptr)
+    {
+        try
+        {
+            auto pwrObj = static_cast<PowerInterface*>(context);
+            int pgood = pwrObj->getPgood();
+            log<level::INFO>(
+                fmt::format("callbackGetPgood: {}", pgood).c_str());
+
+            sdbusplus::message::message(msg).append(pgood);
+        }
+        catch (sdbusplus::exception_t& e)
+        {
+            return sd_bus_error_set(error, e.name(), e.description());
+        }
+    }
+    else
+    {
+        // The message or context were null
+        log<level::ERR>("Unable to service get pgood property callback");
+        return -1;
+    }
+
+    return 1;
+}
+
+int PowerInterface::callbackGetPgoodTimeout(sd_bus* /*bus*/,
+                                            const char* /*path*/,
+                                            const char* /*interface*/,
+                                            const char* /*property*/,
+                                            sd_bus_message* msg, void* context,
+                                            sd_bus_error* error)
+{
+    if (msg != nullptr && context != nullptr)
+    {
+        try
+        {
+            auto pwrObj = static_cast<PowerInterface*>(context);
+            int timeout = pwrObj->getPgoodTimeout();
+            log<level::INFO>(
+                fmt::format("callbackGetPgoodTimeout: {}", timeout).c_str());
+
+            sdbusplus::message::message(msg).append(timeout);
+        }
+        catch (sdbusplus::exception_t& e)
+        {
+            return sd_bus_error_set(error, e.name(), e.description());
+        }
+    }
+    else
+    {
+        // The message or context were null
+        log<level::ERR>(
+            "Unable to service get pgood timeout property callback");
+        return -1;
+    }
+
+    return 1;
+}
+
+int PowerInterface::callbackGetPowerState(sd_bus_message* msg, void* context,
+                                          sd_bus_error* error)
+{
+    if (msg != nullptr && context != nullptr)
+    {
+        try
+        {
+            auto pwrObj = static_cast<PowerInterface*>(context);
+            // Return the current power state of the GPIO, rather than the last
+            // requested power state change
+            int pgood = pwrObj->getPgood();
+            log<level::INFO>(
+                fmt::format("callbackGetPowerState: {}", pgood).c_str());
+
+            auto reply = sdbusplus::message::message(msg).new_method_return();
+            reply.append(pgood);
+            reply.method_return();
+        }
+        catch (sdbusplus::exception_t& e)
+        {
+            return sd_bus_error_set(error, e.name(), e.description());
+        }
+    }
+    else
+    {
+        // The message or context were null
+        log<level::ERR>("Unable to service getPowerState method callback");
+        return -1;
+    }
+
+    return 1;
+}
+
+int PowerInterface::callbackSetPgoodTimeout(sd_bus* /*bus*/,
+                                            const char* /*path*/,
+                                            const char* /*interface*/,
+                                            const char* /*property*/,
+                                            sd_bus_message* msg, void* context,
+                                            sd_bus_error* error)
+{
+    if (msg != nullptr && context != nullptr)
+    {
+        try
+        {
+            auto m = sdbusplus::message::message(msg);
+
+            int timeout{};
+            m.read(timeout);
+
+            auto pwrObj = static_cast<PowerInterface*>(context);
+            log<level::INFO>(
+                fmt::format("callbackSetPgoodTimeout: {}", timeout).c_str());
+            pwrObj->setPgoodTimeout(timeout);
+        }
+        catch (sdbusplus::exception_t& e)
+        {
+            return sd_bus_error_set(error, e.name(), e.description());
+        }
+    }
+    else
+    {
+        // The message or context were null
+        log<level::ERR>(
+            "Unable to service set pgood timeout property callback");
+        return -1;
+    }
+
+    return 1;
+}
+
+int PowerInterface::callbackGetState(sd_bus* /*bus*/, const char* /*path*/,
+                                     const char* /*interface*/,
+                                     const char* /*property*/,
+                                     sd_bus_message* msg, void* context,
+                                     sd_bus_error* error)
+{
+    if (msg != nullptr && context != nullptr)
+    {
+        try
+        {
+            auto pwrObj = static_cast<PowerInterface*>(context);
+            int state = pwrObj->getState();
+            log<level::INFO>(
+                fmt::format("callbackGetState: {}", state).c_str());
+
+            sdbusplus::message::message(msg).append(state);
+        }
+        catch (sdbusplus::exception_t& e)
+        {
+            return sd_bus_error_set(error, e.name(), e.description());
+        }
+    }
+    else
+    {
+        // The message or context were null
+        log<level::ERR>("Unable to service get state property callback");
+        return -1;
+    }
+
+    return 1;
+}
+
+int PowerInterface::callbackSetPowerState(sd_bus_message* msg, void* context,
+                                          sd_bus_error* error)
+{
+    if (msg != nullptr && context != nullptr)
+    {
+        try
+        {
+            auto m = sdbusplus::message::message(msg);
+
+            int state{};
+            m.read(state);
+
+            if (state != 1 && state != 0)
+            {
+                return sd_bus_error_set(error,
+                                        "org.openbmc.ControlPower.Error.Failed",
+                                        "Invalid power state");
+            }
+
+            auto pwrObj = static_cast<PowerInterface*>(context);
+            log<level::INFO>(
+                fmt::format("callbackSetPowerState: {}", state).c_str());
+            pwrObj->setState(state);
+
+            m.new_method_return().method_return();
+        }
+        catch (sdbusplus::exception_t& e)
+        {
+            return sd_bus_error_set(error, e.name(), e.description());
+        }
+    }
+    else
+    {
+        // The message or context were null
+        log<level::ERR>("Unable to service setPowerState method callback");
+        return -1;
+    }
+
+    return 1;
+}
+
+void PowerInterface::emitPowerGoodSignal()
+{
+    log<level::INFO>("emitPowerGoodSignal");
+    _serverInterface.new_signal("PowerGood").signal_send();
+}
+
+void PowerInterface::emitPowerLostSignal()
+{
+    log<level::INFO>("emitPowerLostSignal");
+    _serverInterface.new_signal("PowerLost").signal_send();
+}
+
+void PowerInterface::emitPropertyChangedSignal(const char* property)
+{
+    log<level::INFO>(
+        fmt::format("emitPropertyChangedSignal: {}", property).c_str());
+    _serverInterface.property_changed(property);
+}
+
+const sdbusplus::vtable::vtable_t PowerInterface::_vtable[] = {
+    sdbusplus::vtable::start(),
+    // Method setPowerState takes an int parameter and returns void
+    sdbusplus::vtable::method("setPowerState", "i", "", callbackSetPowerState),
+    // Method getPowerState takes no parameters and returns int
+    sdbusplus::vtable::method("getPowerState", "", "i", callbackGetPowerState),
+    // Signal PowerGood
+    sdbusplus::vtable::signal("PowerGood", ""),
+    // Signal PowerLost
+    sdbusplus::vtable::signal("PowerLost", ""),
+    // Property pgood is type int, read only, and uses the emits_change flag
+    sdbusplus::vtable::property("pgood", "i", callbackGetPgood,
+                                sdbusplus::vtable::property_::emits_change),
+    // Property state is type int, read only, and uses the emits_change flag
+    sdbusplus::vtable::property("state", "i", callbackGetState,
+                                sdbusplus::vtable::property_::emits_change),
+    // Property pgood_timeout is type int, read write, and uses the emits_change
+    // flag
+    sdbusplus::vtable::property("pgood_timeout", "i", callbackGetPgoodTimeout,
+                                callbackSetPgoodTimeout,
+                                sdbusplus::vtable::property_::emits_change),
+    sdbusplus::vtable::end()};
+
+} // namespace phosphor::power::sequencer