diff --git a/Classes/Command/AppCommandController.php b/Classes/Command/AppCommandController.php
new file mode 100644
index 0000000..f7427bc
--- /dev/null
+++ b/Classes/Command/AppCommandController.php
@@ -0,0 +1,123 @@
+<?php
+namespace Yeebase\Readiness\Command;
+
+/**
+ * This file is part of the Yeebase.Readiness package.
+ *
+ * (c) 2018 yeebase media GmbH
+ *
+ * This package is Open Source Software. For the full copyright and license
+ * information, please view the LICENSE file which was distributed with this
+ * source code.
+ */
+
+use Neos\Error\Messages\Error;
+use Neos\Error\Messages\Result;
+use Neos\Flow\Annotations as Flow;
+use Neos\Flow\Cli\CommandController;
+use Neos\Flow\Log\SystemLoggerInterface;
+use Yeebase\Readiness\Service\ReadyTaskRunner;
+use Yeebase\Readiness\Service\TestRunner;
+use Yeebase\Readiness\Task\TaskInterface;
+use Yeebase\Readiness\Test\TestInterface;
+
+/**
+ * @Flow\Scope("singleton")
+ */
+class AppCommandController extends CommandController
+{
+    /**
+     * @Flow\Inject
+     * @var SystemLoggerInterface
+     */
+    protected $systemLogger;
+
+    /**
+     * @return Result
+     */
+    protected function runReadyTasks(): Result
+    {
+        $taskRunner = new ReadyTaskRunner();
+        $taskRunner->onBeforeTask(function (TaskInterface $task) {
+            $this->output('Executing %s... ', [$task->getName()]);
+        });
+        $taskRunner->onTaskResult(function (TaskInterface $task, Result $result) {
+            if ($result->hasErrors()) {
+                $this->outputFormatted('<error>%s</error>', [$task->getErrorLabel()]);
+            } else if ($result->hasNotices()) {
+                $this->outputFormatted('<comment>%s</comment>', [$task->getNoticeLabel()]);
+            } else {
+                $this->outputFormatted('<success>%s</success>', [$task->getSuccessLabel()]);
+            }
+        });
+
+        try {
+            return $taskRunner->run();
+        } catch (\Exception $exception) {
+            $this->output->output('<error>%s</error>', [$exception->getMessage()]);
+            $this->systemLogger->logException($exception);
+            $result = new Result();
+            $result->addError(new Error('Chain failed'));
+            return $result;
+        }
+    }
+
+    /**
+     * @return Result
+     */
+    protected function runTests(): Result
+    {
+        $testRunner = new TestRunner();
+
+        $testRunner->onBeforeTest(function (TestInterface $test) {
+            $this->output->output('Testing %s... ', [$test->getName()]);
+        });
+        $testRunner->onTestResult(function (TestInterface $test, Result $result) {
+            if ($result->hasErrors()) {
+                $this->output->outputLine('<error>%s</error>', [$test->getErrorLabel()]);
+            } else if ($result->hasNotices()) {
+                $this->output->outputLine('<commment>%s</commment>', [$test->getNoticeLabel()]);
+            } else {
+                $this->output->outputLine('<info>%s</info>', [$test->getSuccessLabel()]);
+            }
+        });
+
+        return $testRunner->run();
+    }
+
+    /**
+     * Checks the readiness of the application
+     */
+    public function isReadyCommand()
+    {
+        $this->outputLine();
+        $this->outputLine('<info>Running tests...</info>');
+        $this->outputLine();
+        $testResult = $this->runTests();
+        $this->outputLine();
+        if (!$testResult->hasErrors()) {
+            $this->outputLine();
+            $this->outputLine('<info>All checks passed, executing ready tasks...</info>');
+            $this->outputLine();
+            $readyResult = $this->runReadyTasks();
+            $this->outputLine();
+
+            if (!$readyResult->hasErrors()) {
+                $this->outputLine('<success>Application is ready</success>');
+                $this->outputLine();
+                $this->outputLine();
+                $this->quit(0);
+            } else {
+                $this->outputLine('<error>Application did not pass all ready tasks and is not ready</error>');
+                $this->outputLine();
+                $this->outputLine();
+                $this->quit(1);
+            }
+        } else {
+            $this->outputLine();
+            $this->outputLine('<error>Application did not pass all checks and is not ready</error>');
+            $this->outputLine();
+            $this->quit(1);
+        }
+    }
+}
diff --git a/Classes/Eel/Helper/ChainHelper.php b/Classes/Eel/Helper/ChainHelper.php
new file mode 100644
index 0000000..4de2c25
--- /dev/null
+++ b/Classes/Eel/Helper/ChainHelper.php
@@ -0,0 +1,67 @@
+<?php
+namespace Yeebase\Readiness\Eel\Helper;
+
+/**
+ * This file is part of the Yeebase.XY package.
+ *
+ * (c) 2018 yeebase media GmbH
+ *
+ * This package is Open Source Software. For the full copyright and license
+ * information, please view the LICENSE file which was distributed with this
+ * source code.
+ */
+
+use Neos\Error\Messages\Error;
+use Neos\Flow\Annotations as Flow;
+use Neos\Eel\ProtectedContextAwareInterface;
+use Yeebase\Readiness\Service\EelRuntime;
+
+class ChainHelper implements ProtectedContextAwareInterface
+{
+
+    /**
+     * @Flow\Inject
+     * @var EelRuntime
+     */
+    protected $runtime;
+
+    /**
+     * @return bool
+     */
+    public function isValid(): bool
+    {
+        $result = $this->runtime->getChainResult();
+        return !$result->hasErrors();
+    }
+
+    /**
+     * @return bool
+     */
+    public function isInvalid(): bool
+    {
+        $result = $this->runtime->getChainResult();
+        return $result->hasErrors();
+    }
+
+    /**
+     * @return string
+     */
+    public function getCombinedErrorMessages(): string
+    {
+        $result = $this->runtime->getChainResult();
+        $messages = array_map(function (Error $error) {
+            return $error->getMessage();
+        }, $result->getErrors());
+
+        return implode(PHP_EOL, $messages);
+    }
+
+    /**
+     * @param string $methodName
+     * @return boolean
+     */
+    public function allowsCallOfMethod($methodName)
+    {
+        return $this->runtime->isTaskContext();
+    }
+}
diff --git a/Classes/Eel/Helper/LockHelper.php b/Classes/Eel/Helper/LockHelper.php
new file mode 100644
index 0000000..2e5f6ec
--- /dev/null
+++ b/Classes/Eel/Helper/LockHelper.php
@@ -0,0 +1,127 @@
+<?php
+namespace Yeebase\Readiness\Eel\Helper;
+
+/**
+ * This file is part of the Yeebase.XY package.
+ *
+ * (c) 2018 yeebase media GmbH
+ *
+ * This package is Open Source Software. For the full copyright and license
+ * information, please view the LICENSE file which was distributed with this
+ * source code.
+ */
+
+use Neos\Cache\Frontend\FrontendInterface;
+use Neos\Eel\ProtectedContextAwareInterface;
+use Neos\Flow\Annotations as Flow;
+use Neos\Flow\Cache\CacheManager;
+use Yeebase\Readiness\Service\EelRuntime;
+
+class LockHelper implements ProtectedContextAwareInterface
+{
+    /**
+     * @Flow\InjectConfiguration("lockPrefix")
+     * @var string
+     */
+    protected $lockPrefix;
+
+    /**
+     * @Flow\InjectConfiguration("defaultCacheName")
+     * @var string
+     */
+    protected $defaultCacheName;
+
+    /**
+     * @var string
+     */
+    protected $overrideCacheName;
+
+    /**
+     * @Flow\Inject
+     * @var CacheManager
+     */
+    protected $cacheManager;
+
+    /**
+     * @Flow\Inject
+     * @var EelRuntime
+     */
+    protected $runtime;
+
+    /**
+     * @param string $name
+     * @return string
+     */
+    protected function getEntryIdentifier(string $name): string
+    {
+        return (!empty($this->lockPrefix) ? $this->lockPrefix . '_' : '') . $name;
+    }
+
+    /**
+     * @return FrontendInterface
+     */
+    protected function getCache(): FrontendInterface
+    {
+        try {
+            $cache = $this->cacheManager->getCache($this->overrideCacheName ?? $this->defaultCacheName);
+        } finally {
+            $this->overrideCacheName = null;
+        }
+
+        return $cache;
+    }
+
+    /**
+     * @param string $cacheName
+     * @return $this
+     */
+    public function withCache(string $cacheName)
+    {
+        $this->overrideCacheName = $cacheName;
+        return $this;
+    }
+
+    /**
+     * @param string $lockName
+     * @param string $value
+     */
+    public function set(string $lockName, string $value = '1')
+    {
+        $this->getCache()->set($this->getEntryIdentifier($lockName), $value, [], 0);
+    }
+
+    /**
+     * @param string $lockName
+     */
+    public function unset(string $lockName)
+    {
+        $this->getCache()->remove($this->getEntryIdentifier($lockName));
+    }
+
+    /**
+     * @param string $lockName
+     * @return bool
+     */
+    public function isSet(string $lockName)
+    {
+        return $this->getCache()->has($this->getEntryIdentifier($lockName));
+    }
+
+    /**
+     * @param string $lockName
+     * @return bool
+     */
+    public function isUnset(string $lockName)
+    {
+        return !$this->isSet($lockName);
+    }
+
+    /**
+     * @param string $methodName
+     * @return boolean
+     */
+    public function allowsCallOfMethod($methodName)
+    {
+        return substr($methodName, 0, 2) === 'is' || $this->runtime->isTaskContext();
+    }
+}
diff --git a/Classes/Service/AbstractTaskRunner.php b/Classes/Service/AbstractTaskRunner.php
new file mode 100644
index 0000000..fbbf799
--- /dev/null
+++ b/Classes/Service/AbstractTaskRunner.php
@@ -0,0 +1,221 @@
+<?php
+namespace Yeebase\Readiness\Service;
+
+/**
+ * This file is part of the Yeebase.XY package.
+ *
+ * (c) 2018 yeebase media GmbH
+ *
+ * This package is Open Source Software. For the full copyright and license
+ * information, please view the LICENSE file which was distributed with this
+ * source code.
+ */
+
+use Neos\Error\Messages\Error;
+use Neos\Error\Messages\Notice;
+use Neos\Flow\Annotations as Flow;
+use Neos\Error\Messages\Result;
+use Neos\Flow\Configuration\Exception\InvalidConfigurationException;
+use Neos\Flow\Log\SystemLoggerInterface;
+use Neos\Flow\ObjectManagement\ObjectManagerInterface;
+use Neos\Utility\PositionalArraySorter;
+use Yeebase\Readiness\Task\TaskInterface;
+
+/**
+ *
+ */
+abstract class AbstractTaskRunner
+{
+    /**
+     * @Flow\Inject
+     * @var SystemLoggerInterface
+     */
+    protected $systemLogger;
+
+    /**
+     * @var ObjectManagerInterface
+     */
+    protected $objectManager;
+
+    /**
+     * @var \Closure
+     */
+    protected $onTaskResultClosure;
+
+    /**
+     * @var \Closure
+     */
+    protected $onBeforeTaskClosure;
+
+    /**
+     * @var string
+     */
+    protected $defaultTaskClassName = 'Yeebase\Readiness\Task\%sTask';
+
+
+    /**
+     * @var string
+     */
+    protected $defaultCondition;
+
+    /**
+     * @var array
+     */
+    protected $chain = [];
+
+    /**
+     * @var string
+     */
+    protected $context;
+
+    /**
+     * @var Result
+     */
+    protected $chainResult;
+
+    /**
+     * @Flow\Inject
+     * @var EelRuntime
+     */
+    protected $runtime;
+
+    /**
+     * @var bool
+     */
+    protected $stopOnFail = false;
+
+    /**
+     * @param ObjectManagerInterface $objectManager
+     */
+    public function injectObjectManager(ObjectManagerInterface $objectManager)
+    {
+        $this->objectManager = $objectManager;
+    }
+
+    /**
+     *
+     */
+    public function __construct()
+    {
+        $this->onTaskResultClosure = function () {
+        };
+        $this->onBeforeTaskClosure = function () {
+        };
+    }
+
+    /**
+     * @param \Closure $onTaskResultClosure
+     * @return $this
+     */
+    public function onTaskResult(\Closure $onTaskResultClosure)
+    {
+        $this->onTaskResultClosure = $onTaskResultClosure;
+        return $this;
+    }
+
+    /**
+     * @param \Closure $onBeforeTaskClosure
+     * @return $this
+     */
+    public function onBeforeTask(\Closure $onBeforeTaskClosure)
+    {
+        $this->onBeforeTaskClosure = $onBeforeTaskClosure;
+        return $this;
+    }
+
+    /**
+     * @param string $objectName
+     * @return string
+     */
+    protected function resolveTaskClassName(string $objectName): string
+    {
+        if ($this->objectManager->isRegistered($objectName)) {
+            return $objectName;
+        }
+
+        return sprintf($this->defaultTaskClassName, ucfirst($objectName));
+    }
+
+    /**
+     * @param TaskInterface $task
+     * @param array $configuration
+     * @return bool
+     */
+    protected function shouldSkipTask(TaskInterface $task, array $configuration): bool
+    {
+        return !$this->runtime->evaluate($configuration['condition'] ?? $this->defaultCondition);
+    }
+
+
+    /**
+     * @param TaskInterface $task
+     * @param array $configuration
+     */
+    protected function afterTaskInvocation(TaskInterface $task, array $configuration)
+    {
+        if (isset($configuration['afterInvocation'])) {
+            $this->runtime->evaluate($configuration['afterInvocation']);
+        }
+    }
+
+    /**
+     * @param string $name
+     * @param array $configuration
+     * @return Result
+     * @throws InvalidConfigurationException
+     */
+    protected function runTask(string $name, array $configuration): Result
+    {
+        $implementationClassName = $configuration[$this->context];
+        $className = $this->resolveTaskClassName($implementationClassName);
+
+        $task = new $className($name, $configuration['options'] ?? []);
+
+        if (!($task instanceof TaskInterface)) {
+            throw new InvalidConfigurationException(sprintf('%s does not implement \Yeebase\Readiness\Task\TaskInterface', get_class($task)), 1502699058);
+        }
+
+        $onBeforeTask = $this->onBeforeTaskClosure;
+        $onBeforeTask($task);
+
+        $result = $task->getResult();
+        try {
+            if ($this->shouldSkipTask($task, $configuration)) {
+                $result->addNotice(new Notice('Skipped'));
+            } else {
+                $task->run();
+                $this->afterTaskInvocation($task, $configuration);
+            }
+        } catch (\Exception $exception) {
+            $result->addError(new Error($exception->getMessage(), $exception->getCode()));
+            $this->systemLogger->logException($exception);
+        }
+
+        $onTaskResult = $this->onTaskResultClosure;
+        $onTaskResult($task, $result);
+
+        return $result;
+    }
+
+    /**
+     * @return Result
+     */
+    public function run(): Result
+    {
+        $this->chainResult = new Result();
+        $this->runtime->setTaskContext($this->context);
+        $this->runtime->setChainResult($this->chainResult);
+
+        $sorter = new PositionalArraySorter($this->chain);
+
+        foreach ($sorter->toArray() as $key => $task) {
+            $result = $this->runTask($task['name'] ?? ucfirst($key), $task);
+            $this->chainResult->merge($result);
+            if ($result->hasErrors() && $this->stopOnFail) {
+                break;
+            }
+        }
+
+        return $this->chainResult;
+    }
+}
diff --git a/Classes/Service/EelRuntime.php b/Classes/Service/EelRuntime.php
new file mode 100644
index 0000000..59fafe4
--- /dev/null
+++ b/Classes/Service/EelRuntime.php
@@ -0,0 +1,109 @@
+<?php
+namespace Yeebase\Readiness\Service;
+
+/**
+ * This file is part of the Yeebase.XY package.
+ *
+ * (c) 2018 yeebase media GmbH
+ *
+ * This package is Open Source Software. For the full copyright and license
+ * information, please view the LICENSE file which was distributed with this
+ * source code.
+ */
+
+use Neos\Error\Messages\Result;
+use Neos\Flow\Annotations as Flow;
+use Neos\Eel\InterpretedEvaluator;
+use Neos\Eel\Utility as EelUtility;
+
+/**
+ * @Flow\Scope("singleton")
+ */
+class EelRuntime
+{
+    const CONTEXT_TEST = 'test';
+    const CONTEXT_TASK = 'task';
+
+    /**
+     * @Flow\InjectConfiguration("defaultContext")
+     * @var array
+     */
+    protected $eelContext;
+
+    /**
+     * @var array
+     */
+    protected $defaultContextVariables;
+
+    /**
+     * @var string
+     */
+    protected $taskContext;
+
+    /**
+     * @var Result
+     */
+    protected $chainResult;
+
+    /**
+     * @param string $taskContext
+     */
+    public function setTaskContext(string $taskContext)
+    {
+        $this->taskContext = $taskContext;
+    }
+
+    /**
+     * @return bool
+     */
+    public function isTaskContext(): bool
+    {
+        return $this->taskContext === self::CONTEXT_TASK;
+    }
+
+    /**
+     * @return bool
+     */
+    public function isTestContext(): bool
+    {
+        return $this->taskContext === self::CONTEXT_TEST;
+    }
+
+    /**
+     * @param Result $chainResult
+     */
+    public function setChainResult(Result $chainResult)
+    {
+        $this->chainResult = $chainResult;
+    }
+
+    /**
+     * @return Result
+     */
+    public function getChainResult(): Result
+    {
+        return $this->chainResult;
+    }
+
+    /**
+     * @return array
+     */
+    protected function getDefaultContextVariables()
+    {
+        if ($this->defaultContextVariables === null) {
+            $this->defaultContextVariables = array();
+            $this->defaultContextVariables = EelUtility::getDefaultContextVariables($this->eelContext);
+        }
+        return $this->defaultContextVariables;
+    }
+
+    /**
+     * @param string $expression
+     * @return mixed
+     */
+    public function evaluate(string $expression)
+    {
+        $evaluator = new InterpretedEvaluator();
+        return EelUtility::evaluateEelExpression($expression, $evaluator, $this->getDefaultContextVariables());
+    }
+}
diff --git a/Classes/Service/ReadyTaskRunner.php b/Classes/Service/ReadyTaskRunner.php
new file mode 100644
index 0000000..316f9a7
--- /dev/null
+++ b/Classes/Service/ReadyTaskRunner.php
@@ -0,0 +1,54 @@
+<?php
+namespace Yeebase\Readiness\Service;
+
+/**
+ * This file is part of the Yeebase.XY package.
+ *
+ * (c) 2018 yeebase media GmbH
+ *
+ * This package is Open Source Software. For the full copyright and license
+ * information, please view the LICENSE file which was distributed with this
+ * source code.
+ */
+
+use Neos\Flow\Annotations as Flow;
+use Neos\Error\Messages\Result;
+
+/**
+ *
+ */
+class ReadyTaskRunner extends AbstractTaskRunner
+{
+    /**
+     * @Flow\InjectConfiguration("readyChain")
+     * @var array
+     */
+    protected $chain;
+
+    /**
+     * @Flow\InjectConfiguration("defaultReadyTaskCondition")
+     * @var string
+     */
+    protected $defaultCondition;
+
+    /**
+     * @var string
+     */
+    protected $context = EelRuntime::CONTEXT_TASK;
+
+    /**
+     * @param string $name
+     * @param array $configuration
+     * @return Result
+     */
+    protected function runTask(string $name, array $configuration): Result
+    {
+        if (isset($configuration['lockName'])) {
+            $cacheOverride = isset($configuration['cacheName']) ? sprintf('.withCache("%s")', $configuration['cacheName']) : '';
+            $configuration['condition'] = sprintf('${Lock%s.isUnset("%s")}', $cacheOverride, $configuration['lockName']);
+            $configuration['afterInvocation'] = sprintf('${Lock%s.set("%s")}', $cacheOverride, $configuration['lockName']);
+        }
+
+        return parent::runTask($name, $configuration);
+    }
+}
diff --git a/Classes/Service/TestRunner.php b/Classes/Service/TestRunner.php
new file mode 100644
index 0000000..ad7ce70
--- /dev/null
+++ b/Classes/Service/TestRunner.php
@@ -0,0 +1,63 @@
+<?php
+namespace Yeebase\Readiness\Service;
+
+/**
+ * This file is part of the Yeebase.XY package.
+ *
+ * (c) 2018 yeebase media GmbH
+ *
+ * This package is Open Source Software. For the full copyright and license
+ * information, please view the LICENSE file which was distributed with this
+ * source code.
+ */
+
+use Neos\Flow\Annotations as Flow;
+
+/**
+ * @Flow\Scope("singleton")
+ */
+class TestRunner extends AbstractTaskRunner
+{
+    /**
+     * @Flow\InjectConfiguration("testChain")
+     * @var array
+     */
+    protected $chain;
+
+    /**
+     * @Flow\InjectConfiguration("defaultTestCondition")
+     * @var string
+     */
+    protected $defaultCondition;
+
+    /**
+     * @var string
+     */
+    protected $defaultTaskClassName = 'Yeebase\Readiness\Test\%sTest';
+
+    /**
+     * @var bool
+     */
+    protected $stopOnFail = true;
+
+    /**
+     * @var string
+     */
+    protected $context = EelRuntime::CONTEXT_TEST;
+
+    /**
+     * @param \Closure $onBeforeTest
+     */
+    public function onBeforeTest(\Closure $onBeforeTest)
+    {
+        $this->onBeforeTask($onBeforeTest);
+    }
+
+    /**
+     * @param \Closure $onTestResult
+     */
+    public function onTestResult(\Closure $onTestResult)
+    {
+        $this->onTaskResult($onTestResult);
+    }
+}
diff --git a/Classes/Task/AbstractTask.php b/Classes/Task/AbstractTask.php
new file mode 100644
index 0000000..1113fe5
--- /dev/null
+++ b/Classes/Task/AbstractTask.php
@@ -0,0 +1,101 @@
+<?php
+namespace Yeebase\Readiness\Task;
+
+/**
+ * This file is part of the Yeebase.XY package.
+ *
+ * (c) 2018 yeebase media GmbH
+ *
+ * This package is Open Source Software. For the full copyright and license
+ * information, please view the LICENSE file which was distributed with this
+ * source code.
+ */
+
+use Neos\Error\Messages\Result;
+
+abstract class AbstractTask implements TaskInterface
+{
+    /**
+     * @var string
+     */
+    protected $name;
+
+    /**
+     * @var array
+     */
+    protected $options;
+
+    /**
+     * @var Result
+     */
+    protected $result;
+
+
+    /**
+     * @param string $name
+     * @param array $options
+     */
+    public function __construct(string $name, array $options = [])
+    {
+        $this->name = $name;
+        $this->options = $options;
+        $this->result = new Result();
+        $this->validateOptions($options);
+    }
+
+    /**
+     * @param array $options
+     */
+    protected function validateOptions(array $options)
+    {
+    }
+
+    /**
+     * @return string
+     */
+    public function getName(): string
+    {
+        return $this->name;
+    }
+
+    /**
+     * @return string
+     */
+    public function getSuccessLabel(): string
+    {
+        return 'Done';
+    }
+
+    /**
+     * @return string
+     */
+    public function getErrorLabel(): string
+    {
+        $error = $this->result->getFirstError();
+        return $error ? $error->getMessage() : 'Failed';
+    }
+
+    /**
+     * @return string
+     */
+    public function getNoticeLabel(): string
+    {
+        return $this->result->getFirstNotice()->getMessage();
+    }
+
+    /**
+     * @return array
+     */
+    public function getOptions(): array
+    {
+        return $this->options;
+    }
+
+    /**
+     * @return Result
+     */
+    public function getResult(): Result
+    {
+        return $this->result;
+    }
+}
diff --git a/Classes/Task/CommandTask.php b/Classes/Task/CommandTask.php
new file mode 100644
index 0000000..f65d103
--- /dev/null
+++ b/Classes/Task/CommandTask.php
@@ -0,0 +1,55 @@
+<?php
+namespace Yeebase\Readiness\Task;
+
+/**
+ * This file is part of the Yeebase.XY package.
+ *
+ * (c) 2018 yeebase media GmbH
+ *
+ * This package is Open Source Software. For the full copyright and license
+ * information, please view the LICENSE file which was distributed with this
+ * source code.
+ */
+
+use Neos\FLow\Annotations as Flow;
+use Neos\Flow\Configuration\Exception\InvalidConfigurationException;
+use Neos\Flow\Core\Booting\Exception\SubProcessException;
+use Neos\Flow\Core\Booting\Scripts;
+use Neos\Flow\Log\SystemLoggerInterface;
+
+class CommandTask extends AbstractTask
+{
+    /**
+     * @Flow\InjectConfiguration(package="Neos.Flow")
+     * @var array
+     */
+    protected $flowSettings;
+
+    /**
+     * @Flow\Inject
+     * @var SystemLoggerInterface
+     */
+    protected $systemLogger;
+
+    /**
+     * @param array $options
+     * @throws InvalidConfigurationException
+     */
+    protected function validateOptions(array $options)
+    {
+        if (!isset($options['command'])) {
+            throw new InvalidConfigurationException('"command" task needs a "command" option', 1502701492);
+        }
+    }
+
+    /**
+     * @throws SubProcessException
+     */
+    public function run()
+    {
+        $success = Scripts::executeCommand($this->options['command'], $this->flowSettings, false, $this->options['arguments'] ?? []);
+        if (!$success) {
+            throw new SubProcessException(sprintf('Command "%s" did not return true', $this->options['command']), 1511529104);
+        }
+    }
+}
diff --git a/Classes/Task/EelTask.php b/Classes/Task/EelTask.php
new file mode 100644
index 0000000..c609d08
--- /dev/null
+++ b/Classes/Task/EelTask.php
@@ -0,0 +1,51 @@
+<?php
+namespace Yeebase\Readiness\Task;
+
+/**
+ * This file is part of the Yeebase.XY package.
+ *
+ * (c) 2018 yeebase media GmbH
+ *
+ * This package is Open Source Software. For the full copyright and license
+ * information, please view the LICENSE file which was distributed with this
+ * source code.
+ */
+
+use Neos\Flow\Annotations as Flow;
+use Neos\Flow\Configuration\Exception\InvalidConfigurationException;
+use Neos\Flow\Log\SystemLoggerInterface;
+use Yeebase\Readiness\Service\EelRuntime;
+
+class EelTask extends AbstractTask
+{
+    /**
+     * @Flow\Inject
+     * @var EelRuntime
+     */
+    protected $runtime;
+
+    /**
+     * @Flow\Inject
+     * @var SystemLoggerInterface
+     */
+    protected $systemLoggerInterface;
+
+    /**
+     * @param array $options
+     * @throws InvalidConfigurationException
+     */
+    protected function validateOptions(array $options)
+    {
+        if (!isset($options['expression'])) {
+            throw new InvalidConfigurationException('"expression" not set', 1502701561);
+        }
+    }
+
+    /**
+     *
+     */
+    public function run()
+    {
+        $this->runtime->evaluate($this->options['expression']);
+    }
+}
diff --git a/Classes/Task/RedisTask.php b/Classes/Task/RedisTask.php
new file mode 100644
index 0000000..a7da016
--- /dev/null
+++ b/Classes/Task/RedisTask.php
@@ -0,0 +1,55 @@
+<?php
+namespace Yeebase\Readiness\Task;
+
+/**
+ * This file is part of the Yeebase.XY package.
+ *
+ * (c) 2018 yeebase media GmbH
+ *
+ * This package is Open Source Software. For the full copyright and license
+ * information, please view the LICENSE file which was distributed with this
+ * source code.
+ */
+
+use Neos\Flow\Configuration\Exception\InvalidConfigurationException;
+use Neos\Flow\Core\Booting\Exception\SubProcessException;
+use Neos\Flow\Core\Booting\Scripts;
+
+class RedisTask extends AbstractTask
+{
+
+    /**
+     * @param array $options
+     * @throws InvalidConfigurationException
+     */
+    protected function validateOptions(array $options)
+    {
+        if (!isset($options['hostname'])) {
+            throw new InvalidConfigurationException('Redis readiness task needs a "hostname" option', 1502701659);
+        }
+
+        if (!isset($options['database'])) {
+            throw new InvalidConfigurationException('Redis readiness task needs a "database" option', 1502701660);
+        }
+
+        if (!isset($options['command'])) {
+            throw new InvalidConfigurationException('Redis readiness task needs a "command" option', 1502701661);
+        }
+    }
+
+
+    /**
+     * @throws SubProcessException
+     */
+    public function run()
+    {
+        $redis = new \Redis();
+        $redis->connect($this->options['hostname']);
+        $redis->select($this->options['database']);
+        $success = $redis->rawCommand($this->options['command'], ...($this->options['arguments'] ?? []));
+
+        if (!$success) {
+            throw new \RedisException($redis->getLastError());
+        }
+    }
+}
diff --git a/Classes/Task/TaskInterface.php b/Classes/Task/TaskInterface.php
new file mode 100644
index 0000000..d2579b5
--- /dev/null
+++ b/Classes/Task/TaskInterface.php
@@ -0,0 +1,52 @@
+<?php
+namespace Yeebase\Readiness\Task;
+
+/**
+ * This file is part of the Yeebase.XY package.
+ *
+ * (c) 2018 yeebase media GmbH
+ *
+ * This package is Open Source Software. For the full copyright and license
+ * information, please view the LICENSE file which was distributed with this
+ * source code.
+ */
+
+use Neos\Error\Messages\Result;
+
+interface TaskInterface
+{
+    /**
+     * @return void
+     */
+    public function run();
+
+    /**
+     * @return Result
+     */
+    public function getResult(): Result;
+
+    /**
+     * @return string
+     */
+    public function getName(): string;
+
+    /**
+     * @return string
+     */
+    public function getSuccessLabel(): string;
+
+    /**
+     * @return string
+     */
+    public function getErrorLabel(): string;
+
+    /**
+     * @return string
+     */
+    public function getNoticeLabel(): string;
+
+    /**
+     * @return array
+     */
+    public function getOptions(): array;
+}
diff --git a/Classes/Test/AbstractTest.php b/Classes/Test/AbstractTest.php
new file mode 100644
index 0000000..85fee19
--- /dev/null
+++ b/Classes/Test/AbstractTest.php
@@ -0,0 +1,37 @@
+<?php
+namespace Yeebase\Readiness\Test;
+
+/**
+ * This file is part of the Yeebase.XY package.
+ *
+ * (c) 2018 yeebase media GmbH
+ *
+ * This package is Open Source Software. For the full copyright and license
+ * information, please view the LICENSE file which was distributed with this
+ * source code.
+ */
+
+use Neos\Error\Messages\Error;
+use Yeebase\Readiness\Task\AbstractTask;
+
+abstract class AbstractTest extends AbstractTask implements TestInterface
+{
+    /**
+     * @return void
+     */
+    final public function run()
+    {
+        $passed = $this->test();
+        if (!$passed) {
+            $this->result->addError(new Error($this->getErrorLabel()));
+        }
+    }
+
+    /**
+     * @return string
+     */
+    public function getSuccessLabel(): string
+    {
+        return 'Ready';
+    }
+}
diff --git a/Classes/Test/BeanstalkTest.php b/Classes/Test/BeanstalkTest.php
new file mode 100644
index 0000000..6a0213b
--- /dev/null
+++ b/Classes/Test/BeanstalkTest.php
@@ -0,0 +1,38 @@
+<?php
+namespace Yeebase\Readiness\Test;
+
+/**
+ * This file is part of the Yeebase.XY package.
+ *
+ * (c) 2018 yeebase media GmbH
+ *
+ * This package is Open Source Software. For the full copyright and license
+ * information, please view the LICENSE file which was distributed with this
+ * source code.
+ */
+
+use Neos\Flow\Configuration\Exception\InvalidConfigurationException;
+use Pheanstalk\Pheanstalk;
+
+class BeanstalkTest extends AbstractTest
+{
+    /**
+     * @param array $options
+     * @throws InvalidConfigurationException
+     */
+    protected function validateOptions(array $options)
+    {
+        if (!isset($options['hostname'])) {
+            throw new InvalidConfigurationException('Beanstalk readiness test needs a "hostname" option', 1502701630);
+        }
+    }
+
+    /**
+     * @return bool
+     */
+    public function test(): bool
+    {
+        $beanstalkClient = new Pheanstalk($this->options['hostname']);
+        return $beanstalkClient->getConnection()->isServiceListening();
+    }
+}
diff --git a/Classes/Test/DatabaseTest.php b/Classes/Test/DatabaseTest.php
new file mode 100644
index 0000000..ff9020c
--- /dev/null
+++ b/Classes/Test/DatabaseTest.php
@@ -0,0 +1,46 @@
+<?php
+namespace Yeebase\Readiness\Test;
+
+/**
+ * This file is part of the Yeebase.XY package.
+ *
+ * (c) 2018 yeebase media GmbH
+ *
+ * This package is Open Source Software. For the full copyright and license
+ * information, please view the LICENSE file which was distributed with this
+ * source code.
+ */
+
+use Neos\Flow\Configuration\Exception\InvalidConfigurationException;
+
+class DatabaseTest extends AbstractTest
+{
+    /**
+     * @param array $options
+     * @throws InvalidConfigurationException
+     */
+    protected function validateOptions(array $options)
+    {
+        if (!isset($options['hostname'])) {
+            throw new InvalidConfigurationException('Database readiness test needs a "hostname" option', 1502701660);
+        }
+    }
+
+
+    /**
+     * @return bool
+     */
+    public function test(): bool
+    {
+        try {
+            new \PDO(
+                'mysql:host=' . $this->options['hostname'],
+                $this->options['username'] ?? null,
+                $this->options['password'] ?? null
+            );
+            return true;
+        } catch (\PDOException $exception) {
+            return false;
+        }
+    }
+}
diff --git a/Classes/Test/DoctrineTest.php b/Classes/Test/DoctrineTest.php
new file mode 100644
index 0000000..1771d0f
--- /dev/null
+++ b/Classes/Test/DoctrineTest.php
@@ -0,0 +1,42 @@
+<?php
+namespace Yeebase\Readiness\Test;
+
+/**
+ * This file is part of the Yeebase.XY package.
+ *
+ * (c) 2018 yeebase media GmbH
+ *
+ * This package is Open Source Software. For the full copyright and license
+ * information, please view the LICENSE file which was distributed with this
+ * source code.
+ */
+
+use Doctrine\Common\Persistence\ObjectManager as DoctrineObjectManager;
+use Doctrine\ORM\EntityManager as DoctrineEntityManager;
+
+class DoctrineTest extends AbstractTest
+{
+    /**
+     * @var DoctrineEntityManager
+     */
+    private $entityManager;
+
+    /**
+     * @param DoctrineObjectManager $entityManager
+     * @return void
+     */
+    public function injectEntityManager(DoctrineObjectManager $entityManager)
+    {
+        $this->entityManager = $entityManager;
+    }
+
+
+    /**
+     * @return bool
+     */
+    public function test(): bool
+    {
+        $databaseConnection = $this->entityManager->getConnection();
+        return $databaseConnection->isConnected() || $databaseConnection->connect();
+    }
+}
diff --git a/Classes/Test/EelTest.php b/Classes/Test/EelTest.php
new file mode 100644
index 0000000..30d681a
--- /dev/null
+++ b/Classes/Test/EelTest.php
@@ -0,0 +1,46 @@
+<?php
+namespace Yeebase\Readiness\Test;
+
+/**
+ * This file is part of the Yeebase.XY package.
+ *
+ * (c) 2018 yeebase media GmbH
+ *
+ * This package is Open Source Software. For the full copyright and license
+ * information, please view the LICENSE file which was distributed with this
+ * source code.
+ */
+
+use Neos\Flow\Annotations as Flow;
+use Neos\Flow\Configuration\Exception\InvalidConfigurationException;
+use Yeebase\Readiness\Service\EelRuntime;
+
+class EelTest extends AbstractTest
+{
+    /**
+     * @Flow\Inject
+     * @var EelRuntime
+     */
+    protected $runtime;
+
+    /**
+     * @param array $options
+     * @throws InvalidConfigurationException
+     */
+    protected function validateOptions(array $options)
+    {
+        if (!isset($options['expression'])) {
+            throw new InvalidConfigurationException('"expression" not set', 1502701561);
+        }
+    }
+
+    /**
+     * @return bool
+     */
+    public function test(): bool
+    {
+        $this->runtime->setTaskContext('test');
+        $result = $this->runtime->evaluate($this->options['expression']);
+        return $result ?: false;
+    }
+}
diff --git a/Classes/Test/ElasticSearchTest.php b/Classes/Test/ElasticSearchTest.php
new file mode 100644
index 0000000..898e0e7
--- /dev/null
+++ b/Classes/Test/ElasticSearchTest.php
@@ -0,0 +1,44 @@
+<?php
+namespace Yeebase\Readiness\Test;
+
+/**
+ * This file is part of the Yeebase.XY package.
+ *
+ * (c) 2018 yeebase media GmbH
+ *
+ * This package is Open Source Software. For the full copyright and license
+ * information, please view the LICENSE file which was distributed with this
+ * source code.
+ */
+
+use Neos\Flow\Annotations as Flow;
+use Flowpack\ElasticSearch\Domain\Factory\ClientFactory as ElasticSearchFactory;
+use Neos\Flow\Configuration\Exception\InvalidConfigurationException;
+use Neos\Flow\ObjectManagement\ObjectManagerInterface;
+
+class ElasticSearchTest extends AbstractTest
+{
+
+    /**
+     * @Flow\Inject
+     * @var ObjectManagerInterface
+     */
+    protected $objectManager;
+
+    /**
+     * @return bool
+     * @throws InvalidConfigurationException
+     */
+    public function test(): bool
+    {
+        if (!class_exists(ElasticSearchFactory::class)) {
+            throw new InvalidConfigurationException('ElasticSearchTest depends on FlowPack\ElasticSearch', 1502795288);
+        }
+
+        /** @var ElasticSearchFactory $elasicSearchFactory */
+        $elasticSearchFactory = $this->objectManager->get(ElasticSearchFactory::class);
+        $elasticSearchClient = $elasticSearchFactory->create();
+        $response = $elasticSearchClient->request('GET', '/_cluster/health');
+        return $response->getTreatedContent()['status'] !== 'red';
+    }
+}
diff --git a/Classes/Test/RedisTest.php b/Classes/Test/RedisTest.php
new file mode 100644
index 0000000..7cdd56e
--- /dev/null
+++ b/Classes/Test/RedisTest.php
@@ -0,0 +1,43 @@
+<?php
+namespace Yeebase\Readiness\Test;
+
+/**
+ * This file is part of the Yeebase.XY package.
+ *
+ * (c) 2018 yeebase media GmbH
+ *
+ * This package is Open Source Software. For the full copyright and license
+ * information, please view the LICENSE file which was distributed with this
+ * source code.
+ */
+
+use Neos\Flow\Configuration\Exception\InvalidConfigurationException;
+
+class RedisTest extends AbstractTest
+{
+    /**
+     * @param array $options
+     * @throws InvalidConfigurationException
+     */
+    protected function validateOptions(array $options)
+    {
+        if (!isset($options['hostname'])) {
+            throw new InvalidConfigurationException('Redis readiness test needs a "hostname" option', 1502701659);
+        }
+    }
+
+    /**
+     * @return bool
+     */
+    public function test(): bool
+    {
+        $redis = new \Redis();
+        $result = $redis->connect($this->options['hostname']);
+
+        if ($result) {
+            $redis->close();
+        }
+
+        return $result;
+    }
+}
diff --git a/Classes/Test/TestInterface.php b/Classes/Test/TestInterface.php
new file mode 100644
index 0000000..780ae74
--- /dev/null
+++ b/Classes/Test/TestInterface.php
@@ -0,0 +1,22 @@
+<?php
+namespace Yeebase\Readiness\Test;
+
+/**
+ * This file is part of the Yeebase.XY package.
+ *
+ * (c) 2018 yeebase media GmbH
+ *
+ * This package is Open Source Software. For the full copyright and license
+ * information, please view the LICENSE file which was distributed with this
+ * source code.
+ */
+
+use Yeebase\Readiness\Task\TaskInterface;
+
+interface TestInterface extends TaskInterface
+{
+    /**
+     * @return bool
+     */
+    public function test(): bool;
+}
diff --git a/Configuration/Caches.yaml b/Configuration/Caches.yaml
new file mode 100644
index 0000000..b7433e0
--- /dev/null
+++ b/Configuration/Caches.yaml
@@ -0,0 +1,3 @@
+Yeebase_Readiness_Lock:
+  frontend: Neos\Cache\Frontend\StringFrontend
+  backend: Neos\Cache\Backend\FileBackend
\ No newline at end of file
diff --git a/Configuration/Objects.yaml b/Configuration/Objects.yaml
new file mode 100644
index 0000000..dbbdaa0
--- /dev/null
+++ b/Configuration/Objects.yaml
@@ -0,0 +1,9 @@
+Yeebase\Readiness\Eel\Helper\LockHelper:
+  properties:
+    lockCache:
+      object:
+        factoryObjectName: Neos\Flow\Cache\CacheManager
+        factoryMethodName: getCache
+        arguments:
+          1:
+            value: Yeebase_Readiness_Lock
\ No newline at end of file
diff --git a/Configuration/Settings.yaml b/Configuration/Settings.yaml
new file mode 100644
index 0000000..ef11d36
--- /dev/null
+++ b/Configuration/Settings.yaml
@@ -0,0 +1,56 @@
+Yeebase:
+  Readiness:
+    lockPrefix: 'app'
+    defaultReadyTaskCondition: '${Lock.isUnset("ready")}'
+    defaultTestCondition: '${true}'
+    defaultCacheName: 'Yeebase_Readiness_Lock'
+
+    defaultContext:
+      Lock: 'Yeebase\Readiness\Eel\Helper\LockHelper'
+      Chain: 'Yeebase\Readiness\Eel\Helper\ChainHelper'
+
+    testChain:
+      readinessFailed:
+        name: 'Readiness did not previously fail'
+        test: 'eel'
+        options:
+          expression: '${Lock.isUnset("failed")}'
+        position: 'start 1000'
+
+      readinessInProgress:
+        name: 'Readiness chain finished or not yet started'
+        test: 'eel'
+        options:
+          expression: '${Lock.isUnset("busy")}'
+        position: 'end 1000'
+
+    readyChain:
+      lockProgress:
+        name: 'Set progress lock'
+        task: 'eel'
+        options:
+          expression: '${Lock.set("busy")}'
+        position: 'start 1000'
+
+      unlockProgress:
+        name: 'Remove progress lock'
+        task: 'eel'
+        options:
+          expression: '${Lock.unset("busy")}'
+        position: 'end 1000'
+
+      lockReady:
+        name: 'Set ready lock'
+        task: 'eel'
+        condition: '${Chain.isValid() && Lock.isUnset("ready")}'
+        options:
+          expression: '${Lock.set("ready")}'
+        position: 'end 1001'
+
+      lockFailed:
+        name: 'Set failed lock if necessary'
+        task: 'eel'
+        condition: '${Chain.isInvalid() && Lock.isUnset("ready")}'
+        options:
+          expression: '${Lock.set("failed", Chain.getCombinedErrorMessages())}'
+        position: 'end 1002'
\ No newline at end of file
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..62072ca
--- /dev/null
+++ b/README.md
@@ -0,0 +1,134 @@
+# Yeebase.Readiness
+Package to check the rediness of a flow application.
+
+Useful in a kubernetes [readiness probe](https://kubernetes.io/docs/tasks/configure-pod-container/configure-liveness-readiness-probes/)
+to determine if a pod can serve traffic.
+
+## Usage
+Simply execute the flow command `./flow app:isready`.
+
+This will execute all tests defined in the `Yeebase.Readiness.testChain` of the Settings.yaml.
+If all tests have passed, the `readyChain` tasks will be executed.
+
+After a successfully run of the ready chain an internal lock will be set to prevent repeated execution,
+so only the `readyChain` will be executed again. The `testChain` will be executed on every run.
+So the readyChain should bring your application in an "ready state". Make sure to initialize everything you need. 
+The testChain should ping all services your application depends on.
+
+## Configuration
+Add all your tests in the following format in your apps Settings.yaml:
+
+```yaml
+Yeebase:
+  Readiness:
+    testChain:
+      yourUniqueTestKey:
+        name: 'Optional name'
+        test: 'database' // shorthand for a predefined task in Yeebase\Readiness\Test\*.Test or a full qualified class name
+        options:
+          key: 'value' // optional options for your test
+        position: 'after otherTestKey' // optional position   
+```
+
+After that, the check will execute the ready chain:
+
+```yaml
+Yeebase:
+  Readiness:
+    readyChain:
+      yourUniqueTaskKey:
+        name: 'Optional name'
+        task: 'command' // shorthand for a predefined task in Yeebase\Readiness\Task\*.Task or a full qualified class name
+        options:
+          key: 'value' // optional options for your task
+        position: 'after otherTaskKey' / optional position
+        lockName: 'mylock' // optional lock override. This will create a lock for this task only and ignore the global lock
+```
+
+## Advanced configuration
+
+Before each attempt to execute a ready task, 
+the check will test the `Yeebase.Readiness.defaultReadyTaskCondition` to see if the task should be executed.
+In the default configuration this is simply a check to see if the ready lock is not yet set.
+
+You can override this behaviour on a per task basis:
+
+```yaml
+Yeebase:
+  Readiness:
+    readyChain:
+      yourUniqueTaskKey:
+        condition: '${Lock.isSet("mylock")}' // this can be any eel expression
+        afterInvocation: '${Lock.set("mylock")}' // this will be executed after a successfull invocation
+```
+_(the `lockName` setting is simply a shorthand for exactly this example)_
+
+To extend the eel context, you can provide additional helpers in `Yeebase.Readiness.defaultContext`. 
+
+
+## Example Configuration
+
+This example could be used in your Flow package to make sure that your application pod has a ready state
+to serve traffic. Therefore it will always check the ping status for doctrine, redis and beanstalk.
+On the first run all missing database migrations will be executed, the redis cache flushed and static resources published.
+After a successfull run only the testChain will be executed again.
+
+```yaml
+Yeebase:
+  Readiness:
+    testChain:
+      database:
+        test: doctrine
+        position: start
+      redis:
+        test: redis
+        options: 
+          hostmane: your-redis-host
+      beanstalk:
+        test: beanstalk
+        options:
+          hostname: your-beanstalk-host
+    readyChain:
+      migrations:
+        task: command
+        options: 
+          command: 'neos.flow:doctrine:migrate'
+      flushRedis:
+        name: 'Flush redis'
+        position: 'start 100'
+        task: redis
+        options:
+          hostname: your-redis-host 
+          command: FLUSHDB
+          database: 0
+      staticResources:
+        name: 'Publish static resources'
+        task: command
+        position: 'end 20' 
+        lockname: staticresources
+        cacheName: Yeebase_Readiness_LocalLock
+        options:
+          command: 'neos.flow:resource:publish'
+          arguments:
+            collection: static
+```
+
+Note the `lockname` configuration. This Configuration enables you to run tasks only once per deployment or always.
+By default the `Yeebase_Readiness_Lock` cache is used to read and write locks. Add this to your Caches.yaml and all your application pods will
+rely on the same lock files as they don't use the local file storage but redis. This will result in a execution once per deployment:
+
+```yaml
+Yeebase_Readiness_Lock:
+  backend: Neos\Cache\Backend\RedisBackend
+  backendOptions:
+    hostname: 'your-redis-server'
+    database: 2
+```
+
+The `staticResources` task has a custom cacheName configured. To ensure that this task will be executed in each application pod set it to local file storage:
+
+```yaml
+Yeebase_Readiness_LocalLock:
+  frontend: Neos\Cache\Frontend\StringFrontend
+  backend: Neos\Cache\Backend\FileBackend
+```
\ No newline at end of file
diff --git a/composer.json b/composer.json
new file mode 100644
index 0000000..81a0db0
--- /dev/null
+++ b/composer.json
@@ -0,0 +1,19 @@
+{
+    "description": "",
+    "type": "neos-yeebase",
+    "name": "yeebase/readiness",
+    "license": "MIT",
+    "require": {
+        "neos/flow": "^4.3.0"
+    },
+    "autoload": {
+        "psr-4": {
+            "Yeebase\\Readiness\\": "Classes/"
+        }
+    },
+    "extra": {
+        "neos": {
+            "package-key": "Yeebase.Readiness"
+        }
+    }
+}
\ No newline at end of file