How do you make progress when you don’t know the destination?
When I start a new CAD design, I begin with a sketch.
And that sketch begins with a single line.
Over the years, I’ve noticed something uncomfortable:
no matter how much time I spend thinking about that first line, it’s always wrong.
I only discover how it’s wrong after I’ve built the rest of the design around it.
Changing that line later is painful.
It cascades. Dimensions shift, constraints break, and suddenly everything depends on a decision I made before I knew what mattered.
But there’s no way around it.
I can only know how to draw the first line after drawing the whole thing.
When I started writing my blog, I didn’t know if I’d keep doing it — or what a good writing setup would even look like.
So I wanted to start with something simple.
At first, I thought I might write on paper and then type it up, but that felt slow and clunky.
I wanted something I could use both at my desk and when I was out walking, so it needed to sync to the cloud.
Since I already used Google Keep for other notes, that’s where I began.
At first, I had a single note for post ideas — just titles.
When I started writing one, I’d make a new note for it.
Over time, I wanted to add more detail to each idea.
So it became one note per post.
While working on one post, I’d often have ideas for two or three more.
It was an explosion of ideas, and an explosion of notes.
This worked surprisingly well. I wrote around thirty posts like this.
Eventually, though, I ran into a new problem.
I could capture ideas easily —
but I couldn’t see which ones to work on next.
Some posts had been published, some were in progress, others half-written.
I found myself rummaging through notes, trying to work out where I was.
I wasn’t short of ideas.
I was drowning in them.
So I added structure.
I’m a Scrum Master, but writing with full Scrum would have been overkill.
Something like Kanban, though, felt right.
What I really wanted was to assign states to my notes.
In the end, I settled on Trello.
In Trello, you create cards and organise them into lists that represent states — usually To Do → In Progress → Done.
Each card could be a post, and the lists could be the stages of writing.
Of course, the scrum master in me didn’t stop at three stages.
I ended up with eleven. Excessive?
Probably.
But I like knowing exactly where everything is.
It might sound ridiculous, but that level of granularity helped.
Even if I didn’t write for a few days, I could open Trello and instantly see where I was.
Trello solved the organisation problem.
It was free, cloud-synced, and supported Markdown.
I wrote forty-five posts using it.
But Trello was never really designed for writing — and it showed.
There was a 16k character limit, and the editing window was tiny.
Writing felt like peering through a letterbox.
I had structure.
But the writing experience was painful.
I tried a few other card-and-list tools.
Every single one was worse.
One day, when I was seriously considering getting a Jira license,
it hit me:
Do I really need a full ticketing system?
These systems are built for teams.
They come with multi-user support, checklists, calendar reminders —
all functionality I didn’t actually need.
What I really wanted was much simpler:
cards containing Markdown content,
and a way to move them between states.
That didn’t require a platform at all.
It could just as easily be done with Markdown files and folders.
Each post could be a file.
Each state a folder.
It was a much lower-tech solution — and much more flexible.
It wasn’t one tool anymore, but a few working together.
In return, I got the choice and control I’d been missing.
So I created eleven folders — one for each state.
Each post is a Markdown file that lives inside a folder.
I use Google Drive to sync the files, which means I can use whatever Markdown editor I want.
Right now, that’s Obsidian.
Not because it’s perfect, but because it’s nice to write in.
Setting this up took some effort.
But this time, it felt justified.
I wasn’t guessing anymore.
I knew what I needed because I’d learnt from the earlier versions.
I’ve been writing like this for a while now, and it’s been good.
Not perfect, but the structure is there when I need it, and invisible when I don’t.
I spend less time fighting the system, and more time writing.
Of course, I still notice things I could improve.
I always do.
But those changes are smaller now, and more specific.
Over the last year, I’ve used three different writing environments.
Does that mean the earlier ones were bad?
No.
When I began, I didn’t know if I’d keep writing — or what a “good” environment would even look like.
You can’t design something when you don’t yet know what you need.
The only way to find out was to try.
Each version solved the problems of the one before it.
Each step made the next one clearer.
Over time, the painful parts got smaller and the improvements less dramatic.
Not because there was nothing left to improve, but because the biggest problems were already solved.
I didn’t arrive at a perfect setup.
I arrived at one that fits the way I actually work,
because I learned from each step.
I didn’t need to know the destination.
I just needed to make it better, one step at a time.
It’s a bit like climbing a hill in thick fog.
You can’t see the top, and there’s no map.
You can only feel the slope beneath your feet.
So you take a step uphill, pause, and notice what’s changed.
Each move gives you a little more information about where to go next.
You don’t need to see the summit to make progress.
It’s how I write too.
I start with an idea and a rough direction, but not the exact path.
Each sentence, edit, or draft brings the words closer to the idea.
I don’t need to know exactly where I’ll end up.
I just need to keep taking the next step.
And often it’s only when I reach the end,
when I climb out of the clouds,
that I finally see the whole view.
Davide la Locomotive 
Leave a comment