Windmill: Ubah Script Python, TypeScript, Bash, dan SQL Jadi Workflow, API, dan UI

Halo temen-temen, di tutorial kali ini aku mau ngajak kalian kenalan sama satu tool yang menurutku sangat underrated tapi impact-nya gede banget buat produktivitas tim developer, namanya Windmill. Kalau kalian sering nulis script kecil-kecilan buat automasi, misalnya kirim email, sync data antar database, panggil API pihak ketiga, atau bikin laporan harian, biasanya script itu berakhir nangkring di laptop kalian sendiri, atau paling banter di server lewat cron yang susah dimonitor. Nah, Windmill datang buat nyelesain masalah itu.

Windmill adalah developer platform open-source yang tugasnya mengubah script biasa jadi tiga hal sekaligus, yaitu workflow, API endpoint, dan UI otomatis. Jadi kalian cukup nulis fungsi main() di Python, TypeScript, Bash, atau SQL, terus Windmill bakal otomatis bikinin form input berdasarkan parameter fungsi kalian, plus endpoint yang bisa dipanggil lewat HTTP. Keren kan? Di tutorial ini kita bakal bahas dari nol, mulai dari konsep, cara install pakai Docker, nulis script Python dengan main() yang ber-type hint, nyusun beberapa script jadi flow, scheduling, ngatur secret dan resource, sampai trigger lewat webhook. Yuk kita mulai.

Introduction

Sebelum kita loncat ke instalasi, aku mau jelasin dulu kenapa Windmill ini beda dari tool automasi lain yang mungkin udah kalian kenal seperti Zapier, n8n, atau Airflow. Windmill itu code-first tapi tetap low-friction. Maksudnya gimana? Di Zapier atau n8n, kalian klik-klik node di kanvas, dan kalau butuh logic yang kompleks kalian mentok. Di Airflow, kalian nulis DAG dengan boilerplate yang lumayan banyak dan susah buat dijalanin sekali klik. Windmill ngambil jalan tengah yang menurutku pas banget, yaitu kalian nulis kode beneran (jadi kalian bebas mau ngapain aja), tapi Windmill ngasih layer di atasnya yang bikin kode itu langsung punya UI, punya endpoint, punya penjadwalan, punya manajemen permission, dan punya observability tanpa kalian perlu setup apa-apa.

Ada tiga konsep inti yang wajib kalian pahami di Windmill, yaitu Script, Flow, dan App.

Yang pertama, Script. Ini adalah unit terkecil di Windmill. Satu script itu isinya satu fungsi main() dalam bahasa pilihan kalian. Begitu kalian simpan, Windmill baca signature fungsi kalian dan otomatis generate dua hal, yaitu form UI dari parameter fungsi, dan endpoint API buat manggil script itu. Jadi misalnya kalian punya fungsi def main(nama: str, umur: int), Windmill langsung nampilin form dengan input teks buat nama dan input angka buat umur. Ajaib banget kan, kalian nggak perlu nyentuh HTML sama sekali.

Yang kedua, Flow. Flow itu adalah cara kalian nyambungin beberapa script jadi satu pipeline. Bayangin kalian punya script A yang ngambil data dari API, script B yang transform data itu, dan script C yang nyimpen ke database. Di Flow, kalian tinggal susun A lalu B lalu C, dan output dari step sebelumnya bisa dipakai jadi input step berikutnya. Flow ini support fitur canggih kayak for-loop (buat proses data berulang), branch (percabangan logika), error handler, retry otomatis, dan approval step (buat human-in-the-loop). Semua ini bisa kalian atur lewat editor visual atau lewat definisi YAML.

Yang ketiga, App. App itu buat kalian yang pengen bikin internal tool dengan tampilan yang lebih niat. Windmill punya app builder drag-and-drop, di mana kalian bisa taruh tabel, tombol, form, chart, terus nyambungin komponen itu ke script backend. Cocok banget buat bikin admin dashboard atau tool operasional buat tim non-teknis.

Selain tiga konsep itu, ada juga tiga jenis penyimpanan state yang penting, yaitu Variable, Secret, dan Resource. Variable itu nilai yang bisa dipakai ulang di banyak script. Secret itu variable yang di-encrypt, cocok buat nyimpen password atau API key. Resource itu kumpulan konfigurasi terstruktur, misalnya kredensial database yang isinya host, port, user, password, dan nama database dalam satu objek. Nanti kita bahas detail masing-masing.

