Windmill – Developer Platform for Workflows, Scripts & Apps

Price range: $20.00 through $160.00

Deploy your dedicated Windmill developer platform on Bajhi Cloud. Code-first orchestration for workflows, scripts (TypeScript, Python, Go, Bash, SQL), auto-generated UIs, and AI agents with full sandboxing, enterprise-grade observability, and zero infrastructure overhead.

Description
Open Source Code-First Orchestration

Code-first platform for internal software & AI agents

Built for teams to build and collaborate on internal tools, automated workflows, and autonomous AI agents. Turn scripts in Python, TypeScript, Go, Bash, and SQL into auto-generated UIs, APIs, and event-driven data pipelines.

✓ Open-source & self-hostable with zero vendor lock-in
✓ Workflows, internal UIs & AI agents in one unified system
✓ Multi-language scripts with auto-generated web forms
✓ Ultra-fast Rust job orchestrator with sub-millisecond overhead
windmill-orchestrator :: live worker log
RUNNING
✦ Agent Orchestrating churn mitigation flow 0.02s
● SQL SELECT * FROM accounts WHERE health < 40 0.08s
● Script u/admin/calculate_risk_score.ts 0.14s
✦ MCP Tool trigger_intercom_retention_campaign() 0.19s
✔ Done Dispatched 14 high-priority escalations 0.24s
Zero-Ops Worker Pool Active
Mem: 42MB | Latency: 1.2ms
Trusted by 4,000+ engineering teams & leading organizations
Zoom
Kahoot!
CFA Institute
Axians
PhotoRoom
Pave
Panther Labs
Multi-Language Execution

Write scripts for production in any language

Write scripts in TypeScript, Python, Go, Bash, SQL, or Rust. Windmill handles the runtime, dependencies, auto-generated UI, webhook URLs, and real-time logs.

Auto-Generated UIs & Forms

Windmill automatically inspects script type signatures and creates sleek, interactive web forms so non-technical team members can safely run them.

Instant Webhook & Cron Triggers

Every script gets instant sync and async webhook endpoints, cron schedules, Kafka/NATS queue consumers, or Postgres CDC event triggers.

Zero Cold Starts & Auto-Deps

Windmill parses imports, caches packages across executions, and leverages isolated Linux sandboxes for sub-millisecond execution times.

Python
TypeScript
SQL
Bash
Go
import wmill
from typing import List
# Auto-generated UI form generated from types!
def main(table_name: str, min_score: int = 75) -> dict:
    """Fetch high-priority customer records and sync to CRM."""
    db = wmill.get_resource("u/admin/postgres_db")
    results = db.query(
        f"SELECT id, email, score FROM {table_name} WHERE score >= %s",
        [min_score]
    )
    return {
        "processed": len(results),
        "accounts": results
    }
import * as wmill from "npm:windmill-client";
export async function main(
  customerEmail: string,
  refundAmount: number
) {
  // Access centrally managed secrets securely
  const stripeKey = await wmill.getVariable("STRIPE_SECRET_KEY");
  console.log(`Processing refund of $${refundAmount} for ${customerEmail}`);
  
  return {
    status: "approved",
    timestamp: new Date().toISOString()
  };
}
-- Direct database querying with typed parameters
SELECT 
    users.id,
    users.email,
    count(orders.id) as total_orders,
    sum(orders.total) as lifetime_value
FROM users
JOIN orders ON orders.user_id = users.id
WHERE orders.created_at >= :start_date
GROUP BY users.id, users.email
HAVING sum(orders.total) > :min_spend;
#!/usr/bin/env bash
# Inputs are automatically injected as environment variables!
echo "Running system backup for workspace: $WORKSPACE_NAME"
pg_dump -h $PG_HOST -U $PG_USER $PG_DATABASE > /tmp/backup.sql
aws s3 cp /tmp/backup.sql s3://$S3_BUCKET/backups/$(date +%Y-%m-%d).sql
echo "Backup successfully uploaded to S3!"
package main
import (
    "fmt"
    "github.com/windmill-labs/windmill-go-client"
)
type Input struct {
    ClusterID string `json:"cluster_id"`
}
func Main(args Input) (map[string]interface{}, error) {
    fmt.Printf("Deploying update to cluster: %s\n", args.ClusterID)
    return map[string]interface{}{
        "status": "synchronized",
        "cluster": args.ClusterID,
    }, nil
}
Distributed Workflow Engine

Compose scripts into fault-tolerant DAGs

