DEV Community: wanjiang

How an API Key Leak Suspended My Live AI Project Overnight 🚨 Every solo dev dreads opening their inbox to this:

wanjiang — Wed, 09 Sep 2026 06:33:08 +0000

Every solo dev dreads opening their inbox to this:

"Your project was suspended because it engaged in abusive activity consistent with hijacking resources."

Within hours, an unauthorized bot scraped one of my Gemini API keys (Generative Language API Key3) and burned hundreds of dollars in automated, high-frequency requests. Google's automated security tripwires immediately froze my entire project.

The Post-Mortem 📉

The Cause: The key was accidentally exposed during a rapid deployment cycle. Scraping bots snatched it within minutes.
The Damage: An instant surge to nearly HK$300 in a single day, followed by a total project lockout that took down live user sessions.
The Fix: Deleted the compromised key immediately, moved all AI interactions behind server-side Next.js route handlers with rate limiting, and configured aggressive billing budget alerts.

What I Was Building: RadioShadow 📻

The compromised key powered RadioShadow — a web app designed to break the dreaded "Intermediate Plateau" in language learning.

Textbook apps make you feel confident, but real-world radio—packed with slang, fast speech, and overlapping voices—is an entirely different beast.

RadioShadow solves this through the Shadowing technique:

Global Radio Streams: Tap into unedited live broadcasts worldwide.
Real-Time Subtitles & AI Feedback: Low-latency transcription, live translations, and pronunciation scoring directly through the mic.
"✨ Help Me Choose" Wizard: A conversational selector that matches you to the right station based on language and vibe, avoiding the paradox of choice.

Tech Stack & Lessons 🛠️

Stack: Next.js (App Router), Tailwind CSS, Framer Motion, Web Audio API, Gemini API, Firebase.
Key Lesson: Never let API keys touch client-facing bundles, even for "quick local tests." Always proxy calls through authenticated, rate-limited backend routes.

The app is back up at radioshadow.ai.studio (free live streams available to test).

How does the audio stream latency feel on your end, and what safeguards do you use to protect your AI tokens? Drop your thoughts below! 👇

I got tired of robotic language apps, so I connected real-world radio stations to an AI

wanjiang — Fri, 28 Aug 2026 09:29:24 +0000

I got tired of robotic language apps, so I connected real-world radio stations to an AI 📻

If you’ve ever tried to learn a foreign language, you know the dreaded "Intermediate Plateau."

You spend months on apps like Duolingo or textbook audio courses. You feel confident. You think you’re ready. Then, you turn on a real French news broadcast or a fast-paced American sports radio station, and suddenly... you understand absolutely nothing.

Real people don't speak like robotic text-to-speech engines. They mumble, they use slang, they talk over each other, and they speak fast.

I realized that if I wanted to truly master a language at a C1/C2 level, I needed raw, unedited, real-world audio. But I also needed a coach to help me break it down.

So, I built RadioShadow — a Next.js web app that captures live global radio streams and uses AI to generate real-time subtitles, translations, and pronunciation coaching.

The "Aha" Moment 💡

The core idea of RadioShadow is based on the "Shadowing" technique — a highly effective language learning method where you listen to a native speaker and immediately repeat what they say, mimicking their intonation and rhythm.

My goal was simple in theory but technically challenging:

Tap into live radio streams across the globe (news, talk shows, music).
Process the audio stream with low latency.
Use an AI model to transcribe and translate the live feed instantly.
Let the user use their microphone to "shadow" the broadcaster, and have the AI score their pronunciation.

Building the MVP: Map, Streams, and UX Challenges 🗺️

I built the frontend using Next.js and Tailwind CSS, aiming for a clean, minimalist, light-mode SaaS aesthetic.

One of the most interesting challenges was the UX design for station selection. When you have access to tens of thousands of global radio stations, the "Paradox of Choice" kicks in. Users would stare at the world map, see thousands of options, and get completely overwhelmed.

To fix this, I had to balance geographical exploration with guided intent.

I implemented an interactive world map where users can click on a country to filter regional streams. But what if a user just wants to learn French and doesn't know which country's station is best?

I recently shipped a "✨ Help Me Choose" wizard right at the top of the control panel.