Satu hal yang bikin aku suka Windmill adalah dia self-hostable. Jadi semua data dan kode kalian tetap di infrastruktur kalian sendiri, nggak ada yang bocor ke cloud pihak ketiga. Buat kalian yang kerja di perusahaan dengan requirement data privacy ketat, ini nilai plus yang gede. Dan enaknya lagi, self-hosting-nya gampang banget karena tinggal pakai Docker Compose. Yuk kita langsung praktek.

Instalasi

Cara paling gampang buat nyobain Windmill di mesin sendiri adalah pakai Docker Compose. Yang kalian butuhin cuma Docker dan Docker Compose udah terinstall. Kalau belum, install dulu ya dari situs resmi Docker. Kalau udah siap, kita ikutin langkah berikut.

Pertama, kita bikin folder buat project Windmill kita.

mkdir windmill-demo && cd windmill-demo

Kedua, kita download file docker-compose.yml resmi dari Windmill dan file .env template-nya.

curl -o docker-compose.yml https://raw.githubusercontent.com/windmill-labs/windmill/main/docker-compose.yml
curl -o .env https://raw.githubusercontent.com/windmill-labs/windmill/main/.env

File docker-compose.yml ini udah ngatur semua service yang dibutuhin Windmill, yaitu database PostgreSQL (buat nyimpen semua data), server Windmill, worker (yang eksekusi script kalian), dan Caddy sebagai reverse proxy. Kalau kalian penasaran, coba buka file itu, isinya kira-kira mirip potongan di bawah ini yang aku sederhanakan biar gampang dibaca.

cat docker-compose.yml

Struktur intinya kayak gini, temen-temen. Aku tulis ulang versi minimal biar kalian paham komponennya.

version: "3.7"

services:
  db:
    image: postgres:16
    restart: unless-stopped
    volumes:
dbdata:/var/lib/postgresql/data

    environment:

      POSTGRESPASSWORD: changeme
      POSTGRESDB: windmill

    healthcheck:
      test: ["CMD-SHELL", "pgisready -U postgres"]
      interval: 10s
      timeout: 5s
      retries: 5

  windmillserver:

    image: ghcr.io/windmill-labs/windmill:main
    restart: unless-stopped
    dependson:
      db:
        condition: servicehealthy

    environment:
      DATABASEURL: postgres://postgres:changeme@db/windmill
      MODE: server
    ports:
"8000:8000"

  windmillworker:

    image: ghcr.io/windmill-labs/windmill:main
    restart: unless-stopped
    dependson:
      db:
        condition: servicehealthy

    environment:
      DATABASEURL: postgres://postgres:changeme@db/windmill
      MODE: worker
      WORKERGROUP: default


volumes:
  dbdata:

Ketiga, kita jalanin semua service pakai satu perintah aja.

docker compose up -d

Perintah ini bakal download image yang dibutuhin (agak lama di awal karena ukurannya lumayan), terus jalanin semua container di background. Kalian bisa cek status container-nya pakai perintah ini.

docker compose ps

Kalau semua container statusnya running atau healthy, berarti Windmill kalian udah siap. Sekarang buka browser dan akses http://localhost:8000. Kalian bakal disambut halaman setup awal. Untuk login pertama kali, default-nya biasanya pakai email admin@windmill.dev dengan password changeme. Ingat ya, ini cuma buat development. Kalau kalian mau deploy ke production, WAJIB banget ganti password default itu dan set environment variable yang bener, terutama POSTGRESPASSWORD dan BASEURL.

Setelah login, kalian bakal lihat konsep Workspace. Workspace ini kayak ruang kerja yang misahin project satu sama lain. Buat mulai, bikin dulu satu workspace, misalnya kasih nama demo. Setelah workspace dibuat, kalian udah masuk ke dashboard utama Windmill di mana kalian bisa bikin script, flow, dan app.

Buat kalian yang nggak mau ribet self-host dulu dan cuma pengen nyoba-nyoba, Windmill juga punya versi cloud di app.windmill.dev yang ada free tier-nya. Tapi buat tutorial ini aku saranin kalian pakai self-host aja biar kerasa full control-nya. Oke, sekarang instalasi beres, lanjut ke bagian yang paling seru, yaitu nulis script.

