diff --git a/Makefile.am b/Makefile.am
index 370d024..888f8cf 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -1,5 +1,13 @@
 sbin_PROGRAMS = phosphor-watchdog
 
+noinst_HEADERS = timer.hpp
+
 phosphor_watchdog_SOURCES = \
-				argument.cpp \
-				mainapp.cpp
+                argument.cpp \
+                timer.cpp \
+                mainapp.cpp
+
+phosphor_watchdog_LDFLAGS = $(SYSTEMD_LIBS) \
+                            ${PHOSPHOR_LOGGING_LIBS}
+phosphor_watchdog_CXXFLAGS = $(SYSTEMD_CFLAGS)\
+                             ${PHOSPHOR_LOGGING_CFLAGS}
diff --git a/configure.ac b/configure.ac
index 2f48a68..2f06b7b 100644
--- a/configure.ac
+++ b/configure.ac
@@ -18,6 +18,9 @@
 # For linking
 LT_INIT
 
+PKG_CHECK_MODULES([SYSTEMD], [libsystemd >= 221], [], [AC_MSG_ERROR(["systemd required and not found"])])
+PKG_CHECK_MODULES([PHOSPHOR_LOGGING], [phosphor-logging],, [AC_MSG_ERROR([Could not find phosphor-logging...openbmc/phosphor-logging package required])])
+
 # Create configured output
 AC_CONFIG_FILES([Makefile])
 AC_OUTPUT
diff --git a/mainapp.cpp b/mainapp.cpp
index 19aeb6a..4ab811c 100644
--- a/mainapp.cpp
+++ b/mainapp.cpp
@@ -15,7 +15,9 @@
  */
 
 #include <iostream>
+#include <phosphor-logging/log.hpp>
 #include "argument.hpp"
