TL;DR: <a href="https://zigflow.dev?utm_source=dailydev&amp;utm_medium=blog&amp;utm_campaign=intro" target="_blank" rel="noopener nofollow">Zigflow</a> lets you write Temporal workflows in YAML, so you can focus on what happens instead of how to make it reliable.
<hr>
<a href="https://temporal.io?utm_source=dailydev&amp;utm_medium=blog&amp;utm_campaign=intro" target="_blank" rel="noopener nofollow">Temporal</a> is one of those tools that feels like a superpower once it clicks. Durable workflows, automatic retries and crash recovery baked in.
But getting there can feel heavy.
Since I joined Temporal last April, I’ve really seen first-hand how it helps engineers make their application bullet-proof whilst writing less code.
Last summer, I had a week of customer calls where a common pattern kept repeating. The whole week, I heard some version of the same thing:
<blockquote>
Temporal is great for developers, but we want our business users to be able to define workflows. Is there a DSL we can use?
</blockquote>
They loved Temporal for its durability and reliability, but they didn’t want every workflow change to require an engineer, a code review and a deployment. For them, the workflow wasn’t the complexity, but the implementation was.
That tension was the spark for <a href="https://zigflow.dev?utm_source=dailydev&amp;utm_medium=blog&amp;utm_campaign=intro" target="_blank" rel="noopener nofollow">Zigflow</a>.
<h2>Temporal is powerful, but there is a learning curve</h2>
Temporal workflows are just code, but not necessarily normal code. Workflows are replayed. You have to understand determinism (and non-determinism). Things that once felt natural have to be reconsidered.
For experienced Temporal users, that’s fine. It can even feel elegant.
For newbies, it’s a whole new paradigm.
Also, most workflows aren’t algorithmically complex:
They’re sequences.
They branch.
They wait.
They call services.
They loop.
They retry.
Most workflows aren’t complex in what they do - they’re complex in how they’re made reliable.
<h2>Enter Zigflow</h2>
<a href="https://zigflow.dev?utm_source=dailydev&amp;utm_medium=blog&amp;utm_campaign=intro" target="_blank" rel="noopener nofollow"><img src="https://media.daily.dev/image/fetch/s--qIiB37dn--/f_auto,q_auto/https://simonemms.com/img/blog/zigflow.png?_a=BAMAMiiu0" alt="Zigflow"></a>
<a href="https://zigflow.dev?utm_source=dailydev&amp;utm_medium=blog&amp;utm_campaign=intro" target="_blank" rel="noopener nofollow">Zigflow</a> is a declarative DSL for Temporal workflows.
Instead of writing your workflow code directly, you describe your workflow in YAML. Zigflow turns that description into a real Temporal workflow with retries, durability and all the usual Temporal guarantees.
Think of it as a way to start simple with Temporal, without painting yourself in a corner.
You get all the reliability, observability and scalability without having to think about the sharp edges on day one.
A DSL (domain-specific language) is a specialised language, focused on the problem. Rather than inventing yet another DSL, Zigflow builds on the CNCF’s <a href="https://serverlessworkflow.io" target="_blank" rel="noopener nofollow">Serverless Workflow</a> specification - a vendor-neutral standard designed for exactly this problem.
<h2>Show me the money</h2>
If you’ve gotten this far, you’ll want to see how it all works.
<pre><code class="language-yaml">document:
 dsl: 1.0.0
 namespace: zigflow
 name: hello-world
 version: 1.0.0
do:
 - set:
 output:
 as:
 data: ${ . }
 set:
 message: Hello from Ziggy
</code></pre>
This isn’t pseudo-code, but a full Temporal workflow ready to receive triggers.
Run this with the Zigflow CLI (<code>zigflow -f ./workflow.yaml</code>) and you’ve got a running Temporal workflow. Trigger this from the Temporal UI (task queue: <code>zigflow</code> and workflow type: <code>hello-world</code>) and you’ll see the response:
<pre><code class="language-json">{
 &quot;data&quot;: {
 &quot;message&quot;: &quot;Hello from Ziggy&quot;
 }
}
</code></pre>
The goal of Zigflow isn’t low-code for the sake of it, but to allow you to focus on what the workflow does. And you get the added bonus of Temporal best practices.
<h2>Best practices as guardrails</h2>
As a workflow grows, Temporal concepts start to matter:
<ul>
<li>Histories get long, so you need Continue-As-New</li>
<li>Activities get slow, so you need heartbeats</li>
<li>You want visibility, so you need search attributes</li>
</ul>
Zigflow bakes all these ideas in from the start, so you don’t need to learn them upfront. You still benefit from them, but they’re implemented as sensible defaults so you only need to know about them when they matter.
And if you know Temporal already, Zigflow becomes a way to standardise and accelerate workflow creation.
<h2>Written in Go. Not locked to Go</h2>
Zigflow is written in Go, but the workflows it runs are just Temporal workflows.
That means they’re language-agnostic by nature.
You can trigger them from TypeScript, signal from the Temporal UI, query from Python and update from Java.
<h2>Why you might want to try it</h2>
<ul>
<li>You’re curious about Temporal, but put off by the learning curve</li>
<li>You want to prototype workflows fast</li>
<li>You like the idea of workflows being readable by humans</li>
<li>You’re building tooling or platforms on top of Temporal</li>
</ul>
If any of this resonates, Zigflow is worth a look:
<ul>
<li>👉 Docs: <a href="https://zigflow.dev?utm_source=dailydev&amp;utm_medium=blog&amp;utm_campaign=intro" target="_blank" rel="noopener nofollow">zigflow.dev</a></li>
<li>👉 Code: <a href="https://github.com/mrsimonemms/zigflow" target="_blank" rel="noopener nofollow">github.com/mrsimonemms/zigflow</a></li>
</ul>
If you try it and like it, please add a GitHub star. I know it’s a bit of a vanity-metric, but it’s great seeing feedback from people who are using it. And that motivates me to keep building.
This is just the beginning and I’ve got so many ideas about new features (including a drag-and-drop UI). If this resonates, try it out. And I’m planning a follow-up post diving into these ideas.
And let me know what you build.

Simon Emms

Zigflow is a YAML-based DSL for Temporal workflows that eliminates the learning curve by letting you define workflows declaratively. Built on the CNCF Serverless Workflow specification, it provides all of Temporal's durability and reliability guarantees while baking in best practices like Continue-As-New and heartbeats as defaults. The tool addresses a common need: enabling non-engineers to define workflows without requiring code changes and deployments, while still leveraging Temporal's powerful orchestration capabilities.

Zigflow: The Missing Temporal DSL