Google Sheets to GitHub, Jekyll posts published clean

Content production breaks in boring places. A topic list lives in a spreadsheet, research is scattered across tabs, and publishing turns into a careful copy-paste routine you have to get “just right” every time.

This Jekyll post automation hits busy marketers hardest, but founders shipping thought leadership and agency teams managing client blogs feel it too. You end up spending an hour on process instead of writing, editing, or promotion.

This workflow turns a Google Sheets topic row into a clean Jekyll-ready Markdown file committed to GitHub, then marks the topic as done. You’ll see how it works, what you need, and where teams usually trip up.

How This Automation Works

The full n8n workflow, from trigger to final output:

n8n Workflow Template: Google Sheets to GitHub, Jekyll posts published clean

Click to explore

flowchart LR

    subgraph sg0["Schedule Flow"]
        direction LR
        n8@{ icon: "mdi:play-circle", form: "rounded", label: "Schedule Trigger", pos: "b", h: 48 }
    end

    subgraph sg1["Flow 2"]
        direction LR
        n9@{ icon: "mdi:database", form: "rounded", label: "Get Topic from Google Sheet", pos: "b", h: 48 }
    end

    subgraph sg2["Flow 3"]
        direction LR
        n2@{ icon: "mdi:swap-vertical", form: "rounded", label: "Extract Blog Title", pos: "b", h: 48 }
    end

    subgraph sg3["Flow 4"]
        direction LR
        n7@{ icon: "mdi:cog", form: "rounded", label: "Tavily Web Search", pos: "b", h: 48 }
    end

    subgraph sg4["Flow 5"]
        direction LR
        n4["<div style='background:#f5f5f5;padding:10px;border-radius:8px;display:inline-block;border:1px solid #e0e0e0'><img src='https://flowpast.com/wp-content/uploads/n8n-workflow-icons/code.svg' width='40' height='40' /></div><br/>Summarize Search Results"]
    end

    subgraph sg5["Generate Blog with G Flow"]
        direction LR
        n0@{ icon: "mdi:robot", form: "rounded", label: "Generate Blog with Gemini", pos: "b", h: 48 }
    end

    subgraph sg6["Flow 7"]
        direction LR
        n5["<div style='background:#f5f5f5;padding:10px;border-radius:8px;display:inline-block;border:1px solid #e0e0e0'><img src='https://flowpast.com/wp-content/uploads/n8n-workflow-icons/github.dark.svg' width='40' height='40' /></div><br/>Commit Blog Post to GitHub"]
    end

    subgraph sg7["Flow 8"]
        direction LR
        n10@{ icon: "mdi:database", form: "rounded", label: "Mark Topic as Done in Sheet", pos: "b", h: 48 }
    end

    subgraph sg8["Flow 9"]
        direction LR
        n6@{ icon: "mdi:swap-vertical", form: "rounded", label: "Prepare File for Commit", pos: "b", h: 48 }
    end

    subgraph sg9["Flow 10"]
        direction LR
        n3@{ icon: "mdi:brain", form: "rounded", label: "Google Gemini Chat Model", pos: "b", h: 48 }
    end

    subgraph sg10["Fetch Wikipedia Cont Flow"]
        direction LR
        n1@{ icon: "mdi:wrench", form: "rounded", label: "Fetch Wikipedia Context", pos: "b", h: 48 }
    end

    %% Styling
    classDef trigger fill:#e8f5e9,stroke:#388e3c,stroke-width:2px
    classDef ai fill:#e3f2fd,stroke:#1976d2,stroke-width:2px
    classDef aiModel fill:#e8eaf6,stroke:#3f51b5,stroke-width:2px
    classDef decision fill:#fff8e1,stroke:#f9a825,stroke-width:2px
    classDef database fill:#fce4ec,stroke:#c2185b,stroke-width:2px
    classDef api fill:#fff3e0,stroke:#e65100,stroke-width:2px
    classDef code fill:#f3e5f5,stroke:#7b1fa2,stroke-width:2px
    classDef disabled stroke-dasharray: 5 5,opacity: 0.5
    class n8 trigger
    class n0 ai
    class n3 aiModel
    class n1 ai
    class n9,n10 database
    class n4 code
    classDef customIcon fill:none,stroke:none
    class n4,n5 customIcon

