DEV Community: Shrisab Shrestha

Turn one devlog into posts for every channel with n8n + AI

Shrisab Shrestha — Tue, 14 Jul 2026 07:33:43 +0000

If you're a solo game developer, you know the drill: you ship an update, write a devlog… and then you have to rewrite it four times. A punchy tweet. A longer Reddit post that doesn't sound like an ad. A casual Discord ping. A newsletter blurb. By the third rewrite you've lost the will to post at all.

I automated the rewriting with n8n, Google Gemini, and Notion. I write the devlog once, hit run, and get channel-ready drafts waiting in Notion. It doesn't auto-post, it makes drafts I review and send myself, which keeps everything authentic and inside each platform's rules.

Here's a short demo of the finished workflow:
👉 https://www.loom.com/share/f108f0a003b448b2bc414a8be742d772

What it does

For one devlog you paste in, it:

Sends your update to Gemini
Reformats it for four channels: Twitter/Bluesky, Reddit, Discord, newsletter
Parses the result into separate fields
Saves them as one Notion row with a draft per channel

The flow looks like this:

Manual Trigger
  → Devlog Input
  → AI Reformat (Gemini)
  → Parse Drafts
  → Save Drafts to Notion

What you need

n8n running locally (Docker is easiest)
A Notion account + an internal integration
A Google Gemini API key (free tier is fine to start)

Step 1 - Run n8n

docker volume create n8n_data

docker run -d --name n8n \
  -p 5678:5678 \
  -v n8n_data:/home/node/.n8n \
  docker.n8n.io/n8nio/n8n

Open http://localhost:5678 and create your account.

Step 2 - The devlog input

Add a Code node where you write your update once. Keeping it in a Code node means you just edit two variables each time:

const devlog_title = "Update 0.3 — Online Co-op";
const devlog_body = `We just shipped online co-op for up to 4 players,
fixed the save-corruption bug, and added 2 new levels.
Next up: controller support and a Steam demo.`;

return [{ json: { devlog_title, devlog_body } }];

(Later you can swap this for a Form Trigger so you get a little web form, or a Notion Trigger that fires when you add a devlog page.)

Step 3 - Reformat with Gemini

Add the Google Gemini node. The trick is to make it return strict JSON so the next node can split it cleanly:

You are a social media manager for a solo indie game developer.

Here is a devlog update:
Title: {{ $json.devlog_title }}
Body: {{ $json.devlog_body }}

Rewrite it for each channel. Return ONLY valid JSON (no markdown,
no code fences, no text outside the JSON) with these exact keys:
{
  "twitter": "280 characters max, punchy, 1-2 relevant hashtags",
  "reddit": "friendly longer post for r/IndieDev, first person, no hashtags, no hard selling",
  "discord": "casual short announcement for a community server, 1-2 emojis ok",
  "newsletter": "2-3 sentence email blurb"
}

Step 4 - Parse the drafts

LLMs sometimes wrap JSON in code fences, so a small Code node cleans and parses it, with a fallback so you never lose output:

const raw = ($json.content?.parts?.[0]?.text) || "";

// \x60 is a backtick (char code 96). This strips a code fence
// if the model wraps its JSON output in one.
let clean = raw.trim()
  .replace(/^\x60{3}json\s*/i, "")
  .replace(/^\x60{3}\s*/, "")
  .replace(/\x60{3}$/, "")
  .trim();

let parsed;
try {
  parsed = JSON.parse(clean);
} catch (e) {
  parsed = { twitter: "", reddit: raw, discord: "", newsletter: "" };
}

const input = $('Devlog Input').item.json;

return [{
  json: {
    devlog_title: input.devlog_title,
    twitter: parsed.twitter || "",
    reddit: parsed.reddit || "",
    discord: parsed.discord || "",
    newsletter: parsed.newsletter || "",
  }
}];

Step 5 - Save to Notion

Create a Notion database called Devlog Drafts with these properties: Name (title), Twitter (text), Reddit (text), Discord (text), Newsletter (text), Status (text), Created (date).

Create an internal integration at notion.so/my-integrations, connect it to the database, then map the fields in n8n's Notion node. Set the title to {{ $json.devlog_title }} and each channel field to its matching value ({{ $json.twitter }}, etc.).

Run the workflow and you'll get a new row with four drafts - review, tweak, and post whenever you like.

Gotchas

All text lands in the Reddit field → the model didn't return clean JSON that run. Re-run, or tighten the prompt ("Return ONLY valid JSON"). The fallback in Step 4 keeps your output safe.
Empty Notion rows → property names must match exactly.
Very long drafts → normal devlogs are fine; extremely long posts may get truncated in Notion text fields.

Want the done-for-you version?

I packaged this, plus a Steam competitor-tracking workflow - into an importable pack with setup guides, the AI prompts, troubleshooting, and example screenshots:

👉 https://shrisab.gumroad.com/l/indie-launch-ops/LAUNCH

Either way, write the devlog once, and stop dreading the four rewrites. Questions welcome in the comments.

Automate weekly Steam competitor research with n8n, Gemini, and Notion