Instead of a generic search bar or an annoying popup, it’s a lightweight conversational UI. It asks you what language you are targeting and your current vibe (e.g., Hardcore News or Relaxed Talk Show), and instantly teleports you to the perfect live stream.

The Tech Stack 🛠️

Frontend: Next.js (App Router), Tailwind CSS, Framer Motion (for those buttery smooth state transitions).
Audio Processing: Web Audio API to handle the live stream buffering and microphone capturing.
AI Engine: Integrating LLMs for real-time transcription, contextual translation, and acoustic scoring for the user's shadowing practice.
Database & Auth: Firebase & NextAuth for seamless Google sign-ins and saving user pronunciation history.

What's Next? (And I need your feedback!) 🚀

Building this has been a wild ride of wrestling with audio streams, managing complex frontend states, and dealing with real-time AI latency. But hearing a live broadcast from Paris and having AI break it down for you instantly feels like magic.

The app is live at radioshadow.ai.studio (You can try the free real-time stream right away).

I am currently trying to refine the UI/UX and improve the AI scoring latency. Since this community has always been incredibly supportive of indie makers, I would love to hear your brutally honest feedback.

Does the map navigation feel intuitive?
How is the audio latency on your end?
Any features you think are missing for language learners?

Let me know in the comments! 👇

From n8n Automations to Android: Why I built a "Deadman's Switch" for personal safety 🚨

wanjiang — Fri, 13 Mar 2026 10:11:21 +0000

Hey DEV community! 👋

Some of you might know me from my previous posts about building and sharing n8n workflow automations. I absolutely love connecting APIs and watching data flow seamlessly.

But recently, I took a hard pivot. I shifted my focus from server automation to Android development. Why? Because I realized the most critical "automation" we need isn't for our emails or databases—it's for our physical safety.

Let me explain.

The Problem with Standard "Panic Buttons"

I was looking into personal safety apps for solo travelers and people walking home late at night. Almost all of them rely on a standard "Panic Button" approach.

Here is the fatal flaw: If you are incapacitated, ambushed, or your phone is out of reach, you cannot press a panic button. As someone obsessed with automation, I thought: Why not automate the cry for help?

The Solution: An Automated "Deadman's Switch"

