diff --git a/.idea/codeStyles/Project.xml b/.idea/codeStyles/Project.xml
index b6c57434e..9672c273a 100644
--- a/.idea/codeStyles/Project.xml
+++ b/.idea/codeStyles/Project.xml
@@ -49,6 +49,7 @@
       </option>
       <option name="IMPORT_LAYOUT_TABLE">
         <value>
+          <package name="" withSubpackages="true" static="false" module="true" />
           <package name="" withSubpackages="true" static="true" />
           <emptyLine />
           <package name="" withSubpackages="true" static="false" />
diff --git a/README.md b/README.md
index e5061ea73..d8f13c7d1 100644
--- a/README.md
+++ b/README.md
@@ -441,6 +441,7 @@ For Spring Boot applications, there is a starter `db-scheduler-spring-boot-start
     ```
    **NOTE**: This includes the db-scheduler dependency itself.
 2. In your configuration, expose your `Task`'s as Spring beans. If they are recurring, they will automatically be picked up and started.
+ Alternative option for creating recurring tasks is to use `@RecurringTask` annotation ([see examples](./examples/spring-boot-example/src/main/java/com/github/kagkarlsson/examples/boot/config/BasicExamplesConfiguration.java)). In this case the task is created and registered in Spring context.
 3. If you want to expose `Scheduler` state into actuator health information you need to enable `db-scheduler` health indicator. [Spring Health Information.](https://docs.spring.io/spring-boot/docs/current/reference/html/production-ready-features.html#production-ready-health)
 4. Run the app.
 
diff --git a/db-scheduler-boot-starter/src/main/java/com/github/kagkarlsson/scheduler/boot/autoconfigure/RecurringTask.java b/db-scheduler-boot-starter/src/main/java/com/github/kagkarlsson/scheduler/boot/autoconfigure/RecurringTask.java
new file mode 100644
index 000000000..3bf150244
--- /dev/null
+++ b/db-scheduler-boot-starter/src/main/java/com/github/kagkarlsson/scheduler/boot/autoconfigure/RecurringTask.java
@@ -0,0 +1,27 @@
+package com.github.kagkarlsson.scheduler.boot.autoconfigure;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Scheduled tasks are created from the methods that are marked with this annotation. The method
+ * must follow these rules: - it must be public - it returns void - it has 0, 1 or 2 inputs with the
+ * following types: - {@link com.github.kagkarlsson.scheduler.task.TaskInstance}, generic is ignored
+ * and considered Void - {@link com.github.kagkarlsson.scheduler.task.ExecutionContext}
+ */
+@Target({ElementType.METHOD, ElementType.ANNOTATION_TYPE})
+@Retention(RetentionPolicy.RUNTIME)
+public @interface RecurringTask {
+
+  String name();
+
+  /*
+  The value can be either basic cron or a path to a property
+  Examples:
+    - ${recurring-sample-task-annotation-no-inputs.cron}
+    - 0 * * * * *
+   */
+  String cron();
+}
diff --git a/db-scheduler-boot-starter/src/main/java/com/github/kagkarlsson/scheduler/boot/autoconfigure/RecurringTaskAnnotationAutoConfiguration.java b/db-scheduler-boot-starter/src/main/java/com/github/kagkarlsson/scheduler/boot/autoconfigure/RecurringTaskAnnotationAutoConfiguration.java
new file mode 100644
index 000000000..0d393f10f
--- /dev/null
+++ b/db-scheduler-boot-starter/src/main/java/com/github/kagkarlsson/scheduler/boot/autoconfigure/RecurringTaskAnnotationAutoConfiguration.java
@@ -0,0 +1,20 @@
+package com.github.kagkarlsson.scheduler.boot.autoconfigure;
+
+import javax.sql.DataSource;
+import org.springframework.boot.autoconfigure.AutoConfiguration;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.support.GenericApplicationContext;
+
+@AutoConfiguration(before = DbSchedulerAutoConfiguration.class)
+@ConditionalOnBean(DataSource.class)
+@ConditionalOnProperty(value = "db-scheduler.enabled", matchIfMissing = true)
+public class RecurringTaskAnnotationAutoConfiguration {
+
+  @Bean
+  public RecurringTaskRegistryPostProcessor recurringTaskRegistryPostProcessor(
+      GenericApplicationContext context) {
+    return new RecurringTaskRegistryPostProcessor(context);
+  }
+}
diff --git a/db-scheduler-boot-starter/src/main/java/com/github/kagkarlsson/scheduler/boot/autoconfigure/RecurringTaskRegistryPostProcessor.java b/db-scheduler-boot-starter/src/main/java/com/github/kagkarlsson/scheduler/boot/autoconfigure/RecurringTaskRegistryPostProcessor.java
new file mode 100644
index 000000000..8d067ae29
--- /dev/null
+++ b/db-scheduler-boot-starter/src/main/java/com/github/kagkarlsson/scheduler/boot/autoconfigure/RecurringTaskRegistryPostProcessor.java
@@ -0,0 +1,155 @@
+package com.github.kagkarlsson.scheduler.boot.autoconfigure;
+
+import com.github.kagkarlsson.scheduler.task.ExecutionContext;
+import com.github.kagkarlsson.scheduler.task.Task;
+import com.github.kagkarlsson.scheduler.task.TaskInstance;
+import com.github.kagkarlsson.scheduler.task.helper.Tasks;
+import com.github.kagkarlsson.scheduler.task.schedule.Schedules;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.util.Arrays;
+import java.util.Set;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.BeansException;
+import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
+import org.springframework.beans.factory.support.BeanDefinitionRegistry;
+import org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor;
+import org.springframework.beans.factory.support.GenericBeanDefinition;
+import org.springframework.context.support.GenericApplicationContext;
+import org.springframework.util.ReflectionUtils;
+
+/**
+ * A {@link BeanDefinitionRegistryPostProcessor} that scans for methods annotated with {@link
+ * RecurringTask} and registers them as {@link Task}s in the Spring context.
+ *
+ * <p>The methods must have a return type of {@code void} and can accept parameters of type {@link
+ * TaskInstance}, {@link ExecutionContext}.
+ */
+public class RecurringTaskRegistryPostProcessor implements BeanDefinitionRegistryPostProcessor {
+
+  private static final Logger log =
+      LoggerFactory.getLogger(RecurringTaskRegistryPostProcessor.class);
+
+  private static final Set<Class<?>> INPUT_ARGUMENTS_AVAILABLE_CLASSES =
+      Set.of(TaskInstance.class, ExecutionContext.class);
+
+  private final GenericApplicationContext context;
+
+  public RecurringTaskRegistryPostProcessor(GenericApplicationContext context) {
+    this.context = context;
+  }
+
+  @Override
+  public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry)
+      throws BeansException {
+    String[] beanNames = registry.getBeanDefinitionNames();
+    for (String beanName : beanNames) {
+      var beanDef = registry.getBeanDefinition(beanName);
+      String beanClassName = beanDef.getBeanClassName();
+      if (beanClassName == null) {
+        continue;
+      }
+      try {
+        Class<?> beanClass = Class.forName(beanClassName);
+        ReflectionUtils.doWithMethods(
+            beanClass,
+            method -> {
+              RecurringTask recurringTask = method.getAnnotation(RecurringTask.class);
+              if (recurringTask != null) {
+                validateMethod(method);
+                GenericBeanDefinition taskDef =
+                    buildTaskBeanDefinition(recurringTask, method, beanName);
+                registry.registerBeanDefinition(recurringTask.name(), taskDef);
+              }
+            },
+            method -> method.isAnnotationPresent(RecurringTask.class));
+      } catch (ClassNotFoundException ignored) {
+      }
+    }
+  }
+
+  private GenericBeanDefinition buildTaskBeanDefinition(
+      RecurringTask recurringTask, Method method, String beanName) {
+    GenericBeanDefinition taskDef = new GenericBeanDefinition();
+    taskDef.setBeanClass(Task.class);
+    taskDef.setInstanceSupplier(
+        () -> {
+          String resolvedCron = resolveCron(recurringTask.cron());
+          log.info(
+              "Creating a task from @RecurringTask with name={} and cron={}",
+              recurringTask.name(),
+              resolvedCron);
+          return createTaskFromMethod(
+              recurringTask, method, context.getBean(beanName), resolvedCron);
+        });
+    return taskDef;
+  }
+
+  private String resolveCron(String rawCron) {
+    if (rawCron.startsWith("$")) {
+      return context.getEnvironment().resolveRequiredPlaceholders(rawCron);
+    } else {
+      return rawCron;
+    }
+  }
+
+  private void validateMethod(Method method) {
+    if (!Modifier.isPublic(method.getModifiers())) {
+      throw new IllegalArgumentException(
+          "RecurringTask annotated method must be public, see the annotation javadoc");
+    }
+    if (!method.getReturnType().equals(Void.TYPE)) {
+      throw new IllegalArgumentException(
+          "RecurringTask annotated method must have return type Void, see the annotation javadoc");
+    }
+
+    if (method.getParameterCount() != 0) {
+      for (Class<?> parameterType : method.getParameterTypes()) {
+        if (!INPUT_ARGUMENTS_AVAILABLE_CLASSES.contains(parameterType)) {
+          throw new IllegalArgumentException(
+              "RecurringTask annotated method is required to have specific inputs: "
+                  + INPUT_ARGUMENTS_AVAILABLE_CLASSES);
+        }
+      }
+    }
+  }
+
+  private Task<?> createTaskFromMethod(
+      RecurringTask recurringTask, Method method, Object existingObject, String resolvedCron) {
+
+    return Tasks.recurring(recurringTask.name(), Schedules.cron(resolvedCron))
+        .execute(
+            (instance, ctx) -> {
+              Object[] inputs =
+                  Arrays.stream(method.getParameterTypes())
+                      .map(
+                          paramType -> {
+                            if (paramType.equals(TaskInstance.class)) {
+                              return instance;
+                            } else if (paramType.equals(ExecutionContext.class)) {
+                              return ctx;
+                            }
+                            throw new IllegalArgumentException(
+                                "RecurringTask annotated method is required to have specific inputs: "
+                                    + INPUT_ARGUMENTS_AVAILABLE_CLASSES);
+                          })
+                      .toArray();
+              try {
+                method.invoke(existingObject, inputs);
+              } catch (IllegalAccessException | InvocationTargetException e) {
+                throw new RuntimeException(
+                    "An error happened while calling a task method through reflection, method name: "
+                        + method.getName(),
+                    e);
+              }
+            });
+  }
+
+  @Override
+  public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)
+      throws BeansException {
+    // No-op
+  }
+}
diff --git a/db-scheduler-boot-starter/src/main/resources/META-INF/spring.factories b/db-scheduler-boot-starter/src/main/resources/META-INF/spring.factories
index 37d192cac..5f7561443 100644
--- a/db-scheduler-boot-starter/src/main/resources/META-INF/spring.factories
+++ b/db-scheduler-boot-starter/src/main/resources/META-INF/spring.factories
@@ -1,4 +1,5 @@
 org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
 com.github.kagkarlsson.scheduler.boot.autoconfigure.DbSchedulerAutoConfiguration,\
 com.github.kagkarlsson.scheduler.boot.autoconfigure.DbSchedulerMetricsAutoConfiguration,\