Basic Usage

Di bagian ini kita bakal nulis script Python pertama kita di Windmill. Buat mulai, di dashboard klik menu Scripts, terus klik tombol untuk bikin script baru dan pilih bahasa Python. Windmill bakal nunjukin editor kode dengan template awal.

Konsep paling penting yang harus kalian ingat adalah setiap script Windmill WAJIB punya fungsi bernama main. Fungsi inilah yang jadi entry point. Parameter dari fungsi main inilah yang bakal diubah jadi form input otomatis oleh Windmill. Makanya, kasih type hint yang jelas ke setiap parameter itu penting banget, karena dari type hint itulah Windmill nentuin jenis input form-nya.

Yuk kita tulis script sederhana yang menghitung dan nampilin salam personal.

def main(nama: str, umur: int, sukakopi: bool = True):
    if sukakopi:
        pesankopi = "kayaknya kamu butuh kopi dulu nih sebelum ngoding"

    else:
        pesankopi = "wah kamu tim teh ya"

    return {
        "salam": f"Halo {nama}, umur kamu {umur} tahun",
        "catatan": pesankopi,

        "status": "ok",
    }

Coba perhatiin, temen-temen. Fungsi main di atas punya tiga parameter, yaitu nama bertipe str, umur bertipe int, dan sukakopi bertipe bool dengan nilai default True. Begitu kalian simpan script ini, Windmill langsung generate form di sebelah kanan dengan input teks buat nama, input angka buat umur, dan toggle switch buat sukakopi. Parameter yang punya nilai default (kayak sukakopi) bakal jadi opsional di form, sedangkan yang nggak punya default jadi wajib diisi. Ini yang aku maksud dengan auto-generated UI tadi. Kalian nggak nulis satu baris HTML pun, tapi udah dapat form yang fungsional.

Setelah script disimpan, kalian bisa langsung klik tombol Run buat nyoba. Isi form-nya, klik run, dan kalian bakal lihat hasilnya di bagian output. Output-nya berupa objek yang kalian return dari fungsi main. Windmill nampilin output ini dalam format JSON yang rapi.

Sekarang gimana kalau script kalian butuh library eksternal, misalnya requests buat manggil API? Nah ini salah satu fitur pintar Windmill. Kalian tinggal import aja library-nya, dan Windmill bakal otomatis deteksi dependency itu terus install-nya buat kalian. Jadi nggak perlu ngurus requirements.txt atau pip install manual. Coba lihat contoh berikut yang ngambil data cuaca dari API publik.

import requests

def main(kota: str = "Jakarta"):
    url = "https://wttr.in/" + kota
    params = {"format": "j1"}
    resp = requests.get(url, params=params, timeout=10)
    resp.raiseforstatus()
    data = resp.json()

    kondisi = data["currentcondition"][0]

    return {
        "kota": kota,
        "suhucelsius": kondisi["tempC"],

        "kelembaban": kondisi["humidity"],
        "deskripsi": kondisi["weatherDesc"][0]["value"],
    }

# argumen pertama adalah nama folder yang mau dicek
folder="$1"

if [ -z "$folder" ]; then
  echo "folder tidak boleh kosong"
  exit 1
fi

echo "Mengecek isi folder: $folder"
jumlahfile=$(ls -1 "$folder" 2>/dev/null | wc -l)
echo "Jumlah file: $jumlahfile"

import requests

def main(limit: int = 5):
    resp = requests.get("https://jsonplaceholder.typicode.com/users", timeout=10)
    resp.raiseforstatus()

    users = resp.json()
    return users[:limit]

def main(user: dict):
    nama = user.get("name", "tanpa nama")
    email = user.get("email", "tanpa email")
    print(f"Mengirim notifikasi ke {nama} di {email}")
    return {"terkirim": True, "email": email}

Cara nyambungin output step ke input step berikutnya di Windmill itu pakai referensi. Kalau di editor visual, kalian tinggal klik input field terus pilih dari mana datanya. Secara internal, Windmill nyimpen flow ini dalam format yang bisa kalian lihat sebagai JSON atau YAML. Referensi antar step ditulis pakai ekspresi kayak results.a yang artinya output dari step dengan id a. Buat data yang lagi di-loop, kalian pakai flowinput.iter.value buat ngambil elemen yang sedang diproses. Ini fleksibel banget karena kalian bisa transform data di antara step.

