diff --git a/README.md b/README.md
index af194fa..f2b9178 100644
--- a/README.md
+++ b/README.md
@@ -9,80 +9,101 @@ Sophisticated scheduler for durable tasks, built on Durable Object Alarms.
 - query tasks by description or id (or by time range?)
 - cancel tasks
 
-Bonus: This will be particularly useful when wired up with an LLM agent, so you'll be able to schedule tasks by describing them in natural language. Like "remind me to call my friend every monday at 10:00"
+The killer app: This will be particularly useful when wired up with an LLM agent, so you'll be able to schedule tasks by describing them in natural language. Like "remind me to call my friend every monday at 10:00"
 
 ```ts
 import { Scheduler } from "durable-scheduler";
 
-type Task = {
-  id: string;
-  description: string;
-  time: Date;
-} & (
-  | {
-      time: Date;
-      type: "scheduled";
-    }
-  | {
-      delayInSeconds: number;
-      type: "delayed";
-    }
-  | {
-      cron: string;
-      type: "cron";
-    }
-);
-
-class MyClass extends Scheduler {
-  foo() {
-    // schedule at specific time
-    this.scheduler.scheduleTask({
-      description: "my-task",
-      time: new Date(Date.now() + 1000),
-    });
-
-    // schedule after a certain amount of time
-    this.scheduler.scheduleTask({
-      description: "my-task",
-      delayInSeconds: 1000, // in ms? s?
-    });
-
-    // schedule to run periodically
-    this.scheduler.scheduleTask({
-      description: "my-task",
-      cron: "*/1 * * * *", // every minute
-    });
-
-    // you can also specify an id
-    this.scheduler.scheduleTask({
-      id: "my-task",
-      time: new Date(Date.now() + 1000),
-    });
-
-    // ids must be unique
-
-    // if you don't provide an id, it will default to a random uuid
-    // if you try to schedule a task with an id that already exists,
-    // it will overwrite the existing task
-
-    // query for tasks
-    const tasks = this.scheduler.query({
-      // by description
-      // by id
-      // by time range
-      // some kind of sql syntax here? dunno..
-    });
-
-    // cancel a task
-    tasks.forEach((task) => {
-      this.scheduler.cancelTask(task.id);
-    });
-  }
-}
+export { Scheduler };
+// also setup wrangler.toml to create a durable object binding
+// let's say you've done it this way:
+
+// [[durable_objects.bindings]]
+// name = "SCHEDULER"
+// class_name = "Scheduler"
+
+export default {
+  fetch(request: Request, env: Env, ctx: ExecutionContext) {
+    // access a scheduler instance
+    const id = env.SCHEDULER.idFromName("my-scheduler");
+    const scheduler = env.SCHEDULER.get(id);
+    // now you can use the scheduler
+  },
+};
 ```
 
+A task has a few parts:
+
+- **description**: which is a string that you can use to identify the task
+- **payload**: which is a JSON object that is passed to the task
+- **type**: which is one of "delayed", "cron", or "scheduled"
+  - **`type: delayed`**: the task will be run after a delay **`delayInSeconds`**
+  - **`type: cron`**: the task will be run on a cron schedule **`cron`**
+  - **`type: scheduled`**: the task will be run at a specific date **`time`**
+- **callback**: which is a function that is called when the task is run. It can be of type `webhook`, ` durable-object` or `service`
+  - **`type: webhook`**: the task will be run by POSTing to a **`url`**
+  - **`type: durable-object`**: the task will be run by calling a function on a durable object
+  - **`type: service`**: the task will be run by calling a function on a service
+
+Here are some examples:
+
+- This will schedule a task to be run after a delay of 60 seconds, and call a webhook at `https://example.com/webhook` with the payload `{ message: "Hello, world!" }`
+
+  ```ts
+  scheduler.scheduleTask({
+    description: "my-task",
+    type: "delayed",
+    delayInSeconds: 60,
+    payload: {
+      message: "Hello, world!",
+    },
+    callback: {
+      type: "webhook",
+      url: "https://example.com/webhook",
+    },
+  });
+  ```
+
+- This will schedule a task to be run every Friday at 6pm, and call a durable object binding `MYDURABLE` of id "some-id" with the function `myFunction` with the payload `{ message: "Hello, world!" }`
+
+  ```ts
+  scheduler.scheduleTask({
+    description: "my-task",
+    type: "cron",
+    cron: "0 18 * * 5",
+    payload: {
+      message: "Hello, world!",
+    },
+    callback: {
+      type: "durable-object",
+      namespace: "MYDURABLE",
+      id: "some-id",
+      function: "myFunction",
+    },
+  });
+  ```
+
+- This will schedule a task to be run at a specific date and time, and call a service binding `MYSERVICE` with the function `myFunction` with the payload `{ message: "Hello, world!" }`
+
+  ```ts
+  scheduler.scheduleTask({
+    description: "my-task",
+    type: "scheduled",
+    time: new Date("2024-01-01T12:00:00Z"),
+    payload: {
+      message: "Hello, world!",
+    },
+    callback: {
+      type: "service",
+      service: "MYSERVICE",
+      function: "myFunction",
+    },
+  });
+  ```
+
 ## todo:
 