Chain multi-language scripts, queries, approval steps, and AI agents into reliable, resilient data pipelines and asynchronous workflows.

Trigger ●
Webhook Event

POST /api/v1/new-order

Python Script ●
Fraud Detection

calculate_fraud_score.py

AI Agent ●
LLM Reasoning

Evaluate edge cases via MCP

Branch ●
Auto-Approval

Capture payment & email

Autonomous Intelligence

Build AI agents with full control & observability

For platform teams who deploy AI agents to production and need strict control over permissions, sandboxing, tool execution, and detailed audit logs.

Any LLM Provider

Seamlessly connect OpenAI, Anthropic, Azure, DeepSeek, Google Gemini, Groq, Together AI, or your own self-hosted Ollama/vLLM endpoints. Switch providers in one click without altering code.

Tools via Scripts & MCP

Turn any Windmill script into an LLM tool automatically via typed parameters. Connect Model Context Protocol (MCP) servers and external databases without leaking credentials.

Sandboxed Coding Agents

Run Claude Code, Codex, and Opencode inside nsjail-isolated containers with persistent volumes. Give them full terminal and file capabilities while ensuring they never escape the sandbox.

Internal UI Builder

Build rich internal applications in minutes

Assemble complex admin panels, customer support consoles, and operational dashboards. Connect UI widgets directly to Windmill scripts and databases with granular access control.

Drag-and-Drop + React/Svelte

Combine pre-built tables, charts, buttons, and forms with full custom React, Vue, or Svelte component support.

Direct Script & DB Binding

Trigger scripts directly on button click, paginate database queries in tables, and stream output with zero frontend boilerplate.

Enterprise Role-Based Access

Restrict UI actions, inputs, and database operations based on team member roles with centralized permission trees.

Transparent Pricing

Deploy your dedicated Windmill cloud

Get an isolated, high-performance Windmill instance hosted 24/7 on Bajhi Cloud with dedicated NVMe compute, automatic backups, and seamless Single Sign-On.

Dedicated Cloud Instance

Windmill Cloud Standard

Everything you need to orchestrate internal software and AI agents at scale.

$ 13.33 / month
Billed annually at $160/year (Save 33%)
✓ Dedicated NVMe Cloud Instance (Isolated compute)
✓ Multi-Language Workers (Python, TS, Go, Bash, SQL, Rust)
✓ AI Agents & MCP Integration (Claude Code sandbox)
✓ Visual Flow & DAG Editor with conditional branching
✓ App & UI Builder for internal tool deployment
✓ Unlimited Workflows & Runs with zero per-seat fees
✓ Automated SSL & Custom Domain included
✓ Seamless Single Sign-On via apps.bajhi.com
Deploy Dedicated Instance
Common Questions

Frequently Asked Questions

What languages does Windmill support for scripts? ▼
Windmill natively supports TypeScript (via Deno and Bun), Python, Go, Bash, SQL (PostgreSQL, MySQL, MS SQL, BigQuery, Snowflake), Rust, PHP, C#, GraphQL, and Docker containers. Each script runs in an isolated sandbox with automated dependency management.
How do Windmill AI agents differ from frameworks like LangChain? ▼
Windmill is an end-to-end execution platform rather than a pure library. Your existing scripts automatically become AI tools via their typed signatures. You get built-in worker sandboxing, role-based access control (RBAC), retry queues, execution audit logs, and web UIs without writing custom glue code.
How does the Claude Code / Codex sandbox work? ▼
Windmill runs coding agents inside nsjail-isolated worker environments where they can run terminal commands, write code, and query databases at full power. Pre-configured caches provide instant cold starts, and persistent volume storage gives the agent continuous memory across runs.
Can I trigger scripts from webhooks, schedules, and queues? ▼
Yes. Every script automatically gets synchronous and asynchronous webhook URLs. You can also trigger scripts on cron schedules, listen to Postgres CDC changes, consume messages from Kafka, NATS, or SQS queues, or invoke them manually via auto-generated forms.
How does Bajhi Cloud deployment work? ▼
When you deploy Windmill on Bajhi Cloud, an isolated instance is automatically provisioned for you on dedicated NVMe compute with automated daily backups, SSL certificates, and continuous monitoring. You access your instance securely through Single Sign-On (SSO) at apps.bajhi.com.
Reviews (0)
0 reviews
0
0
0
0
0

There are no reviews yet.

Only logged in customers who have purchased this product may leave a review.

Vendor Info

Vendor Information

  • Store Name: Bajhi Team
  • Vendor: Bajhi Team
  • No ratings found yet!