Run a scheduled Python job built by an agent

A [cron.<name>] block in floo.app.toml runs a command on a UTC schedule inside one of the app’s service images. This page deploys an hourly Python job that fetches a JSON document and stores a snapshot in managed Postgres. Requires a GitHub repository for the job. The job runs in a web service’s image, so the repository also serves one small HTTP app.

Set up your agent

curl -fsSL https://getfloo.com/install.sh | bash
floo auth login

For Claude Code, also run floo skills install --path .claude/skills/floo. Other agents: Agent setup.

Agent prompt

Paste into your agent. Replace snapshots with your app name and the URL with the document to fetch.

Deploy this Python script to floo as an hourly cron job with managed Postgres. App name: snapshots.
Confirm the floo org with `floo orgs list`. If the org has no plan, have me run `floo billing upgrade`.
Keep the job in jobs/snapshot.py. It reads SOURCE_URL and DATABASE_URL from the environment, exits non-zero on failure, and is safe to run twice.
Add a minimal FastAPI app at app/main.py with a GET /health route, and a Dockerfile that starts uvicorn on 0.0.0.0:$PORT.
Run `floo init snapshots`. In floo.app.toml, set port 8000 on [services.web], add [managed.default] with type = "postgres", and add [cron.snapshot] with schedule "0 * * * *", command "python jobs/snapshot.py", service "web".
Run `floo preflight --json` and fix every error.
Commit and push to the default branch.
Have me open https://github.com/apps/getfloo/installations/new, choose the repository's owner, and select this repository. Wait for me to confirm.
Run `floo apps github setup --no-browser` and give me the printed link. Wait for me to confirm GitHub access.
Run `floo apps github connect <owner>/<repo> --no-browser`, then `floo deploys status --app snapshots --json` until the deploy is live.
Run `floo env set SOURCE_URL=https://example.com/data.json --app snapshots --restart` and wait for that deploy the same way.
Run `floo cron run snapshot --app snapshots` and report its result.

floo.app.toml

[app]
name = "snapshots"

[services.web]
type = "web"
path = "."
port = 8000
ingress = "public"

[managed.default]
type = "postgres"

[cron.snapshot]
schedule = "0 * * * *"
command = "python jobs/snapshot.py"
service = "web"
timeout = 300

The job runs in the web image with the same DATABASE_URL and env vars as the service. timeout is in seconds, 1 to 1500, default 300. Dev and prod each run their own copy of the job on schedule, against their own database.

The job

requirements.txt lists fastapi, uvicorn, and psycopg[binary]. The Dockerfile is the one in FastAPI: add a Dockerfile.

jobs/snapshot.py

import json
import os
import urllib.request

import psycopg
from psycopg.types.json import Jsonb


def main() -> None:
    with urllib.request.urlopen(os.environ["SOURCE_URL"], timeout=30) as resp:
        payload = json.load(resp)
    with psycopg.connect(os.environ["DATABASE_URL"]) as conn:
        conn.execute(
            "CREATE TABLE IF NOT EXISTS snapshots ("
            "taken_at timestamptz NOT NULL DEFAULT now(), payload jsonb NOT NULL)"
        )
        conn.execute("INSERT INTO snapshots (payload) VALUES (%s)", [Jsonb(payload)])
    print("stored snapshot")


if __name__ == "__main__":
    main()

app/main.py

from fastapi import FastAPI

app = FastAPI()


@app.get("/health")
def health() -> dict[str, bool]:
    return {"ok": True}

Cron runs do not retry. A run that exits non-zero or passes timeout is marked failed, and the next scheduled run is the only recovery.

CLI commands

The same deploy by hand. Replace owner/snapshots with your repository.

floo init snapshots
floo preflight
git add . && git commit -m "feat: hourly snapshot job on floo"
git push origin main
floo apps github setup
floo apps github connect owner/snapshots
floo deploys watch --app snapshots
floo env set SOURCE_URL=https://example.com/data.json --app snapshots --restart
floo deploys watch --app snapshots

--restart redeploys so the service and the job pick up SOURCE_URL. floo apps github setup needs the floo GitHub App installed on the repository’s owner first. See Quickstart steps 2 and 3.

Verify

floo cron list --app snapshots
floo cron run snapshot --app snapshots
floo logs query --app snapshots --cron snapshot --env dev
floo db query --app snapshots "SELECT count(*) FROM snapshots"

cron list shows the job and its schedule. cron run triggers it now instead of waiting for the hour. The log query prints stored snapshot under [cron:snapshot], and the row count goes up by one per run. A push syncs the dev jobs; a GitHub release syncs the prod jobs. floo cron list, run, and logs query --cron take --env prod for prod.

Next steps

Cron jobs

Schedule expressions, fields, failure handling, and JSON output.

Environment variables

Set secrets from stdin, scope them to services, and import from files.

Postgres

Injected variables, compute limits, and keeping the database awake.

Agent webhooks

Send repeated job failures to your agent or on-call.

Get started

Build with your stack

Deploy from your agent

Configure your app

Ship and release

Data

Domains and networking

App users and access

Operate

Team and billing

For agents

Run a scheduled Python job built by an agent

Set up your agent

Agent prompt

floo.app.toml

The job

CLI commands

Verify

Next steps

Cron jobs

Environment variables

Postgres

Agent webhooks

​Set up your agent

​Agent prompt

​floo.app.toml

​The job

​CLI commands

​Verify

​Next steps

Cron jobs

Environment variables

Postgres

Agent webhooks

Set up your agent

Agent prompt

floo.app.toml

The job

CLI commands

Verify

Next steps