-com.github.kagkarlsson.scheduler.boot.autoconfigure.DbSchedulerActuatorAutoConfiguration
+com.github.kagkarlsson.scheduler.boot.autoconfigure.DbSchedulerActuatorAutoConfiguration,\
+com.github.kagkarlsson.scheduler.boot.autoconfigure.RecurringTaskAnnotationAutoConfiguration
diff --git a/db-scheduler-boot-starter/src/main/resources/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports b/db-scheduler-boot-starter/src/main/resources/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports
index a02cd6bd3..fdbfd1efc 100644
--- a/db-scheduler-boot-starter/src/main/resources/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports
+++ b/db-scheduler-boot-starter/src/main/resources/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports
@@ -1,3 +1,4 @@
 com.github.kagkarlsson.scheduler.boot.autoconfigure.DbSchedulerAutoConfiguration
 com.github.kagkarlsson.scheduler.boot.autoconfigure.DbSchedulerMetricsAutoConfiguration
 com.github.kagkarlsson.scheduler.boot.autoconfigure.DbSchedulerActuatorAutoConfiguration
+com.github.kagkarlsson.scheduler.boot.autoconfigure.RecurringTaskAnnotationAutoConfiguration
diff --git a/db-scheduler-boot-starter/src/test/java/com/github/kagkarlsson/scheduler/boot/autoconfigure/DbSchedulerAutoConfigurationTest.java b/db-scheduler-boot-starter/src/test/java/com/github/kagkarlsson/scheduler/boot/autoconfigure/DbSchedulerAutoConfigurationTest.java
index 435d5a991..c53d42713 100644
--- a/db-scheduler-boot-starter/src/test/java/com/github/kagkarlsson/scheduler/boot/autoconfigure/DbSchedulerAutoConfigurationTest.java
+++ b/db-scheduler-boot-starter/src/test/java/com/github/kagkarlsson/scheduler/boot/autoconfigure/DbSchedulerAutoConfigurationTest.java
@@ -7,6 +7,7 @@
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.fail;
 
