Today's Deep-Dive: Windmill

Welcome to the deep dive where we cut through the noise and get straight to the

insights you need

Have you ever found yourself writing, you know a handy script maybe to automate a

report or manage some data

Oh, absolutely all the time and then you wish it could be more than just well a

script like maybe it had a button or

Proper web interface. Yeah, or could easily talk to other services

Exactly without you having to suddenly become like a full stack developer overnight.

Uh-huh. That's the dream

Well today we're diving into something that might just make that dream a reality

But before we unpack this exciting solution just quick word from our supporter

Safe server cares about the hosting of this software and they are here to support

you in your digital transformation

You can find more info at www safe server dot DE

Okay, so our mission for you today is really a shortcut a shortcut to understanding

how this

Powerful open source platform can literally transform how you build and automate

things and we're really talking about turning those one-off scripts

Those little helpers into genuinely powerful scalable internal tools, right?

Even if you're maybe just starting out in the world of development or you know

infrastructure

We've pulled insights directly from its github repository and the official windmill

website. So we've got the ground truth here

Okay, let's get into it. We're talking about windmill for someone new to this space

Maybe just looking for like smarter ways to automate their work. What is windmill

exactly? Why should it grab their attention?

Okay. So what's really fascinating here is that windmill is fundamentally an open-source

developer platform think of it as your

Comprehensive toolkit. It lets you take those everyday scripts

You write could be Python for data bash for servers

Maybe type script write the usual suspect exactly and it lets you instantly

transform them into incredibly useful things like web hooks or

Robust workflows or even you know fully interactive user interfaces Wow

It's core promise really is to drastically speed up your development

They talk about helping you write and deploy software up to like 10 times faster 10

times

that's a big claim it is but it's also about running it with high reliability and

Crucially deep observability. So, you know what's going on

Observability always important definitely and for people familiar with other tools

in this space

Maybe things like retool or temporal pipe dream super blocks

Windmill positions itself as a really compelling open source alternative. Okay, so

if I'm getting this right

it's not just another automation tool, it's more like a a

Developer superpower for building internal stuff. That's a good way to put it. Yeah.

So for you listening right now

Maybe you're looking to streamline tasks build internal apps

But you don't want to get bogged down in weeks of setup or figuring out complex

front-end stuff

Yeah, this sound like it's seriously lowers that barrier to entry exactly. Is that

where the 10x speed claim comes?

Yeah, just removing all those traditional hurdles precisely. Yeah that 10x speed

isn't just about like raw code execution being faster, though

It is fast. It's really about eliminating the friction friction

Okay, think about all the time you normally spend building basic ui's setting up

API's managing deployments trying to connect different services

Yeah, the plumbing right windmill consolidates a lot of that

It kind of takes away the need to manually stitch together all these separate bits

Scripting scheduling API's UI and lets you just focus on the logic the problem you

actually want to solve that is a powerful promise

Okay, this is where it gets really interesting for me

How does windmill actually do this? How does it work?

What are the main concepts the building blocks someone needs to grasp to turn their

scripts into these tools?

Well, it breaks down into a few core

Very flexible components. Yeah at its heart windmill is all about letting you

define minimal generic scripts minimal and generic

Oh, when I say generic, I mean really polyglot

You can write these scripts in a huge range of languages Python typescript go bash

SQL even things like PHP rust

C-shop was quite a list it is and you can write them right inside their web IDE

Which is super handy or if you prefer your own setup, you can just sync them

directly with your github repo

Okay, so you write the script then what then comes one of the really clever bits

Especially if you aren't a fan of front-end development, uh-huh guilty as charged

sometimes right so windmill

Automatically parses your scripts parameters the inputs it needs and it generates a

basic front-end UI for it automatically automatically

Imagine you write a Python script. It takes maybe a user's email and a message

string

Okay, and poof windmill just gives you a simple web form with input fields for that

email and message

It instantly turns your code into a shareable tool that even non-technical people

can use that's fascinating

So I just write my script to find the inputs

Yeah, and windmill kind of figures out the UI doesn't guess input types like this

should be text. This should be a number exactly

Yeah, it intelligently infers the types. It gives you sensible defaults and you can

tweak them if needed. Okay, cool

So once I have these individual smart scripts, what's the next step? How do I build

something more complex, right?

So you've got these building blocks. The next step is chaining them together

You can link your own scripts or even pull in community shared scripts from

something they call windmill hub

Ah a community aspect too. Yeah, and you combine these into flows

think of flows like a

Sophisticated recipe or workflow diagram. Okay, technically they're directed a cyclic

graphs or DAGs

Which is just a fancy way of saying it's a sequence of steps that run in the right

order

No loops going backward, you know

Like you mix ingredients before you bake the cake got it makes sense and this lets