Flow juga support fitur lanjutan lain yang berguna banget di dunia nyata. Ada branch buat percabangan, misalnya kalau kondisi tertentu terpenuhi maka jalanin step X, kalau nggak jalanin step Y. Ada error handler yang otomatis jalan kalau ada step yang gagal, cocok buat ngirim alert. Ada retry policy, di mana kalian bisa set step buat otomatis dicoba ulang beberapa kali kalau gagal, dengan jeda tertentu. Dan ada approval step, di mana flow berhenti dan nunggu approval manual dari manusia sebelum lanjut. Approval step ini keren buat proses yang butuh persetujuan, misalnya sebelum ngirim email massal atau sebelum ngehapus data.

Scheduling

Salah satu use case paling umum dari Windmill adalah menjalankan script atau flow secara terjadwal, menggantikan cron tradisional yang susah dimonitor. Windmill punya fitur schedule built-in yang jauh lebih enak dipakai.

Buat bikin jadwal, buka script atau flow yang mau kalian jadwalin, terus cari opsi Schedule. Kalian bakal diminta masukin ekspresi cron. Formatnya standar cron yang mungkin udah familiar buat kalian. Misalnya kalian mau flow jalan tiap hari jam 9 pagi, kalian tulis ekspresi cron 0 9 . Kalau tiap 15 menit, /15 . Windmill juga minta kalian set timezone, jadi kalian nggak perlu pusing konversi waktu UTC.

Kelebihan schedule di Windmill dibanding cron biasa adalah kalian dapat history lengkap tiap eksekusi. Kalian bisa lihat kapan aja script itu jalan, berapa lama durasinya, apa outputnya, dan kalau gagal kalian bisa lihat error lengkapnya. Kalian juga bisa set error handler khusus buat schedule, jadi kalau ada eksekusi terjadwal yang gagal, kalian langsung dapat notifikasi. Ini game changer banget dibanding cron di server yang error-nya cuma masuk ke log file yang jarang dicek.

Secret, Variable, dan Resource

Sekarang kita bahas soal manajemen kredensial dan konfigurasi, karena ini krusial buat automasi yang aman. Windmill punya tiga konsep, yaitu Variable, Secret, dan Resource.

Variable itu nilai yang bisa dipakai ulang. Misalnya kalian punya URL base API yang dipakai di banyak script, mending kalian simpan sebagai variable biar kalau berubah tinggal ganti di satu tempat. Buat bikin variable, masuk ke menu Variables, kasih path (misalnya u/ruby/baseapiurl), terus isi nilainya.

Secret itu sebenarnya variable juga, tapi nilainya di-encrypt di database dan nggak akan ditampilin lagi setelah disimpan. Ini tempat yang tepat buat nyimpen API key, token, atau password. Kalian tinggal centang opsi secret waktu bikin variable.

Cara akses variable dan secret di dalam script Python itu pakai library bawaan Windmill bernama wmill. Contohnya kayak gini.

import wmill

def main(pesan: str):
    # ambil secret API key yang sudah disimpan di Windmill
    apikey = wmill.getvariable("u/ruby/telegramtoken")

    baseurl = wmill.getvariable("u/ruby/baseapiurl")


    print(f"Memakai base url: {baseurl}")
    # apikey dipakai untuk otentikasi, tidak pernah ditulis di kode

    hasil = kirimpesan(apikey, pesan)

    return {"status": "terkirim", "detail": hasil}


def kirimpesan(token: str, pesan: str):
    # ilustrasi saja, di dunia nyata di sini kamu panggil API beneran
    return {"panjangpesan": len(pesan)}

Perhatiin, temen-temen, di kode di atas kita nggak pernah nulis API key secara literal di dalam script. Kita ambil dari Windmill lewat wmill.getvariable. Ini best practice keamanan yang penting banget, jangan sampai kredensial nyangkut di kode yang bisa kelihatan orang lain atau ke-commit ke git.

Resource itu konsep yang lebih terstruktur. Bayangin kalian mau connect ke database PostgreSQL. Kalian butuh host, port, user, password, dan nama database. Daripada bikin lima variable terpisah, kalian bikin satu Resource bertipe PostgreSQL yang isinya semua field itu dalam satu objek. Windmill udah punya banyak resource type bawaan buat layanan populer seperti PostgreSQL, MySQL, MongoDB, AWS S3, SMTP, dan banyak lagi. Cara akses resource di script juga lewat wmill.

