How it works
Closed-loop content — from brief to live page.
Content that never ships is just a draft. Unpushed runs the whole stretch: prioritize what to write from Search Console, research, and Google Notebook, draft it, approve it, push it live, check the real page, then use what you learn for the next piece — one site or many.
Request access
The content loop
This is the core. Not a separate “content tool” bolted onto hosting — the same loop that publishes a new page also refreshes a ranking URL and proves both landed.
01
See what to write
Priority comes from Search Console, topical research, and what you’ve grounded in Google Notebook — not from whoever shouted last in Slack.
02
Brief and draft
Lock what “done” looks like, generate the page, and keep an owner on it. Drafts live on a preview you can actually read.
03
Approve and ship
You sign off on the preview. Unpushed pushes it live — same path for a refresh, a new article, or a whole new site.
04
Check, then write again
Confirm the real page matches what you approved, watch traffic after, and feed what you learn into the next slot.
Priority is ordered by traffic impact and coverage gaps — GSC when you have history, research when you don't, Notebook notes when you need a grounded angle. Then the same stages take a title refresh, a new guide, or a parked domain live. Nothing sits “almost published” with a vague status.
How content gets prioritized
The calendar is not a gut call. Three inputs decide what rises — your own search performance, market research when history is thin, and source-grounded notes from Google Notebook.
Google Search Console
Once the site is connected, GSC is demand truth on your own URLs — impressions, clicks, and queries that already move. Pages that slip, queries with no page, and traffic worth protecting rise to the top of the list.
Research
When a site is new or GSC is still thin, topical research maps the demand you should cover — seeds expand into a topic map and candidate pages so the calendar isn’t empty while you wait for history.
Google Notebook
Grounded notes from Notebook (competitor pages, briefs, source packs you trust) sharpen the brief: what’s already covered, what’s missing, and what “done” should mean before a draft starts.
How they stack. Search Console wins once the locale has real history — it is your live demand truth. Research fills the cold start and keeps the map honest when GSC is quiet. Notebook sharpens the brief so the next slot isn't generic: you write the gap the sources actually leave open.
What comes out is a to-do with a URL (or a new page to create), an owner, and a clear “done” — ordered by the traffic it protects or unlocks, not by which tool shouted last.
One piece of content, end to end
Closed loop means the work doesn't stop at “draft ready.” It closes when the live page matches the brief — and opens again when priority sources say what to write next.
Prioritize the gap
GSC shows what’s earning or slipping. Research fills cold-start coverage. Notebook notes pin the angle. Together they answer what to write next — not “publish more.”
Brief it
What the page should say, who it’s for, and what “done” means — before anyone writes a line.
Draft it
Generate or revise the page on a branch with a preview URL. You read the page, not a ticket description.
Ship it
Approve, push live, keep a way back. Content isn’t done when the doc is finished — it’s done when visitors see it.
Check it stuck
Unpushed re-reads the live page, then watches impressions and clicks. Misses reopen as work; wins reshape the next priority.
Under the hood
After you're in, Unpushed reads hosting, your repo, and Search Console through familiar connections. Research and Google Notebook feed priority and briefs so the calendar and the live site stay one picture.
Cloudflare
DNS, edge, and the path a content change takes to the live site
GitHub
The repo of record behind every draft, preview, and push
Google Search Console
Live search truth on your URLs — the backbone of content priority once history exists
Inside the loop
A content item does not become a live page until it is tied to a URL, a person, and what done looks like. Step through the stages below to see the same record change as it moves: each stage adds the fields the next one depends on.
What needs work
Your tools and your own eyes surface what to fix next. Duplicates collapse, noise gets closed, and what's left is tied to a site and a URL.
- +Problems arrive from connected tools and what you spot yourself
- +Duplicates across sources collapse into one item
- +Every item is pinned to a site and an exact URL or pattern
Exit: Leaves when the problem is real, unique, and tied to a URL
The record
created
- site
- hosting-guide.dev
- url
- /guides/hosting
- state
- unpushed
- source
- tools + your eyes (deduped)
- priority
- —
- owner
- —
- done_means
- —
- preview_url
- —
- rollback_point
- —
- checked_on
- —
Verification after the push
A green “published” in the CMS is not proof. Unpushed checks the change on the real page, then watches traffic after so the content closes with evidence — and the next brief starts from what actually happened.
Read the real page
After the deploy settles, Unpushed fetches the live page itself — not the preview, not the CMS record, not a screenshot from last week.
Compare to what "done" meant
The brief had a clear “done.” Unpushed checks title, body claims, status codes, and redirects against that — so a publish isn’t a shrug.
Watch traffic after
Impressions, clicks, and Core Web Vitals for the URLs you touched are tracked past the push. Regressions and wins both become the next content work.
Keep a way back
Every push has a recorded previous state. If the live site disagrees, roll back in one move and the item reopens for another draft.
If the live site disagrees with what you signed off, the item reopens and the previous version is one click away. Unpushed does not celebrate the push — it celebrates the check on the real page.
Proof, not promises
See a content change checked on the live page.
Every check, every failure reason, every way back — on the real page, not in a publish dialog.
What happens when it fails
A check fails
The checklist shows exactly what failed, what you expected, what showed up, and where. The draft stays in preview — nothing half-publishes.
A push fails after the check
If the real page disagrees with what you signed off, the item reopens and the previous version is one move away. The content list knows.
Noise gets closed
Not every alert needs a new page. Duplicates and dead ends get closed with a reason, so the calendar stays honest.
Ownership changes
A brief can move owners anytime. History keeps who briefed it, who approved the draft, and who pushed it live.
Who it is for
Unpushed is built for people who own content after launch — one site or many. If you prioritize from Search Console, research, and Notebook notes, then need publishing to keep moving without losing the live site, this is the loop: prioritized gap → brief → live page → proof → next slot.
It is not a replacement for your CMS, your hosting, or your analytics. Unpushed sits across the tools you already use so a content brief becomes a checked change on the real page. The tools stay where they are. The writing gets a path that closes.
Fits your setup
One site or many — same content loop.
Keep your stack. Unpushed gives every page a path from brief to shipped to checked.
Last call
Free to look. Pay when work ships.
Looking at what needs attention is free. You pay when content ships.