diff --git a/src/spider/CMakeLists.txt b/src/spider/CMakeLists.txt
index 6c08825..2bedefc 100644
--- a/src/spider/CMakeLists.txt
+++ b/src/spider/CMakeLists.txt
@@ -87,7 +87,7 @@ target_link_libraries(
     spider_task_executor
     PRIVATE
         spider_core
-        spider_client_lib
+        spider_client
 )
 target_link_libraries(
     spider_task_executor
@@ -131,7 +131,9 @@ set(SPIDER_CLIENT_SHARED_SOURCES
 set(SPIDER_CLIENT_SHARED_HEADERS
     client/Data.hpp
     client/Driver.hpp
+    client/Job.hpp
     client/task.hpp
+    client/spider.hpp
     client/TaskContext.hpp
     client/TaskGraph.hpp
     client/type_utils.hpp
@@ -143,28 +145,15 @@ set(SPIDER_CLIENT_SHARED_HEADERS
     "spider client shared header files"
 )
 
-add_library(spider_client_lib)
-target_sources(spider_client_lib PRIVATE ${SPIDER_CLIENT_SHARED_SOURCES})
-target_sources(spider_client_lib PUBLIC ${SPIDER_CLIENT_SHARED_HEADERS})
+add_library(spider_client)
+target_sources(spider_client PRIVATE ${SPIDER_CLIENT_SHARED_SOURCES})
+target_sources(spider_client PUBLIC ${SPIDER_CLIENT_SHARED_HEADERS})
 target_link_libraries(
-    spider_client_lib
+    spider_client
     PUBLIC
+        spider_core
         Boost::boost
         absl::flat_hash_map
 )
 
-set(SPIDER_CLIENT_SOURCES CACHE INTERNAL "spider client source files")
-
-set(SPIDER_CLIENT_HEADERS
-    client/spider.hpp
-    client/Job.hpp
-    CACHE INTERNAL
-    "spider client header files"
-)
-
-add_library(spider_client)
-target_sources(spider_client PRIVATE ${SPIDER_CLIENT_SOURCES})
-target_sources(spider_client PUBLIC ${SPIDER_CLIENT_HEADERS})
-target_link_libraries(spider_client PRIVATE spider_core)
-target_link_libraries(spider_client PUBLIC spider_client_lib)
 add_library(spider::spider ALIAS spider_client)
diff --git a/src/spider/client/Driver.hpp b/src/spider/client/Driver.hpp
index 6e30a21..3e79393 100644
--- a/src/spider/client/Driver.hpp
+++ b/src/spider/client/Driver.hpp
@@ -6,14 +6,20 @@
 #include <stdexcept>
 #include <string>
 #include <thread>
+#include <tuple>
+#include <type_traits>
 #include <vector>
 
+#include <boost/uuid/random_generator.hpp>
 #include <boost/uuid/uuid.hpp>
+#include <fmt/format.h>
 
+#include "../core/Error.hpp"
 #include "../core/TaskGraphImpl.hpp"
 #include "../io/Serializer.hpp"
 #include "../worker/FunctionManager.hpp"
 #include "Data.hpp"
+#include "Exception.hpp"
 #include "Job.hpp"
 #include "task.hpp"
 #include "TaskGraph.hpp"
@@ -39,6 +45,8 @@ namespace spider {
 namespace core {
 class MetadataStorage;
 class DataStorage;
+class Task;
+class TaskGraph;
 }  // namespace core
 
 /**
@@ -126,28 +134,98 @@ class Driver {
      *
      * @tparam ReturnType
      * @tparam Params
+     * @tparam Inputs
      * @param task
      * @param inputs
      * @return A job representing the running task.
      * @throw spider::ConnectionException
      */
-    template <TaskIo ReturnType, TaskIo... Params>
+    template <TaskIo ReturnType, TaskIo... Params, TaskIo... Inputs>
     auto
-    start(TaskFunction<ReturnType, Params...> const& task, Params&&... inputs) -> Job<ReturnType>;
+    start(TaskFunction<ReturnType, Params...> const& task, Inputs&&... inputs) -> Job<ReturnType> {
+        // Check input type
+        static_assert(
+                sizeof...(Inputs) == sizeof...(Params),
+                "Number of inputs must match number of parameters."
+        );
+        for_n<sizeof...(Inputs)>([&](auto i) {
+            using InputType = std::tuple_element_t<i.cValue, std::tuple<Inputs...>>;
+            using ParamType = std::tuple_element_t<i.cValue, std::tuple<Params...>>;
+            if constexpr (!std::is_same_v<
+                                  std::remove_cvref_t<InputType>,
+                                  std::remove_cvref_t<ParamType>>)
+            {
+                throw std::invalid_argument("Input type does not match parameter type.");
+            }
+        });
+
+        std::optional<core::Task> optional_task = core::TaskGraphImpl::create_task(task);
+        if (!optional_task.has_value()) {
+            throw std::invalid_argument("Failed to create task.");
+        }
+        core::Task& new_task = optional_task.value();
+        if (!core::TaskGraphImpl::task_add_input(new_task, std::forward<Inputs>(inputs)...)) {
+            throw std::invalid_argument("Failed to add inputs to task.");
+        }
+        boost::uuids::random_generator gen;
+        boost::uuids::uuid const job_id = gen();
+        core::TaskGraph graph;
+        graph.add_task(new_task);
+        graph.add_input_task(new_task.get_id());
+        graph.add_output_task(new_task.get_id());
+        core::StorageErr err = m_metadata_storage->add_job(job_id, m_id, graph);
+        if (!err.success()) {
+            throw ConnectionException(fmt::format("Failed to start job: {}", err.description));
+        }
+
+        return Job<ReturnType>{job_id, m_metadata_storage, m_data_storage};
+    }
 
     /**
      * Starts running a task graph with the given inputs on Spider.
      *
      * @tparam ReturnType
      * @tparam Params
+     * @tparam Inputs
      * @param graph
      * @param inputs
      * @return A job representing the running task graph.
      * @throw spider::ConnectionException
      */
-    template <TaskIo ReturnType, TaskIo... Params>
+    template <TaskIo ReturnType, TaskIo... Params, TaskIo... Inputs>
     auto
-    start(TaskGraph<ReturnType(Params...)> const& graph, Params&&... inputs) -> Job<ReturnType>;
+    start(TaskGraph<ReturnType, Params...> const& graph, Inputs&&... inputs) -> Job<ReturnType> {
+        // Check input type
+        static_assert(
+                sizeof...(Inputs) == sizeof...(Params),
+                "Number of inputs must match number of parameters."
+        );
+        for_n<sizeof...(Inputs)>([&](auto i) {
+            using InputType = std::tuple_element_t<i.cValue, std::tuple<Inputs...>>;
+            using ParamType = std::tuple_element_t<i.cValue, std::tuple<Params...>>;
+            if constexpr (!std::is_same_v<
+                                  std::remove_cvref_t<InputType>,
+                                  std::remove_cvref_t<ParamType>>)
+            {
+                throw std::invalid_argument("Input type does not match parameter type.");
+            }
+        });
+
+        if (!graph.m_impl->add_inputs(std::forward<Inputs>(inputs)...)) {
+            throw std::invalid_argument("Failed to add inputs to task graph.");
+        }
+        // Reset ids in case the same graph is submitted before
+        graph.m_impl->reset_ids();
+        boost::uuids::random_generator gen;
+        boost::uuids::uuid const job_id = gen();
+        core::StorageErr const err
+                = m_metadata_storage->add_job(job_id, m_id, graph.m_impl->get_graph());
+        if (!err.success()) {
+            throw ConnectionException(fmt::format("Failed to start job: {}", err.description));
+        }
+
+        return Job<ReturnType>{job_id, m_metadata_storage, m_data_storage};
+    }
 
     /**
      * Gets all scheduled and running jobs started by drivers with the current client's ID.
@@ -157,7 +235,14 @@ class Driver {
      * @return IDs of the jobs.
      * @throw spider::ConnectionException
      */
-    auto get_jobs() -> std::vector<boost::uuids::uuid>;
+    auto get_jobs() -> std::vector<boost::uuids::uuid> {
+        std::vector<boost::uuids::uuid> job_ids;
+        core::StorageErr const err = m_metadata_storage->get_jobs_by_client_id(m_id, &job_ids);
+        if (!err.success()) {
+            throw ConnectionException("Failed to get jobs.");
+        }
+        return job_ids;
+    }
 
 private:
     boost::uuids::uuid m_id;
diff --git a/src/spider/client/Job.hpp b/src/spider/client/Job.hpp
index 79e3244..fc6a242 100644
--- a/src/spider/client/Job.hpp
+++ b/src/spider/client/Job.hpp
@@ -1,13 +1,39 @@
 #ifndef SPIDER_CLIENT_JOB_HPP
 #define SPIDER_CLIENT_JOB_HPP
 
+#include <chrono>
+#include <cstddef>
 #include <cstdint>
+#include <memory>
+#include <optional>
 #include <string>
+#include <thread>
+#include <tuple>
 #include <utility>
+#include <vector>
 
+#include <boost/uuid/uuid.hpp>
+#include <fmt/format.h>
+
+#include "../core/DataImpl.hpp"
+#include "../core/Error.hpp"
+#include "../core/JobMetadata.hpp"
+#include "../io/MsgPack.hpp"  // IWYU pragma: keep
+#include "../storage/MetadataStorage.hpp"
+#include "Data.hpp"
 #include "task.hpp"
+#include "type_utils.hpp"
 
 namespace spider {
+namespace core {
+class Data;
+class DataStorage;
+class MetadataStorage;
+class Task;
+class TaskOutput;
+}  // namespace core
+class Driver;
+
 // TODO: Use std::expected or Boost's outcome so that the user can get the result of the job in one
 // call rather than the current error-prone approach which requires that the user check the job's
 // status and then call the relevant method.
@@ -32,7 +58,25 @@ class Job {
      *
      * @throw spider::ConnectionException
      */
-    auto wait_complete();
+    auto wait_complete() -> void {
+        bool complete = false;
+        core::StorageErr err = m_metadata_storage->get_job_complete(m_id, &complete);
+        if (!err.success()) {
+            throw ConnectionException{
+                    fmt::format("Failed to get job completion status: {}", err.description)
+            };
+        }
+        while (!complete) {
+            constexpr int cSleepMs = 10;
+            std::this_thread::sleep_for(std::chrono::milliseconds(cSleepMs));
+            err = m_metadata_storage->get_job_complete(m_id, &complete);
+            if (!err.success()) {
+                throw ConnectionException{
+                        fmt::format("Failed to get job completion status: {}", err.description)
+                };
+            }
+        }
+    }
 
     /**
      * Cancels the job and waits for the job's tasks to be cancelled.
@@ -45,8 +89,28 @@ class Job {
      * @return Status of the job.
      * @throw spider::ConnectionException
      */
-    auto get_status() -> JobStatus;
+    auto get_status() -> JobStatus {
+        core::JobStatus status = core::JobStatus::Running;
+        core::StorageErr const err = m_metadata_storage->get_job_status(m_id, &status);
+        if (!err.success()) {
+            throw ConnectionException{fmt::format("Failed to get job status: {}", err.description)};
+        }
+        switch (status) {
+            case core::JobStatus::Running:
+                return JobStatus::Running;
+            case core::JobStatus::Succeeded:
+                return JobStatus::Succeeded;
+            case core::JobStatus::Failed:
+                return JobStatus::Failed;
+            case core::JobStatus::Cancelled:
+                return JobStatus::Cancelled;
+        }
+        throw ConnectionException{
+                fmt::format("Unknown job status: {}", static_cast<uint8_t>(status))
+        };
+    }
 
+    // NOLINTBEGIN(readability-function-cognitive-complexity)
     /**
      * NOTE: It is undefined behavior to call this method for a job that is not in the `Succeeded`
      * state.
@@ -54,7 +118,131 @@ class Job {
      * @return Result of the job.
      * @throw spider::ConnectionException
      */
-    auto get_result() -> ReturnType;
+    auto get_result() -> ReturnType {
+        std::vector<boost::uuids::uuid> output_task_ids;
+        core::StorageErr err = m_metadata_storage->get_job_output_tasks(m_id, &output_task_ids);
+        if (!err.success()) {
+            throw ConnectionException{
+                    fmt::format("Failed to get job output tasks: {}", err.description)
+            };
+        }
+        std::vector<core::Task> tasks;
+        for (auto const& id : output_task_ids) {
+            core::Task task{""};
+            err = m_metadata_storage->get_task(id, &task);
+            if (!err.success()) {
+                throw ConnectionException{fmt::format("Failed to get task: {}", err.description)};
+            }
+            tasks.push_back(task);
+        }
+        ReturnType result;
+        if constexpr (cIsSpecializationV<ReturnType, std::tuple>) {
+            size_t task_index = 0;
+            size_t output_index = 0;
+            for_n<std::tuple_size_v<ReturnType>>([&](auto i) {
+                using T = std::tuple_element_t<i.cValue, ReturnType>;
+                if (task_index >= output_task_ids.size()) {
+                    throw ConnectionException{fmt::format("Not enough output tasks for job result")
+                    };
+                }
+                core::Task const& task = tasks[task_index];
+                if (output_index >= task.get_num_outputs()) {
+                    throw ConnectionException{fmt::format("Not enough outputs for task")};
+                }
+                core::TaskOutput const& output = task.get_output(output_index);
+                if (output.get_type() != typeid(T).name()) {
+                    throw ConnectionException{fmt::format("Output type mismatch")};
+                }
+                if constexpr (cIsSpecializationV<T, Data>) {
+                    using DataType = ExtractTemplateParamT<T>;
+                    core::Data data;
+                    std::optional<boost::uuids::uuid> const optional_data_id = output.get_data_id();
+                    if (!optional_data_id.has_value()) {
+                        throw ConnectionException{fmt::format("Output data ID is missing")};
+                    }
+                    err = m_data_storage->get_data(optional_data_id.value(), &data);
+                    if (!err.success()) {
+                        throw ConnectionException{
+                                fmt::format("Failed to get data: {}", err.description)
+                        };
+                    }
+                    std::get<i.cValue>(result) = core::DataImpl::create_data<DataType>(
+                            std::make_unique<core::Data>(std::move(data)),
+                            m_data_storage
+                    );
+                } else {
+                    std::optional<std::string> const optional_value = output.get_value();
+                    if (!optional_value.has_value()) {
+                        throw ConnectionException{fmt::format("Output value is missing")};
+                    }
+                    std::string const& value = optional_value.value();
+                    try {
+                        msgpack::object_handle const handle
+                                = msgpack::unpack(value.data(), value.size());
+                        msgpack::object const& obj = handle.get();
+                        std::get<i.cValue>(result) = obj.as<T>();
+                    } catch (msgpack::type_error const& e) {
+                        throw ConnectionException{fmt::format("Failed to unpack data: {}", e.what())
+                        };
+                    }
+                }
+                output_index++;
+                if (output_index >= task.get_num_outputs()) {
+                    task_index++;
+                    output_index = 0;
+                }
+            });
+        } else {
+            if (output_task_ids.size() != 1) {
+                throw ConnectionException{fmt::format("Expected one output task for job result")};
+            }
+            core::Task task{""};
+            err = m_metadata_storage->get_task(output_task_ids[0], &task);
+            if (!err.success()) {
+                throw ConnectionException{fmt::format("Failed to get task: {}", err.description)};
+            }
+            if (task.get_num_outputs() != 1) {
+                throw ConnectionException{fmt::format("Expected one output for task")};
+            }
+            core::TaskOutput const& output = task.get_output(0);
+            if (output.get_type() != typeid(ReturnType).name()) {
+                throw ConnectionException{fmt::format("Output type mismatch")};
+            }
+            if constexpr (cIsSpecializationV<ReturnType, Data>) {
+                using DataType = ExtractTemplateParamT<ReturnType>;
+                core::Data data;
+                std::optional<boost::uuids::uuid> const optional_data_id = output.get_data_id();
+                if (!optional_data_id.has_value()) {
+                    throw ConnectionException{fmt::format("Output data ID is missing")};
+                }
+                err = m_data_storage->get_data(optional_data_id.value(), &data);
+                if (!err.success()) {
+                    throw ConnectionException{fmt::format("Failed to get data: {}", err.description)
+                    };
+                }
+                return core::DataImpl::create_data<DataType>(
+                        std::make_unique<core::Data>(std::move(data)),
+                        m_data_storage
+                );
+            } else {
+                std::optional<std::string> const optional_value = output.get_value();
+                if (!optional_value.has_value()) {
+                    throw ConnectionException{fmt::format("Output value is missing")};
+                }
+                std::string const& value = optional_value.value();
+                try {
+                    msgpack::object_handle const handle
+                            = msgpack::unpack(value.data(), value.size());
+                    msgpack::object const& obj = handle.get();
+                    return obj.as<ReturnType>();
+                } catch (msgpack::type_error const& e) {
+                    throw ConnectionException{fmt::format("Failed to unpack data: {}", e.what())};
+                }
+            }
+        }
+    }
+
+    // NOLINTEND(readability-function-cognitive-complexity)
 
     /**
      * NOTE: It is undefined behavior to call this method for a job that is not in the `Failed`
@@ -66,6 +254,20 @@ class Job {
      * @throw spider::ConnectionException
      */
     auto get_error() -> std::pair<std::string, std::string>;
+
+private:
+    Job(boost::uuids::uuid id,
+        std::shared_ptr<core::MetadataStorage> metadata_storage,
+        std::shared_ptr<core::DataStorage> data_storage)
+            : m_id{id},
+              m_metadata_storage{std::move(metadata_storage)},
+              m_data_storage{std::move(data_storage)} {}
+
+    boost::uuids::uuid m_id;
+    std::shared_ptr<core::MetadataStorage> m_metadata_storage;
+    std::shared_ptr<core::DataStorage> m_data_storage;
+
+    friend class Driver;
 };
 }  // namespace spider
 
diff --git a/src/spider/client/type_utils.hpp b/src/spider/client/type_utils.hpp
index 1a1a062..6c87cb1 100644
--- a/src/spider/client/type_utils.hpp
+++ b/src/spider/client/type_utils.hpp
@@ -1,7 +1,10 @@
 #ifndef SPIDER_CLIENT_TYPE_UTILS_HPP
 #define SPIDER_CLIENT_TYPE_UTILS_HPP
 
+#include <cstddef>
+#include <initializer_list>
 #include <type_traits>
+#include <utility>
 
 namespace spider {
 // The template and partial specialization below check whether a given type is a specialization of
@@ -27,5 +30,34 @@ struct IsSpecialization<type<TypeParams...>, type> : public std::true_type {};
 
 template <class Type, template <typename...> class template_type>
 inline constexpr bool cIsSpecializationV = IsSpecialization<Type, template_type>::value;
+
+template <std::size_t n>
+struct Num {
+    static constexpr auto cValue = n;
+};
+
+template <class F, std::size_t... is>
+void for_n(F func, std::index_sequence<is...>) {
+    (void)std::initializer_list{0, ((void)func(Num<is>{}), 0)...};
+}
+
+template <std::size_t n, typename F>
+void for_n(F func) {
+    for_n(func, std::make_index_sequence<n>());
+}
+
+template <class T>
+struct ExtractTemplateParam {
+    using Type = T;
+};
+
+template <template <class> class t, class P>
+struct ExtractTemplateParam<t<P>> {
+    using Type = P;
+};
+
+template <class T>
+using ExtractTemplateParamT = typename ExtractTemplateParam<T>::Type;
+
 }  // namespace spider
 #endif  // SPIDER_CLIENT_TYPE_UTILS_HPP
diff --git a/src/spider/core/JobMetadata.hpp b/src/spider/core/JobMetadata.hpp
index 9f4715f..9b27d88 100644
--- a/src/spider/core/JobMetadata.hpp
+++ b/src/spider/core/JobMetadata.hpp
@@ -2,6 +2,7 @@
 #define SPIDER_CORE_JOBMETADATA_HPP
 
 #include <chrono>
+#include <cstdint>
 
 #include <boost/uuid/uuid.hpp>
 
@@ -34,6 +35,13 @@ class JobMetadata {
     std::chrono::system_clock::time_point m_creation_time;
 };
 
+enum class JobStatus : std::uint8_t {
+    Running,
+    Succeeded,
+    Failed,
+    Cancelled
+};
+
 }  // namespace spider::core
 
 #endif  // SPIDER_CORE_JOBMETADATA_HPP
diff --git a/src/spider/core/TaskGraphImpl.hpp b/src/spider/core/TaskGraphImpl.hpp
index 17aee65..9a6c261 100644
--- a/src/spider/core/TaskGraphImpl.hpp
+++ b/src/spider/core/TaskGraphImpl.hpp
@@ -1,11 +1,13 @@
 #ifndef SPIDER_CORE_TASKGRAPHIMPL_HPP
 #define SPIDER_CORE_TASKGRAPHIMPL_HPP
 
+#include <cstddef>
 #include <cstdint>
 #include <optional>
 #include <string>
 #include <tuple>
 #include <type_traits>
+#include <vector>
 
 #include <boost/uuid/uuid.hpp>
 
@@ -52,8 +54,10 @@ class TaskGraphImpl {
                 );
                 if (!optional_parent.has_value()) {
                     fail = true;
+                    return;
                 }
                 graph.m_graph.add_task(optional_parent.value());
+                graph.m_graph.add_dependency(optional_parent.value().get_id(), task.get_id());
                 graph.m_graph.add_input_task(optional_parent.value().get_id());
             } else if constexpr (cIsSpecializationV<InputType, spider::TaskGraph>) {
                 TaskGraph parent_graph
@@ -61,6 +65,7 @@ class TaskGraphImpl {
                 parent_graph.reset_ids();
                 if (!add_graph_input(task, parent_graph, position)) {
                     fail = true;
+                    return;
                 }
                 for (boost::uuids::uuid const& intput_task_id : parent_graph.get_input_tasks()) {
                     graph.m_graph.add_input_task(intput_task_id);
@@ -68,15 +73,23 @@ class TaskGraphImpl {
                 for (auto const& [task_id, task] : parent_graph.get_tasks()) {
                     graph.m_graph.add_task(task);
                 }
+                for (auto const& [parent, child] : parent_graph.get_dependencies()) {
+                    graph.m_graph.add_dependency(parent, child);
+                }
+                for (boost::uuids::uuid const& output_task_id : parent_graph.get_output_tasks()) {
+                    graph.m_graph.add_dependency(output_task_id, task.get_id());
+                }
             } else if constexpr (TaskIo<InputType>) {
                 if (position >= task.get_num_inputs()) {
                     fail = true;
+                    return;
                 }
                 TaskInput& input = task.get_input_ref(position);
                 position++;
                 // Check type match
                 if (input.get_type() != typeid(InputType).name()) {
                     fail = true;
+                    return;
                 }
                 if constexpr (cIsSpecializationV<InputType, spider::Data>) {
                     input.set_data_id(std::get<i.cValue>(std::forward_as_tuple(inputs...))
@@ -106,7 +119,6 @@ class TaskGraphImpl {
 
     // NOLINTEND(readability-function-cognitive-complexity, cppcoreguidelines-missing-std-forward)
 
-private:
     template <TaskIo ReturnType, TaskIo... TaskParams>
     static auto create_task(TaskFunction<ReturnType, TaskParams...> const& task_function
     ) -> std::optional<Task> {
@@ -134,6 +146,101 @@ class TaskGraphImpl {
         return task;
     }
 
+    // NOLINTBEGIN(cppcoreguidelines-missing-std-forward)
+    template <TaskIo... Params>
+    static auto task_add_input(Task& task, Params&&... params) -> bool {
+        if (task.get_num_inputs() != sizeof...(Params)) {
+            return false;
+        }
+        bool fail = false;
+        for_n<sizeof...(Params)>([&](auto i) {
+            if (fail) {
+                return;
+            }
+            using ParamType
+                    = std::remove_cvref_t<std::tuple_element_t<i.cValue, std::tuple<Params...>>>;
+            ParamType const& param = std::get<i.cValue>(std::forward_as_tuple(params...));
+            TaskInput& task_input = task.get_input_ref(i.cValue);
+            // Check type match
+            if (task_input.get_type() != typeid(ParamType).name()) {
+                fail = true;
+                return;
+            }
+            if constexpr (cIsSpecializationV<ParamType, spider::Data>) {
+                task_input.set_data_id(param.get_impl()->get_id());
+            } else if constexpr (Serializable<ParamType>) {
+                msgpack::sbuffer buffer;
+                msgpack::pack(buffer, param);
+                std::string const value(buffer.data(), buffer.size());
+                task_input.set_value(value);
+            }
+        });
+        return !fail;
+    }
+
+    template <TaskIo... Params>
+    auto add_inputs(Params&&... params) -> bool {
+        size_t input_task_index = 0;
+        size_t task_input_index = 0;
+
+        std::vector<boost::uuids::uuid> const& input_task_ids = m_graph.get_input_tasks();
+        bool fail = false;
+        for_n<sizeof...(Params)>([&](auto i) {
+            if (fail) {
+                return;
+            }
+            using ParamType
+                    = std::remove_cvref_t<std::tuple_element_t<i.cValue, std::tuple<Params...>>>;
+            ParamType const& param = std::get<i.cValue>(std::forward_as_tuple(params...));
+            if (input_task_index >= input_task_ids.size()) {
+                fail = true;
+                return;
+            }
+            boost::uuids::uuid const& input_task_id = input_task_ids[input_task_index];
+            std::optional<Task*> optional_input_task = m_graph.get_task(input_task_id);
+            if (!optional_input_task.has_value()) {
+                fail = true;
+                return;
+            }
+            Task& input_task = *optional_input_task.value();
+            if (task_input_index >= input_task.get_num_inputs()) {
+                fail = true;
+                return;
+            }
+            TaskInput& task_input = input_task.get_input_ref(task_input_index);
+            task_input_index++;
+            if (task_input_index >= input_task.get_num_inputs()) {
+                input_task_index++;
+                task_input_index = 0;
+            }
+            // Check type
+            if (task_input.get_type() != typeid(ParamType).name()) {
+                fail = true;
+                return;
+            }
+            if constexpr (cIsSpecializationV<ParamType, spider::Data>) {
+                task_input.set_data_id(param.get_impl()->get_id());
+            } else if constexpr (Serializable<ParamType>) {
+                msgpack::sbuffer buffer;
+                msgpack::pack(buffer, param);
+                std::string const value(buffer.data(), buffer.size());
+                task_input.set_value(value);
+            }
+        });
+        if (fail) {
+            return false;
+        }
+        // Check all inputs are consumed
+        return input_task_index == input_task_ids.size() && task_input_index == 0;
+    }
+
+    // NOLINTEND(cppcoreguidelines-missing-std-forward)
+
+    auto reset_ids() -> void { m_graph.reset_ids(); }
+
+    auto get_graph() -> TaskGraph& { return m_graph; }
+
+private:
     template <class ReturnType, class... TaskParams>
     static auto add_task_input(
             Task& task,
@@ -147,7 +254,7 @@ class TaskGraphImpl {
         Task const& parent = optional_parent.value();
         if constexpr (cIsSpecializationV<ReturnType, std::tuple>) {
             for_n<std::tuple_size_v<ReturnType>>([&](auto i) {
-                if (position >= sizeof...(TaskParams)) {
+                if (position >= task.get_num_inputs()) {
                     return std::nullopt;
                 }
                 TaskInput& input = task.get_input_ref(position);
@@ -155,7 +262,7 @@ class TaskGraphImpl {
                 input.set_output(parent.get_id(), i.cValue);
             });
         } else {
-            if (position >= sizeof...(TaskParams)) {
+            if (position >= task.get_num_inputs()) {
                 return std::nullopt;
             }
             TaskInput& input = task.get_input_ref(position);
diff --git a/src/spider/storage/MetadataStorage.hpp b/src/spider/storage/MetadataStorage.hpp
index efbe9c9..665db84 100644
--- a/src/spider/storage/MetadataStorage.hpp
+++ b/src/spider/storage/MetadataStorage.hpp
@@ -35,6 +35,12 @@ class MetadataStorage {
     add_job(boost::uuids::uuid job_id, boost::uuids::uuid client_id, TaskGraph const& task_graph
     ) -> StorageErr = 0;
     virtual auto get_job_metadata(boost::uuids::uuid id, JobMetadata* job) -> StorageErr = 0;
+    virtual auto get_job_complete(boost::uuids::uuid id, bool* complete) -> StorageErr = 0;
+    virtual auto get_job_status(boost::uuids::uuid id, JobStatus* status) -> StorageErr = 0;
+    virtual auto get_job_output_tasks(
+            boost::uuids::uuid id,
+            std::vector<boost::uuids::uuid>* task_ids
+    ) -> StorageErr = 0;
     virtual auto get_task_graph(boost::uuids::uuid id, TaskGraph* task_graph) -> StorageErr = 0;
     virtual auto get_jobs_by_client_id(
             boost::uuids::uuid client_id,
diff --git a/src/spider/storage/MysqlStorage.cpp b/src/spider/storage/MysqlStorage.cpp
index 795527a..8c4f121 100644
--- a/src/spider/storage/MysqlStorage.cpp
+++ b/src/spider/storage/MysqlStorage.cpp
@@ -1,5 +1,6 @@
 #include "MysqlStorage.hpp"
 
+#include <algorithm>
 #include <array>
 #include <chrono>
 #include <cstdint>
@@ -88,6 +89,26 @@ char const* const cCreateTaskTable = R"(CREATE TABLE IF NOT EXISTS tasks (
     PRIMARY KEY (`id`)
 ))";
 
+char const* const cCreateInputTaskTable = R"(CREATE TABLE IF NOT EXISTS input_tasks (
+    `job_id` BINARY(16) NOT NULL,
+    `task_id` BINARY(16) NOT NULL,
+    `position` INT UNSIGNED NOT NULL,
+    CONSTRAINT `input_task_job_id` FOREIGN KEY (`job_id`) REFERENCES `jobs` (`id`) ON UPDATE NO ACTION ON DELETE CASCADE,
+    CONSTRAINT `input_task_task_id` FOREIGN KEY (`task_id`) REFERENCES `tasks` (`id`) ON UPDATE NO ACTION ON DELETE CASCADE,
+    INDEX (`job_id`, `position`),
+    PRIMARY KEY (`task_id`)
+))";
+
+char const* const cCreateOutputTaskTable = R"(CREATE TABLE IF NOT EXISTS output_tasks (
+    `job_id` BINARY(16) NOT NULL,
+    `task_id` BINARY(16) NOT NULL,
+    `position` INT UNSIGNED NOT NULL,
+    CONSTRAINT `output_task_job_id` FOREIGN KEY (`job_id`) REFERENCES `jobs` (`id`) ON UPDATE NO ACTION ON DELETE CASCADE,
+    CONSTRAINT `output_task_task_id` FOREIGN KEY (`task_id`) REFERENCES `tasks` (`id`) ON UPDATE NO ACTION ON DELETE CASCADE,
+    INDEX (`job_id`, `position`),
+    PRIMARY KEY (`task_id`)
+))";
+
 char const* const cCreateTaskInputTable = R"(CREATE TABLE IF NOT EXISTS `task_inputs` (
     `task_id` BINARY(16) NOT NULL,
     `position` INT UNSIGNED NOT NULL,
@@ -178,7 +199,7 @@ char const* const cCreateTaskKVDataTable = R"(CREATE TABLE IF NOT EXISTS `task_k
     CONSTRAINT `kv_data_task_id` FOREIGN KEY (`task_id`) REFERENCES `tasks` (`id`) ON UPDATE NO ACTION ON DELETE CASCADE
 ))";
 
-std::array<char const* const, 14> const cCreateStorage = {
+std::array<char const* const, 16> const cCreateStorage = {
         cCreateDriverTable,  // drivers table must be created before data_ref_driver
         cCreateSchedulerTable,
         cCreateJobTable,  // jobs table must be created before task
@@ -189,6 +210,8 @@ std::array<char const* const, 14> const cCreateStorage = {
         cCreateDataRefTaskTable,
         cCreateClientKVDataTable,
         cCreateTaskKVDataTable,
+        cCreateInputTaskTable,
+        cCreateOutputTaskTable,
         cCreateTaskOutputTable,  // task_outputs table must be created before task_inputs
         cCreateTaskInputTable,
         cCreateTaskDependencyTable,
@@ -468,6 +491,7 @@ void MySqlMetadataStorage::add_task(sql::bytes job_id, Task const& task) {
     }
 }
 
+// NOLINTBEGIN(readability-function-cognitive-complexity)
 auto MySqlMetadataStorage::add_job(
         boost::uuids::uuid job_id,
         boost::uuids::uuid client_id,
@@ -486,9 +510,9 @@ auto MySqlMetadataStorage::add_job(
         }
 
         // Tasks must be added in graph order to avoid the dangling reference.
-        std::vector<boost::uuids::uuid> const& inputs = task_graph.get_input_tasks();
+        std::vector<boost::uuids::uuid> const& input_task_ids = task_graph.get_input_tasks();
         absl::flat_hash_set<boost::uuids::uuid> heads;
-        for (boost::uuids::uuid const task_id : inputs) {
+        for (boost::uuids::uuid const task_id : input_task_ids) {
             heads.insert(task_id);
         }
         std::deque<boost::uuids::uuid> queue;
@@ -502,7 +526,13 @@ auto MySqlMetadataStorage::add_job(
             Task const* task = task_option.value();
             this->add_task(job_id_bytes, *task);
             for (boost::uuids::uuid const id : task_graph.get_child_tasks(task_id)) {
-                queue.push_back(id);
+                std::vector<boost::uuids::uuid> const parents = task_graph.get_parent_tasks(id);
+                if (std::ranges::all_of(parents, [&](boost::uuids::uuid const& parent) {
+                        return heads.contains(parent);
+                    }))
+                {
+                    queue.push_back(id);
+                }
             }
         }
         // Then go over all tasks in queue
@@ -519,7 +549,13 @@ auto MySqlMetadataStorage::add_job(
                 Task const* task = task_option.value();
                 this->add_task(job_id_bytes, *task);
                 for (boost::uuids::uuid const id : task_graph.get_child_tasks(task_id)) {
-                    queue.push_back(id);
+                    std::vector<boost::uuids::uuid> const parents = task_graph.get_parent_tasks(id);
+                    if (std::ranges::all_of(parents, [&](boost::uuids::uuid const& parent) {
+                            return heads.contains(parent);
+                        }))
+                    {
+                        queue.push_back(id);
+                    }
                 }
             }
         }
@@ -538,6 +574,36 @@ auto MySqlMetadataStorage::add_job(
             dep_statement->executeUpdate();
         }
 
+        // Add input tasks
+        for (size_t i = 0; i < input_task_ids.size(); i++) {
+            std::unique_ptr<sql::PreparedStatement> input_statement{m_conn->prepareStatement(
+                    "INSERT INTO `input_tasks` (`job_id`, `task_id`, `position`) VALUES (?, ?, ?)"
+            )};
+            input_statement->setBytes(1, &job_id_bytes);
+            sql::bytes task_id_bytes = uuid_get_bytes(input_task_ids[i]);
+            input_statement->setBytes(2, &task_id_bytes);
+            input_statement->setUInt(3, i);
+            input_statement->executeUpdate();
+        }
+        // Add output tasks
+        std::vector<boost::uuids::uuid> const& output_task_ids = task_graph.get_output_tasks();
+        for (size_t i = 0; i < output_task_ids.size(); i++) {
+            if (!task_graph.get_tasks().contains(output_task_ids[i])) {
+                spdlog::error(
+                        "Task graph inconsistent: {} not in task graph",
+                        to_string(output_task_ids[i])
+                );
+            }
+            std::unique_ptr<sql::PreparedStatement> output_statement{m_conn->prepareStatement(
+                    "INSERT INTO `output_tasks` (`job_id`, `task_id`, `position`) VALUES (?, ?, ?)"
+            )};
+            output_statement->setBytes(1, &job_id_bytes);
+            sql::bytes task_id_bytes = uuid_get_bytes(output_task_ids[i]);
+            output_statement->setBytes(2, &task_id_bytes);
+            output_statement->setUInt(3, i);
+            output_statement->executeUpdate();
+        }
+
         // Mark head tasks as ready
         for (boost::uuids::uuid const& task_id : task_graph.get_input_tasks()) {
             std::unique_ptr<sql::PreparedStatement> statement(
@@ -559,6 +625,8 @@ auto MySqlMetadataStorage::add_job(
     return StorageErr{};
 }
 
+// NOLINTEND(readability-function-cognitive-complexity)
+
 namespace {
 
 auto fetch_task(std::unique_ptr<sql::ResultSet> const& res) -> Task {
@@ -756,6 +824,29 @@ auto MySqlMetadataStorage::get_task_graph(boost::uuids::uuid id, TaskGraph* task
                     read_id(dep_res->getBinaryStream(2))
             );
         }
+
+        // Get input tasks
+        std::unique_ptr<sql::PreparedStatement> input_task_statement(
+                m_conn->prepareStatement("SELECT `task_id`, `position` FROM `input_tasks` WHERE "
+                                         "`job_id` = ? ORDER BY `position`")
+        );
+        input_task_statement->setBytes(1, &id_bytes);
+        std::unique_ptr<sql::ResultSet> const input_task_res(input_task_statement->executeQuery());
+        while (input_task_res->next()) {
+            task_graph->add_input_task(read_id(input_task_res->getBinaryStream(1)));
+        }
+        // Get output tasks
+        std::unique_ptr<sql::PreparedStatement> output_task_statement(
+                m_conn->prepareStatement("SELECT `task_id`, `position` FROM `output_tasks` WHERE "
+                                         "`job_id` = ? ORDER BY `position`")
+        );
+        output_task_statement->setBytes(1, &id_bytes);
+        std::unique_ptr<sql::ResultSet> const output_task_res(output_task_statement->executeQuery()
+        );
+        while (output_task_res->next()) {
+            task_graph->add_output_task(read_id(output_task_res->getBinaryStream(1)));
+        }
+
     } catch (sql::SQLException& e) {
         m_conn->rollback();
         if (e.getErrorCode() == ErKeyNotFound) {
@@ -823,6 +914,92 @@ auto MySqlMetadataStorage::get_job_metadata(boost::uuids::uuid id, JobMetadata*
     return StorageErr{};
 }
 
+auto MySqlMetadataStorage::get_job_complete(boost::uuids::uuid const id, bool* complete)
+        -> StorageErr {
+    try {
+        std::unique_ptr<sql::PreparedStatement> const statement{
+                m_conn->prepareStatement("SELECT `state` FROM `tasks` WHERE `job_id` = ? AND "
+                                         "`state` NOT IN ('success', 'cancel', 'fail') ")
+        };
+        sql::bytes id_bytes = uuid_get_bytes(id);
+        statement->setBytes(1, &id_bytes);
+        std::unique_ptr<sql::ResultSet> const res{statement->executeQuery()};
+        *complete = 0 == res->rowsCount();
+    } catch (sql::SQLException& e) {
+        m_conn->rollback();
+        return StorageErr{StorageErrType::OtherErr, e.what()};
+    }
+    m_conn->commit();
+    return StorageErr{};
+}
+
+auto MySqlMetadataStorage::get_job_status(boost::uuids::uuid const id, JobStatus* status)
+        -> StorageErr {
+    try {
+        std::unique_ptr<sql::PreparedStatement> const running_statement{
+                m_conn->prepareStatement("SELECT `state` FROM `tasks` WHERE `job_id` = ? AND "
+                                         "`state` NOT IN ('success', 'cancel', 'fail') ")
+        };
+        sql::bytes id_bytes = uuid_get_bytes(id);
+        running_statement->setBytes(1, &id_bytes);
+        std::unique_ptr<sql::ResultSet> const running_res{running_statement->executeQuery()};
+        if (running_res->rowsCount() > 0) {
+            *status = JobStatus::Running;
+            m_conn->commit();
+            return StorageErr{};
+        }
+        std::unique_ptr<sql::PreparedStatement> failed_statement{m_conn->prepareStatement(
+                "SELECT `state` FROM `tasks` WHERE `job_id` = ? AND `state` = 'fail'"
+        )};
+        failed_statement->setBytes(1, &id_bytes);
+        std::unique_ptr<sql::ResultSet> const failed_res{failed_statement->executeQuery()};
+        if (failed_res->rowsCount() > 0) {
+            *status = JobStatus::Failed;
+            m_conn->commit();
+            return StorageErr{};
+        }
+        std::unique_ptr<sql::PreparedStatement> canceled_statement{m_conn->prepareStatement(
+                "SELECT `state` FROM `tasks` WHERE `job_id` = ? AND `state` = 'cancel'"
+        )};
+        canceled_statement->setBytes(1, &id_bytes);
+        std::unique_ptr<sql::ResultSet> const canceled_res{canceled_statement->executeQuery()};
+        if (canceled_res->rowsCount() > 0) {
+            *status = JobStatus::Cancelled;
+            m_conn->commit();
+            return StorageErr{};
+        }
+        *status = JobStatus::Succeeded;
+    } catch (sql::SQLException& e) {
+        m_conn->rollback();
+        return StorageErr{StorageErrType::OtherErr, e.what()};
+    }
+    m_conn->commit();
+    return StorageErr{};
+}
+
+auto MySqlMetadataStorage::get_job_output_tasks(
+        boost::uuids::uuid const id,
+        std::vector<boost::uuids::uuid>* task_ids
+) -> StorageErr {
+    try {
+        task_ids->clear();
+        std::unique_ptr<sql::PreparedStatement> statement{m_conn->prepareStatement(
+                "SELECT `task_id` FROM `output_tasks` WHERE `job_id` = ? ORDER BY `position`"
+        )};
+        sql::bytes id_bytes = uuid_get_bytes(id);
+        statement->setBytes(1, &id_bytes);
+        std::unique_ptr<sql::ResultSet> const res{statement->executeQuery()};
+        while (res->next()) {
+            task_ids->emplace_back(read_id(res->getBinaryStream(1)));
+        }
+    } catch (sql::SQLException& e) {
+        m_conn->rollback();
+        return StorageErr{StorageErrType::OtherErr, e.what()};
+    }
+    m_conn->commit();
+    return StorageErr{};
+}
+
 auto MySqlMetadataStorage::get_jobs_by_client_id(
         boost::uuids::uuid client_id,
         std::vector<boost::uuids::uuid>* job_ids
diff --git a/src/spider/storage/MysqlStorage.hpp b/src/spider/storage/MysqlStorage.hpp
index 765063f..c712efd 100644
--- a/src/spider/storage/MysqlStorage.hpp
+++ b/src/spider/storage/MysqlStorage.hpp
@@ -40,6 +40,10 @@ class MySqlMetadataStorage : public MetadataStorage {
     add_job(boost::uuids::uuid job_id, boost::uuids::uuid client_id, TaskGraph const& task_graph
     ) -> StorageErr override;
     auto get_job_metadata(boost::uuids::uuid id, JobMetadata* job) -> StorageErr override;
+    auto get_job_complete(boost::uuids::uuid id, bool* complete) -> StorageErr override;
+    auto get_job_status(boost::uuids::uuid id, JobStatus* status) -> StorageErr override;
+    auto get_job_output_tasks(boost::uuids::uuid id, std::vector<boost::uuids::uuid>* task_ids)
+            -> StorageErr override;
     auto get_task_graph(boost::uuids::uuid id, TaskGraph* task_graph) -> StorageErr override;
     auto get_jobs_by_client_id(
             boost::uuids::uuid client_id,
diff --git a/src/spider/worker/FunctionManager.hpp b/src/spider/worker/FunctionManager.hpp
index 3eaee6f..d63c283 100644
--- a/src/spider/worker/FunctionManager.hpp
+++ b/src/spider/worker/FunctionManager.hpp
@@ -5,7 +5,6 @@
 #include <cstdint>
 #include <exception>
 #include <functional>
-#include <initializer_list>
 #include <memory>
 #include <optional>
 #include <string>
@@ -77,21 +76,6 @@ struct signature<R (*)(Args...)> {
     using ret_t = R;
 };
 
-template <std::size_t n>
-struct Num {
-    static constexpr auto cValue = n;
-};
-
-template <class F, std::size_t... is>
-void for_n(F func, std::index_sequence<is...>) {
-    (void)std::initializer_list{0, ((void)func(Num<is>{}), 0)...};
-}
-
-template <std::size_t n, typename F>
-void for_n(F func) {
-    for_n(func, std::make_index_sequence<n>());
-}
-
 enum class FunctionInvokeError : std::uint8_t {
     Success = 0,
     WrongNumberOfArguments = 1,
diff --git a/test-tasks.yaml b/test-tasks.yaml
index c6dbc7d..55bd142 100644
--- a/test-tasks.yaml
+++ b/test-tasks.yaml
@@ -40,6 +40,7 @@ tasks:
           TARGETS: [
             "spider_task_executor",
             "worker_test",
+            "client_test",
             "spider_worker",
             "spider_scheduler",
             "integrationTest"]
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 47e0919..0731b52 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -36,7 +36,7 @@ target_link_libraries(
     unitTest
     PRIVATE
         spider_core
-        spider_client_lib
+        spider_client
 )
 target_link_libraries(
     unitTest
@@ -51,12 +51,25 @@ target_link_libraries(
 add_dependencies(unitTest worker_test)
 
 add_library(worker_test SHARED)
+target_sources(worker_test PUBLIC worker/worker-test.hpp)
 target_sources(worker_test PRIVATE worker/worker-test.cpp)
 target_link_libraries(
     worker_test
     PRIVATE
         spider_core
-        spider_client_lib
+        spider_client
+)
+
+add_executable(client_test)
+target_sources(client_test PRIVATE client/client-test.cpp)
+target_link_libraries(
+    client_test
+    PRIVATE
+        spider_core
+        spider_client
+        worker_test
+        Boost::program_options
+        spdlog::spdlog
 )
 
 add_custom_target(integrationTest ALL)
@@ -67,4 +80,8 @@ add_custom_command(
         ${CMAKE_COMMAND} -E copy_directory ${CMAKE_CURRENT_SOURCE_DIR}/integration
         ${CMAKE_CURRENT_BINARY_DIR}/integration
 )
-add_dependencies(integrationTest worker_test)
+add_dependencies(
+    integrationTest
+    worker_test
+    client_test
+)
diff --git a/tests/client/client-test.cpp b/tests/client/client-test.cpp
new file mode 100644
index 0000000..24c6d46
--- /dev/null
+++ b/tests/client/client-test.cpp
@@ -0,0 +1,113 @@
+#include <string>
+
+#include <boost/any/bad_any_cast.hpp>
+#include <boost/program_options/errors.hpp>
+#include <boost/program_options/options_description.hpp>
+#include <boost/program_options/parsers.hpp>
+#include <boost/program_options/value_semantic.hpp>
+#include <boost/program_options/variables_map.hpp>
+#include <spdlog/sinks/stdout_color_sinks.h>  // IWYU pragma: keep
+#include <spdlog/spdlog.h>
+
+#include "../../src/spider/client/Data.hpp"
+#include "../../src/spider/client/Driver.hpp"
+#include "../../src/spider/client/Job.hpp"
+#include "../../src/spider/client/TaskGraph.hpp"
+#include "../worker/worker-test.hpp"
+
+namespace {
+auto parse_args(int const argc, char** argv) -> boost::program_options::variables_map {
+    boost::program_options::options_description desc;
+    desc.add_options()("help", "spider client test");
+    desc.add_options()(
+            "storage_url",
+            boost::program_options::value<std::string>(),
+            "storage server url"
+    );
+
+    boost::program_options::variables_map variables;
+    boost::program_options::store(
+            // NOLINTNEXTLINE(misc-include-cleaner)
+            boost::program_options::parse_command_line(argc, argv, desc),
+            variables
+    );
+    boost::program_options::notify(variables);
+    return variables;
+}
+
+constexpr int cCmdArgParseErr = 1;
+constexpr int cJobFailed = 2;
+
+}  // namespace
+
+// NOLINTNEXTLINE(bugprone-exception-escape)
+auto main(int argc, char** argv) -> int {
+    // NOLINTNEXTLINE(misc-include-cleaner)
+    spdlog::set_pattern("[%Y-%m-%d %H:%M:%S.%e] [%^%l%$] [spider.scheduler] %v");
+#ifndef NDEBUG
+    spdlog::set_level(spdlog::level::trace);
+#endif
+
+    boost::program_options::variables_map const args = parse_args(argc, argv);
+
+    std::string storage_url;
+    try {
+        if (!args.contains("storage_url")) {
+            spdlog::error("storage_url is required");
+            return cCmdArgParseErr;
+        }
+        storage_url = args["storage_url"].as<std::string>();
+    } catch (boost::bad_any_cast& e) {
+        return cCmdArgParseErr;
+    } catch (boost::program_options::error& e) {
+        return cCmdArgParseErr;
+    }
+
+    // Create driver
+    spider::Driver driver{storage_url};
+    spdlog::debug("Driver created");
+
+    // Run a complicated graph that should succeed
+    spider::TaskGraph const left = driver.bind(&sum_test, &data_test, &data_test);
+    spider::TaskGraph const graph = driver.bind(&sum_test, left, &sum_test);
+    spdlog::debug("Graph created");
+    spider::Data<int> d1 = driver.get_data_builder<int>().build(1);
+    spider::Data<int> d2 = driver.get_data_builder<int>().build(2);
+    spdlog::debug("Data created");
+    spider::Job<int> job = driver.start(graph, d1, d2, 3, 4);
+    spdlog::debug("Job started");
+    job.wait_complete();
+    spdlog::debug("Job completed");
+    if (job.get_status() != spider::JobStatus::Succeeded) {
+        spdlog::error("Job failed");
+        return cJobFailed;
+    }
+    constexpr int cExpectedResult = 10;
+    if (job.get_result() != cExpectedResult) {
+        spdlog::error("Wrong job result. Get {}. Expect 10", job.get_result());
+        return cJobFailed;
+    }
+
+    // Run fail job
+    spider::Job fail_job = driver.start(&error_test, 1);
+    spdlog::debug("Fail job started");
+    fail_job.wait_complete();
+    spdlog::debug("Fail job completed");
+    if (fail_job.get_status() != spider::JobStatus::Failed) {
+        spdlog::error("Job should fail");
+        return cJobFailed;
+    }
+
+    // Run random fail job
+    constexpr int cFailRate = 5;
+    spider::Job random_fail_job = driver.start(&random_fail_test, cFailRate);
+    spdlog::debug("Random fail job started");
+    random_fail_job.wait_complete();
+    spdlog::debug("Random fail job completed");
+    if (random_fail_job.get_status() != spider::JobStatus::Succeeded) {
+        spdlog::error("Random fail job failed");
+        return cJobFailed;
+    }
+
+    return 0;
+}
diff --git a/tests/integration/test_client.py b/tests/integration/test_client.py
new file mode 100644
index 0000000..fa2b1a5
--- /dev/null
+++ b/tests/integration/test_client.py
@@ -0,0 +1,64 @@
+import subprocess
+import time
+from pathlib import Path
+from typing import Tuple
+
+import pytest
+
+from .client import (
+    storage,
+    storage_url,
+)
+
+
+def start_scheduler_worker(
+    storage_url: str, scheduler_port: int
+) -> Tuple[subprocess.Popen, subprocess.Popen]:
+    # Start the scheduler
+    dir_path = Path(__file__).resolve().parent
+    dir_path = dir_path / ".." / ".." / "src" / "spider"
+    scheduler_cmds = [
+        str(dir_path / "spider_scheduler"),
+        "--port",
+        str(scheduler_port),
+        "--storage_url",
+        storage_url,
+    ]
+    scheduler_process = subprocess.Popen(scheduler_cmds)
+    worker_cmds = [
+        str(dir_path / "spider_worker"),
+        "--storage_url",
+        storage_url,
+        "--libs",
+        "tests/libworker_test.so",
+    ]
+    worker_process = subprocess.Popen(worker_cmds)
+    return scheduler_process, worker_process
+
+
+scheduler_port = 6103
+
+
+@pytest.fixture(scope="class")
+def scheduler_worker(storage):
+    scheduler_process, worker_process = start_scheduler_worker(
+        storage_url=storage_url, scheduler_port=scheduler_port
+    )
+    # Wait for 5 second to make sure the scheduler and worker are started
+    time.sleep(5)
+    yield
+    scheduler_process.kill()
+    worker_process.kill()
+
+
+class TestClient:
+    def test_client(self, scheduler_worker):
+        dir_path = Path(__file__).resolve().parent
+        dir_path = dir_path / ".."
+        client_cmds = [
+            str(dir_path / "client_test"),
+            "--storage_url",
+            storage_url,
+        ]
+        p = subprocess.run(client_cmds)
+        assert p.returncode == 0
diff --git a/tests/worker/worker-test.cpp b/tests/worker/worker-test.cpp
index 5033435..7971ce0 100644
--- a/tests/worker/worker-test.cpp
+++ b/tests/worker/worker-test.cpp
@@ -1,26 +1,27 @@
+#include "worker-test.hpp"
+
 #include <iostream>
 #include <random>
 #include <stdexcept>
 
 #include "../../src/spider/client/Data.hpp"
+#include "../../src/spider/client/Driver.hpp"
 #include "../../src/spider/client/TaskContext.hpp"
-#include "../../src/spider/worker/FunctionManager.hpp"
 
-namespace {
-auto sum_test(spider::TaskContext const& /*context*/, int const x, int const y) -> int {
+auto sum_test(spider::TaskContext& /*context*/, int const x, int const y) -> int {
     std::cerr << x << " + " << y << " = " << x + y << "\n";
     return x + y;
 }
 
-auto error_test(spider::TaskContext const& /*context*/, int const /*x*/) -> int {
+auto error_test(spider::TaskContext& /*context*/, int const /*x*/) -> int {
     throw std::runtime_error("Simulated error in worker");
 }
 
-auto data_test(spider::TaskContext const& /*context*/, spider::Data<int>& data) -> int {
+auto data_test(spider::TaskContext& /*context*/, spider::Data<int>& data) -> int {
     return data.get();
 }
 
-auto random_fail_test(spider::TaskContext const& /*context*/, int fail_rate) -> int {
+auto random_fail_test(spider::TaskContext& /*context*/, int fail_rate) -> int {
     std::random_device rd;
     std::mt19937 gen{rd()};
     constexpr int cMaxFailRate = 100;
@@ -33,11 +34,10 @@ auto random_fail_test(spider::TaskContext const& /*context*/, int fail_rate) ->
     }
     return 0;
 }
-}  // namespace
 
 // NOLINTBEGIN(cert-err58-cpp)
-SPIDER_WORKER_REGISTER_TASK(sum_test);
-SPIDER_WORKER_REGISTER_TASK(error_test);
-SPIDER_WORKER_REGISTER_TASK(data_test);
-SPIDER_WORKER_REGISTER_TASK(random_fail_test);
+SPIDER_REGISTER_TASK(sum_test);
+SPIDER_REGISTER_TASK(error_test);
+SPIDER_REGISTER_TASK(data_test);
+SPIDER_REGISTER_TASK(random_fail_test);
 // NOLINTEND(cert-err58-cpp)
diff --git a/tests/worker/worker-test.hpp b/tests/worker/worker-test.hpp
new file mode 100644
index 0000000..9446822
--- /dev/null
+++ b/tests/worker/worker-test.hpp
@@ -0,0 +1,15 @@
+#ifndef SPIDER_TEST_WORKER_TEST_HPP
+#define SPIDER_TEST_WORKER_TEST_HPP
+
+#include "../../src/spider/client/Data.hpp"
+#include "../../src/spider/client/TaskContext.hpp"
+
+auto sum_test(spider::TaskContext& /*context*/, int x, int y) -> int;
+
+auto error_test(spider::TaskContext& /*context*/, int /*x*/) -> int;
+
+auto data_test(spider::TaskContext& /*context*/, spider::Data<int>& data) -> int;
+
+auto random_fail_test(spider::TaskContext& /*context*/, int fail_rate) -> int;
+
+#endif