import wmill

def main():
    # ambil resource database yang tersimpan sebagai objek utuh
    db = wmill.getresource("u/ruby/postgresprod")

    host = db["host"]
    port = db["port"]
    user = db["user"]
    dbname = db["dbname"]

    print(f"Terhubung ke {dbname} di {host}:{port} sebagai {user}")
    return {"terhubung": True, "database": dbname}

Dengan resource, konfigurasi kalian jadi rapi, aman, dan gampang dipakai ulang di banyak script tanpa duplikasi. Kalau password database berubah, kalian cukup update di satu resource, dan semua script yang pakai resource itu langsung ikut update.

Trigger Lewat Webhook

Ini fitur yang menurutku bikin Windmill sangat powerful buat integrasi. Setiap script dan flow di Windmill otomatis punya webhook URL. Artinya kalian bisa memicu eksekusi script cuma dengan ngirim HTTP request ke URL itu. Use case-nya banyak banget, misalnya kalian mau script jalan tiap kali ada form baru disubmit, tiap kali ada pembayaran masuk dari payment gateway, atau tiap kali ada event dari layanan lain.

Buat lihat webhook URL, buka script atau flow kalian, terus cari bagian yang nunjukin cara trigger via webhook. Windmill kasih dua jenis webhook, yaitu yang sync (nunggu sampai selesai dan langsung balikin hasil) dan yang async (langsung balikin job id, eksekusi jalan di background). Buat manggil webhook, kalian perlu token otentikasi yang bisa kalian generate di setting akun.

Contoh manggil webhook script pakai curl kayak gini.

# ganti TOKEN, WORKSPACE, dan path script sesuai punyamu
TOKEN="wmtokenrahasiakamu"

WORKSPACE="demo"
SCRIPTPATH="u/ruby/cekcuaca"


curl -X POST \
  "http://localhost:8000/api/w/${WORKSPACE}/jobs/runwaitresult/p/${SCRIPTPATH}" \
  -H "Authorization: Bearer ${TOKEN}" \
  -H "Content-Type: application/json" \
  -d '{"kota": "Bandung"}'

Endpoint runwaitresult di atas itu tipe sync, jadi curl bakal nunggu sampai script selesai dan langsung nampilin hasilnya. Kalau kalian mau yang async biar nggak nunggu, kalian pakai endpoint yang berbeda yang langsung balikin job id.

TOKEN="wmtokenrahasiakamu"
WORKSPACE="demo"
SCRIPTPATH="u/ruby/cekcuaca"


versi async, langsung dapat job id tanpa menunggu selesai
curl -X POST \
  "http://localhost:8000/api/w/${WORKSPACE}/jobs/run/p/${SCRIPTPATH}" \
  -H "Authorization: Bearer ${TOKEN}" \
  -H "Content-Type: application/json" \
  -d '{"kota": "Surabaya"}'

Body JSON yang kalian kirim di request itu langsung di-map ke parameter fungsi main kalian. Jadi {"kota": "Bandung"} bakal jadi argumen kota="Bandung" di fungsi main. Praktis banget kan. Dengan webhook ini, Windmill bisa jadi backend automasi buat hampir apa aja. Kalian bisa nyambungin form website ke Windmill, nyambungin Stripe ke Windmill, atau nyambungin sistem internal kalian ke Windmill, semuanya lewat HTTP request sederhana.

Best Practices

Setelah kita keliling fitur-fitur Windmill, sekarang aku mau bagi beberapa best practice yang aku rasa penting biar penggunaan Windmill kalian rapi dan aman untuk jangka panjang.

Pertama, selalu simpan kredensial sebagai Secret atau Resource, jangan pernah hardcode di script. Ini aku ulang lagi karena saking pentingnya. Kredensial yang nyangkut di kode itu bom waktu. Kalau script-nya ke-export atau ada orang lain yang punya akses baca, kredensial kalian bocor. Dengan Secret dan Resource, nilai sensitif itu di-encrypt dan cuma di-inject saat runtime.

Kedua, kasih type hint yang jelas dan spesifik di fungsi main. Karena Windmill generate UI dari type hint, semakin spesifik type hint kalian, semakin bagus form yang dihasilkan. Pakai int buat angka, bool buat toggle, dan kalian bahkan bisa pakai enum atau literal buat bikin dropdown pilihan. Kalian juga bisa kasih nilai default yang masuk akal biar user nggak bingung.