The Problem: Jekyll publishing turns into spreadsheet chaos

It sounds simple: pick a topic, research it, write the post, and publish. In practice, the “simple” part dies the moment you need consistent front matter, correct filenames, the right _posts/ path, and a reliable way to track what’s done. One person updates the sheet, another person publishes late, and suddenly you have duplicates, missing dates, or posts that build locally but break on GitHub Pages. Worst part, honestly: you can’t tell if the bottleneck is writing or the process around it.

The friction compounds.

You lose about 30 minutes per post just doing research “setup” across tabs and sources.
Front matter drifts over time, which means inconsistent categories, tags, and excerpts.
GitHub commits become a manual ceremony, so posts sit in draft purgatory for days.
Spreadsheet status tracking is easy to forget, so your “pipeline” is never accurate.

The Solution: Google Sheets → researched draft → GitHub commit

This n8n workflow takes your topic backlog in Google Sheets and turns it into publishable Jekyll posts, without you stitching the pieces together by hand. It starts on a schedule, grabs the next row where status is blank, then pulls the title out as the “source of truth.” From there it collects context using Tavily search and (optionally) Wikipedia, condenses that research into something the AI can actually use, and asks Gemini to generate a Markdown post with YAML front matter. Finally, it builds a filename and commit message, commits the .md file into your GitHub repo’s _posts/ directory, and marks the Google Sheet row as done when the commit succeeds.

It begins with a scheduled trigger and a single “next topic” lookup in Google Sheets. Research and summarization happen in the middle, so the AI isn’t guessing. The output is a Jekyll-ready Markdown file in GitHub, ready for GitHub Pages to build.

What You Get: Automation vs. Results

What This Workflow Automates Results You’ll Get

Pulls the next unpublished topic from Google Sheets on a schedule.
Fetches web context via Tavily and adds Wikipedia details when useful.
Generates Markdown with consistent YAML front matter using Gemini.
Commits the finished post into GitHub’s _posts/ path and updates the sheet status.

Most teams get about 1 hour back per post by removing research and publishing busywork.
Your blog front matter stays uniform, so categories and tags don’t get messy.
Publishing becomes predictable because the workflow runs on schedule, not memory.
You cut down “where is this draft?” messages because GitHub is the source of truth.
It’s easier to scale output because the sheet becomes a real pipeline, not a wish list.

Example: What This Looks Like

Say you publish 3 technical posts a week from a Google Sheets backlog. Manually, you might spend about 30 minutes gathering sources, another 20 minutes formatting Markdown and YAML front matter, then 10 minutes to commit, place the file correctly, and update the sheet. Call it about 1 hour per post. With this workflow, you spend maybe 5 minutes maintaining the topic row, then wait for the run to finish and do a quick editorial pass. That’s roughly 2 to 3 hours back every week, and your GitHub history stays clean.

What You’ll Need

n8n instance (try n8n Cloud free)
Self-hosting option if you prefer (Hostinger works well)
Google Sheets for your topic list and status tracking
GitHub to store posts in your Jekyll repo
Tavily API key (get it from your Tavily dashboard)
Gemini API key (get it from Google AI Studio / Google Cloud)

Skill level: Intermediate. You’ll connect credentials, confirm repo paths, and tweak a prompt, but you won’t be writing code unless you want deeper customization.

Don’t want to set this up yourself? Talk to an automation expert (free 15-minute consultation).

How It Works

A schedule kicks things off. The workflow runs daily (or on whatever cadence you set) so your content engine keeps moving even when your calendar doesn’t.

