There's a well-known paradox every developer and lifelong learner faces: the best way to truly understand a topic is to teach it, but the time it takes to document and share your journey is often a luxury you don't have. This friction is the silent killer of the "learning in public" movement.

I ran headfirst into this wall on my own data science learning journey. My desire to consistently share my progress on LinkedIn and X (Twitter) to reinforce my knowledge and build a presence clashed directly with my actual study time. The manual process of drafting, tailoring content for different platforms, and scheduling dozens of posts a week was simply unsustainable.

I realized I needed a system. Not just any system, but one that treated content as an automatic byproduct of my learning, not a separate, time-consuming chore.

This article breaks down that system: a fully autonomous, scalable AI content pipeline built with n8n, Google Gemini, and Airtable. It's a workflow that ingests my weekly study notes from a single file on GitHub and, with zero further intervention, transforms them into more than 50 pieces of tailored, scheduled content for the entire week.

But this is more than a simple content generator. Its true strength lies in its dynamic and resilient architecture, designed specifically to adapt to a changing curriculum. We'll dive into the three-part system, the critical debugging challenges I faced, and the key lessons I learned about building intelligent automations that solve real-world problems

The Why: Motivation Behind the Project

I had two main goals for this project:

• Reinforce My Learning: The best way to solidify knowledge is to explain it. Creating daily content on my learning topics is a forcing function to synthesize the material, which deepens my understanding.

• Automate My Online Presence: I wanted to "learn in public" by sharing my progress on LinkedIn and Twitter. However, the daily grind of creating, tailoring, and scheduling over ten posts is a huge time sink. Automation was the only way to make this sustainable.

I needed a system that was not just automated, but intelligent, resilient, and flexible enough to handle the unpredictable nature of a real-world learning curriculum.

The Grand Design: A 3-Workflow Architecture

After extensive planning and debugging, I landed on a robust three-part architecture. This design separates concerns, which makes the entire system incredibly reliable. I think of it as a factory assembly line with a Supervisor, a Factory, and a Publisher.

1. The Supervisor: Weekly Run Scheduler This workflow is the system's brain. Instead of a simple weekly trigger, it runs every four hours to ask one question: "Has the content for this week been generated yet?" It checks a tracker in Airtable. If the work is done, it goes back to sleep. If not, it triggers the Content Factory. This "persistent checking" model makes the system self-healing; if there's ever downtime, it will always catch up.

   

2. The Content Factory: Content Generation Engine This is the heart of the operation. Triggered only once per week, it does all the heavy lifting. In a complex chain of events, it turns a single source file into over 50 scheduled social media posts. We'll do a deep dive into this one next.

   

3. The Publisher: Social Media Poster This is the final workhorse. It runs independently every 30 minutes, checking the Airtable queue for any posts ready to be published. It handles posting to the correct platform, updates the status in Airtable, and sends me a real-time success or failure notification on Telegram.

   

A Deeper Dive: Inside the Content Factory

This workflow was the most challenging and rewarding to build. It needed to be incredibly intelligent to handle a dynamic curriculum.

Finding Content Dynamically

The GitHub repository I'm learning from has unpredictable folder names, like Week-3 (Python - 3). Instead of relying on a hardcoded path, the workflow dynamically finds the correct content. It first lists all folders in the repository and uses a Code node to search that list for the folder matching the current week. It then repeats this process to find the correct file inside that folder.

Handling Any File Type 🧠

I knew the weekly content might be a Jupyter Notebook (.ipynb), a Markdown file (.md), or plain text (.txt). I designed the workflow to handle them all. A Switch node checks the file extension and routes the file down the correct processing path:

• An .ipynb file is parsed by a Code node that extracts only the human-readable text from the notebook's JSON structure.

• An .md or .txt file is sent to a simpler Code node that just decodes the text.

The two paths then merge, ensuring the AI always receives a clean, consistent block of text to work with.

The AI Generation Chain

For maximum reliability, the AI process is split into three distinct steps:

1. Topic Splitting: The first Gemini node reads the entire text and splits it into five logical, daily topics.

2. LinkedIn Generation: Inside a loop that runs for each of the five topics, a second Gemini node generates five tailored posts for LinkedIn.

3. Twitter Generation: A third Gemini node does the same, generating five concise and punchy tweets for each topic.

Scheduling the Posts

A final Code node takes all 50 generated posts, calculates their staggered posting times for the upcoming week, and saves everything to our Airtable Content Queue, ready for the Publisher.

The Gauntlet: Challenges & Lessons Learned 🐛

Building this system was a masterclass in debugging. Here are the biggest challenges I faced:

• The = Nemesis: My most common error was using a spreadsheet-style = at the beginning of n8n expressions. n8n doesn't use this, and it caused my workflows to fail silently. Lesson: Always double-check expression syntax in the platform you're using.

• Taming the AI: Getting consistent JSON from a Large Language Model is an art. My initial, complex prompt asking for all posts at once was unreliable. The solution was to split the task into smaller, more focused prompts, which made the AI's output far more predictable.

• The "Invalid time value" Saga: This was my most frustrating bug. A date calculation was failing deep inside a loop. After hours of debugging, I discovered the root cause was malformed data entering the loop from an earlier AI node. Lesson: Fix bad data at the source, not where you see the symptom. I added a dedicated "Parser" node to clean and validate the data before the loop begins.

• Self-Hosted vs. Cloud Credentials: Setting up OAuth credentials (like for LinkedIn) is completely different when self-hosting n8n versus using the cloud version. This was a huge learning experience in how webhooks and redirect URLs work in a real-world application.

The Final Result ✅

After all the building and debugging, the system works flawlessly. At the start of each week, the Content Factory populates my Airtable base with 50 unique, AI-generated posts, each with a specific topic, platform, and scheduled time.

Then, throughout the week, the Publisher picks them up one by one and sends them out, giving me instant notifications on Telegram if it was successfully posted or not

Conclusion

This project was far more than a technical exercise; it was a deep dive into system design, debugging, and the practical application of AI. It taught me that the most robust automations are often a chain of simple, single-purpose workflows working together to perform a complex task.

Most importantly, I now have a system that helps me learn more effectively while building my personal brand and sharing my journey—all without me lifting a finger during the week.

Thanks for reading! Let me know if you have any questions or have built similar systems in the comments below