you build really powerful automations

It has built-in stuff for proper error handling automatic retries if a step is flaky

Loops for processing lists of things conditional branches like if this then do that

all the logic you need

It's a real workflow orchestration basically

Absolutely, and then beyond those auto-generated ui's for single scripts if you

need something more polished or custom for say a whole process

There's a low code app editor loco to yeah, it's drag-and-drop

You get over 60 built-in component buttons tables charts inputs

And you can visually build quite rich data intensive applications right on top of

your scripts and flows

You can go from just a script to a pretty decent internal app surprisingly fast

That's quite a spectrum from simple script UI to low-code apps it really is and

finally these scripts and flows

They don't just sit there waiting for you to click a button. They can be triggered

the automation part exactly

You can run them on standard cron schedules like run this every hour

They can be triggered by web hooks and get this every script and flow automatically

gets its own web hook URL generated

Oh, that's huge for integrations totally or you can trigger them via a command line

interface the CLI or even integrate them with things

Like slack or incoming emails. It's designed to fit into how you already work. That

is incredible

Okay, so let me recap you write a bit of code in your favorite language

Windmill instantly gives it a UI like a button

Uh-huh, you can then string those buttons those scripts together into complex flows

to automate whole processes

Or even build a full application around them using the low code editor

Oh all without becoming a front-end wizard or an orchestration expert. You've got

it. That's the core value proposition

Simplifying all that complexity. It really does sound like it simplifies things

Especially for someone who's maybe strong on scripting but less so on the UI or

infrastructure side

But it makes me wonder with all that power and flexibility

What's actually driving it? What's under the hood making it tick? How are they

getting that speed and

Importantly security. Yeah excellent question because the architecture underneath

is actually a big differentiator for windmill

They really pride themselves on being quote the fastest self-hostable workflow

engine out there fastest

Yeah, they published benchmarks showing it can be significantly faster up to 13

times faster

They claim than alternatives like say Apache airflow 13 times Wow

And that applies apparently to both lightweight really quick tasks and those long-running

heavy background jobs

That raw speed means your automations just run more efficiently tasks finish faster

Less waiting fewer resources tied up. So what's the secret sauce there? What's the

tech stack?

Okay delving into the tech stack. The back end is primarily written in rust rust

known for performance and safety

Exactly using rust gives them that speed memory safety reliability fewer unexpected

crashes

They use Postgres a rock-solid database for storage standard robust choice

Yep, and the front end the UI you interact with is built with svelte, which is

known for creating really fast responsive interfaces

Okay, and for running the scripts themselves. That's key to for JavaScript

They use things like denna core which leverages Google's v8 engine for TypeScript

They use bun and Dino again very modern fast runtimes and for other languages like

Python or go

They use standard battle tested runtimes

This choice of modern high-performance components is absolutely crucial to how they

achieve that speed and flexibility and that polyglot support

You mentioned Python go TypeScript whatever being able to just use what you know

best sounds like a huge productivity win

How does it handle dependencies like if my Python script needs specific libraries?

Yeah, that's managed really smoothly to when you define a script

You can specify its dependencies right there like a requirements dot txt for Python

or a package dot JSON for node and TypeScript

Okay, and windmill just handles it

It sets up the right environment make sure those dependencies are installed and

available when the script runs

You're not messing around with virtual environments or NPM install on the server

yourself. Oh nice abstraction

Exactly. It takes care of that setup letting you focus just on your code and this

makes it really easy to mix languages in a flow

Because each script runs in its own kind of defined isolated environment isolation

Yeah, that brings up security

Especially with internal tools potentially touching sensitive systems or data. How's

that handled? Yeah, absolutely critical

They take it very seriously script executions are sandboxed using something called

Google's ends jail

Sandboxed like contained precisely sandboxing means each script runs in its own

little isolated mini environment like a secure container

So if one script messes up or has some weird vulnerability, it can't easily affect

other scripts or the main windmill system

That's vital. It really is. It's the same kind of tech that fly.io uses for example

for their production environments

It's considered multi-tenant grade secure. Okay, and what about secrets API keys

passwords?

Good point for sensitive data like credentials windmill uses an encryption key

specific to each workspace to encrypt those secrets before storing them and they

also strongly recommend as a best practice

Encrypting the entire Postgres database itself for an extra layer. That's actually

what they do for their own cloud offering Wow

Okay, that sounds like a really solid approach to both performance and security

So let's bring it back to the practical side for someone listening may be thinking.

Okay, this sounds cool

I want to try it, but maybe they're intimidated by server setup

How easy is it to actually get started to just experiment or run a small internal

project, right?

And this is another area where windmill really shines, especially for learners or

smaller teams

It's designed to be incredibly easy to self-host easy self-hosting. Tell me more