+#include "timer.hpp"
 
 static void exitWithError(const char* err, char** argv)
 {
@@ -26,6 +28,8 @@
 
 int main(int argc, char** argv)
 {
+    using namespace phosphor::logging;
+
     // Read arguments.
     auto options = phosphor::watchdog::ArgumentParser(argc, argv);
 
@@ -48,5 +52,29 @@
     // on meeting a condition.
     auto target = (options)["target"];
 
+    sd_event* event = nullptr;
+    auto r = sd_event_default(&event);
+    if (r < 0)
+    {
+        log<level::ERR>("Error creating a default sd_event handler");
+        return r;
+    }
+    phosphor::watchdog::EventPtr eventP{event};
+    event = nullptr;
+
+    // TODO: Creating the timer object would be inside watchdog implementation.
+    //       Putting this here for completion of this piece
+    phosphor::watchdog::Timer timer(eventP);
+
+    while(!timer.expired())
+    {
+        // -1 denotes wait for ever
+        r = sd_event_run(eventP.get(), (uint64_t)-1);
+        if (r < 0)
+        {
+            log<level::ERR>("Error waiting for events");
+            return -1;
+        }
+    }
     return 0;
 }
diff --git a/timer.cpp b/timer.cpp
new file mode 100644
index 0000000..bf1a470
--- /dev/null
+++ b/timer.cpp
@@ -0,0 +1,118 @@
+#include <chrono>
+#include <systemd/sd-event.h>
+#include <phosphor-logging/log.hpp>
+#include "timer.hpp"
+namespace phosphor
+{
+namespace watchdog
+{
+
+// Initializes the timer object
+void Timer::initialize()
+{
+    // This can not be called more than once.
+    if (eventSource.get())
+    {
+        // TODO: Need to throw elog exception stating its already added.
+        throw std::runtime_error("Timer already initialized");
+    }
+
+    // Add infinite expiration time
+    decltype(eventSource.get()) sourcePtr = nullptr;
+    auto r = sd_event_add_time(event.get(),
+                               &sourcePtr,
+                               CLOCK_MONOTONIC, // Time base
+                               UINT64_MAX,      // Expire time - way long time
+                               0,               // Use default event accuracy
+                               timeoutHandler,  // Callback handler on timeout
+                               this);           // User data
+    eventSource.reset(sourcePtr);
+
+    if (r < 0)
+    {
+        // TODO: throw elog exception
+        throw std::runtime_error("Timer initialization failed");
+    }
+
+    // Disable the timer for now
+    setEnabled<std::false_type>();
+}
+
+// callback handler on timeout
+int Timer::timeoutHandler(sd_event_source* eventSource,
+                          uint64_t usec, void* userData)
+{
+    using namespace phosphor::logging;
+
+    auto timer = static_cast<Timer*>(userData);
+    timer->expire = true;
+
+    log<level::INFO>("Timer Expired");
+
+    //TODO: Need to call user callback function.
+    return 0;
+}
+
+// Gets the time from steady_clock
+std::chrono::microseconds Timer::getCurrentTime()
+{
+    using namespace std::chrono;
+    auto usec = steady_clock::now().time_since_epoch();
+    return duration_cast<microseconds>(usec);
+}
+
+// Sets the expiration time and arms the timer
+void Timer::start(std::chrono::microseconds usec)
+{
+    // Get the current MONOTONIC time and add the delta
+    auto expireTime = getCurrentTime() + usec;
+
+    // Set the time
+    auto r = sd_event_source_set_time(eventSource.get(),
+                                      expireTime.count());
+    if (r < 0)
+    {
+        // TODO throw elog exception
+        throw std::runtime_error("Error setting the expiration time");
+    }
+}
+
+// Returns current timer enablement type
+int Timer::getEnabled() const
+{
+    int enabled{};
+    auto r = sd_event_source_get_enabled(eventSource.get(), &enabled);
+    if (r < 0)
+    {
+        // TODO: Need to throw elog exception
+        throw std::runtime_error("Error geting current time enablement state");
+    }
+    return enabled;
+}
+
+// Enables / disables the timer
+void Timer::setEnabled(int type)
+{
+    auto r = sd_event_source_set_enabled(eventSource.get(), type);
+    if (r < 0)
+    {
+        // TODO: Need to throw elog exception
+        throw std::runtime_error("Error altering enabled property");
+    }
+}
+
+// Returns time remaining before expiration
+std::chrono::microseconds Timer::getRemaining() const
+{
+    uint64_t next = 0;
+    auto r = sd_event_source_get_time(eventSource.get(), &next);
+    if (r < 0)
+    {
+        // TODO: Need to throw elog exception
+        throw std::runtime_error("Error altering enabled property");
+    }
+    return std::chrono::microseconds(next);
+}
+
+} // namespace watchdog
+} // namespace phosphor
diff --git a/timer.hpp b/timer.hpp
new file mode 100644
index 0000000..49580d7
--- /dev/null
+++ b/timer.hpp
@@ -0,0 +1,132 @@
+#pragma once
+
+#include <memory>
+#include <chrono>
+#include <systemd/sd-event.h>
+namespace phosphor
+{
+namespace watchdog
+{
+
+/* Need a custom deleter for freeing up sd_event */
+struct EventDeleter
+{
+    void operator()(sd_event* event) const
+    {
+        event = sd_event_unref(event);
+    }
+};
+using EventPtr = std::unique_ptr<sd_event, EventDeleter>;
+
+/* Need a custom deleter for freeing up sd_event_source */
+struct EventSourceDeleter
+{
+    void operator()(sd_event_source* eventSource) const
+    {
+        eventSource = sd_event_source_unref(eventSource);
+    }
+};
+using EventSourcePtr = std::unique_ptr<sd_event_source, EventSourceDeleter>;
+
+/** @class Timer
+ *  @brief Manages starting timers and handling timeouts
+ */
+class Timer
+{
+    public:
+        Timer() = delete;
+        ~Timer() = default;
+        Timer(const Timer&) = delete;
+        Timer& operator=(const Timer&) = delete;
+        Timer(Timer&&) = delete;
+        Timer& operator=(Timer&&) = delete;
+
+        /** @brief Constructs timer object
+         *
+         *  @param[in] event - sd_event unique pointer reference
+         */
+        Timer(EventPtr& event)
+            : event(event)
+        {
+            // Initialize the timer
+            initialize();
+        }
+
+        /** @brief Tells whether the timer is expired or not */
+        inline auto expired() const
+        {
+            return expire;
+        }
+
+        /** @brief Returns the current Timer enablement type */
+        int getEnabled() const;
+
+        /** @brief Enables / disables the timer.
+         *         <T> is an integral constant boolean
+         */
+        template <typename T> void setEnabled()
+        {
+            constexpr auto type = T::value ? SD_EVENT_ONESHOT : SD_EVENT_OFF;
+            return setEnabled(type);
+        }
+
+        /** @brief Returns time remaining in usec before expiration
+         *         which is an offset to current steady clock
+         */
+        std::chrono::microseconds getRemaining() const;
+
+        /** @brief Starts the timer with specified expiration value.
+         *         std::steady_clock is used for base time.
+         *
+         *  @param[in] usec - Microseconds from the current time
+         *                    before expiration.
+         *
+         *  @return None.
+         *
+         *  @error Throws exception
+         */
+        void start(std::chrono::microseconds usec);
+
+        /** @brief Gets the current time from steady clock */
+        static std::chrono::microseconds getCurrentTime();
+
+    private:
+        /** @brief Reference to sd_event unique pointer */
+        EventPtr& event;
+
+        /** @brief event source */
+        EventSourcePtr eventSource;
+
+        /** @brief Set to true when the timeoutHandler is called into */
+        bool expire = false;
+
+        /** @brief Initializes the timer object with infinite
+         *         expiration time and sets up the callback handler
+         *
+         *  @return None.
+         *
+         *  @error Throws exception
+         */
+        void initialize();
+
+        /** @brief Callback function when timer goes off
+         *
+         *  @param[in] eventSource - Source of the event
+         *  @param[in] usec        - time in microseconds
+         *  @param[in] userData    - User data pointer
+         *
+         */
+        static int timeoutHandler(sd_event_source* eventSource,
+                                  uint64_t usec, void* userData);
+
+        /** @brief Enables / disables the timer
+         *
+         *  @param[in] type - Timer type.
+         *                    This implementation uses only SD_EVENT_OFF
+         *                    and SD_EVENT_ONESHOT
+         */
+        void setEnabled(int type);
+};
+
+} // namespace watchdog
+} // namespace phosphor