Shrisab Shrestha — Mon, 13 Jul 2026 14:37:09 +0000

If you're a solo game developer, you probably mean to keep an eye on your Steam competitors - player counts, review trends, what people praise or complain about. And then you don't, because opening five store pages every week is boring.

I automated the whole thing with n8n, Steam's public APIs, Google Gemini, and Notion. No Steam API key required, and it runs on free tiers. Here's exactly how it works, so you can build your own, and if you'd rather skip the wiring, there's a ready-to-import pack at the end.

Here's a 2-minute demo of the finished workflow:
👉 https://www.loom.com/share/4edd443f3ae341088dfa025d55efcc34

What it does

Once a week (or on demand), for every competitor you list, it:

Pulls the current player count from Steam
Pulls review score + total reviews
Calculates a simple popularity score
Writes a short AI brief (what players care about, risks, one lesson for a solo dev)
Saves one Notion row per game

The flow looks like this:

Schedule Trigger
  → Competitor List
  → Loop Over Items
      → Get Player Count (Steam)
      → Get Reviews (Steam)
      → Calculate Score
      → AI Summary (Gemini)
      → Save to Notion

What you need

n8n running locally (Docker is easiest)
A Notion account + an internal integration
A Google Gemini API key (free tier is fine to start)

No Steam API key, the endpoints we use are public.

Step 1 - Run n8n

docker volume create n8n_data

docker run -d --name n8n \
  -p 5678:5678 \
  -v n8n_data:/home/node/.n8n \
  docker.n8n.io/n8nio/n8n

Open http://localhost:5678 and create your account.

Step 2 - The competitor list

Add a Code node that returns the games you want to track. The app_id is the number in a game's Steam store URL (store.steampowered.com/app/APP_ID/...):

const games = [
  { game_name: "PlateUp!", app_id: "1687950" },
  { game_name: "Unrailed!", app_id: "754150" },
  { game_name: "Overcooked! 2", app_id: "728880" },
];

return games.map(g => ({ json: g }));

Feed it into a Loop Over Items node so each game runs through the pipeline.

Step 3 - Current players (no API key)

An HTTP Request node:

GET https://api.steampowered.com/ISteamUserStats/GetNumberOfCurrentPlayers/v1/
  ?appid={{ $json.app_id }}
  &format=json

Returns {"response":{"player_count":1234,"result":1}}. A 404 means a bad App ID, double-check the number.

Step 4 - Reviews

Another HTTP Request node hits Steam's public review summary:

GET https://store.steampowered.com/appreviews/{{ $json.app_id }}
  ?json=1
  &language=english
  &num_per_page=0

You get query_summary.total_reviews and review_score_desc (e.g. "Very Positive").

Step 5 - A simple popularity score

A Code node combines players and reviews so a game with lots of players and lots of reviews ranks higher:

const game = $('Loop Over Items').item.json;
const players = ($('Get Player Count').item.json.response || {}).player_count || 0;
const review = $('Get Reviews').item.json.query_summary || {};
const total = review.total_reviews || 0;

const popularity = Math.round(players * Math.log10(total + 1));

return [{
  json: {
    game_name: game.game_name,
    app_id: game.app_id,
    player_count: players,
    review_score: review.review_score_desc || "No score",
    total_reviews: total,
    popularity_score: popularity,
    steam_link: `https://store.steampowered.com/app/${game.app_id}`,
  }
}];

Step 6 - AI brief with Gemini

Add the Google Gemini node and give it a focused prompt so you get solo-dev insight, not marketing fluff:

You are a game market analyst helping a solo indie developer.

Game: {{ $json.game_name }}
Current players: {{ $json.player_count }}
Review score: {{ $json.review_score }}
Total reviews: {{ $json.total_reviews }}

Write short markdown:
1. What players likely care about (3 bullets)
2. Possible complaints or risks (2 bullets)
3. One lesson a solo dev could learn from this game

Under 180 words. Be practical, not hype.

Step 7 - Save to Notion

Create a Notion database with these properties: Name (title), AI Summary (text), Steam App ID (text), Player Count (number), Review Score (text), Popularity Score (number), Steam Link (URL), Last Updated (date).

Create an internal integration at notion.so/my-integrations, connect it to the database, then map the fields in n8n's Notion node. The Gemini text lands in AI Summary.

Step 8 - Put it on a schedule

Add a Schedule Trigger (e.g. every 7 days), connect it to the Competitor List, and set the workflow Active. Now Notion updates itself while you build your game.

Gotchas

404 on player count → wrong App ID.
Empty Notion rows → property names must match exactly.
Duplicate rows each week → this version appends history; upsert-by-App-ID is a later enhancement.

Want the done-for-you version?

If you'd rather import a tested workflow than wire eight nodes, I packaged this with a setup guide, troubleshooting doc, the AI prompt, and example screenshots:

👉 https://shrisab.gumroad.com/l/indie-launch-ops/LAUNCH

Either way, automate the boring launch chores so you can spend the time making your game. Questions welcome in the comments.