for a quick start

Seriously, you can deploy the whole thing with just three configuration files using

Docker compose. It's literally a single command

No way. Yeah, you just need Docker running on your machine Mac Windows Linux

Whatever you grab the Docker dash compose dot AML a caddy file for networking and

in dot ENV file for settings from

Their github repo. Okay, then you just run Docker compose up DE in your terminal

and a voila as they say

It's up and running available right there at HTTP local host. That's it

That's basically it for a basic local setup

The default admin login is admin at windmill dev with the password change obviously

change that password

But you can log in and start building flows like within minutes

That is genuinely minimal setup for what sounds like maximum impact. It really

lowers the barrier now for more serious or production

Setups. It also supports kubernetes deployment using Helm charts and you can even

run it from pre-compiled binaries if you don't want to use Docker

So it scales up to oh, yeah

It's designed to scale from you know

Your laptop or a single virtual machine all the way up to large kubernetes clusters

managing potentially hundreds or even a thousand worker nodes

It can grow with your needs and for local development if I want to code scripts in

my own editor

They've got you covered there too. There's a powerful command line interface the CLI

and also a VS code extension

these let you sync scripts directly from files on your computer or your github repos

and

Test and run them locally against your windmill instance. It integrates into a

typical developer workflow quite nicely

Okay, one last crucial question on the practical side

Licensing it's open source. You said yes fully open source under the AGPL v3

license AGPL v3

Yeah, what does that mean for someone using it internally good question?

AGPL basically means if you modify windmill and then distribute that modified

version to others like offering it as a service

You generally need to share your modifications under the same AGPL license. It

ensures the core stays open

However, they also have what they call the community addition

This is what you get from the Docker images or the github binary releases

It actually includes some extra proprietary features built on top of the open

source core

ah, so there's a bit more in the easy-to-install versions exactly and

Importantly this community edition is free to use internally within your own

organization

Although there might be certain quotas on some of the advanced proprietary features

Okay, so if we're just building internal tools for my company, I'm generally good

to go

absolutely the main time you'd need a commercial license is if you are planning to

take parts of windmill and like

re-expose them as a core feature of your own commercial product that you sell to

others

But for simply using windmill internally to run your automations build your ui's

use its API's

No commercial license needed. It makes it super accessible for learning

Experimenting and just running your internal operations

It really sounds like they've put a ton of thought into lowering that barrier to

entry even though it's pretty comprehensive platform

That's a massive plus for you know, the learner

We talked about somebody who wants to experiment and build powerful stuff without

getting tangled in a massive scary setup

Definitely being able to go from zero to building flows in minutes is a game

changer

Okay, so let's zoom out again for you are curious listener hearing all this

What's the biggest takeaway? Why should windmill be on your radar right now?

What kind of real tangible impact could have on your journey with automation or

building internal tools?

Yeah, connecting it back to the bigger picture. I think windmill offers huge value

in a few key ways

Yes, like we said, it just significantly accelerates your development process the

speed factor again, right?

Imagine that critical report pipeline that used to take a week of coding testing

Maybe some basic UI with windmill because the UI is instant and the workflow part

is built in

Maybe that's a day or two instead. That's a serious difference

It is and it helps reduce that feeling of infrastructure sprawl where you have

scripts here scheduled tasks

There may be a separate UI tool it consolidates the one platform to rule them all

kind of maybe not rule but certainly simplify

Second that ability to auto generate you eyes and also build low code apps is

genuinely transformative

I think so it means people who aren't developers can easily interact with and

trigger potentially complex automations that you've built

It breaks down those silos between say

engineering and marketing or sales

Empowerment for other teams exactly. I've seen scenarios where like a simple button

on a windmill app

Let's the sales team generate their own custom reports instantly without needing to

file a ticket with engineering that saves everyone time and hassle

I can definitely see the value there and finally the open source aspect. That means

total transparency. You can see the code

there's a community contributing improvements and

You have the ultimate flexibility to self-host it customize it own your data own

your operations full control full control

Which is just invaluable, especially today

It's really about empowering you the user to build smarter faster and with much

more control over your technology stack

Okay

So for your final thought today something to chew on after this deep dive

Think about your own work your own projects or processes

What complex or slow or just annoying manual task?

Could you imagine turning into a one-click button or a fully automated workflow

using something like windmill?

Consider the possibilities that open up when scripting automation and UI building

aren't these separate difficult hurdles anymore

But they become integrated superpowers right at your fingertips. What could you

build then?

We really hope this deep dive into windmill has given you some valuable insights

and maybe spark some ideas

Until next time keep exploring and once again a huge

Thank you to safe server for supporting this deep dive and helping with your

You can find more information at www.safeserver.de

You can find more information at www.safeserver.de