I spent the last few months building Lifeline SOS, an Android app built around a proactive timer system (essentially a Deadman's Switch).

Here is the "workflow" in real life:

You are about to enter a risky situation (taking a late-night Uber, going on a blind date, walking through a dark alley).
You set a countdown timer in the app (e.g., 30 minutes).
If you are safe, you just tap the screen to cancel it.
If the timer hits zero and you haven't checked in, the app automatically runs a background task to send an SOS message with your live GPS location to your emergency contacts.

Besides the core timer, I also added two features that I found highly requested:

A Fake Call Generator: To politely (but urgently) escape uncomfortable situations like bad dates.
A Spy Camera Scanner: To find hidden cameras in Airbnbs using the phone's magnetic sensor.

The Technical Pivot (And the struggles)

Transitioning from n8n to native Android was a wild ride. The biggest headache? Background Services and Battery Optimization. Getting an Android device to reliably keep a timer running and fire off an SMS exactly when the timer hits zero—while the OS is aggressively trying to kill background apps to save battery—was an absolute nightmare. (If anyone here is an Android background task wizard, I’d love to hear your architecture tips!)

I Need Your Brutal Honesty (Roast My App) 🔥

I just launched the MVP on Google Play. Since I built this entire project using Flutter, I'm especially curious about how it performs across different native environments. I need real, unfiltered feedback from fellow developers.

UX/UI: Is the timer interface intuitive? Or does it look too complex?
Performance: How is the Flutter background execution holding up? Does the background timer drain too much battery on your specific Android device?
Features: What would make this more robust?

If you have an Android device, I would be incredibly grateful if you could download it, play around with the timer, and let me know what breaks.

🔗 [https://play.google.com/store/apps/details?id=com.lifeline.sos]

Thanks for reading, and keep building awesome things! Let me know in the comments if you've ever built something that shifted your entire tech stack, or if you have any secret tips for taming background tasks in Flutter!

40GB of Bot Traffic Later: I'm Open Sourcing 8,000+ n8n Workflows 🚀

wanjiang — Tue, 03 Feb 2026 02:15:01 +0000

The Dream

Two months ago, I built n8nworkflows.world.
The goal was simple: The official n8n template library was hard to search, and I wanted to build a "Google for n8n" that allowed developers to find workflows by Role (e.g., Marketer, DevOps) or Integration pairs (e.g., "Notion to Slack").

I indexed over 8,400+ verified workflows. Traffic started growing. Real users were finding value. I was happy.

The Attack 🤖

Then, last week, things got weird.
I woke up to check my Google Analytics and saw a massive spike in traffic. But something was off.

Source: 100% Direct/None.
Location: Almost entirely from a single city: Lanzhou, China (a known hub for data centers and proxy pools).
Behavior: They weren't reading the articles. They were hitting the "Copy JSON" endpoint. Systematically. One by one.

The Damage

I checked my Supabase dashboard, and my heart sank.

(Image: My database egress hit 40GB, 600% over the free limit)

The scrapers weren't just visiting; they were downloading the entire database. They sucked out 40GB of data in a few days. My free tier was obliterated, and I was facing potential account suspension.

The Decision: Fight or Fold? 🛡️ vs 🎁

I had two choices:

Fight it: Spend days configuring Cloudflare WAFs, upgrading to enterprise plans, and playing whack-a-mole with rotating IPs.
The "Nuclear" Option: If they want the data so bad... just give it to them.

I realized that as an indie developer, I shouldn't be hoarding this data. The n8n community deserves better access to these templates without me worrying about server bills.

So, I killed the database connection.
I converted the entire site into a static frontend and pushed the entire dataset to GitHub.

🚀 Introducing: Free n8n Workflows (Open Source)

Today, I am officially open-sourcing the entire project.

What you get:

📂 The Database: A full dump of 8,414+ n8n workflows (JSON format).
💻 The Code: The Next.js source code for the search engine.
✅ No Limits: No sign-ups, no server limits, no paywalls.

You can find the repo here:
👉 github.com/pxw3504k-web/free-n8n-workflows

(Please drop a ⭐️ Star if you find it useful! It helps a lot.)

🚧 What I'm Building Next (Coming Soon)

Since I'm no longer maintaining the n8n server, I'm shifting my focus to two mobile apps centered around personal safety and privacy.

They are currently in development. If you like what I did with the open-source n8n project, I'd love for you to join the Waitlist or follow me for the launch.

1. 🆘 LifelineSOS: Family Locator

I'm building a privacy-first alternative to Life360. No ads, no data selling.

Real-time Safety: Private location sharing for your close family.
SOS Alerts: One-tap emergency notifications with location history.
Status: In closed beta. Launching soon.

2. 🕵️‍♂️ Hidden Camera Detector

For the frequent travelers and digital nomads.

Scan Your Room: Detect hidden spy cameras in Hotels and Airbnbs using magnetic sensors and network analysis.
Peace of Mind: Ensure your privacy when you are on the road.
Status: Under active development.

Join Waitlist:

https://forms.gle/ws6ZxMPMk1WGV5658

📢 How to get them?
I will announce the release on my GitHub and X (Twitter).
👉 Follow me on X for Early Access
(Or just Star the n8n repository, and I'll update the README when they are live!)

Final Thoughts

To the scrapers in Lanzhou: You win. You wanted the data? Here it is. Now I don't have to pay for the bandwidth.

To the community: Enjoy the workflows! I hope this repository helps you automate your work faster.

Happy coding!

I indexed 8,000+ n8n workflows, then realized "Search" was broken. Here is how I fixed it.

wanjiang — Tue, 20 Jan 2026 12:33:49 +0000

The "Data Dump" Problem

Last week, the n8n community saw a massive release of 8,000+ raw workflow JSON files. As a developer, my first instinct was pure excitement: "More data = Better, right?"

I immediately indexed them all into my search engine, n8nworkflows.world.

But as I watched the analytics, I noticed a weird pattern. New users would land on the site, stare at the search bar, and... leave.

The "Blank Canvas" Paralysis

I realized that having 8,000 options isn't a feature; it's a bug.

Power users know to search for specific nodes like "HTTP Request" or "Postgres Trigger." But beginners? They don't think in nodes. They think in Job Titles and Goals.

A Marketer doesn't want "Gmail API"; they want "Cold Outreach Automation."
A Founder doesn't want "Stripe Webhook"; they want "SaaS Churn Alert."

The raw database was technically "complete," but functionally "useless" for the people who needed it most.

The Solution: Context > Code

I decided to stop just "indexing" files and start "curating" experiences. This weekend, I shipped a major update: The "Who Am I?" Wizard.

Instead of forcing users to guess keywords, I reversed the flow:

Select your Role: (e.g., Marketer, Founder, Developer, HR).
Get Curated Paths: The engine filters out 90% of the noise and shows only the automations relevant to that persona.

How I Built It (The Tech Stack)

Frontend: Next.js 14 (App Router) for the dynamic filtering UI.
Backend: Supabase. I had to restructure my DB schema to support the new metadata.

Old Schema: 
workflow_id -> nodes

New Schema: 
workflow_id -> nodes + target_roles[] + complexity_score

The "Verified" Logic

I also added a "Community Verified" layer. We run a check against the JSON structure to ensure it doesn't contain deprecated nodes (v0.x) that would break in the current n8n version.

The Result

The bounce rate on the search page has already dropped. Users are clicking "Marketer" and instantly finding the Notion-to-LinkedIn generator they didn't even know how to ask for.

If you are building a tool for developers, remember: Don't just give them a database. Give them a map.

🚀 Try it out here: n8nworkflows.world
(Feedback on the "Role" accuracy is highly appreciated!)

I curated 27+ Google Opal Templates and paired them with n8n Workflows for actual automation.

wanjiang — Thu, 15 Jan 2026 16:55:29 +0000

Google recently launched Opal (powered by Gemini), and it’s a fantastic low-code builder for specific AI tasks.

But while playing with it, I realized a pattern: Opal is great at generating the "Content", but it lacks the "Action".

For example, Opal can generate a perfect SQL query, but it can't run it on your database. It can write a cold email, but it can't send it.

The "Opal + n8n" Pattern

I spent the weekend exploring this and curated a directory of 27 Google Opal templates. For each category, I mapped out which n8n workflow you should use to turn that generation into an actual automation.

I categorized them into 3 buckets:

1. Developer Tools 🛠️

The App: Python Script Assistant or Cron Expression Generator.
The Workflow: Instead of just copying the code, I linked n8n workflows that can take these scripts and execute them immediately via the Code Node or set up triggers based on the generated Cron schedule.

2. Business & Ops 💼

The App: Cold Email Generator or SOP Writer.
The Workflow: I paired these with n8n workflows that connect to Gmail or Notion.
Idea: Generate the email in Opal -> Copy to n8n -> Auto-send to your leads list from Google Sheets.

3. Lifestyle & Viral 🚀

The App: Meal Prep Planner or Dream Trip Itinerary.
The Workflow: These pair perfectly with Google Calendar or Todoist nodes in n8n to turn a text plan into a scheduled reality.

Why I built this directory

Searching for specific Opal use cases was messy. I wanted a clean, dark-mode visual library where you can:

Click "Try in Opal" to clone the official Google template.
See immediately which n8n nodes/workflows make sense to use with it.

It’s completely free to browse. I’m just trying to bridge the gap between "Generative AI" (Google) and "Process Automation" (n8n).

👉 Check out the collection here: n8nworkflows.world/googleopal

Let me know if there are other Opal templates you think I should add!

How I Generated 2,800+ SEO Pages for n8n Workflows using Next.js

wanjiang — Fri, 09 Jan 2026 03:11:06 +0000

"If you build it, they will come."
...Well, not really. Not if Google doesn't know you exist.

I've been building n8nworkflows.world, a search engine for n8n automation templates. My goal was simple: make it easier to find high-quality, verified n8n workflows than the official forums.

But I hit a wall. People don't just search for "n8n workflows". They search for specific problems:

"How to save Telegram files to Google Drive"
"Notion to Slack automation"
"Postgres to Google Sheets sync"

To capture this traffic, I needed a landing page for every single possible integration combination. Writing them manually would take years.

So, I used Next.js and Programmatic SEO to generate 2,819+ pages overnight. Here is how I did it.

1. The Problem: The "Long-Tail" Void 🕳️

The n8n ecosystem is vast. There are hundreds of nodes (integrations).
Mathematically, the number of potential connections (Node A → Node B) is massive.

Most users are looking for these specific pairs. If I only have a homepage, I miss out on 99% of search intent. I needed a structured directory that Google could crawl, indexing specific terms like Agile CRM + Schedule Trigger or Gmail + OpenAI.

2. The Tech Stack 🛠️

Frontend: Next.js 14 (App Router)
Database: Supabase (PostgreSQL)
Language: TypeScript
Data Processing: Python (for analyzing JSON relationships)

3. The Implementation: From JSON to SEO Pages

Step 1: Analyzing the Relationships

I have a database of 6,000+ n8n workflow JSON files.
I wrote a Python script to parse these JSONs and extract "Node Pairs".

For example, if a workflow contains a Telegram Trigger node and a Google Drive node, that creates a relationship: telegram-to-google-drive.

I stored these pairs in a separate Supabase table: integration_pairs.

slug: "telegram-to-google-drive"
app_a: "Telegram"
app_b: "Google Drive"
count: 42 (number of workflows using this pair)

Step 2: Dynamic Routing with Next.js

This is where Next.js shines. Instead of creating 2,000 physical files, I used Dynamic Routes.

I created a folder structure like this:
app/integration/[slug]/page.tsx

// app/integration/[slug]/page.tsx

import { createClient } from '@/utils/supabase/server';

export async function generateMetadata({ params }) {
  // Auto-generate SEO titles based on the URL slug
  const pair = params.slug.replace('-', ' to ');
  return {
    title: `Best ${pair} n8n Workflows & Templates (Free Download)`,
    description: `Discover verified automation templates to connect ${pair}. Download free JSONs.`
  };
}

export default async function IntegrationPage({ params }) {
  const { slug } = params;

  // Fetch all workflows that match this pair
  const workflows = await getWorkflowsByPair(slug);

  return (
      <div className="container mx-auto">
        <h1>{slug.split('-').join(' ')} Integrations</h1>
        <div className="grid grid-cols-1 md:grid-cols-3 gap-4">
          {workflows.map(wf => (
             <WorkflowCard key={wf.id} data={wf} />
          ))}
        </div>
      </div>
  );
}

Step 3: The Directory Index (The "Map")

To help Google find these 2,800+ dynamic pages, I built a massive Directory Page.

It lists every single combination alphabetically (A-Z). This serves as a "Sitemap" for users and crawlers.

4. The Result: A SEO Machine 🚀

By deploying this structure, I instantly created:

2,819+ New Entry Points: Users searching for niche automations can now land directly on a page dedicated to their specific stack.
Better UX: Users can browse by "Apps". If you want to see everything you can do with Notion, just go to the Notion collection.
Scalability: If I add a new workflow that connects "DeepSeek" to "Whatsapp", the page /integration/deepseek-to-whatsapp is created automatically.

5. Bonus: The Leaderboard 🏆

To make the site stickier, I also added a "Hall of Fame" Leaderboard.

It tracks the "Heat Index" (Views + Downloads) of workflows in real-time, so you can see what the community is actually building right now.

What's Next?

I'm currently working on an AI Agent that reads the workflow JSONs to automatically extract the original author's name and social links. The goal is to give credit back to the creators and build "Author Portfolio" pages (another SEO win!).

Check out the live directory here:
👉 n8n Integration Directory

Let me know what you think! Have you tried Programmatic SEO for your projects?

Challenge accepted! 🚀 Stack: Cloud Run, Gemini & Antigravity. Let's go! #googlecloud #gemini

wanjiang — Thu, 08 Jan 2026 03:23:48 +0000

Join the New Year, New You Portfolio Challenge: $3,000 in Prizes + Feedback from Google AI Team (For Winners and Runner Ups!)

Jess Lee for The DEV Team ・ Jan 1

#devchallenge #googleaichallenge #career #gemini

I Built an AI Creative Director: Automating FB Ad Gen with GPT-4o Vision & Structured Outputs

wanjiang — Wed, 07 Jan 2026 03:40:54 +0000

Creating high-converting Facebook ads is a grind. You need to analyze what's working, understand your product's unique selling points, and then churn out dozens of visual variations.

"Prompter's block" is real. Staring at an empty Midjourney or DALL-E prompt box often leads to generic, unusable results.

So, I decided to automate the "Creative Director" role.

Instead of guessing prompts, I built a workflow in n8n that uses GPT-4o's Vision capabilities to "see" successful ads, analyze my product, and structurally engineer new ad concepts.

Here is how I built a Multimodal AI Pipeline that turns raw product photos into ready-to-test ad creatives.

![Screenshot: Full Workflow Overview in n8n canvas]

The Architecture: Eye, Brain, and Hand

This isn't just a simple "Text-to-Image" flow. It is a "Image-to-Text-to-Image" pipeline (Multimodal).

The workflow consists of three distinct phases:

The Eye (Input Analysis): GPT-4o Vision analyzes reference images (inspiration) and product images.
The Brain (Structured Logic): A LangChain Agent synthesizes these inputs into a strict JSON format.
The Hand (Execution): A loop triggers the OpenAI Image Generation API for each concept.

Let's break down the technical implementation.

Phase 1: The "Vision" Analysis (Reverse Engineering)

First, we need to understand what makes a good ad. We don't want to describe it manually; we want the AI to do it.

I set up two parallel Google Drive nodes to fetch files:

Inspiration Folder: Contains high-performing ads from competitors.
Product Folder: Contains raw shots of the product we are selling.

Then, I pass these images (as Base64) into the OpenAI Chat Model node using gpt-4o.

For the Inspiration Analysis, I use a specific prompt to extract the principles rather than the content:

"Describe the visual style of this image... create a template of the style for inspirations. Ensure you do not make this product specific, rather focusing on creating outlines for static ad styles."

For the Product Analysis, I ask it to extract the emotions and selling points:

"Identify the core emotions behind it and the main product. We will use this later to connect the product image with some ad styles."

Now, we have two distinct text chunks: one describing the "Vibe" and one describing the "Subject".

Phase 2: From Chaos to JSON (The Structured Output)

This is the most critical part of any AI automation. LLMs love to chat. They love to say "Here are 10 prompts for you:".

We cannot automate "chat". We need Arrays.

To fix this, I used the Advanced AI nodes in n8n, specifically the Structured Output Parser.

I connected a LangChain Agent to the Structured Output Parser and defined a strict JSON Schema. This forces the AI to ignore its chatty tendencies and output pure, parseable JSON.

Here is the schema example I provided to the model:

[
  {
    "Prompt": "Sun-drenched poolside shot of the product on a marble ledge at golden hour, with soft shadows and warm tones. Aspect ratio 1:1."
  },
  {
    "Prompt": "Cool lavender-tinted sunset beach backdrop behind the product, highlighting reflective metallic accents. Aspect ratio 4:5."
  }
]

The Agent takes the Style Description (from Node A) and the Product Description (from Node B) and merges them into this exact format.

Why is this a game changer?
Because now I have a programmatic array of 10 prompts that I can iterate over. No regex, no string parsing, just clean data.

Phase 3: The Factory Line (Execution Loop)

Once we have the array, we use a Split Out node to separate the JSON items.

Instead of using a pre-built DALL-E node, I opted for a raw HTTP Request node to hit the https://api.openai.com/v1/images/generations endpoint.

Why raw HTTP?
It gives me granular control over the API parameters (like quality, style, or testing new model IDs like dall-e-3 standard vs HD) that might not yet be exposed in standard nodes.

Here is the body configuration:

{
  "model": "dall-e-3",
  "prompt": "={{ $json.Prompt }}",
  "size": "1024x1024",
  "quality": "standard",
  "n": 1
}

A Note on Rate Limits

When generating images via API, you will hit rate limits fast. I added a Wait node inside the loop (not shown in standard templates, but essential for production).

It pauses for a few seconds between requests to ensure we stay within the "Tokens Per Minute" (TPM) limits of the OpenAI API.

The Result: Automated Creativity

Finally, the workflow grabs the Base64 data from the API response, converts it to a binary file using Convert to File, and uploads the fresh, AI-generated ad to a specific "Output" folder in Google Drive.

The Workflow Flow:

Read Reference Image (Input).
Read Product Image (Input).
Analyze both with GPT-4o.
Synthesize 10 new prompts via LangChain.
Generate 10 new images via DALL-E 3.
Save to Drive.

I built this because I wanted to test 50 different visual hooks for a campaign without briefing a designer 50 times. The results are surprisingly coherent because they are grounded in the visual analysis of ads that already work.

Get the Workflow

I've cleaned up the credentials and packaged this workflow into a JSON file you can import directly into your n8n instance.

👉 Download the AI Product Image Generator Workflow

Note: You will need your own OpenAI API Key (with GPT-4o access) and Google Drive credentials to run this.

Happy automating! 🤖

Build a Local Lead Gen Machine: Scraping Google Maps with n8n (Reliably)

wanjiang — Tue, 06 Jan 2026 07:33:25 +0000

Let's be real: "Lead Generation" is usually boring. But when you need to extract thousands of verified business contacts for a client (or your own SaaS) from a specific area, it becomes a fun engineering challenge.

I recently needed to build a pipeline to find local businesses in specific zip codes. I didn't just need names; I needed the "High-Value" metadata: phone numbers, website URLs, review counts, and exact coordinates.

Most Python scripts I tried hit the Google Maps API rate limits and died halfway through. So, I built a robust workflow in n8n that handles the heavy lifting, error handling, and data cleaning automatically.

Here represents the architecture of a production-ready scraper.

The Output: What are we actually getting?

Before we look at the nodes, let's look at the data. This workflow doesn't just dump raw JSON. It structures the data into a clean Google Sheet that your marketing team (or CRM) can actually use.

We are extracting specific fields via the Google Places API (New v1) using a FieldMask to save costs and bandwidth:

nationalPhoneNumber: Direct line for cold calling.
websiteUri: Essential for scraping their site later or finding emails.
rating & userRatingCount: This is the gold. (e.g., Filter for businesses with < 3 stars to sell them reputation management services).
formattedAddress & location: For precise mapping.

The Logic: "Carpet Bombing" via Nested Loops

A simple search for "Plumbers in New York" misses 80% of the results. To get everyone, you need to be granular.

This workflow uses a Nested Loop strategy:

Outer Loop (Zip Codes): Reads a list of target zip codes from Google Sheets.
Inner Loop (Subcategories): Iterates through keywords (e.g., "Plumber," "HVAC," "Electrician") for each zip code.

This ensures comprehensive coverage. If you are targeting a whole state, you simply upload the zip code list, and the bot goes to work.

The "Secret Sauce": Handling Rate Limits (Exponential Backoff)

This is where most low-code automations fail. If you hit Google's API with 500 requests in a minute, you get a 429 Too Many Requests.

Instead of a simple "Retry," I implemented a custom Exponential Backoff algorithm using a Code node and a Wait node.

Here is the logic inside the workflow:

// From the "Exponential Backoff" node
const retryCount = $json["retryCount"] || 0;
const maxRetries = 5;
const initialDelay = 1; // Start with 1 second

if (retryCount < maxRetries) {
    // Wait 1s, then 2s, then 4s, etc.
    const currentDelayInSeconds = initialDelay * Math.pow(2, retryCount); 

    return {
        json: {
            retryCount: retryCount + 1,
            waitTimeInSeconds: currentDelayInSeconds,
            status: 'retrying',
        }
    };
}

If the API chokes, the workflow pauses intelligently, cools down, and tries again. It makes the difference between a bot that crashes after 10 minutes and one that runs all night.

Data Hygiene: No Duplicates Allowed

Google Maps often returns the same business for adjacent zip codes. To prevent polluting the database, I added a Remove Duplicates node.

It checks the unique place.id returned by Google. If we've seen this ID before in this run, it gets tossed. The result is a clean, unique list of leads ready for outreach.

How to use it

I've packaged this entire logic—including the OAuth setup, the loop logic, and the error handling code—into a single template.

You can download the JSON here:
👉 Automate Google Maps Lead Generation Workflow

Prerequisites:

n8n instance (Self-hosted or Cloud).
Google Cloud Console: Enable "Places API (New)" and create OAuth credentials.
Google Sheets: To host your zip codes and receive the data.

Final Thoughts

This workflow turns the chaotic Google Maps data into structured SQL-ready rows. I've used this to generate datasets for real estate analysis and local B2B sales, and the cost per lead is a fraction of buying a list.

If you download it and find a way to optimize the FieldMask further, let me know in the comments!

Happy scraping! 🤖

I built a "Hall of Fame" for n8n automations because I was tired of broken JSONs.

wanjiang — Mon, 05 Jan 2026 06:31:38 +0000

I built a live Leaderboard for n8n Workflows. Here is why you should be on it. 🏆

The Problem:
We all love n8n, but finding high-quality, working templates is a mess. GitHub is fragmented, and forums are full of snippets that don't work.

The Solution:
I spent the last weekend building a Real-time Leaderboard for my platform, n8nworkflows.world.

👉 Live Demo: Check the Hall of Fame

It tracks:

🔥 Heat Index: A weighted algorithm of views + downloads.
🚀 Rising Stars: New workflows that are gaining traction fast.
💎 Verified Status: Only clean, working JSONs.

Why did I build this?
I want to highlight the best creators in our community. If you are building cool stuff with n8n, you deserve credit (and traffic).

🚀 Challenge for Dev.to Community:
I'm looking for the first 50 "Founding Contributors".
If you have a workflow that saves you time:

Upload it here (https://n8nworkflows.world/submit).
I will verify it personally within 24 hours.
If it's good, I'll feature it in the "Rising Stars" section next week.

Let's build the best automation library together!

I analyzed 6,000+ n8n Workflows. Here are the top 3 mistakes that break automations.

wanjiang — Sun, 04 Jan 2026 03:35:20 +0000

The "Data Dig" 🔍

Over the past month, I've been building a search engine for n8n workflows. To make it useful, I scraped and indexed over 6,000 public workflow JSON files from various repositories and communities.

I thought I would find a goldmine of ready-to-use automation.

Instead, I found a lot of... let's call it "fragile creativity." 😅

While there are some brilliant engineers out there, a huge portion of open-source workflows are unusable for the average user. After parsing thousands of nodes, I noticed 3 specific patterns that make shared workflows fail.

If you are building automations (for yourself or to share), please avoid these.

Mistake #1: The "Hardcoded Secret" 🔑

This is the most common issue. I found hundreds of workflows where API Keys, Webhook URLs, or worse—passwords—were pasted directly into the node parameters (strings) instead of using n8n's Credential System.

Why this is bad:

Security Risk: You are sharing your secrets with the world.
Usability Nightmare: If I download your workflow, I have to hunt down every single node and manually replace the strings.

✅ Best Practice:
Always use n8n Credentials. If you need a dynamic value, use an Expression that references a variable or an environment variable (e.g., {{ $env.MY_API_KEY }}).

Mistake #2: The "Spaghetti Monolith" 🍝

I saw workflows with 50+ nodes in a single, tangled mess. No "Execute Workflow" nodes, no sub-workflows, just one giant canvas doing everything from scraping to database writing to email sending.

Why this is bad:

Impossible to Debug: If it fails, good luck finding which branch caused it.
Visual Overload: It looks scary to new users.

✅ Best Practice:
Break it down! If your workflow handles three distinct tasks (e.g., "Get Data", "Process Data", "Save Data"), split them into 3 separate workflows and connect them using the Execute Workflow node. It makes your logic reusable and clean.

Mistake #3: The "Ghost Node" 👻

This happens when workflows rely on Custom Nodes that are not installed by default (community nodes) or, worse, use very old versions of core nodes (e.g., Function Item vs Code Node).

When a user imports this JSON, they just see a blank error or a "Node not found" warning. The automation is dead on arrival.

✅ Best Practice:
Stick to the standard node library whenever possible. If you must use a community node, document it clearly in the Notes!

So, I decided to fix it. 🛠️

I got tired of downloading broken JSONs.

I realized that Search wasn't enough; we needed Quality Control.

I spent the last week building a "Verification Layer" for my platform. I used a combination of script analysis and manual review to flag workflows that:

Use standard nodes.
Have clean structures.
Are free of hardcoded secrets.

I've curated the first batch of 500+ "Community Verified" Workflows.

If you want to skip the debugging and just get automations that actually work (with visual previews before you download), you can check out the collection here:

👉 Search the Verified Collection

(I also added a "Verified" badge so you can spot them easily)

Let's write cleaner automation in 2026! 🚀