Skip to content
Skills Library
DevOps & cloud · Automation

windmill

/windmill

Windmill is an open-source platform for turning scripts into internal tools, workflows and webhooks, with auto-generated UIs, a flow editor and an app builder. Use when a user asks to build internal tools or admin dashboards, orchestrate scripts and cron jobs, automate DevOps tasks, or self-host a code-first alternative to Retool, Zapier or Airflow.

Repository
skills ↗
Licence
Apache-2.0
Last repository change
25.10.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
2
Scripts
0
HTML comments
0
URLs in SKILL.md
7
Deprecation

No signals detected. Repository changed on 25.10.2026, without references to retired models or APIs.

Licence

Apache-2.0, otwarta: można używać i zmieniać, z zachowaniem licencji i informacji o zmianach.

What it does and when to use it

Windmill is an open-source platform for turning scripts into internal tools, workflows and webhooks, with auto-generated UIs, a flow editor and an app builder. Use when a user asks to build internal tools or admin dashboards, orchestrate scripts and cron jobs, automate DevOps tasks, or self-host a code-first alternative to Retool, Zapier or Airflow.

Original author description

Windmill is an open-source platform for turning scripts into internal tools, workflows and webhooks, with auto-generated UIs, a flow editor and an app builder. Use when a user asks to build internal tools or admin dashboards, orchestrate scripts and cron jobs, automate DevOps tasks, or self-host a code-first alternative to Retool, Zapier or Airflow.

How it works

  1. Overview
  2. Instructions
  3. Examples
  4. Guidelines
Original SKILL.md headings · 136 lines, 1,148 words
SKILL.md preview
---
name: windmill
description: >-
  Windmill is an open-source platform for turning scripts into internal tools, workflows and webhooks, with auto-generated UIs, a flow editor and an app builder. Use when a user asks to build internal tools or admin dashboards, orchestrate scripts and cron jobs, automate DevOps tasks, or self-host a code-first alternative to Retool, Zapier or Airflow.
license: Apache-2.0
compatibility: "Self-hosted with Docker or Kubernetes (needs Postgres), or Windmill Cloud. Scripts in TypeScript (Bun/Deno), Python, Go, Bash, SQL, Rust, PHP and more."
metadata:
  author: terminal-skills
  version: "1.1.0"
  category: automation
  repository: https://github.com/windmill-labs/windmill
  tags: "windmill, internal-tools, workflow, scripts, automation"
---

# Windmill

## Overview

Windmill is a platform where a script is the unit of work. Write a function in TypeScript, Python, Go, Bash, SQL, Rust and other languages; Windmill reads its signature and builds a form, an API endpoint and a webhook for it, then runs it on workers. Scripts chain into flows (steps, branches, loops, approvals, retries) and flows or scripts back apps built in a drag-and-drop editor. Triggers include schedules, webhooks, HTTP routes, Kafka, WebSockets and email.

The backend is Rust, the state is Postgres, and workers pull jobs from a Postgres queue. The repository is AGPLv3 plus a free "Community Edition" binary and Docker image that includes some proprietary features; internal use is free, but reselling or embedding it needs a commercial licence (see the licence section of the README and the pricing page). Version at the time of writing: 1.822.0.

## Instructions

### Self-host with Docker Compose

Windmill needs Postgres, so a lone `docker run` of the image does not work. The repository ships three files that bring up Postgres, server, workers and a Caddy proxy:

```bash
mkdir windmill && cd windmill
# Pin to a release tag, not the moving main branch, and read each file before running it
WM=v1.822.0
base=https://raw.githubusercontent.com/windmill-labs/windmill/$WM
curl -fsSL $base/docker-compose.yml -o docker-compose.yml
curl -fsSL $base/Caddyfile -o Caddyfile
curl -fsSL $base/.env -o .env
less docker-compose.yml Caddyfile .env
docker compose up -d
```

Open `http://localhost`. The default login is `admin@windmill.dev` with password `changeme`; change it immediately. Before production, change the Postgres password in `.env`/`docker-compose.yml`, put the instance behind HTTPS (set `BASE_URL` for Caddy), and pin `WM_IMAGE` to a release tag instead of `main`. For an external database, set `DATABASE_URL` in `.env` and set the `db` replicas to 0. For Kubernetes use the Helm chart (`helm repo add windmill https://windmill-labs.github.io/windmill-helm-charts/`). Postgres 18 is now the default in the compose file: an existing Postgres 16 volume will not start and must be migrated with `pg_dumpall`, as the self-host docs describe.

### Write a script

Scripts live in folders like `f/<folder>/<name>`. The arguments of `main` become the form; types and defaults drive the widgets, and an object type that matches a resource type (for example `postgresql`) becomes a resource picker. Secrets live in variables and resources, not in arguments.

```typescript
import * as wmill from "windmill-client";

type Postgresql = { host: string; port: number; user: string; dbname: string; password: string; sslmode: string };

export async function main(db: Postgresql, table: "orders" | "refunds", days: number = 7) {
  const apiKey = await wmill.getVariable("f/billing/stripe_key"); // permissioned, by path
  console.log(`checking ${table} for the last ${days} days`);
  return { table, days, keyLength: apiKey.length };
}
```

```python
def main(region: str, since: str = "2026-09-01") -> list[dict]:
    import requests  # imports are resolved and installed automatically
    r = requests.get("https://api.status.internal/v1/incidents", params={"region": region, "since": since}, timeout=30)
    r.raise_for_status()
    return r.json()["incidents"]
```

### Develop locally with the CLI