+import com.github.kagkarlsson.scheduler.ScheduledExecution;
 import com.github.kagkarlsson.scheduler.Scheduler;
 import com.github.kagkarlsson.scheduler.boot.actuator.DbSchedulerHealthIndicator;
 import com.github.kagkarlsson.scheduler.boot.config.DbSchedulerCustomizer;
@@ -19,11 +20,14 @@
 import com.github.kagkarlsson.scheduler.stats.StatsRegistry;
 import com.github.kagkarlsson.scheduler.stats.StatsRegistry.DefaultStatsRegistry;
 import com.github.kagkarlsson.scheduler.task.ExecutionComplete;
+import com.github.kagkarlsson.scheduler.task.ExecutionContext;
 import com.github.kagkarlsson.scheduler.task.Task;
+import com.github.kagkarlsson.scheduler.task.TaskInstance;
 import com.github.kagkarlsson.scheduler.task.helper.Tasks;
 import com.google.common.collect.ImmutableList;
 import io.micrometer.core.instrument.Meter;
 import io.micrometer.core.instrument.MeterRegistry;
+import java.util.List;
 import java.util.Objects;
 import java.util.function.Function;
 import javax.sql.DataSource;
@@ -62,6 +66,7 @@ public DbSchedulerAutoConfigurationTest() {
                     HealthContributorAutoConfiguration.class,
                     DbSchedulerMetricsAutoConfiguration.class,
                     DbSchedulerActuatorAutoConfiguration.class,
+                    RecurringTaskAnnotationAutoConfiguration.class,
                     DbSchedulerAutoConfiguration.class));
   }
 