-- replace with a decorator syntax
 - add a dashboard for visualizing tasks and their status?
-- what's a good api for actually running the tasks? (maybe just a simple http api? like a webhook?)
+- how to handle errors?
+- how to handle retries?
+- testing story?
diff --git a/eslint.config.mjs b/eslint.config.mjs
index ab1c78c..0d3a96b 100644
--- a/eslint.config.mjs
+++ b/eslint.config.mjs
@@ -50,6 +50,7 @@ export default [
       "@typescript-eslint/no-unused-vars": ["warn", { argsIgnorePattern: "^_" }],
       "@typescript-eslint/require-await": "off",
       "@typescript-eslint/await-thenable": "off",
+      "no-console": "off",
       // React rules
       ...reactPlugin.configs.recommended.rules,
       "react/react-in-jsx-scope": "off",
@@ -64,9 +65,6 @@ export default [
           alphabetize: { order: "asc", caseInsensitive: true },
         },
       ],
-
-      // General rules
-      "no-console": ["warn", { allow: ["warn", "error"] }],
     },
   },
   {
diff --git a/example/src/client/app.tsx b/example/src/client/app.tsx
index 4b9ecbe..95077f8 100644
--- a/example/src/client/app.tsx
+++ b/example/src/client/app.tsx
@@ -1,16 +1,15 @@
 import { useState } from "react";
 
-import { SqlTask } from "../../../src";
+import { Task } from "../../../src";
 
 interface ToDo {
   id: string;
   inputText: string;
-  parsedTask: SqlTask | undefined;
+  task: Task | undefined;
   completed: boolean;
 }
 
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-const ROOM_ID = "username"; // TODO: this will read a username from auth later
+// const ROOM_ID = "username"; // TODO: this will read a username from auth later
 
 export default function App() {
   const [todos, setTodos] = useState<ToDo[]>([]);
@@ -24,7 +23,7 @@ export default function App() {
       const newToDo: ToDo = {
         id: crypto.randomUUID(),
         inputText,
-        parsedTask: undefined,
+        task: undefined,
         completed: false,
       };
 
@@ -37,7 +36,6 @@ export default function App() {
         body: inputText,
       });
       const parsedTask = await result.json();
-      // eslint-disable-next-line no-console
       console.log("parsedTask", parsedTask);
       // ok now let's schedule it
 
@@ -94,9 +92,9 @@ export default function App() {
               />
               <div className="flex-1">
                 <p className={`text-gray-800 ${todo.completed ? "line-through" : ""}`}>
-                  {todo.parsedTask?.description}
+                  {todo.task?.description}
                 </p>
-                <p className="text-sm text-gray-500">Due: {todo.parsedTask?.time}</p>
+                <p className="text-sm text-gray-500">Due: {todo.task?.time.toISOString()}</p>
               </div>
               <button
                 onClick={() => void handleDeleteToDo(todo.id)}
diff --git a/example/src/server/index.ts b/example/src/server/index.ts
index d8bcc9c..bf2bf17 100644
--- a/example/src/server/index.ts
+++ b/example/src/server/index.ts
@@ -98,6 +98,7 @@ export default {
   async fetch(request: Request, env: Env, _ctx: ExecutionContext) {
     const url = new URL(request.url);
 
+    // reroute vite dev server requests to the client
     if (!url.pathname.startsWith("/api/")) {
       return fetch(request.url.replace("http://localhost:8787", "http://localhost:5173"), request);
     }
@@ -124,9 +125,6 @@ ${await request.text()}
 `,
         });
 
-        // eslint-disable-next-line no-console
-        console.log(result.object);
-
         return new Response(JSON.stringify(result.object));
       }
     }
diff --git a/src/index.ts b/src/index.ts
index f756867..8581747 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -1,7 +1,7 @@
 import { DurableObject } from "cloudflare:workers";
 import cronParser from "cron-parser";
 
-export type Task = {
+export type RawTask = {
   id: string;
   description?: string | undefined;
   payload?: Record<string, unknown> | undefined;
@@ -24,17 +24,36 @@ export type Task = {
     }
 );
 
+export type Task = RawTask & {
+  time: Date;
+};
+
 export type SqlTask = {
   id: string;
   description: string | null;
   payload: string | null;
   callback: string | null;
-  type: string | null;
-  time: number | null;
-  delayInSeconds: number | null;
-  cron: string | null;
-  created_at: number | null;
-};
+  created_at: number;
+} & (
+  | {
+      type: "scheduled";
+      time: number;
+    }
+  | {
+      type: "delayed";
+      time: number;
+      delayInSeconds: number;
+    }
+  | {
+      type: "cron";
+      time: number;
+      cron: string;
+    }
+  | {
+      type: "no-schedule";
+      time: number;
+    }
+);
 
 type Callback =
   | {
@@ -46,6 +65,11 @@ type Callback =
       namespace: string;
       id: string;
       function: string;
+    }
+  | {
+      type: "service";
+      service: string;
+      function: string;
     };
 
 export class Scheduler<Env> extends DurableObject<Env> {
@@ -105,12 +129,12 @@ export class Scheduler<Env> extends DurableObject<Env> {
     if (!result) return;
 
     if (result.length > 0 && "time" in result[0]) {
-      const nextTime = new Date((result[0].time as number) * 1000);
+      const nextTime = new Date(result[0].time * 1000);
       await this.ctx.storage.setAlarm(nextTime);
     }
   }
 
-  async scheduleTask(task: Task): Promise<Task> {
+  async scheduleTask(task: RawTask): Promise<Task> {
     const { id } = task;
 
     if ("time" in task && task.time) {
@@ -172,6 +196,7 @@ export class Scheduler<Env> extends DurableObject<Env> {
         payload: task.payload,
         callback: task.callback,
         delayInSeconds: task.delayInSeconds,
+        time,
         type: "delayed",
       };
     } else if ("cron" in task && task.cron) {
@@ -203,12 +228,15 @@ export class Scheduler<Env> extends DurableObject<Env> {
         payload: task.payload,
         callback: task.callback,
         cron: task.cron,
+        time: nextExecutionTime,
         type: "cron",
       };
     } else {
+      const time = new Date(Date.now());
+      const timestamp = Math.floor(time.getTime() / 1000);
       const query = `
-        INSERT OR REPLACE INTO tasks (id, description, payload, callback, type)
-        VALUES (?, ?, ?, ?, 'no-schedule')
+        INSERT OR REPLACE INTO tasks (id, description, payload, callback, type, time)
+        VALUES (?, ?, ?, ?, 'no-schedule', ?)
       `;
       this.querySql([
         {
@@ -218,6 +246,7 @@ export class Scheduler<Env> extends DurableObject<Env> {
             task.description || null,
             JSON.stringify(task.payload || null),
             JSON.stringify(task.callback || null),
+            timestamp,
           ],
         },
       ]);
@@ -227,6 +256,7 @@ export class Scheduler<Env> extends DurableObject<Env> {
         description: task.description,
         payload: task.payload,
         callback: task.callback,
+        time,
         type: "no-schedule",
       };
     }
@@ -268,53 +298,74 @@ export class Scheduler<Env> extends DurableObject<Env> {
       description: row.description,
       payload: row.payload ? (JSON.parse(row.payload) as Record<string, unknown>) : undefined,
       callback: row.callback ? (JSON.parse(row.callback) as Callback) : undefined,
-    } as Task;
+    } as RawTask;
 
     switch (row.type) {
       case "scheduled":
         return {
           ...base,
-          time: new Date((row.time as number) * 1000),
+          time: new Date(row.time * 1000),
           type: "scheduled",
         };
       case "delayed":
         return {
           ...base,
-          delayInSeconds: row.delayInSeconds as number,
+          delayInSeconds: row.delayInSeconds,
+          time: new Date(row.time * 1000),
           type: "delayed",
         };
       case "cron":
         return {
           ...base,
-          cron: row.cron as string,
+          cron: row.cron,
+          time: new Date(row.time * 1000),
           type: "cron",
         };
+      case "no-schedule":
+        return {
+          ...base,
+          time: new Date(row.time * 1000),
+          type: "no-schedule",
+        };
       default:
+        // @ts-expect-error expected wrong type
         throw new Error(`Unknown task type: ${row.type as string}`);
     }
   }
 
   private async executeTask(task: Task): Promise<void> {
     // This is where you would implement the actual task execution
-    // eslint-disable-next-line no-console
     console.log(`Executing task ${task.id}:`, task);
     if ("callback" in task && task.callback) {
       const { type } = task.callback;
       if (type === "webhook") {
-        await fetch(task.callback.url, {
+        const response = await fetch(task.callback.url, {
           method: "POST",
           body: JSON.stringify(task.payload),
           headers: {
             "Content-Type": "application/json",
           },
         });
+        if (!response.ok) {
+          const text = await response.text();
+          throw new Error(`Webhook failed with status ${response.status} and body ${text}`);
+        }
+        // drain body
+        const responseBody = await response.text();
+        console.log(`Webhook response body: ${responseBody}`);
       } else if (type === "durable-object") {
         //@ts-expect-error  yeah whatever
         // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
         const stub = this.env[task.callback.namespace].get(task.callback.id);
 
         // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
-        await stub[task.callback.function](task.payload);
+        stub[task.callback.function](task.payload).catch((e: unknown) => {
+          console.error("Error executing durable object function:", e);
+        });
+      } else if (type === "service") {
+        //@ts-expect-error  yeah whatever
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+        this.env[task.callback.service][task.callback.function](task.payload);
       }
     }
   }
@@ -363,7 +414,7 @@ export class Scheduler<Env> extends DurableObject<Env> {
     return true;
   }
 
-  querySql<T>(qs: SqliteQuery[], isRaw = false): QueueResult<T> {
+  querySql<T>(qs: SqliteQuery[], isRaw = false): SqlResult<T> {
     try {
       if (!qs.length) {
         throw new Error("No query found to run");
@@ -448,7 +499,7 @@ export class Scheduler<Env> extends DurableObject<Env> {
   }
 }
 
-export type QueueResult<T> =
+export type SqlResult<T> =
   | {
       result: T[];
       error: null;
diff --git a/tests/index.test.ts b/tests/index.test.ts
index fc69b96..df4deb4 100644
--- a/tests/index.test.ts
+++ b/tests/index.test.ts
@@ -99,6 +99,11 @@ describe("Hello World worker", () => {
       delayInSeconds,
     });
 
+    const timestamp = Math.floor((new Date().getTime() + delayInSeconds * 1000) / 1000);
+
+    // pull out the time from the task
+    const { time: taskTime } = task;
+
     expect(task).toMatchInlineSnapshot(`
       {
         "callback": {
@@ -111,6 +116,11 @@ describe("Hello World worker", () => {
         "payload": {
           "test": "test",
         },
+        "time": ${
+          // @ts-expect-error I'm bad at typescript
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+          taskTime.toISOString()
+        },
         "type": "delayed",
       }
     `);
@@ -118,8 +128,6 @@ describe("Hello World worker", () => {
     const debug = await stub.getAllTasks();
     expect(debug.result).toHaveLength(1);
 
-    const timestamp = Math.floor((new Date().getTime() + delayInSeconds * 1000) / 1000);
-
     const {
       // eslint-disable-next-line @typescript-eslint/no-unused-vars
       created_at,
@@ -171,6 +179,7 @@ describe("Hello World worker", () => {
         "payload": {
           "test": "test",
         },
+        "time": ${next.toDate().toISOString()},
         "type": "cron",
       }
     `);
@@ -201,6 +210,7 @@ describe("Hello World worker", () => {
   it("can schedule a no-schedule task", async () => {
     const stub = getStub(env);
     const id = "no-schedule-task-001";
+    // const time = new Date(Date.now());
     const task = await stub.scheduleTask({
       id,
       description: "test",
@@ -212,6 +222,9 @@ describe("Hello World worker", () => {
       type: "no-schedule",
     });
 
+    // let's pull out the time from the task
+    const { time } = task;
+
     expect(task).toMatchInlineSnapshot(`
       {
         "callback": {
@@ -223,6 +236,11 @@ describe("Hello World worker", () => {
         "payload": {
           "test": "test",
         },
+        "time": ${
+          // @ts-expect-error I'm bad at typescript
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+          time.toISOString()
+        },
         "type": "no-schedule",
       }
     `);
@@ -244,7 +262,11 @@ describe("Hello World worker", () => {
         "description": "test",
         "id": "no-schedule-task-001",
         "payload": "{"test":"test"}",
-        "time": null,
+        "time": ${Math.floor(
+          // @ts-expect-error I'm bad at typescript
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+          time.getTime() / 1000
+        )},
         "type": "no-schedule",
       }
     `);