Shikake Works
Build logs

Free daily social posts from my blog with Make and Buffer

By Hiro · November 11, 2026

Every post on this site gets three short announcements: one each for X, Bluesky and Threads. I write them once, next to the post. After that, a Make scenario on the free plan schedules them in Buffer on the right day, without me touching anything.

What it does

The site publishes a small queue file. Each morning, Make reads it, keeps only today’s items, and sends them to Buffer. Buffer then posts them in the evening, Japan time, which is morning in the US.

Only published posts are in the queue. If a post is still a draft, its announcements stay out, so nothing points to a page that does not exist yet.

The stack and the flow

The stack is Make (free plan), Buffer (free plan, three channels) and Buffer’s GraphQL API. The site is a static Astro site on Cloudflare.

The announcements live in one small file per post. Each line is a channel, a date and the text. On X, the link goes in a reply under the post instead of in the post itself.

When the site builds, it turns those files into the queue. Each item already holds the full request Buffer expects, with a placeholder where the channel ID goes.

  1. HTTP – Make a requestGET the queue file from the site
  2. Iteratorone bundle per announcement
  3. Filteronly items dated today (UTC) pass
  4. Data store – Add a recordwrite the item's ID as "sending"; skip the item if the ID is already there
  5. HTTP – Make a requestPOST to Buffer's API, with the channel ID swapped in
  6. Routerpost ID in the reply: mark "queued". No post ID: mark "error" and stop that item
The daily scenario after the fix. It runs once a day at 10:00 Japan time.

I used the HTTP module and Buffer’s GraphQL API, not Make’s Buffer app. The request body comes ready-made from the site, so Make only has to swap one placeholder for the right channel ID. A switch() picks the ID for x, bluesky or threads.

What it costs

It costs nothing beyond the free plans. Before the fix, a run used about 2 credits plus 1 per announcement sent: 2 on a day with nothing to send, 4 with two posts, 5 with three.

The fixed version adds two Data store steps per announcement: one write before sending, one update after. Its first run, with three announcements, used 11 credits instead of 5. Even if that happened every day, it would be about 330 credits a month, well inside the free 1,000.

The free plans have limits worth knowing:

  • Make Free: 1,000 credits a month.
  • Buffer Free: three channels and up to 10 scheduled posts per channel.
  • Multi-post threads on X: Buffer’s free plan allows only one scheduled thread on X at a time. My X announcement is a thread (the post plus the link reply), so I keep at most one X item per day.

What broke and how I fixed it

The posting itself worked. In the first three days, five announcements went out at 22:30 Japan time, including the first X thread. The problems were in what happens when something goes wrong.

Nothing happened on the first day

The first run sent nothing, and that was correct. The earliest item in the queue was dated the next day. Check the dates in the queue before you suspect the scenario.

The X thread worked on Buffer’s free plan

The X announcement is a post plus a reply that holds the link. It went out as a proper thread, and the reply showed a link card. Buffer’s free plan allows one scheduled X thread at a time, so I keep at most one X item per day.

Threads and X showed a preview card for the link. Bluesky showed the URL as plain text, both times. I have not found the cause yet.

A manual run posts twice

If I press “Run once” in Make on a day that already ran, the same items go to Buffer again.

The fix is to write before sending. Each queue item has an ID made of the post, the channel and the date. Before calling Buffer, the scenario saves that ID in a Data store with “Add a record” and overwrite turned off. If the ID is already there, the module errors, its error handler is set to ignore, and the item is skipped.

Errors look like success

Buffer’s GraphQL API returns HTTP 200 even when it rejects a post. The error sits inside the response body. Buffer’s own docs say to judge success from the body, not the status code.

So after the call, a Router checks the body. If it holds a post ID, the record is marked “queued”. I do not call it “sent”: a post ID only means Buffer scheduled it, not that it went out. If there is no post ID, the record is marked “error” with the message, and the scenario calls a URL on my own site that returns 404. Make has no simple “throw an error” module, so this is how that item fails on purpose and shows up in the run history.

Two scenario settings matter here. “Commit after each module” is on, so the “sending” record stays even if a later step fails. “Store incomplete executions” is now on too. Without it, the first error stops the whole run, and the other announcements for that day never go out.

Buffer says the queue is empty every night

This one was not a bug. One night my phone showed a Buffer notification saying my queue was empty, and I thought the scenario had stopped. In fact, that day’s three posts had gone out at 22:30, and Make had scheduled them about 13 hours earlier.

The empty queue is by design. The scenario adds only today’s items each morning, so after the evening posts, the queue stays empty until the next 10:00 run. Adding one day at a time also keeps me under Buffer’s free limit of 10 scheduled posts per channel.

Now I read it like this. An empty queue at night is normal. An empty queue after 10:00 means Make may not have run.

Before

  • Run once twice: the same posts are scheduled twice
  • Buffer rejects a post: Make shows success

After

  • Run once twice: the second run skips IDs already saved
  • Buffer rejects a post: the record says "error" and that item stops; the rest still go out
The two fixes, installed on November 10.

The first run with the fixes, on November 11, scheduled all three announcements once. The Data store holds three records, each marked “queued” with Buffer’s post ID. That evening I pressed “Run once” on purpose. The run stopped at the Data store step for all three items and never called Buffer. It used 5 credits, and Buffer still showed each announcement once. The error paths have not been triggered in production yet.

If the call to Buffer itself fails, for example on a timeout, an error route marks the record “unknown” and parks that item for review, with automatic retry turned off. A timeout does not prove the post was not created, so the scenario never resends it on its own. I check Buffer first and only resend if the post really is missing.

What I’d do differently

I would add the “write before sending” step from the first day, before the first manual test run. It costs a Data store and two modules, and it saves cleaning up duplicate posts.

I would also read Buffer’s response body from the start. An API that answers 200 to a rejected post will look fine for weeks if you only watch the status code.

If you would rather start from my version, the scenario is available as a Make blueprint with a setup guide ($9, about ¥1,400). It has my names, IDs and keys taken out.

If you want to build something like this yourself, you can sign up for Make with my link. It gives you the Core plan free for the first month, and I earn a commission if you stay on a paid plan.

Last checked: November 11, 2026. Make Free, Buffer Free.