A single topic row becomes the input. n8n reads Google Sheets, finds the next row where status is blank, and isolates the title so every downstream step stays aligned.

Research is gathered, then condensed. Tavily pulls relevant sources for the topic, Wikipedia can add background context, and a summarization step turns that pile of text into a tight brief Gemini can use.

Gemini writes, GitHub publishes. The AI generates Markdown with YAML front matter, n8n sets the filename and commit details, then commits the file to your repo’s _posts/ directory. After a successful commit, the Google Sheet row is marked done.

You can easily modify the prompt and filename pattern to match your site and editorial rules. See the full implementation guide below for customization options.

Step-by-Step Implementation Guide

Step 1: Configure the Scheduled Trigger

Set the schedule that starts the automation so it can pull the next blog topic every day.

Add and open Scheduled Automation Trigger.
Set the schedule rule so it runs daily at Trigger At Hour 9.
Confirm the workflow timezone matches your desired schedule (this workflow uses Asia/Kolkata).

If you want multiple posts per day, add more schedule entries in Scheduled Automation Trigger.

Step 2: Connect Google Sheets

Pull an unpublished topic from a spreadsheet and later update its status to “done.”

Open Retrieve Topic from Sheet and select your spreadsheet.
Set Document to YOUR_GOOGLE_SHEETS_DOCUMENT_ID and Sheet to gid=0.
Keep the filter so status equals = to target rows awaiting processing.
Credential Required: Connect your googleSheetsOAuth2Api credentials.
Open Update Sheet Status Done, set Operation to update, and map status to done and row_number to {{$json.row_number}}.
Credential Required: Connect your googleSheetsOAuth2Api credentials in Update Sheet Status Done.

⚠️ Common Pitfall: The update node relies on row_number; make sure your sheet includes this column and that it is returned by Retrieve Topic from Sheet.

Step 3: Prepare the Topic and Research Context

Normalize the topic, run a web search, and condense the top results into a compact context block.

In Isolate Topic Title, keep the assignment topic set to {{ $json.Title }}.
Open Tavily Web Lookup and set Query to {{ $json.topic }}.
Ensure options.search_depth is set to advanced for deeper results.
Credential Required: Connect your tavilyApi credentials.
In Condense Search Findings, keep the JavaScript that builds Topic and Context from the top three results.

Step 4: Set Up AI Writing with Gemini

Generate a fully formatted Markdown blog post using the condensed context and Wikipedia tool support.

Open Gemini Chat Language Model and set Model Name to models/gemini-2.5-pro.
Credential Required: Connect your googlePalmApi credentials in Gemini Chat Language Model.
Open Compose Article via Gemini and keep Prompt Type set to define.
Set Text to the template that injects {{$json["Topic"]}} and {{$json["Context"]}}.
Keep the detailed systemMessage that defines YAML front matter and Markdown formatting.
Confirm Retrieve Wikipedia Details is connected as an AI tool to Compose Article via Gemini.

AI tool nodes like Retrieve Wikipedia Details inherit credentials from the parent language model—ensure credentials are added to Gemini Chat Language Model, not the tool node.

Step 5: Configure GitHub Publishing

Build the Markdown file name and content, then commit it to your GitHub repository.

In Assemble Commit File, set filePath to {{ $now.format('yyyy-MM-dd') }}-{{ $('Isolate Topic Title').item.json.topic.toLowerCase().replace(/ /g, '-') }}.md.
Set fileContent to {{$json["output"]}}.
Set commitMessage to Add blog post: {{ $('Retrieve Topic from Sheet').item.json.Title }}.
Open Publish Post to GitHub and set Owner to YOUR_GITHUB_USERNAME and Repository to YOUR_REPOSITORY_NAME.
Set File Path to _posts/{{ $json.filePath }}, File Content to {{ $json.fileContent }}, and Commit Message to {{ $json.commitMessage }}.
Credential Required: Connect your githubOAuth2Api credentials.