@@ -269,6 +274,77 @@ void it_should_exclude_db_scheduler_starter_from_lazy_init() {
         });
   }
 
+  @Test
+  void it_should_mix_bean_tasks_and_annotation_tasks() {
+    ctxRunner
+        .withUserConfiguration(MixingAnnotationAndBeanTaskConfiguration.class)
+        .run(
+            (AssertableApplicationContext ctx) -> {
+              assertThat(ctx).hasSingleBean(Scheduler.class);
+
+              ImmutableList.of("taskFromAnnotation", "firstTask", "secondTask", "thirdTask")
+                  .forEach(beanName -> assertThat(ctx).getBean(beanName, Task.class).isNotNull());
+            });
+  }
+
+  @Test
+  void it_should_create_valid_cron_from_annotation() {
+    ctxRunner
+        .withUserConfiguration(TaskFromAnnotationWithCron.class)
+        .run(
+            (AssertableApplicationContext ctx) -> {
+              assertTaskScheduled("taskFromAnnotationWithCron", ctx);
+            });
+  }
+
+  @Test
+  void it_should_resolve_cron_from_properties() {
+    ctxRunner
+        .withPropertyValues("my-custom-property.cron=0 0 7 19 * *")
+        .withUserConfiguration(TaskFromAnnotationWithCronProperty.class)
+        .run(
+            (AssertableApplicationContext ctx) -> {
+              assertTaskScheduled("taskFromAnnotationWithCronProperty", ctx);
+            });
+  }
+
+  private void assertTaskScheduled(String taskName, AssertableApplicationContext ctx) {
+    assertThat(ctx).hasSingleBean(Scheduler.class);
+
+    Task<Void> task = (Task<Void>) ctx.getBean(taskName, Task.class);
+    assertThat(task).isNotNull();
+
+    Scheduler scheduler = ctx.getBean(Scheduler.class);
+    List<ScheduledExecution<Object>> scheduledExecutions =
+        scheduler.getScheduledExecutionsForTask(taskName);
+    assertThat(scheduledExecutions).hasSize(1);
+  }
+
+  @Test
+  void it_should_parse_input_arguments_for_tasks_from_annotation() {
+    ctxRunner
+        .withUserConfiguration(TasksFromAnnotationWithDifferentInputs.class)
+        .run(
+            (AssertableApplicationContext ctx) -> {
+              assertThat(ctx).hasSingleBean(Scheduler.class);
+
+              ImmutableList.of(
+                      "taskNoInputs",
+                      "taskWithExecutionContextInput",
+                      "taskWithTaskInstanceInput",
+                      "taskWithBothInputsExpectedOrder",
+                      "taskWithBothInputsReverseOrder")
+                  .forEach(
+                      beanName -> {
+                        Task<Void> task = (Task<Void>) ctx.getBean(beanName, Task.class);
+                        assertThat(task).isNotNull();
+
+                        // Runtime validation that input parameters are passed correctly
+                        task.execute(task.instance("1"), null);
+                      });
+            });
+  }
+
   @Configuration
   static class SingleTaskConfiguration {
     @Bean
@@ -337,6 +413,62 @@ public void registerSingleCompletedExecution(ExecutionComplete completeEvent) {}
     }
   }
 