```bash
npm install -g windmill-cli          # or: npx windmill-cli ...; command is `wmill`
wmill workspace add main main http://localhost   # name, workspace id, remote URL (log in when prompted)
mkdir ops && cd ops && wmill init   # writes wmill.yaml, AGENTS.md and agent skills
wmill script new f/ops/disk_report bun --summary "Disk report"
wmill script preview f/ops/disk_report -d '{"threshold": 80}'   # runs the local file, no deploy
wmill generate-metadata              # refresh .script.yaml schema and lock files
wmill sync push --dry-run            # then without --dry-run to deploy
```

`script preview` runs local code without deploying; `script run` runs the deployed version; `sync push` is the deploy and `sync pull` fetches remote changes. `wmill lint` validates flow, schedule and trigger YAML. Other tools: the VS Code extension, Git sync (two-way with a repo), and `wmill dev` for a live preview page.

### Build a flow

`wmill flow new f/ops/nightly --summary "Nightly order check"` creates `f/ops/nightly__flow/flow.yaml`. Steps are `modules`; reference earlier output with `results.fetch_orders` (the step id) and inputs with `flow_input.day`. Inline code uses `!inline file.ts`.

```yaml
summary: Nightly order check
value:
  modules:
    - id: fetch_orders
      value:
        type: rawscript
        language: bun
        content: '!inline fetch_orders.ts'
        input_transforms:
          day: { type: javascript, expr: flow_input.day }
    - id: check_failures
      value:
        type: branchone
        branches:
          - summary: Too many failures
            expr: results.fetch_orders.failed > 2
            modules:
              - id: alert_team
                value:
                  type: rawscript
                  language: bun
                  content: '!inline alert_team.ts'
                  input_transforms:
                    message: { type: javascript, expr: '`${results.fetch_orders.failed} failed orders`' }
        default: []
schema:
  $schema: https://json-schema.org/draft/2020-12/schema
  type: object
  order: [day]
  properties:
    day: { type: string, description: "Date to check, YYYY-MM-DD" }
  required: [day]
```

Run `wmill lint f` to validate it and `wmill flow preview f/ops/nightly -d '{"day": "2026-10-02"}'` to execute it locally. `failure_module` and `preprocessor_module` are top-level fields under `value`, not entries of `modules`. Loops use `forloopflow` with an `iterator` expression; approval steps suspend a flow until someone approves.

### Apps, schedules and triggers

Build apps in the UI editor (low-code) or as full-code React/Svelte/Vue "raw apps". Schedules, webhooks and HTTP routes attach to any script or flow; create them in the UI or as YAML via `wmill schedule new` and `wmill trigger new <path> --kind http`.

## Examples

### Example 1: Self-service refund tool

Request: "Our support team needs a form to issue refunds without touching the database."

Write `f/support/issue_refund.py` with `def main(db: postgresql, order_id: str, amount_cents: int, reason: str)`, preview it with `wmill script preview f/support/issue_refund -d '{"order_id": "A-10482", "amount_cents": 1900, "reason": "damaged"}'`, push it, and share the auto-generated form. Put it in a flow with an approval step above a threshold, and give the support group Operator access so they can run it but not edit it.

### Example 2: Nightly check with a Slack alert

Request: "Every night at 2am check yesterday's failed orders and tell the team if there are more than two."

Create the flow above, then add a schedule with cron `0 0 2 * * *` (Windmill uses a six-field cron with seconds) via the Schedules page or `wmill schedule new f/ops/nightly_schedule`. The Runs page shows each execution with logs and per-step inputs and outputs; failures can go to a failure handler or a workspace error handler.

## Guidelines

- Do not ship `admin@windmill.dev` / `changeme` or the compose Postgres password. Back up Postgres; it holds all code, state and secrets.
- Never hard-code secrets in scripts; use variables (secret flag) and resources, and read them with `wmill.getVariable` or typed resource arguments.
- Community Edition is free internally, with caps (for example 10 users with SSO); Enterprise adds SAML, audit logs and a commercial licence. Check the pricing page for current figures.
- Use `script preview` while iterating, not `sync push`; a push overwrites the workspace version.
- Run `wmill generate-metadata` after changing a script's imports or `main` signature, or the lock and the form schema go stale.
- Workers run arbitrary code: restrict who can create scripts, and use worker groups and isolation for untrusted workloads.
- Not the right tool for durable, high-fan-out microservice orchestration with strict workflow-versioning needs (Temporal fits better), or for a pure no-code audience.
Files in this package (2)
  • SKILL.md 9 KB
  • _scores.json 3 KB

Versions

The database has no other skills named windmill.

Database snapshot: 13.11.2026 · package version 6015d8911ff5 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100retool
    Retool is a platform for building internal tools — admin panels, dashboards and CRUD apps — on top of your own databases and APIs. Use when a user asks to build or edit a Retool app, drive the Retool CLI (retool init, check, push, publish) from a coding agent, write queries and…
  • 100n8n
    n8n is a fair-code workflow automation platform with a visual editor, webhook and schedule triggers, JavaScript and Python code nodes and 1500+ integrations, self-hosted or in n8n Cloud. Use when a user asks to automate business workflows, connect APIs visually, build…
  • 100low-code-platforms
    Low-code and internal tool platforms including Retool, Supabase, Appsmith, Tooljet, n8n, and Zapier. Use when building admin panels, internal tools, workflow automations, or integrating low-code platforms with custom code.
  • 100preview
    MUST use when opening the Windmill dev page / visual preview of a flow, script, or app. Triggers on words like preview, open, navigate to, visualize, see the flow/app/script, and after writing a flow/script/app for visual verification.
  • 95write-workflow-as-code
    MUST use when writing or modifying Windmill Workflow-as-Code scripts using workflow, task, step, sleep, approvals, taskScript, taskFlow, task_script, or task_flow.
  • 100rust-backend
    Rust coding guidelines for the Windmill backend. MUST use when writing or modifying Rust code in the backend directory.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.