⚠️ Common Pitfall: Ensure the repository supports Jekyll-style posts in the _posts directory and that the filename format matches your site generator rules.

Step 6: Test and Activate Your Workflow

Run a manual test to validate data flow, then activate the schedule for production.

Click Execute Workflow to run a manual test from Scheduled Automation Trigger.
Verify Retrieve Topic from Sheet returns a row and Isolate Topic Title outputs a topic.
Check that Compose Article via Gemini outputs a full Markdown article and Publish Post to GitHub creates a file in _posts.
Confirm Update Sheet Status Done sets the sheet row status to done.
Toggle the workflow Active to enable the scheduled publishing cycle.

🔒

Unlock Full Step-by-Step Guide

Get the complete implementation guide + downloadable template

Common Gotchas

Google Sheets OAuth credentials can expire or lack spreadsheet access. If topics stop loading, check the credential in n8n and confirm the sheet is shared with the connected Google account.
If you’re using Wait nodes or external rendering, processing times vary. Bump up the wait duration if downstream nodes fail on empty responses.
Default prompts in AI nodes are generic. Add your brand voice early or you’ll be editing outputs forever.
GitHub OAuth permissions are easy to under-scope. If commits fail, check the GitHub app/token scopes and confirm the workflow is targeting the correct repo and _posts/ path.

Frequently Asked Questions

How long does it take to set up this Jekyll post automation?

About 45 minutes if your credentials and repo are ready.

Do I need coding skills to automate Jekyll post publishing?

No. You’ll mostly connect accounts and edit a prompt. The only “technical” part is confirming your Jekyll repo path and filename format.

Is n8n free to use for this Jekyll post automation workflow?

Yes. n8n has a free self-hosted option and a free trial on n8n Cloud. Cloud plans start at $20/month for higher volume. You’ll also need to factor in Tavily and Gemini API usage costs.

Where can I host n8n to run this automation?

Two options: n8n Cloud (managed, easiest setup) or self-hosting on a VPS. For self-hosting, Hostinger VPS is affordable and handles n8n well. Self-hosting gives you unlimited executions but requires basic server management.

Can I customize this Jekyll post automation workflow for a different front matter template?

Yes, and it’s one of the best tweaks you can make. Update the instructions in the “Compose Article via Gemini” agent so the YAML matches your site (categories, tags, author, excerpt, even a table of contents). If you also want a different filename scheme, change it in the “Assemble Commit File” step where the path and commit message are prepared. Teams commonly add a custom slug field from the Google Sheet, force category defaults, and standardize excerpt length.

Why is my GitHub connection failing in this workflow?

Usually it’s OAuth scope or repo access. Reconnect the GitHub OAuth2 credential in n8n, confirm it can write to the target repository, and double-check the _posts/ path you’re committing into. If it fails only sometimes, rate limiting or a temporary GitHub outage can be the culprit, so look at the execution logs for the exact response.

How many posts can this Jekyll post automation handle?

On self-hosted n8n, it’s basically limited by your server and API quotas.

Is this Jekyll post automation better than using Zapier or Make?

Often, yes, because this flow needs a bit more than simple “A to B.” You’re pulling multiple sources, condensing research, generating long-form Markdown, and committing files into a specific repo path, which is where n8n’s flexibility helps. It also supports self-hosting, so you’re not paying more just because you run it daily. Zapier or Make can still work if you keep it very simple, but you may hit limits when the logic gets branching-heavy. Talk to an automation expert if you want a quick recommendation for your stack.

Once this is running, your spreadsheet stops being a graveyard of “someday topics” and starts behaving like a real publishing pipeline. The workflow handles the repetitive stuff. You handle the ideas and the final edit.

Google Sheets to GitHub, Jekyll posts published clean

How This Automation Works

n8n Workflow Template: Google Sheets to GitHub, Jekyll posts published clean

The Problem: Jekyll publishing turns into spreadsheet chaos