A Writing Workflow for the Blog
The blog is running, drafts can be published, Cloudflare builds reliably. What’s missing is the core activity: writing.
Over the past few weeks I’ve tried different ways to create a post, and learned one thing: the question of how can only be answered once the what is clear. Otherwise you swap tooling every two weeks and still don’t write a post.
This post is about the requirements I have for my workflow, the options I evaluated, and the decision I landed on.
1) Requirements for My Workflow
Before I compare tools, I need a yardstick. A workflow for this blog should:
- work bilingually, creating DE and EN bundles in one step
- minimize friction (one command, not five)
- behave identically locally and in the cloud
- play well with Git and version control
- keep drafts clearly separated from published posts
- be usable from any editor
It should not be a CMS, offer no WYSIWYG interface, and avoid any dependency on an external service. Anything that is not in Git does not exist for me.
2) Option A โ Directly in the Editor
The simplest variant: create two files in the editor, copy front matter from an existing post, start typing.
Upsides: no learning curve, no extra tooling, full control over every line.
Downsides: every repetition is a potential source of error. You forget a front matter field, name the slug inconsistently, or create only the German file and never follow up with the English one. The bilingual pairing happens in your head, not in the tool.
Workable for a one-off post. Too fragile for a blog I want to maintain long-term.
3) Option B โ hugo new content
Hugo ships with a built-in CLI that creates a new content file from an archetype.
hugo new content posts/my-post/index.md
The archetype under archetypes/posts.md defines which front matter gets pre-filled. The result is a file with a consistent skeleton, without copying lines around.
Upsides: official, well documented, zero external dependencies.
Downsides: the command creates only one file. For my bilingual structure I would have to run it twice and build the English bundle by hand around it. The publish step (draft to false, commit, push) is out of scope.
Good as a building block, too incomplete as a workflow.
4) Option C โ make draft
The third option is a Makefile target that calls a shell script under the hood:
make draft SLUG=my-post
The script creates the bundle: content/posts/my-post/index.md and content/posts/my-post/index.en.md, both with correctly pre-filled front matter and draft: true.
On top of that, there is make publish (flips draft: false) and make push (commit and push). The three targets together cover the lifecycle.
The key point: the same scripts run in GitHub Actions. There are no two truths โ the logic lives in one place and is called by both the Makefile and the workflow.
Upsides: one command for setup, one for publish, consistent bundles by construction, no logic duplication between local and online.
Downsides: the scripts have to be built and maintained. For a generic Hugo blog that would be overkill; for my specific bilingual case it fits.
5) Option D โ GitHub Actions Web UI
Option C has a twin in the browser. Under Actions โ Create Draft Post / Publish Draft Post, the same scripts run directly from the GitHub web interface. Enter a slug, click Run workflow, done โ the bundle is created, committed, Cloudflare builds.
The nice thing is that the actions run the same code as the local Make targets. I don’t have to wonder whether a draft created online looks different from a local one. It doesn’t.
What I use it for: when I’m at someone else’s machine, have no repo cloned, or am just lazy. The web UI is unsuitable for actual writing, but for creating a placeholder post while an idea hits me on a walk, it’s enough.
6) Decision
make draft is the main path.
Three reasons: first, it maps exactly to my bilingual structure, with no mental arithmetic. Second, it avoids logic duplication โ the shell script is the single source of truth, whether local or in the cloud. Third, it is simple enough to read and extend in ten minutes, and capable enough to save me work.
hugo new content stays as a backup in case I ever need a single post outside the bundle structure. Option D steps in when I can’t reach the terminal.
7) My Workflow in Practice
A typical post cycle for me looks like this:
- Capture the idea (Obsidian, notepad, anywhere)
- At the desk:
make draft SLUG=new-post - The editor opens the DE bundle, I start writing
- Keep
hugo server -Drunning in parallel to see drafts live - Pull the English version along in the same bundle
make publish SLUG=new-postflipsdraft: falsemake push MESSAGE="Post about X"commits and deploys
On the road the same thing runs via Working Copy plus the GitHub Actions web UI. The workflow is robust enough to work either way, and simple enough that I don’t have to relearn it after two weeks off.
Conclusion
The workflow is a tool, not an end in itself. Every minute I spend tuning tooling is a minute less spent writing.
make draft won for me because it hits my requirements most precisely โ not because Makefiles are inherently superior. For a different blog with a different structure, the right answer might be hugo new content or a CMS.
The only thing that matters is that the friction of starting a post eventually drops to near zero. Then the question “how do I start?” stops being an excuse.