When we started building JustBlogged, we initially thought a lot about the writing experience.
- How should the editor feel?
- How quickly should content update?
- What should the interface look like?
But as we started talking to people who actually publish content, another problem kept appearing:
- Writing isn't necessarily the hardest part.
- The workflow after writing can be.
- The Publishing Pipeline
A typical workflow might look something like:
Idea
↓
Write
↓
Format
↓
Clean up
↓
SEO
↓
Generate slug
↓
Preview
↓
Publish
Each step is manageable.
The problem is that they often happen across different tools.
For a developer, this is an interesting product problem because the challenge isn't simply implementing another feature.
It's reducing unnecessary context switching.
Why We Care About This in JustBlogged
JustBlogged is being built around a simple idea:
The distance between having an idea and publishing it should be smaller.
That doesn't mean every possible blogging feature belongs inside one application.
In fact, we're actively trying to avoid that.
An "all-in-one" product can easily become another complicated dashboard.
Instead, we're looking at the parts of the publishing workflow where users repeatedly experience friction.
Example: URL Slugs
One small example is URL generation.
A writer might have a title like:
How to Build a Better Content Workflow for Your Blog
A clean slug could become:
how-to-build-a-better-content-workflow
It's a tiny task.
But it's also a task that happens repeatedly.
So we built a free Slug Generator as part of our creator tools:
https://justblogged.com/tools/slug-generator
The interesting part isn't the slug algorithm itself.
It's deciding where that functionality belongs in the overall workflow.
Product Engineering Isn't Just Code
This has changed how we think about engineering decisions.
It's easy to ask:
"Can we build this?"
The more useful question is:
"Should this exist in the workflow at all?"
And then:
"If it should exist, where can we put it so the user doesn't have to think about it?"
That distinction matters.
A technically impressive feature can still make a product worse if it introduces another decision or another step.
What User Feedback Changed
We've also started asking different questions when talking to creators.
Instead of:
"What features would you like?"
We're more interested in:
"Tell us about the last time publishing was frustrating."
That produces much more useful information.
People describe what they actually did.
Maybe they copied content between tools.
Maybe they manually fixed formatting.
Maybe they spent time preparing SEO information.
Maybe they simply postponed publishing because the process felt tedious.
Those behaviors tell us much more than a hypothetical feature request.
What We're Building
We're continuing to build JustBlogged around this idea:
Make publishing simpler without making the product simplistic.
That means improving the writing experience, reducing publishing friction, building useful creator tools, and paying close attention to what real users actually struggle with.
We're still early.
And that's exactly why we're sharing the process.
If you're building a blogging platform, CMS, documentation tool, or anything involving content workflows, I'd love to hear:
What's the most annoying part of your publishing pipeline?
And if you'd like to see what we're building:
Top comments (0)