Ever feel like you spend more time formatting a blog post than actually writing it? You’re not alone. According to a 2024 survey by ConvertKit, creators spend an average of 8 hours a week just on formatting, publishing, and other repetitive content tasks. That’s a full workday of pure drudgery. But what if you could cut that down to almost zero? This guide shows you a free, no-code system to automate your content formatting and publishing, saving you over 5 hours a week. No subscriptions, no coding, just a smarter workflow.
Introduction: The Hidden Time Sink of Manual Formatting
You can automate content formatting and publishing using free no-code tools like Make and Obsidian. This guide shows you how to set up a workflow that transforms raw notes into a formatted blog post, complete with images and SEO metadata, and publishes it to your CMS automatically, saving over 5 hours per week.
Think about your last blog post. You probably wrote the draft, then spent time adding headings, tweaking the layout, finding a featured image, writing the meta description, and finally hitting publish. It’s a slog. That manual process eats into the time you could spend on creating new ideas or engaging with your audience. The good news? You can automate almost all of it with a setup that takes about 30 minutes. Let’s get that time back.
- Time your next formatting session to see exactly how many minutes it takes.
- Pick one repetitive task you hate (like adding image alt-text) to automate first.
- Create a new folder on your computer called “Automation Project” to get started.
Your Free, 3-Tool Automation Stack
Forget expensive SaaS subscriptions. The entire system runs on free or generous freemium tiers. Here’s your $0 automation stack:
- Obsidian: A free, powerful note-taking app. You’ll write your raw content here using simple Markdown (like # for headings). It stores everything as plain text files on your computer, which is perfect for automation.
- Make (formerly Integromat): This is the automation brain. Its free plan gives you 1,000 “operations” per month. You’ll use it to watch your Obsidian folder, format the text, and send it to your blog.
- Your CMS (Ghost or WordPress.com): Both have free tiers for hosting a blog. They also provide APIs, which is just a fancy way of saying a door that lets apps like Make publish to them automatically.
Imagine the flow: You finish writing in Obsidian -> Make notices the new file, styles it, and adds an image -> It pushes the polished post as a draft to your Ghost blog. One action triggers the whole chain.
- Download Obsidian (it’s free) and create a vault for your content.
- Sign up for a free Make account.
- Ensure your blog (Ghost/WordPress) is set up and you know how to find your API keys in the settings.
Steps
Here’s the exact, step-by-step playbook. Follow along and you’ll have a working automation by the end.
Step 1: Structure Your Raw Content in Obsidian
The magic of automation needs consistency. You can’t just write a freeform essay and expect a robot to format it perfectly. Instead, you’ll use a simple template in Obsidian. Think of it as giving your future self—and the automation—clear instructions.
Create a new note and structure it like this:
# My Automated Blog Post Title  Here is the introduction to my post. It's engaging and hooks the reader. ## The First Main Point - This is a key takeaway. - Here is another important bullet point. - And a third one for good measure. ## Wrapping Up That's all for this automated post. Pretty neat, right?
See the `![[header-image]]`? That’s a special Obsidian link that acts as a placeholder. Your automation will later replace it with an actual image URL. The key is to use the same structure every time: H1 for title, a placeholder for the image, then your content with H2s and bullet points.
- Open Obsidian and create a new note using the structure above.
- Practice writing a short post using only #, ##, and – for lists.
- Save this note as “Blog_Template” in a dedicated “Templates” folder.
Step 2: Build the Automation in Make (Formerly Integromat)
Now for the fun part: building the robot. In Make, you create a “scenario”—a visual workflow of connected apps. Don’t worry, it’s all click-and-drag. Here’s what the scenario will do, step-by-step:
- Watch a Folder (Obsidian): Make can’t directly watch your computer, but it can watch a cloud folder. The easiest workaround is to use the “Obsidian URI” community plugin to trigger a webhook—a digital doorbell—when you’re ready to publish. For simplicity, let’s assume you’re using a cloud-synced folder (like Dropbox) for your Obsidian vault. The first module in Make will be “Watch for Files” in that specific folder.
- Parse the Text: The next module takes the raw text file and breaks it apart. You’ll use Make’s “Text Parser” tool to find the title (the text after the first #), the body, and that image placeholder.
- Format & Enhance: This is where you add the polish. You can set up modules to:
- Generate a meta description from the first 150 characters of your intro.
- Replace the `![[header-image]]` placeholder with a real image URL. You could even connect to the Unsplash API to fetch a free stock photo based on your post’s title—all automatically.
- Wrap your content in proper HTML tags if your CMS needs it.
- Publish to CMS: The final module is the “WordPress” or “Ghost” app in Make. You’ll connect it using your site’s API key (found in your CMS settings under “Integrations” or “API”). You tell it to “Create a Post,” mapping the parsed title to the title field, the formatted body to the content field, and setting the status to “Draft” for final review.
Start simple. Your first scenario should just take the title and body and publish it. You can add fancy image fetching and SEO later.
- Log into Make and create a new scenario.
- Add the “Watch for Files” module and connect it to your cloud-synced Obsidian folder.
- Add the “Text Parser” module and play with the “Match Pattern” tool to grab your H1 title.
Step 3: Test and Deploy Your One-Click Publishing Flow
Time to see if it works. The best way to test is with a dummy post. Create a new note in your Obsidian folder called “test-post.md” using your template. Write a simple title and a sentence or two.
In Make, run your scenario once. It will process that test file. Then, check your blog’s dashboard. You should see a new draft post with your title and content. If it’s not there, don’t panic. The most common issues are:
- API Key Error: Double-check the API key and secret in your Make module. Ensure there are no extra spaces.
- Path Error: Make might be watching the wrong folder. Verify the folder path in the “Watch for Files” module.
- Parsing Error: If the title is blank, your Text Parser pattern might not match your Markdown exactly. Adjust the pattern.
Once it works, you’ve reached the promised land. Your new workflow: Write in Obsidian. When you’re done, you move the note to a specific “Ready-to-Publish” folder (which Make is watching), or you use a keyboard shortcut with the Obsidian URI plugin to trigger the webhook. The rest happens automatically. You go from raw notes to a formatted draft in under a minute.
- Create and run a test with a dummy file called “test-post.md”.
- Check your blog’s draft posts for the result.
- Schedule your scenario to run every hour, or keep it manual for now.
Real-World Example: Automating a Weekly Newsletter Blog Post
Let’s make this concrete. Meet Alex, a solo creator who writes a weekly industry recap for their audience. Every Friday, Alex used to:
- Write the recap in Google Docs (15 min).
- Copy and paste it into WordPress (5 min).
- Format headings, add links, and fix broken formatting (20 min).
- Find and upload a featured image (10 min).
- Write the SEO title and meta description (10 min).
- Schedule the post (5 min).
Total: About 65 minutes of non-writing work. After setting up the automation with Obsidian and Make, here’s the new Friday:
- Write the recap in Obsidian using the template (15 min).
- Move the note to the “Publish” folder. The automation runs, formatting the text, pulling in a relevant Unsplash image based on the title, and publishing it as a draft to WordPress with a basic meta description.
- Alex logs into WordPress, gives the draft a quick once-over, and hits “Schedule.” (5 min).
Total hands-on time: 20 minutes. Alex saved 45 minutes per week, or about 3 hours a month, without writing a single line of code. The system uses about 30 of Make’s 1,000 free monthly operations, leaving plenty for other tasks.
- Map out your own weekly content task. How many minutes are pure formatting/publishing?
- Identify one step (like image sourcing) that could be fully automated.
- Think of a simple, recurring post type (like a link roundup) that would be perfect to test this on first.
Advanced Tweaks and Time-Saving Templates
Once your basic flow is humming, you can add bells and whistles. Why stop at just publishing? Here are a few ways to level up your automation:
- Auto-Social Snippets: Add a branch to your Make scenario that takes the first paragraph of your post and auto-publishes it to a Twitter/X draft or a Buffer queue, with a link back to the full article.
- Multi-Platform Publishing: Use a router in Make to send the formatted content to both your blog and a platform like Medium or Substack, slightly tweaking the format for each.
- SEO Title Generation: Instead of just using your H1 as the SEO title, use a Make module to generate a more clickable version with a tool like the “SEO Title Generator” API from Seobility (they have a free tier).
The best part? You can share these workflows. Make lets you export your scenario as a blueprint. You can also create a more detailed Obsidian template with frontmatter (like tags, categories, and author name) for the automation to read.
Automation is a muscle. Start with one simple workflow, get it working, and then add complexity one piece at a time.
- Explore the “Router” tool in Make to create conditional paths (e.g., if post has “newsletter” tag, also send to email service).
- Look up the API documentation for Unsplash or Pexels to see how to fetch free images automatically.
- Export your working Make scenario as a backup before you start tweaking it.
FAQ
Do I need to know how to code for this?
Absolutely not. This guide uses entirely no-code, visual tools. You’ll be clicking and dragging modules in Make, not writing a single line of code. The only “technical” step is copying an API key from your blog’s settings into Make.
What if my CMS isn’t Ghost or WordPress?
No problem. Make supports hundreds of apps, including Webflow, Squarespace, and Shopify. The process is identical: your CMS just needs to have an API. Check Make’s app list to see if your platform is there. The steps are the same—watch a folder, parse text, send to the CMS app.
Is the free tier of Make really enough?
Yes, for a solo creator. The free plan offers 1,000 operations per month. This publishing workflow uses about 30-40 operations per post (depending on complexity). That allows for about 25-30 automated posts per month, which is more than enough for most individual creators publishing weekly or even daily.
How do I handle images automatically?
You use a placeholder in your note (like `![[header-image]]`). In Make, after parsing your text, you add an “HTTP” module to call a free stock photo API like Unsplash. You can send your blog post title as a search term, and the API returns a relevant image URL. Then, you replace the placeholder with that real URL before publishing.
References
- ConvertKit 2024 Creator Survey – Source for time-spent statistic.
- Make Pricing Page – Details on free tier operations.
- Ghost API Documentation – For connecting your Ghost blog.
- WordPress REST API Handbook – For connecting your WordPress site.