Writing an article takes a day. Sharing it properly takes another 40 minutes: a short version for X, a longer one for LinkedIn, a helpful post for the Facebook group where your readers hang out, maybe a script for a Short. So most solo builders paste the link with “New post!” and move on, and the group moderator deletes it by lunch.
Those communities matter more than they look. Before LeverSolo launched, a check of 10 buying-intent searches in this niche found a forum thread ranking in the top two results for 9 of them. The places where your readers ask questions are also the places Google sends them.
This guide builds the boring half of distribution as an automation. Your site sends a webhook when a post goes live, an LLM drafts one version per channel, the drafts land in a Google Sheet or Notion table, and you approve them. Posting to LinkedIn on a schedule is optional. Everything is priced against Make’s and n8n’s own billing rules.
The short answer
- Trigger on a publish webhook, not an RSS poll. On Make, polling a feed every 15 minutes costs about 2,880 credits a month before a single draft is written. The webhook version of this pipeline costs about 110 credits a month at eight posts.
- Make the LLM return strict JSON with a character budget per channel. Every draft has to deliver its point without the click. The link goes last, as a reference.
- Approve every draft yourself. Post to X and to communities by hand. If you want any scheduled posting, limit it to LinkedIn through the official app modules.
- Make Free covers it. Pick n8n if you already run it or want approval buttons in your inbox.
The pipeline at a glance
| Stage | What happens | In Make | In n8n |
|---|---|---|---|
| 1. Trigger | Your site sends the new post’s title, URL, and text | Custom webhook | Webhook node |
| 2. Draft | An LLM writes four drafts as one JSON object | HTTP module calling your LLM’s API | An LLM node or HTTP Request node |
| 3. Store | One table row per draft, status “Draft” | Google Sheets or Notion module | Google Sheets or Notion node |
| 4. Notify | You get a message that drafts are waiting | Email module | Send Email node |
| 5. Approve | You edit the draft and set status to “Approved” | You | You, or an Approve button in email |
| 6. Post (optional) | Approved LinkedIn rows go out on a schedule | LinkedIn “Create a User Text Post” | LinkedIn node, Post > Create |
The four channels in this build are X, LinkedIn, a Facebook group or forum post, and a 45-second video script. Swap any of them for the channels you actually use.
Why every draft waits for you
Two sets of rules make fully automatic posting a bad bet: the platforms’ automation rules and each community’s own rules. A third problem is plainer. An LLM summarizing your article will sometimes get a number wrong, and you don’t want that number posted under your name.
X. X’s developer guidelines (checked November 9, 2026) list scheduled informational posts from an automated account as acceptable. The same page bans identical or near-identical content across accounts, unsolicited automated replies and @mentions, and posting into trending topics for visibility. It also says AI-generated replies need X’s approval before deployment. One account posting a fresh, human-approved summary of its own article stays well inside those lines.
LinkedIn. Section 8.2 of the LinkedIn User Agreement (effective November 3, 2025) bars using “bots or other unauthorized automated methods” to create, comment on, like, or share posts. The Make and n8n LinkedIn modules connect through LinkedIn’s own sign-in and API, which is a different thing from a browser script clicking “Post”. Keep the volume human anyway: one post per article.
Communities. Facebook groups, forums, and subreddits set their own rules, and many remove posts whose main job is sending traffic somewhere else. Some allow links only in a weekly thread. An automation can’t read the pinned rules or notice that last week’s thread already answered the question. You can, in about a minute.
So the pipeline stops at a draft in a table with status “Draft”. You change that status, and you press Post.
Webhook vs polling: the credit math
On Make, a trigger module uses one credit every time it runs, even when it finds nothing new (Make Help Center, checked November 9, 2026). A webhook only runs when you publish. That difference decides whether this pipeline fits the free plan.
| Trigger | Runs per month | Credits used before any drafting |
|---|---|---|
| RSS check every 15 min (the Free plan’s shortest interval) | 2,880 | 2,880 |
| RSS check every hour | 720 | 720 |
| RSS check once a day | 30 | 30, but drafts can arrive up to a day late |
| Publish webhook, 8 posts a month | 8 | 8 |
Make’s Free plan has 1,000 credits a month. The 15-minute poll alone would need a paid plan.
The full monthly cost on Make looks like this. Assumptions: 8 posts a month, four drafts per post, one table row per draft.
| Module | Credits per post | Per month |
|---|---|---|
| Webhook trigger | 1 | 8 |
| HTTP call to your LLM’s API | 1 | 8 |
| Parse JSON | 1 | 8 |
| Add a row, four times | 4 | 32 |
| Email to you | 1 | 8 |
| Drafting scenario total | 8 | 64 |
| Optional LinkedIn scheduler: one search per day | 30 | |
| Optional: post plus row update, per approved LinkedIn draft | 2 | 16 |
| Everything | about 110 |
That’s roughly a tenth of the free allowance. Routers and error-handler modules use no credits on Make, so an error route that emails you costs nothing extra. Make Core is $9 a month billed annually for 10,000 credits if your other scenarios push you over (pricing page, checked November 9, 2026).
Two notes on the LLM step. Make’s built-in AI provider charges extra credits based on token use, while a custom AI provider connection costs one credit per operation but is available on paid plans only (Make Help Center, checked November 9, 2026). On the Free plan, a plain HTTP module calling your model provider’s API with your own key keeps the step at one credit. Your LLM provider bills you separately for tokens; one article plus four short drafts is a small request.
On n8n the unit is an execution, one per full workflow run. n8n’s docs say a webhook trigger counts one execution per inbound request, a schedule trigger counts every time it fires, and a polling trigger counts only when it finds new data (n8n docs, checked November 9, 2026). So polling is cheap on n8n. The drafting workflow uses 8 executions a month and a daily LinkedIn scheduler adds 30. Cloud Starter includes 2,500 executions for €20 a month billed annually, and the self-hosted Community edition is free. The webhook still wins on n8n for speed: drafts arrive while the article is fresh in your head.
Step 1: Send a webhook when a post goes live
How you send it depends on where your site lives.
- Ghost has a built-in
post.publishedwebhook event (Ghost docs). Paste your Make or n8n webhook URL into a custom integration. - WordPress needs a webhook plugin, or a small
publish_posthook in your theme’s functions file. - A static site (Astro, Hugo, Eleventy) on Cloudflare Pages, Netlify, or similar: let GitHub Actions send it when a new post file lands on
main.
Here is a GitHub Actions skeleton for the static-site case. It sends the Markdown itself, so the drafting step doesn’t depend on the deploy having finished.
# .github/workflows/social-drafts.yml
name: Send new posts to the drafts pipeline
on:
push:
branches: [main]
paths: ["src/content/posts/**.md"]
jobs:
notify:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
with:
fetch-depth: 0
- name: Post each new article to the webhook
env:
WEBHOOK_URL: ${{ secrets.DRAFTS_WEBHOOK_URL }}
WEBHOOK_TOKEN: ${{ secrets.DRAFTS_WEBHOOK_TOKEN }}
SITE: "https://yoursite.com"
run: |
for f in $(git diff --name-only --diff-filter=A ${{ github.event.before }} ${{ github.sha }} -- 'src/content/posts/*.md'); do
slug=$(basename "$f" .md)
jq -n --arg token "$WEBHOOK_TOKEN" --arg slug "$slug" \
--arg url "$SITE/posts/$slug/" --rawfile markdown "$f" \
'{token: $token, slug: $slug, url: $url, markdown: $markdown}' |
curl -sS -X POST -H "Content-Type: application/json" --data @- "$WEBHOOK_URL"
done--diff-filter=A sends only newly added files, so fixing a typo in an old post doesn’t trigger a fresh batch of drafts. The token field is a shared secret: the first step after the trigger rejects any request without it, because a webhook URL that leaks will otherwise accept anyone’s text.
Step 2: The drafting prompt
The prompt does three jobs: it fences the model to facts in the article, sets a length budget per channel, and forces a JSON shape your table can store.
Character budgets, with the official limits underneath them:
| Channel | Official limit | Target in the prompt |
|---|---|---|
| X | 280 characters, and any link counts as 23 (X developer docs, checked November 9, 2026) | 250 including the link |
| 3,000 characters (LinkedIn Help, checked November 9, 2026) | 700 to 1,300 | |
| Group or forum post | Set by each community | 400 to 900, link on the last line |
| Video script | Not applicable | 110 to 120 spoken words, about 45 seconds |
The targets sit below the limits on purpose. A 250-character X post leaves room for your edit, and a LinkedIn post under 1,300 characters is one most people finish.
You turn one published article into social drafts. A human reviews every
draft before anything is posted.
Rules for every draft:
- Use only facts, numbers, and steps that appear in the article. If a number
is not in the article, do not write one.
- Each draft must be useful to someone who never clicks the link. Give one
concrete takeaway: a number, a step, or a mistake to avoid.
- The link goes last, introduced as a reference, e.g. "Full walkthrough: {{url}}".
Never open with the link.
- No emojis. No "New post!", "Check out", or "Don't miss".
- Do not claim experience ("we tested", "I ran this") unless the article does.
Channels:
1. x: at most 250 characters, counting the URL as 23. One idea. At most one hashtag.
2. linkedin: 700 to 1,300 characters. First line under 120 characters and
names the reader's problem. Short paragraphs. Link at the end.
3. group_post: 400 to 900 characters, written as a helpful answer for a
community of solo site owners. End with one real question for the group.
Put the link alone on the last line, labelled "Source:".
4. video_script: 110 to 120 spoken words. A hook under 12 words, three beats,
one takeaway.
Return only valid JSON, with no text before or after it:
{
"x": {"text": "", "char_count": 0},
"linkedin": {"text": "", "char_count": 0},
"group_post": {"text": "", "char_count": 0},
"video_script": {"hook": "", "beats": ["", "", ""], "takeaway": "", "word_count": 0},
"facts_used": ["every number or claim you used, copied word for word from the article"]
}
Article title: {{title}}
Article URL: {{url}}
Article:
{{markdown}}Two fields exist for the reviewer. facts_used lets you check every claim against the article in ten seconds. char_count is the model’s own count, and models count characters badly, so don’t trust it. Add a column in Google Sheets with =LEN(D2) and conditional formatting that turns the cell red above 250 for X rows. The sheet counts the full URL length rather than X’s 23, so it errs on the safe side.
The video script goes into the pipeline from the faceless short-form video guide, which turns the same fields into a rendered vertical video.
Step 3: Build it in Make
- Create the scenario and add Webhooks > Custom webhook. Copy its URL into your GitHub secret (or Ghost integration), then publish a test post so Make learns the data structure.
- Add a filter right after the trigger: continue only if
tokenequals your secret. - Call your LLM with HTTP > Make a request: your provider’s chat or messages endpoint, your API key in the header, the prompt above in the body with
{{title}},{{url}}, and{{markdown}}mapped from the webhook. Turn on “Parse response”. - Parse the model’s text with JSON > Parse JSON, using the shape from the prompt as the data structure.
- Add four rows to Google Sheets (or four Notion database items). Columns: date, slug, channel, draft text, length, facts_used, status (set to “Draft”), post URL.
- Email yourself a link to the sheet.
- Add an error-handler route on the HTTP module that emails you the error. It costs no credits and tells you when the model returns broken JSON.
Optional LinkedIn scheduler. A second scenario runs once a day at the hour you want to post. Google Sheets > Search Rows finds rows where channel is “linkedin”, status is “Approved”, and the posted date is empty. LinkedIn > Create a User Text Post sends each one, and Update a Row sets status to “Posted” with today’s date.
Step 4: Build it in n8n
- Webhook node, method POST. Use the production URL, which only listens while the workflow is active.
- IF node that stops the run unless
tokenmatches. - LLM step: one of n8n’s model nodes, or an HTTP Request node to your provider’s API with the same prompt.
- Code node that parses the JSON and returns four items, one per channel.
- Google Sheets node (Append Row) or a Notion node.
- Approval. Keep the sheet as your approval queue, or use the Send Email node’s “Send and Wait for Response” operation. It emails you the drafts with Approve and Decline buttons and pauses the workflow until you click (n8n docs). The Slack version of the same operation needs your n8n instance reachable over public HTTPS.
- Optional LinkedIn post: the LinkedIn node’s Post > Create, as Person, on the approved branch.
- Error workflow: a second workflow that starts with an Error Trigger and emails you. n8n doesn’t count error-workflow runs against your execution quota.
If you’d rather skip both tools, the same job fits in one script: a GitHub Action that calls your LLM and commits the drafts as a Markdown file you review in a pull request. Code it yourself vs Make and n8n covers when that trade is worth it.
The approval routine
Budget about ten minutes per post. This is a target, so time your first few and adjust.
- Check the numbers. Every figure in a draft should appear in
facts_usedand in the article. - Read the X draft without the link. If it says nothing useful on its own, rewrite the first line.
- Check where the group post is going. Reread that group’s rules. Post only if it answers something people there are asking, and use the link-only thread if the group has one.
- Delete anything that reads like an ad. “Game-changing” and “must-read” are the usual suspects, even with the prompt’s bans.
- Post by hand where it matters. Copy the X and group drafts yourself; let the scheduler handle LinkedIn if you set it up.
- Mark each row “Posted” or “Skipped” so next month you can see which channels earned clicks.
Who this is for, and who should skip it
Build it if you publish at least weekly, share to two or more channels, and already rewrite each post by hand. The pipeline turns 40 minutes of rewriting into about ten minutes of editing.
Skip it if you publish once a month. Writing three posts by hand is faster than building and maintaining a scenario. Skip it too if what you want is fully hands-off posting into communities: that’s the part this design deliberately leaves to you.
Quick answers
Should I auto-post to X too? We wouldn’t. X’s guidelines allow scheduled informational posts from your own account, but X API access comes with its own terms and pricing on X’s developer site, and copying one approved draft takes 30 seconds. Automate the draft and post it yourself.
Google Sheets or Notion for the approval table? Both work in Make and n8n. Sheets gives you the LEN length check and conditional formatting for free. Use Notion if your content calendar already lives there.
Does Make’s free plan really cover this? Yes, at about 110 credits a month for eight posts with a webhook trigger and the optional LinkedIn scheduler. Switch the trigger to a 15-minute RSS poll and the polling alone needs more than the 1,000 free credits.
More builds like this live in the Automation Workflows pillar. To choose the platform, read Make vs n8n for solo builders. To turn the video script into a finished Short, use the faceless short-form video workflow.