+  @Configuration
+  static class MixingAnnotationAndBeanTaskConfiguration extends MultipleTasksConfiguration {
+
+    @RecurringTask(name = "taskFromAnnotation", cron = "0 0 7 19 * *")
+    public void taskFromAnnotation() {
+      log.info("I'm a task from annotation");
+    }
+  }
+
+  @Configuration
+  static class TaskFromAnnotationWithCron {
+    @RecurringTask(name = "taskFromAnnotationWithCron", cron = "0 0 7 19 * *")
+    public void taskFromAnnotationWithCron() {
+      log.info("I'm a task from annotation");
+    }
+  }
+
+  @Configuration
+  static class TaskFromAnnotationWithCronProperty {
+    @RecurringTask(name = "taskFromAnnotationWithCronProperty", cron = "${my-custom-property.cron}")
+    public void taskFromAnnotationWithCronProperty() {
+      log.info("I'm a task from annotation with property");
+    }
+  }
+
+  @Configuration
+  static class TasksFromAnnotationWithDifferentInputs {
+
+    @RecurringTask(name = "taskNoInputs", cron = "0 0 7 19 * *")
+    public void taskNoInputs() {
+      log.info("I'm a task without inputs");
+    }
+
+    @RecurringTask(name = "taskWithExecutionContextInput", cron = "0 0 7 19 * *")
+    public void taskWithExecutionContextInput(ExecutionContext ctx) {
+      log.info("I'm a task with the execution context input");
+    }
+
+    @RecurringTask(name = "taskWithTaskInstanceInput", cron = "0 0 7 19 * *")
+    public void taskWithTaskInstanceInput(TaskInstance<Void> taskInstance) {
+      log.info("I'm a task with the task instance input");
+    }
+
+    @RecurringTask(name = "taskWithBothInputsExpectedOrder", cron = "0 0 7 19 * *")
+    public void taskWithBothInputsExpectedOrder(
+        TaskInstance<Void> taskInstance, ExecutionContext ctx) {
+      log.info("I'm a task with both inputs expected order");
+    }
+
+    @RecurringTask(name = "taskWithBothInputsReverseOrder", cron = "0 0 7 19 * *")
+    public void taskWithBothInputsReverseOrder(
+        ExecutionContext ctx, TaskInstance<Void> taskInstance) {
+      log.info("I'm a task with both inputs reverse order");
+    }
+  }
+
   private static Task<String> namedStringTask(String name) {
     Objects.requireNonNull(name);
 
diff --git a/examples/spring-boot-example/src/main/java/com/github/kagkarlsson/examples/boot/config/BasicExamplesConfiguration.java b/examples/spring-boot-example/src/main/java/com/github/kagkarlsson/examples/boot/config/BasicExamplesConfiguration.java
index e19eef8bf..b5050f414 100644
--- a/examples/spring-boot-example/src/main/java/com/github/kagkarlsson/examples/boot/config/BasicExamplesConfiguration.java
+++ b/examples/spring-boot-example/src/main/java/com/github/kagkarlsson/examples/boot/config/BasicExamplesConfiguration.java
@@ -17,8 +17,11 @@
 
 import com.github.kagkarlsson.examples.boot.CounterService;
 import com.github.kagkarlsson.examples.boot.ExampleContext;
+import com.github.kagkarlsson.scheduler.boot.autoconfigure.RecurringTask;
+import com.github.kagkarlsson.scheduler.task.ExecutionContext;
 import com.github.kagkarlsson.scheduler.task.Task;
 import com.github.kagkarlsson.scheduler.task.TaskDescriptor;
+import com.github.kagkarlsson.scheduler.task.TaskInstance;
 import com.github.kagkarlsson.scheduler.task.helper.Tasks;
 import java.time.Duration;
 import java.time.Instant;
@@ -38,6 +41,12 @@ public class BasicExamplesConfiguration {
   private static final Logger log = LoggerFactory.getLogger(BasicExamplesConfiguration.class);
   private static int ID = 1;
 
+  private final CounterService counter;
+
+  public BasicExamplesConfiguration(CounterService counter) {
+    this.counter = counter;
+  }
+
   /** Start the example */
   public static void triggerOneTime(ExampleContext ctx) {
     ctx.log(
@@ -64,6 +73,23 @@ Task<Void> recurringSampleTask(CounterService counter) {
             });
   }
 
+  /** A recurring task with dependencies from the current class using annotation. */
+  @RecurringTask(name = "recurring-sample-task-annotation", cron = "*/30 * * * * *")
+  public void recurringSampleTaskAnnotation(TaskInstance<Void> instance, ExecutionContext ctx) {
+    log.info("Running recurring-sample-task-annotation. Instance: {}, ctx: {}", instance, ctx);
+    counter.increase();
+    EventLogger.logTask(
+        "recurring-sample-task-annotation", "Ran. Run-counter current-value=" + counter.read());
+  }
+
+  /** Define a recurring task with no dependencies and no inputs using annotation. */
+  @RecurringTask(
+      name = "recurring-sample-task-annotation-no-inputs",
+      cron = "${recurring-sample-task-annotation-no-inputs.cron}")
+  public void recurringSampleTaskAnnotationNoInputs() {
+    log.info("Running recurring-sample-task-annotation-no-inputs.");
+  }
+
   /** Define a one-time task which have to be manually scheduled. */
   @Bean
   Task<Void> sampleOneTimeTask() {
diff --git a/examples/spring-boot-example/src/main/resources/application.properties b/examples/spring-boot-example/src/main/resources/application.properties
index 9b1d2472f..bc0ceea8a 100644
--- a/examples/spring-boot-example/src/main/resources/application.properties
+++ b/examples/spring-boot-example/src/main/resources/application.properties
@@ -18,3 +18,5 @@ db-scheduler.polling-strategy-lower-limit-fraction-of-threads=0.5
 db-scheduler.polling-strategy-upper-limit-fraction-of-threads=3.0
 db-scheduler.shutdown-max-wait=30m
 db-scheduler.always-persist-timestamp-in-utc=false
+
+recurring-sample-task-annotation-no-inputs.cron=0 * * * * *