Ketiga, pecah logika yang kompleks jadi beberapa script kecil yang di-compose lewat Flow. Jangan bikin satu script raksasa yang ngerjain semuanya. Script kecil itu lebih gampang di-test, lebih gampang dipakai ulang, dan kalau ada yang error kalian lebih gampang tahu step mana yang bermasalah karena Flow nunjukin status tiap step secara terpisah.

Keempat, manfaatin retry dan error handler di Flow buat proses yang kritikal. Di dunia nyata, API bisa timeout, jaringan bisa putus, dan layanan bisa down sementara. Dengan set retry policy, script kalian bakal otomatis nyoba ulang tanpa kalian perlu bangun tengah malam buat re-run manual. Dan dengan error handler, kalau ada yang beneran gagal, kalian langsung dapat notifikasi.

Kelima, gunakan struktur path dan penamaan yang konsisten. Windmill pakai sistem path kayak u/username/namascript buat script milik user dan f/folder/namascript buat script milik folder atau tim. Bikin konvensi penamaan yang jelas dari awal, misalnya prefix berdasarkan fungsi atau tim, biar workspace kalian nggak berantakan waktu udah punya ratusan script.

Keenam, manfaatin fitur version dan git sync. Windmill nyimpen history versi tiap script, jadi kalau kalian salah edit, kalian bisa balik ke versi sebelumnya. Buat tim yang serius, Windmill juga support sync ke git repository, jadi semua script dan flow kalian bisa di-review lewat pull request layaknya kode biasa. Ini bikin workflow kalian auditable dan collaborative.

Ketujuh, monitor resource worker kalian, terutama kalau self-host di server dengan RAM terbatas. Tiap worker eksekusi job di proses terpisah. Kalau kalian jalanin banyak job berat secara bersamaan, RAM bisa cepat habis. Kalian bisa atur jumlah worker dan worker group buat misahin beban kerja, misalnya worker group khusus buat job ringan dan worker group lain buat job berat.

Kedelapan, kasih deskripsi dan dokumentasi di tiap script. Windmill support nambahin summary dan deskripsi di tiap script. Luangkan waktu buat nulis penjelasan singkat apa fungsi script itu dan gimana cara pakainya. Rekan tim kalian (dan diri kalian sendiri enam bulan lagi) bakal berterima kasih.

Conclusion

Nah temen-temen, itu dia perjalanan kita ngulik Windmill dari nol sampai ke fitur-fitur lanjutannya. Kita udah bahas konsep inti berupa Script, Flow, dan App. Kita udah install Windmill pakai Docker Compose dengan gampang. Kita udah nulis script Python dengan fungsi main() ber-type hint yang otomatis dapat UI dan endpoint. Kita udah nyusun beberapa script jadi Flow dengan for-loop, kita udah jadwalin eksekusi pakai cron, kita udah ngatur secret, variable, dan resource dengan aman, dan kita udah trigger script lewat webhook pakai curl.

Menurutku, kekuatan terbesar Windmill ada di kombinasi dua dunia yang biasanya bertentangan, yaitu fleksibilitas penuh dari nulis kode beneran, dengan kemudahan tool no-code yang ngasih UI, endpoint, scheduling, dan monitoring secara otomatis. Buat kalian yang selama ini punya banyak script automasi berserakan di sana sini, Windmill bisa jadi rumah yang rapi buat semua itu. Dan karena open-source dan self-hostable, kalian punya kontrol penuh atas data dan infrastruktur kalian.

Saranku, mulai dari yang kecil dulu. Ambil satu script automasi yang selama ini kalian jalanin manual atau lewat cron, pindahin ke Windmill, kasih dia UI dan jadwal, terus rasakan bedanya. Setelah nyaman, baru kalian eksplorasi Flow dan App buat automasi yang lebih kompleks. Aku yakin sekali kalian nyoba, kalian bakal ketagihan sama betapa enaknya ngelola automasi di Windmill.

Oke, segitu dulu tutorial dari aku kali ini. Semoga bermanfaat dan bikin kalian makin produktif ya. Selamat ngoprek Windmill, dan sampai ketemu di tutorial berikutnya. Happy automating, temen-temen.