TakeSix

Example

A talk you can click through

A talk as a TakeSix diagram: the outline in the order you speak, on one screen, and each part opening into what it says, with the speaker notes one click deeper. Present it by clicking from part to part; after the talk, people read the same diagram at their own pace instead of a deck without the speaker.

Open in the editor

From cron jobs to a job queue

A 15-minute team talk in four parts; open a part for its slides and speaker notes

1

The problem

Cron jobs fail without a sound

2

Three options

Each one tried for a weekend

3

The choice

A queue in our own database

4

Six months later

Failures seen in minutes

Get one like it from your agent

With the TakeSix MCP server or skill connected (see the guide), ask in plain words:

Prompt
Turn the notes for my talk into a TakeSix presentation: the parts in the order of the talk as a staircase, each part opening into one block per slide, speaker notes in the details.
Read this diagram as text
  • The problem: Cron jobs fail without a sound
    • 40 jobs, one crontab: Exports, emails and cleanups on a single server

      Everything that runs on a schedule lives in one crontab on one machine. Nobody owns it as a whole; each team added its lines over five years.

    • Failures nobody saw: A broken export was found by a customer, nine days late

      A cron job that fails writes to a log nobody reads. The nightly export to our biggest customer failed for nine days before they asked where their files were.

    • Overlapping runs: A slow run overlapped the next one and locked tables

      When the invoice job took longer than an hour, the next run started anyway. Two runs locked the same rows and checkout stalled at 2 a.m.

  • Three options: Each one tried for a weekend
    • A hosted queue: Reliable and managed, but one more service and one more bill

      Works well, but every job now needs network access and credentials for a new service, and local development needs an emulator.

    • Redis and a worker: Fast and popular, but Redis would hold state we must not lose

      Our Redis is a cache: we restart it freely and do not back it up. Keeping jobs there would turn a cache into a database.

    • A queue in Postgres: Jobs as rows in the database we already run and back up

      Workers take the next job with `SELECT … FOR UPDATE SKIP LOCKED`. No new service; a job and the data it changes commit in one transaction.

  • The choice: A queue in our own database
    • How it works: A jobs table, a scheduler that adds rows, workers that take them

      ```sql SELECT * FROM jobs WHERE run_at <= now() AND state = 'ready' ORDER BY run_at LIMIT 1 FOR UPDATE SKIP LOCKED; ``` The scheduler only inserts rows; any number of workers can take them.

    • Retries and dead jobs: Three tries with back-off, then an alert with the error

      A failed job is retried after 1, 5 and 30 minutes. After the third failure it is marked dead, and the on-call channel gets the job name and the error.

    • Moving job by job: One job a day, the noisiest first; cron kept as a fallback

      Each job moved on its own day, with its cron line commented out, not deleted, for two weeks. Nothing had to be rolled back.

  • Six months later: Failures seen in minutes
    • Failures in minutes: Every failed job reaches the on-call channel

      The median time from a failure to someone looking at it went from days (when a customer noticed) to under ten minutes.

    • Quieter nights: No more overlapping runs: one worker per job at a time

      Overlaps are impossible by design: a running job holds its row. Night pages about locked tables stopped.

    • What we would do again: Start with the noisiest job, keep the old path for a while

      Moving one job a day kept every change small enough to explain in a sentence. The table of jobs became the documentation nobody wrote before.

More examples